func TestOutputValueFile(t *testing.T) {
if err := nodedb.Initialize(); err != nil {
t.Fatalf("nodedb.Initialize() %s", err)
}
info, err := tools.NewFileSpaceInfo(nodedb.NodeDB)
if err != nil {
t.Fatalf("NewFileSpaceInfo( %s", err)
}
valueFile, err := NewOutputValueFile(info)
if err != nil {
t.Fatalf("NewOutputValueFile %s", err)
}
collectionID := uint32(42)
segmentID := uint64(88)
dataSize := 1024
data := bytes.Repeat([]byte{'a'}, dataSize)
if _, err := valueFile.Store(collectionID, segmentID, data); err != nil {
t.Fatalf("valueFile.Store %s", err)
}
if valueFile.Size() != uint64(dataSize) {
t.Fatalf("size mismatch: expecting %d, found %d", dataSize,
valueFile.Size())
}
if err := valueFile.Close(); err != nil {
t.Fatalf("valueFile.Close() %s", err)
}
}
func NewMessageHandler() chan<- types.Message {
var nimbusioWriter writer.NimbusioWriter
var replyChan chan<- *reply.ReplyMessage
var err error
messageChan := make(chan types.Message, messageChanCapacity)
if err = nodedb.Initialize(); err != nil {
fog.Critical("NewMessageHandler: nodedb.Initialize failed %s", err)
}
if nimbusioWriter, err = writer.NewNimbusioWriter(); err != nil {
fog.Critical("NewMessageHandler: NewNimbusioWriter() failed %s", err)
}
replyChan = reply.NewReplyHandler()
dispatchTable := map[string]messageHandler{
"archive-key-entire": handleArchiveKeyEntire,
"archive-key-start": handleArchiveKeyStart,
"archive-key-next": handleArchiveKeyNext,
"archive-key-final": handleArchiveKeyFinal,
"archive-key-cancel": handleArchiveKeyCancel,
"destroy-key": handleDestroyKey,
"start-conjoined-archive": handleStartConjoinedArchive,
"abort-conjoined-archive": handleAbortConjoinedArchive,
"finish-conjoined-archive": handleFinishConjoinedArchive}
go func() {
for message := range messageChan {
handler, ok := dispatchTable[message.Type]
if !ok {
fog.Error("Unknown message type %s %s",
message.Type, message.Marshalled)
continue
}
go handler(message, nimbusioWriter, replyChan)
}
}()
return messageChan
}