Golang datawriter-writer.NimbusioWriter类(方法)实例源码

func handleFinishConjoinedArchive(message types.Message,
	nimbusioWriter writer.NimbusioWriter,
	replyChan chan<- *reply.ReplyMessage) {

	var conjoined msg.Conjoined
	var err error

	conjoined, err = msg.UnmarshalConjoined(message.Marshalled)
	if err != nil {
		fog.Error("UnmarshalConjoined failed %s", err)
		return
	}

	replyMessage := reply.NewReplyMessage("finish-conjoined-archive", message.ID,
		conjoined.UserRequestID, conjoined.ReturnAddress)

	lgr := logger.NewLogger(conjoined.UserRequestID, conjoined.UnifiedID,
		0, 0, conjoined.Key)
	lgr.Info("finish-conjoined-archive (%d)", conjoined.CollectionID)

	if err = nimbusioWriter.FinishConjoinedArchive(conjoined); err != nil {
		lgr.Error("StartConjoinedArchive: %s", err)
		replyMessage.Error("error", err.Error())
		replyChan <- replyMessage
		return
	}

	replyMessage.Success()
	replyChan <- replyMessage
	return
}

func handleArchiveKeyCancel(message types.Message,
	nimbusioWriter writer.NimbusioWriter,
	replyChan chan<- *reply.ReplyMessage) {

	var archiveKeyCancel msg.ArchiveKeyCancel
	var err error

	archiveKeyCancel, err = msg.UnmarshalArchiveKeyCancel(message.Marshalled)
	if err != nil {
		fog.Error("UnmarshalArchiveKeyCancel failed %s", err)
		return
	}

	replyMessage := reply.NewReplyMessage("archive-key-cancel", message.ID,
		archiveKeyCancel.UserRequestID, archiveKeyCancel.ReturnAddress)

	lgr := logger.NewLogger(archiveKeyCancel.UserRequestID, archiveKeyCancel.UnifiedID,
		archiveKeyCancel.ConjoinedPart, archiveKeyCancel.SegmentNum, "")
	lgr.Info("archive-key-cancel")

	if err = nimbusioWriter.CancelSegment(archiveKeyCancel); err != nil {
		lgr.Error("CancelSegment: %s", err)
		replyMessage.Error("error", err.Error())
		replyChan <- replyMessage
		return
	}

	replyMessage.Success()
	replyChan <- replyMessage
	return
}

func handleDestroyKey(message types.Message,
	nimbusioWriter writer.NimbusioWriter,
	replyChan chan<- *reply.ReplyMessage) {

	var destroyKey msg.DestroyKey
	var err error

	destroyKey, err = msg.UnmarshalDestroyKey(message.Marshalled)
	if err != nil {
		fog.Error("UnmarshalDestroyKey failed %s", err)
		return
	}

	replyMessage := reply.NewReplyMessage("destroy-key", message.ID,
		destroyKey.UserRequestID, destroyKey.ReturnAddress)

	lgr := logger.NewLogger(destroyKey.UserRequestID, destroyKey.UnifiedID,
		destroyKey.ConjoinedPart, destroyKey.SegmentNum, destroyKey.Key)
	lgr.Info("archive-key-cancel")

	if err = nimbusioWriter.DestroyKey(destroyKey); err != nil {
		lgr.Error("DestroyKey: %s", err)
		replyMessage.Error("error", err.Error())
		replyChan <- replyMessage
		return
	}

	replyMessage.Success()
	replyChan <- replyMessage
	return
}

func handleArchiveKeyNext(message types.Message,
	nimbusioWriter writer.NimbusioWriter,
	replyChan chan<- *reply.ReplyMessage) {

	var archiveKeyNext msg.ArchiveKeyNext
	var md5Digest []byte
	var err error

	archiveKeyNext, err = msg.UnmarshalArchiveKeyNext(message.Marshalled)
	if err != nil {
		fog.Error("UnmarshalArchiveKeyNext failed %s", err)
		return
	}

	replyMessage := reply.NewReplyMessage("archive-key-final", message.ID,
		archiveKeyNext.UserRequestID, archiveKeyNext.ReturnAddress)

	lgr := logger.NewLogger(archiveKeyNext.UserRequestID, archiveKeyNext.UnifiedID,
		archiveKeyNext.ConjoinedPart, archiveKeyNext.SegmentNum, archiveKeyNext.Key)
	lgr.Info("archive-key-Next")

	if archiveKeyNext.SegmentSize != uint64(len(message.Data)) {
		lgr.Error("size mismatch (%d != %d)", archiveKeyNext.SegmentSize,
			len(message.Data))
		replyMessage.Error("size-mismatch", "segment size does not match expected value")
		replyChan <- replyMessage
		return
	}

	md5Digest, err = base64.StdEncoding.DecodeString(archiveKeyNext.EncodedSegmentMD5Digest)
	if err != nil {
		lgr.Error("base64.StdEncoding.DecodeString %s", err)
		replyMessage.Error("base64", "base64.StdEncoding.DecodeString")
		replyChan <- replyMessage
		return
	}

	if !MD5DigestMatches(message.Data, md5Digest) {
		lgr.Error("md5 mismatch")
		replyMessage.Error("md5-mismatch", "segment md5 does not match expected value")
		replyChan <- replyMessage
		return
	}

	_, err = nimbusioWriter.StoreSequence(archiveKeyNext.UserRequestID,
		archiveKeyNext.Segment,
		archiveKeyNext.Sequence, message.Data)
	if err != nil {
		lgr.Error("StoreSequence: %s", err)
		replyMessage.Error("error", err.Error())
		replyChan <- replyMessage
		return
	}

	replyMessage.Success()
	replyChan <- replyMessage
	return
}

func handleArchiveKeyEntire(message types.Message,
	nimbusioWriter writer.NimbusioWriter,
	replyChan chan<- *reply.ReplyMessage) {

	var archiveKeyEntire msg.ArchiveKeyEntire
	var md5Digest []byte
	var err error
	var valueFileID uint32

	archiveKeyEntire, err = msg.UnmarshalArchiveKeyEntire(message.Marshalled)
	if err != nil {
		fog.Error("UnmarshalArchiveKeyEntire failed %s", err)
		return
	}

	replyMessage := reply.NewReplyMessage("archive-key-final", message.ID,
		archiveKeyEntire.UserRequestID, archiveKeyEntire.ReturnAddress)

	lgr := logger.NewLogger(archiveKeyEntire.UserRequestID, archiveKeyEntire.UnifiedID,
		archiveKeyEntire.ConjoinedPart, archiveKeyEntire.SegmentNum, archiveKeyEntire.Key)
	lgr.Info("archive-key-entire")

	if archiveKeyEntire.SegmentSize != uint64(len(message.Data)) {
		lgr.Error("size mismatch (%d != %d)", archiveKeyEntire.SegmentSize,
			len(message.Data))
		replyMessage.Error("size-mismatch", "segment size does not match expected value")
		replyChan <- replyMessage
		return
	}

	md5Digest, err = base64.StdEncoding.DecodeString(archiveKeyEntire.EncodedSegmentMD5Digest)
	if err != nil {
		lgr.Error("base64.StdEncoding.DecodeString %s", err)
		replyMessage.Error("base64", "base64.StdEncoding.DecodeString")
		replyChan <- replyMessage
		return
	}

	if !MD5DigestMatches(message.Data, md5Digest) {
		lgr.Error("md5 mismatch")
		replyMessage.Error("md5-mismatch", "segment md5 does not match expected value")
		replyChan <- replyMessage
		return
	}

	err = nimbusioWriter.StartSegment(archiveKeyEntire.UserRequestID, archiveKeyEntire.Segment,
		archiveKeyEntire.NodeNames)
	if err != nil {
		lgr.Error("StartSegment: %s", err)
		replyMessage.Error("error", err.Error())
		replyChan <- replyMessage
		return
	}

	valueFileID, err = nimbusioWriter.StoreSequence(
		archiveKeyEntire.UserRequestID,
		archiveKeyEntire.Segment,
		archiveKeyEntire.Sequence, message.Data)
	if err != nil {
		lgr.Error("StoreSequence: %s", err)
		replyMessage.Error("error", err.Error())
		replyChan <- replyMessage
		return
	}

	metaData := msg.GetMetaFromJSON(message.Marshalled)

	err = nimbusioWriter.FinishSegment(archiveKeyEntire.UserRequestID,
		archiveKeyEntire.Segment,
		archiveKeyEntire.File,
		metaData,
		valueFileID)
	if err != nil {
		lgr.Error("FinishSegment: %s", err)
		replyMessage.Error("error", err.Error())
		replyChan <- replyMessage
		return
	}

	replyMessage.Success()
	replyChan <- replyMessage
	return
}