github.com/zhuohuang-hust/src-cbuild@v0.0.0-20230105071821-c7aab3e7c840/mergeCode/libnetwork/networkdb/message.go (about)

     1  package networkdb
     2  
     3  import "github.com/gogo/protobuf/proto"
     4  
     5  const (
     6  	// Max udp message size chosen to avoid network packet
     7  	// fragmentation.
     8  	udpSendBuf = 1400
     9  
    10  	// Compound message header overhead 1 byte(message type) + 4
    11  	// bytes (num messages)
    12  	compoundHeaderOverhead = 5
    13  
    14  	// Overhead for each embedded message in a compound message 4
    15  	// bytes (len of embedded message)
    16  	compoundOverhead = 4
    17  )
    18  
    19  func encodeRawMessage(t MessageType, raw []byte) ([]byte, error) {
    20  	gMsg := GossipMessage{
    21  		Type: t,
    22  		Data: raw,
    23  	}
    24  
    25  	buf, err := proto.Marshal(&gMsg)
    26  	if err != nil {
    27  		return nil, err
    28  	}
    29  
    30  	return buf, nil
    31  }
    32  
    33  func encodeMessage(t MessageType, msg interface{}) ([]byte, error) {
    34  	buf, err := proto.Marshal(msg.(proto.Message))
    35  	if err != nil {
    36  		return nil, err
    37  	}
    38  
    39  	buf, err = encodeRawMessage(t, buf)
    40  	if err != nil {
    41  		return nil, err
    42  	}
    43  
    44  	return buf, nil
    45  }
    46  
    47  func decodeMessage(buf []byte) (MessageType, []byte, error) {
    48  	var gMsg GossipMessage
    49  
    50  	err := proto.Unmarshal(buf, &gMsg)
    51  	if err != nil {
    52  		return MessageTypeInvalid, nil, err
    53  	}
    54  
    55  	return gMsg.Type, gMsg.Data, nil
    56  }
    57  
    58  // makeCompoundMessage takes a list of messages and generates
    59  // a single compound message containing all of them
    60  func makeCompoundMessage(msgs [][]byte) []byte {
    61  	cMsg := CompoundMessage{}
    62  
    63  	cMsg.Messages = make([]*CompoundMessage_SimpleMessage, 0, len(msgs))
    64  	for _, m := range msgs {
    65  		cMsg.Messages = append(cMsg.Messages, &CompoundMessage_SimpleMessage{
    66  			Payload: m,
    67  		})
    68  	}
    69  
    70  	buf, err := proto.Marshal(&cMsg)
    71  	if err != nil {
    72  		return nil
    73  	}
    74  
    75  	gMsg := GossipMessage{
    76  		Type: MessageTypeCompound,
    77  		Data: buf,
    78  	}
    79  
    80  	buf, err = proto.Marshal(&gMsg)
    81  	if err != nil {
    82  		return nil
    83  	}
    84  
    85  	return buf
    86  }
    87  
    88  // decodeCompoundMessage splits a compound message and returns
    89  // the slices of individual messages. Returns any potential error.
    90  func decodeCompoundMessage(buf []byte) ([][]byte, error) {
    91  	var cMsg CompoundMessage
    92  	if err := proto.Unmarshal(buf, &cMsg); err != nil {
    93  		return nil, err
    94  	}
    95  
    96  	parts := make([][]byte, 0, len(cMsg.Messages))
    97  	for _, m := range cMsg.Messages {
    98  		parts = append(parts, m.Payload)
    99  	}
   100  
   101  	return parts, nil
   102  }