Merge pull request #74 from cloudstruct/feature/chain-sync-message-tests

More unit tests for chain-sync messages

Author: agaffney

cmd/go-ouroboros-network/chainsync.go

@@ -121,15 +121,15 @@ func testChainSync(f *globalFlags) {
 	syncState.oConn = o
 	syncState.readyForNextBlockChan = make(chan bool)
 	syncState.nodeToNode = f.ntnProto
-	intersect := []interface{}{}
+	var point chainsync.Point
 	if len(eraIntersect[f.networkMagic][chainSyncFlags.startEra]) > 0 {
 		// Slot
-		intersect = append(intersect, eraIntersect[f.networkMagic][chainSyncFlags.startEra][0])
+		point.Slot = uint64(eraIntersect[f.networkMagic][chainSyncFlags.startEra][0].(int))
 		// Block hash
 		hash, _ := hex.DecodeString(eraIntersect[f.networkMagic][chainSyncFlags.startEra][1].(string))
-		intersect = append(intersect, hash)
+		point.Hash = hash
 	}
-	if err := o.ChainSync.FindIntersect([]interface{}{intersect}); err != nil {
+	if err := o.ChainSync.FindIntersect([]chainsync.Point{point}); err != nil {
 		fmt.Printf("ERROR: FindIntersect: %s\n", err)
 		os.Exit(1)
 	}

protocol/chainsync/chainsync.go

@@ -4,7 +4,6 @@ import (
 	"fmt"
 	"github.com/cloudstruct/go-ouroboros-network/block"
 	"github.com/cloudstruct/go-ouroboros-network/protocol"
-	"github.com/cloudstruct/go-ouroboros-network/utils"
 )
 
 const (
@@ -163,7 +162,7 @@ func (c *ChainSync) RequestNext() error {
 	return c.SendMessage(msg)
 }
 
-func (c *ChainSync) FindIntersect(points []interface{}) error {
+func (c *ChainSync) FindIntersect(points []Point) error {
 	msg := NewMsgFindIntersect(points)
 	return c.SendMessage(msg)
 }
@@ -184,16 +183,12 @@ func (c *ChainSync) handleRollForward(msgGeneric protocol.Message) error {
 		msg := msgGeneric.(*MsgRollForwardNtN)
 		var blockHeader interface{}
 		var blockType uint
-		blockHeaderType := msg.WrappedHeader.Type
-		switch blockHeaderType {
+		blockEra := msg.WrappedHeader.Era
+		switch blockEra {
 		case block.BLOCK_HEADER_TYPE_BYRON:
-			var wrappedHeaderByron WrappedHeaderByron
-			if _, err := utils.CborDecode(msg.WrappedHeader.RawData, &wrappedHeaderByron); err != nil {
-				return fmt.Errorf("%s: decode error: %s", PROTOCOL_NAME, err)
-			}
-			blockType = wrappedHeaderByron.Unknown.Type
+			blockType = msg.WrappedHeader.ByronType()
 			var err error
-			blockHeader, err = block.NewBlockHeaderFromCbor(blockType, wrappedHeaderByron.RawHeader)
+			blockHeader, err = block.NewBlockHeaderFromCbor(blockType, msg.WrappedHeader.HeaderCbor())
 			if err != nil {
 				return err
 			}
@@ -205,14 +200,9 @@ func (c *ChainSync) handleRollForward(msgGeneric protocol.Message) error {
 				block.BLOCK_HEADER_TYPE_MARY:    block.BLOCK_TYPE_MARY,
 				block.BLOCK_HEADER_TYPE_ALONZO:  block.BLOCK_TYPE_ALONZO,
 			}
-			blockType = blockTypeMap[blockHeaderType]
-			// We decode into a byte array to implicitly unwrap the CBOR tag object
-			var payload []byte
-			if _, err := utils.CborDecode(msg.WrappedHeader.RawData, &payload); err != nil {
-				return fmt.Errorf("%s: decode error: %s", PROTOCOL_NAME, err)
-			}
+			blockType = blockTypeMap[blockEra]
 			var err error
-			blockHeader, err = block.NewBlockHeaderFromCbor(blockType, payload)
+			blockHeader, err = block.NewBlockHeaderFromCbor(blockType, msg.WrappedHeader.HeaderCbor())
 			if err != nil {
 				return err
 			}
@@ -221,17 +211,12 @@ func (c *ChainSync) handleRollForward(msgGeneric protocol.Message) error {
 		return c.callbackConfig.RollForwardFunc(blockType, blockHeader)
 	} else {
 		msg := msgGeneric.(*MsgRollForwardNtC)
-		// Decode only enough to get the block type value
-		var wrappedBlock WrappedBlock
-		if _, err := utils.CborDecode(msg.WrappedData, &wrappedBlock); err != nil {
-			return fmt.Errorf("%s: decode error: %s", PROTOCOL_NAME, err)
-		}
-		blk, err := block.NewBlockFromCbor(wrappedBlock.Type, wrappedBlock.RawBlock)
+		blk, err := block.NewBlockFromCbor(msg.BlockType(), msg.BlockCbor())
 		if err != nil {
 			return err
 		}
 		// Call the user callback function
-		return c.callbackConfig.RollForwardFunc(wrappedBlock.Type, blk)
+		return c.callbackConfig.RollForwardFunc(msg.BlockType(), blk)
 	}
 }
 

protocol/chainsync/messages.go

@@ -88,35 +88,52 @@ func NewMsgAwaitReply() *MsgAwaitReply {
 
 type MsgRollForwardNtC struct {
 	protocol.MessageBase
-	WrappedData []byte
-	Tip         Tip
+	WrappedBlock cbor.Tag
+	Tip          Tip
+	blockType    uint
+	blockCbor    []byte
 }
 
-func NewMsgRollForwardNtC(wrappedData []byte, tip Tip) *MsgRollForwardNtC {
+func NewMsgRollForwardNtC(blockType uint, blockCbor []byte, tip Tip) *MsgRollForwardNtC {
 	m := &MsgRollForwardNtC{
 		MessageBase: protocol.MessageBase{
 			MessageType: MESSAGE_TYPE_ROLL_FORWARD,
 		},
-		WrappedData: wrappedData,
-		Tip:         tip,
+		Tip: tip,
+	}
+	wb := NewWrappedBlock(blockType, blockCbor)
+	content, err := cbor.Marshal(wb)
+	// TODO: figure out better way to handle error
+	if err != nil {
+		return nil
 	}
+	m.WrappedBlock = cbor.Tag{Number: 24, Content: content}
 	return m
 }
 
+func (m *MsgRollForwardNtC) BlockType() uint {
+	return m.blockType
+}
+
+func (m *MsgRollForwardNtC) BlockCbor() []byte {
+	return m.blockCbor
+}
+
 type MsgRollForwardNtN struct {
 	protocol.MessageBase
 	WrappedHeader WrappedHeader
 	Tip           Tip
 }
 
-func NewMsgRollForwardNtN(wrappedHeader WrappedHeader, tip Tip) *MsgRollForwardNtN {
+func NewMsgRollForwardNtN(era uint, byronType uint, blockCbor []byte, tip Tip) *MsgRollForwardNtN {
 	m := &MsgRollForwardNtN{
 		MessageBase: protocol.MessageBase{
 			MessageType: MESSAGE_TYPE_ROLL_FORWARD,
 		},
-		WrappedHeader: wrappedHeader,
-		Tip:           tip,
+		Tip: tip,
 	}
+	wrappedHeader := NewWrappedHeader(era, byronType, blockCbor)
+	m.WrappedHeader = *wrappedHeader
 	return m
 }
 
@@ -139,10 +156,10 @@ func NewMsgRollBackward(point Point, tip Tip) *MsgRollBackward {
 
 type MsgFindIntersect struct {
 	protocol.MessageBase
-	Points []interface{}
+	Points []Point
 }
 
-func NewMsgFindIntersect(points []interface{}) *MsgFindIntersect {
+func NewMsgFindIntersect(points []Point) *MsgFindIntersect {
 	m := &MsgFindIntersect{
 		MessageBase: protocol.MessageBase{
 			MessageType: MESSAGE_TYPE_FIND_INTERSECT,
@@ -205,6 +222,8 @@ type Tip struct {
 }
 
 type Point struct {
+	// Tells the CBOR decoder to convert to/from a struct and a CBOR array
+	_    struct{} `cbor:",toarray"`
 	Slot uint64
 	Hash []byte
 }
@@ -223,28 +242,13 @@ func (p *Point) UnmarshalCBOR(data []byte) error {
 	return nil
 }
 
-type WrappedBlock struct {
-	// Tells the CBOR decoder to convert to/from a struct and a CBOR array
-	_        struct{} `cbor:",toarray"`
-	Type     uint
-	RawBlock cbor.RawMessage
-}
-
-type WrappedHeader struct {
-	// Tells the CBOR decoder to convert to/from a struct and a CBOR array
-	_       struct{} `cbor:",toarray"`
-	Type    uint
-	RawData cbor.RawMessage
-}
-
-type WrappedHeaderByron struct {
-	// Tells the CBOR decoder to convert to/from a struct and a CBOR array
-	_       struct{} `cbor:",toarray"`
-	Unknown struct {
-		// Tells the CBOR decoder to convert to/from a struct and a CBOR array
-		_       struct{} `cbor:",toarray"`
-		Type    uint
-		Unknown uint64
-	}
-	RawHeader []byte
+func (p *Point) MarshalCBOR() ([]byte, error) {
+	var data []interface{}
+	if p.Slot == 0 && p.Hash == nil {
+		// Return an empty list if values are zero
+		data = make([]interface{}, 0)
+	} else {
+		data = []interface{}{p.Slot, p.Hash}
+	}
+	return utils.CborEncode(data)
 }