Merge pull request #56 from cloudstruct/feature/embed-protocol

agaffney · web-flow · commit 04c9d72bb0ff · 2022-04-01T14:20:26.000-05:00
Embed Protocol object in mini-protocol objects
diff --git a/protocol/blockfetch/blockfetch.go b/protocol/blockfetch/blockfetch.go
@@ -65,7 +65,7 @@ var StateMap = protocol.StateMap{
 }
 
 type BlockFetch struct {
-	proto          *protocol.Protocol
+	*protocol.Protocol
 	callbackConfig *BlockFetchCallbackConfig
 }
 
@@ -98,7 +98,7 @@ func New(options protocol.ProtocolOptions, callbackConfig *BlockFetchCallbackCon
 		StateMap:            StateMap,
 		InitialState:        STATE_IDLE,
 	}
-	b.proto = protocol.New(protoConfig)
+	b.Protocol = protocol.New(protoConfig)
 	return b
 }
 
@@ -121,12 +121,12 @@ func (b *BlockFetch) messageHandler(msg protocol.Message, isResponse bool) error
 
 func (b *BlockFetch) RequestRange(start []interface{}, end []interface{}) error {
 	msg := NewMsgRequestRange(start, end)
-	return b.proto.SendMessage(msg, false)
+	return b.SendMessage(msg, false)
 }
 
 func (b *BlockFetch) ClientDone() error {
 	msg := NewMsgClientDone()
-	return b.proto.SendMessage(msg, false)
+	return b.SendMessage(msg, false)
 }
 
 func (b *BlockFetch) handleStartBatch() error {
diff --git a/protocol/chainsync/chainsync.go b/protocol/chainsync/chainsync.go
@@ -88,7 +88,7 @@ var StateMap = protocol.StateMap{
 }
 
 type ChainSync struct {
-	proto          *protocol.Protocol
+	*protocol.Protocol
 	callbackConfig *ChainSyncCallbackConfig
 }
 
@@ -133,7 +133,7 @@ func New(options protocol.ProtocolOptions, callbackConfig *ChainSyncCallbackConf
 		StateMap:            StateMap,
 		InitialState:        STATE_IDLE,
 	}
-	c.proto = protocol.New(protoConfig)
+	c.Protocol = protocol.New(protoConfig)
 	return c
 }
 
@@ -160,12 +160,12 @@ func (c *ChainSync) messageHandler(msg protocol.Message, isResponse bool) error
 
 func (c *ChainSync) RequestNext() error {
 	msg := NewMsgRequestNext()
-	return c.proto.SendMessage(msg, false)
+	return c.SendMessage(msg, false)
 }
 
 func (c *ChainSync) FindIntersect(points []interface{}) error {
 	msg := NewMsgFindIntersect(points)
-	return c.proto.SendMessage(msg, false)
+	return c.SendMessage(msg, false)
 }
 
 func (c *ChainSync) handleAwaitReply() error {
@@ -180,7 +180,7 @@ func (c *ChainSync) handleRollForward(msgGeneric protocol.Message) error {
 	if c.callbackConfig.RollForwardFunc == nil {
 		return fmt.Errorf("received chain-sync RollForward message but no callback function is defined")
 	}
-	if c.proto.Mode() == protocol.ProtocolModeNodeToNode {
+	if c.Mode() == protocol.ProtocolModeNodeToNode {
 		msg := msgGeneric.(*MsgRollForwardNtN)
 		var blockHeader interface{}
 		var blockType uint
diff --git a/protocol/handshake/handshake.go b/protocol/handshake/handshake.go
@@ -48,7 +48,7 @@ var StateMap = protocol.StateMap{
 }
 
 type Handshake struct {
-	proto           *protocol.Protocol
+	*protocol.Protocol
 	allowedVersions []uint16
 	Version         uint16
 	Finished        chan bool
@@ -71,7 +71,7 @@ func New(options protocol.ProtocolOptions, allowedVersions []uint16) *Handshake
 		StateMap:            StateMap,
 		InitialState:        STATE_PROPOSE,
 	}
-	h.proto = protocol.New(protoConfig)
+	h.Protocol = protocol.New(protoConfig)
 	return h
 }
 
@@ -94,14 +94,14 @@ func (h *Handshake) ProposeVersions(versions []uint16, networkMagic uint32) erro
 	// Create our request
 	versionMap := make(map[uint16]interface{})
 	for _, version := range versions {
-		if h.proto.Mode() == protocol.ProtocolModeNodeToNode {
+		if h.Mode() == protocol.ProtocolModeNodeToNode {
 			versionMap[version] = []interface{}{networkMagic, DIFFUSION_MODE_INITIATOR_ONLY}
 		} else {
 			versionMap[version] = networkMagic
 		}
 	}
 	msg := NewMsgProposeVersions(versionMap)
-	return h.proto.SendMessage(msg, false)
+	return h.SendMessage(msg, false)
 }
 
 func (h *Handshake) handleProposeVersions(msgGeneric protocol.Message) error {
@@ -121,7 +121,7 @@ func (h *Handshake) handleProposeVersions(msgGeneric protocol.Message) error {
 	}
 	if highestVersion > 0 {
 		resp := NewMsgAcceptVersion(highestVersion, versionData)
-		if err := h.proto.SendMessage(resp, true); err != nil {
+		if err := h.SendMessage(resp, true); err != nil {
 			return err
 		}
 		h.Version = highestVersion
diff --git a/protocol/keepalive/keepalive.go b/protocol/keepalive/keepalive.go
@@ -49,7 +49,7 @@ var StateMap = protocol.StateMap{
 }
 
 type KeepAlive struct {
-	proto          *protocol.Protocol
+	*protocol.Protocol
 	callbackConfig *KeepAliveCallbackConfig
 	timer          *time.Timer
 }
@@ -81,7 +81,7 @@ func New(options protocol.ProtocolOptions, callbackConfig *KeepAliveCallbackConf
 		StateMap:            StateMap,
 		InitialState:        STATE_CLIENT,
 	}
-	k.proto = protocol.New(protoConfig)
+	k.Protocol = protocol.New(protoConfig)
 	return k
 }
 
@@ -103,7 +103,7 @@ func (k *KeepAlive) messageHandler(msg protocol.Message, isResponse bool) error
 func (k *KeepAlive) Start() {
 	k.timer = time.AfterFunc(KEEP_ALIVE_PERIOD*time.Second, func() {
 		if err := k.KeepAlive(0); err != nil {
-			k.proto.SendError(err)
+			k.SendError(err)
 		}
 	})
 }
@@ -118,7 +118,7 @@ func (k *KeepAlive) Stop() {
 
 func (k *KeepAlive) KeepAlive(cookie uint16) error {
 	msg := NewMsgKeepAlive(cookie)
-	return k.proto.SendMessage(msg, false)
+	return k.SendMessage(msg, false)
 }
 
 func (k *KeepAlive) handleKeepAlive(msgGeneric protocol.Message) error {
@@ -129,7 +129,7 @@ func (k *KeepAlive) handleKeepAlive(msgGeneric protocol.Message) error {
 	} else {
 		// Send the keep-alive response
 		resp := NewMsgKeepAliveResponse(msg.Cookie)
-		return k.proto.SendMessage(resp, true)
+		return k.SendMessage(resp, true)
 	}
 }
 
diff --git a/protocol/localstatequery/localstatequery.go b/protocol/localstatequery/localstatequery.go
@@ -85,7 +85,7 @@ var StateMap = protocol.StateMap{
 }
 
 type LocalStateQuery struct {
-	proto          *protocol.Protocol
+	*protocol.Protocol
 	callbackConfig *CallbackConfig
 }
 
@@ -127,7 +127,7 @@ func New(options protocol.ProtocolOptions, callbackConfig *CallbackConfig) *Loca
 		StateMap:            StateMap,
 		InitialState:        STATE_IDLE,
 	}
-	l.proto = protocol.New(protoConfig)
+	l.Protocol = protocol.New(protoConfig)
 	return l
 }
 
diff --git a/protocol/localtxsubmission/localtxsubmission.go b/protocol/localtxsubmission/localtxsubmission.go
@@ -45,7 +45,7 @@ var StateMap = protocol.StateMap{
 }
 
 type LocalTxSubmission struct {
-	proto          *protocol.Protocol
+	*protocol.Protocol
 	callbackConfig *CallbackConfig
 }
 
@@ -78,7 +78,7 @@ func New(options protocol.ProtocolOptions, callbackConfig *CallbackConfig) *Loca
 		StateMap:            StateMap,
 		InitialState:        STATE_IDLE,
 	}
-	l.proto = protocol.New(protoConfig)
+	l.Protocol = protocol.New(protoConfig)
 	return l
 }
 
@@ -101,12 +101,12 @@ func (l *LocalTxSubmission) messageHandler(msg protocol.Message, isResponse bool
 
 func (l *LocalTxSubmission) SubmitTx(eraId uint16, tx []byte) error {
 	msg := NewMsgSubmitTx(eraId, tx)
-	return l.proto.SendMessage(msg, false)
+	return l.SendMessage(msg, false)
 }
 
 func (l *LocalTxSubmission) Done(tx interface{}) error {
 	msg := NewMsgDone()
-	return l.proto.SendMessage(msg, false)
+	return l.SendMessage(msg, false)
 }
 
 func (l *LocalTxSubmission) handleSubmitTx(msgGeneric protocol.Message) error {
diff --git a/protocol/txsubmission/txsubmission.go b/protocol/txsubmission/txsubmission.go
@@ -89,7 +89,7 @@ var StateMap = protocol.StateMap{
 }
 
 type TxSubmission struct {
-	proto          *protocol.Protocol
+	*protocol.Protocol
 	callbackConfig *CallbackConfig
 }
 
@@ -126,7 +126,7 @@ func New(options protocol.ProtocolOptions, callbackConfig *CallbackConfig) *TxSu
 		StateMap:            StateMap,
 		InitialState:        STATE_HELLO,
 	}
-	t.proto = protocol.New(protoConfig)
+	t.Protocol = protocol.New(protoConfig)
 	return t
 }
 

Original file line number	Diff line number	Diff line change
`@@ -65,7 +65,7 @@ var StateMap = protocol.StateMap{`
`65`	`65`	`}`
`66`	`66`
`67`	`67`	`type BlockFetch struct {`
`68`		`- proto *protocol.Protocol`
	`68`	`+ *protocol.Protocol`
`69`	`69`	`callbackConfig *BlockFetchCallbackConfig`
`70`	`70`	`}`
`71`	`71`
`@@ -98,7 +98,7 @@ func New(options protocol.ProtocolOptions, callbackConfig *BlockFetchCallbackCon`
`98`	`98`	`StateMap: StateMap,`
`99`	`99`	`InitialState: STATE_IDLE,`
`100`	`100`	`}`
`101`		`- b.proto = protocol.New(protoConfig)`
	`101`	`+ b.Protocol = protocol.New(protoConfig)`
`102`	`102`	`return b`
`103`	`103`	`}`
`104`	`104`
`@@ -121,12 +121,12 @@ func (b *BlockFetch) messageHandler(msg protocol.Message, isResponse bool) error`
`121`	`121`
`122`	`122`	`func (b *BlockFetch) RequestRange(start []interface{}, end []interface{}) error {`
`123`	`123`	`msg := NewMsgRequestRange(start, end)`
`124`		`- return b.proto.SendMessage(msg, false)`
	`124`	`+ return b.SendMessage(msg, false)`
`125`	`125`	`}`
`126`	`126`
`127`	`127`	`func (b *BlockFetch) ClientDone() error {`
`128`	`128`	`msg := NewMsgClientDone()`
`129`		`- return b.proto.SendMessage(msg, false)`
	`129`	`+ return b.SendMessage(msg, false)`
`130`	`130`	`}`
`131`	`131`
`132`	`132`	`func (b *BlockFetch) handleStartBatch() error {`
Original file line number	Diff line number	Diff line change
`@@ -88,7 +88,7 @@ var StateMap = protocol.StateMap{`
`88`	`88`	`}`
`89`	`89`
`90`	`90`	`type ChainSync struct {`
`91`		`- proto *protocol.Protocol`
	`91`	`+ *protocol.Protocol`
`92`	`92`	`callbackConfig *ChainSyncCallbackConfig`
`93`	`93`	`}`
`94`	`94`
`@@ -133,7 +133,7 @@ func New(options protocol.ProtocolOptions, callbackConfig *ChainSyncCallbackConf`
`133`	`133`	`StateMap: StateMap,`
`134`	`134`	`InitialState: STATE_IDLE,`
`135`	`135`	`}`
`136`		`- c.proto = protocol.New(protoConfig)`
	`136`	`+ c.Protocol = protocol.New(protoConfig)`
`137`	`137`	`return c`
`138`	`138`	`}`
`139`	`139`
`@@ -160,12 +160,12 @@ func (c *ChainSync) messageHandler(msg protocol.Message, isResponse bool) error`
`160`	`160`
`161`	`161`	`func (c *ChainSync) RequestNext() error {`
`162`	`162`	`msg := NewMsgRequestNext()`
`163`		`- return c.proto.SendMessage(msg, false)`
	`163`	`+ return c.SendMessage(msg, false)`
`164`	`164`	`}`
`165`	`165`
`166`	`166`	`func (c *ChainSync) FindIntersect(points []interface{}) error {`
`167`	`167`	`msg := NewMsgFindIntersect(points)`
`168`		`- return c.proto.SendMessage(msg, false)`
	`168`	`+ return c.SendMessage(msg, false)`
`169`	`169`	`}`
`170`	`170`
`171`	`171`	`func (c *ChainSync) handleAwaitReply() error {`
`@@ -180,7 +180,7 @@ func (c *ChainSync) handleRollForward(msgGeneric protocol.Message) error {`
`180`	`180`	`if c.callbackConfig.RollForwardFunc == nil {`
`181`	`181`	`return fmt.Errorf("received chain-sync RollForward message but no callback function is defined")`
`182`	`182`	`}`
`183`		`- if c.proto.Mode() == protocol.ProtocolModeNodeToNode {`
	`183`	`+ if c.Mode() == protocol.ProtocolModeNodeToNode {`
`184`	`184`	`msg := msgGeneric.(*MsgRollForwardNtN)`
`185`	`185`	`var blockHeader interface{}`
`186`	`186`	`var blockType uint`
Original file line number	Diff line number	Diff line change
`@@ -48,7 +48,7 @@ var StateMap = protocol.StateMap{`
`48`	`48`	`}`
`49`	`49`
`50`	`50`	`type Handshake struct {`
`51`		`- proto *protocol.Protocol`
	`51`	`+ *protocol.Protocol`
`52`	`52`	`allowedVersions []uint16`
`53`	`53`	`Version uint16`
`54`	`54`	`Finished chan bool`
`@@ -71,7 +71,7 @@ func New(options protocol.ProtocolOptions, allowedVersions []uint16) *Handshake`
`71`	`71`	`StateMap: StateMap,`
`72`	`72`	`InitialState: STATE_PROPOSE,`
`73`	`73`	`}`
`74`		`- h.proto = protocol.New(protoConfig)`
	`74`	`+ h.Protocol = protocol.New(protoConfig)`
`75`	`75`	`return h`
`76`	`76`	`}`
`77`	`77`
`@@ -94,14 +94,14 @@ func (h *Handshake) ProposeVersions(versions []uint16, networkMagic uint32) erro`
`94`	`94`	`// Create our request`
`95`	`95`	`versionMap := make(map[uint16]interface{})`
`96`	`96`	`for _, version := range versions {`
`97`		`- if h.proto.Mode() == protocol.ProtocolModeNodeToNode {`
	`97`	`+ if h.Mode() == protocol.ProtocolModeNodeToNode {`
`98`	`98`	`versionMap[version] = []interface{}{networkMagic, DIFFUSION_MODE_INITIATOR_ONLY}`
`99`	`99`	`} else {`
`100`	`100`	`versionMap[version] = networkMagic`
`101`	`101`	`}`
`102`	`102`	`}`
`103`	`103`	`msg := NewMsgProposeVersions(versionMap)`
`104`		`- return h.proto.SendMessage(msg, false)`
	`104`	`+ return h.SendMessage(msg, false)`
`105`	`105`	`}`
`106`	`106`
`107`	`107`	`func (h *Handshake) handleProposeVersions(msgGeneric protocol.Message) error {`
`@@ -121,7 +121,7 @@ func (h *Handshake) handleProposeVersions(msgGeneric protocol.Message) error {`
`121`	`121`	`}`
`122`	`122`	`if highestVersion > 0 {`
`123`	`123`	`resp := NewMsgAcceptVersion(highestVersion, versionData)`
`124`		`- if err := h.proto.SendMessage(resp, true); err != nil {`
	`124`	`+ if err := h.SendMessage(resp, true); err != nil {`
`125`	`125`	`return err`
`126`	`126`	`}`
`127`	`127`	`h.Version = highestVersion`
Original file line number	Diff line number	Diff line change
`@@ -49,7 +49,7 @@ var StateMap = protocol.StateMap{`
`49`	`49`	`}`
`50`	`50`
`51`	`51`	`type KeepAlive struct {`
`52`		`- proto *protocol.Protocol`
	`52`	`+ *protocol.Protocol`
`53`	`53`	`callbackConfig *KeepAliveCallbackConfig`
`54`	`54`	`timer *time.Timer`
`55`	`55`	`}`
`@@ -81,7 +81,7 @@ func New(options protocol.ProtocolOptions, callbackConfig *KeepAliveCallbackConf`
`81`	`81`	`StateMap: StateMap,`
`82`	`82`	`InitialState: STATE_CLIENT,`
`83`	`83`	`}`
`84`		`- k.proto = protocol.New(protoConfig)`
	`84`	`+ k.Protocol = protocol.New(protoConfig)`
`85`	`85`	`return k`
`86`	`86`	`}`
`87`	`87`
`@@ -103,7 +103,7 @@ func (k *KeepAlive) messageHandler(msg protocol.Message, isResponse bool) error`
`103`	`103`	`func (k *KeepAlive) Start() {`
`104`	`104`	`k.timer = time.AfterFunc(KEEP_ALIVE_PERIOD*time.Second, func() {`
`105`	`105`	`if err := k.KeepAlive(0); err != nil {`
`106`		`- k.proto.SendError(err)`
	`106`	`+ k.SendError(err)`
`107`	`107`	`}`
`108`	`108`	`})`
`109`	`109`	`}`
`@@ -118,7 +118,7 @@ func (k *KeepAlive) Stop() {`
`118`	`118`
`119`	`119`	`func (k *KeepAlive) KeepAlive(cookie uint16) error {`
`120`	`120`	`msg := NewMsgKeepAlive(cookie)`
`121`		`- return k.proto.SendMessage(msg, false)`
	`121`	`+ return k.SendMessage(msg, false)`
`122`	`122`	`}`
`123`	`123`
`124`	`124`	`func (k *KeepAlive) handleKeepAlive(msgGeneric protocol.Message) error {`
`@@ -129,7 +129,7 @@ func (k *KeepAlive) handleKeepAlive(msgGeneric protocol.Message) error {`
`129`	`129`	`} else {`
`130`	`130`	`// Send the keep-alive response`
`131`	`131`	`resp := NewMsgKeepAliveResponse(msg.Cookie)`
`132`		`- return k.proto.SendMessage(resp, true)`
	`132`	`+ return k.SendMessage(resp, true)`
`133`	`133`	`}`
`134`	`134`	`}`
`135`	`135`
Original file line number	Diff line number	Diff line change
`@@ -85,7 +85,7 @@ var StateMap = protocol.StateMap{`
`85`	`85`	`}`
`86`	`86`
`87`	`87`	`type LocalStateQuery struct {`
`88`		`- proto *protocol.Protocol`
	`88`	`+ *protocol.Protocol`
`89`	`89`	`callbackConfig *CallbackConfig`
`90`	`90`	`}`
`91`	`91`
`@@ -127,7 +127,7 @@ func New(options protocol.ProtocolOptions, callbackConfig CallbackConfig) Loca`
`127`	`127`	`StateMap: StateMap,`
`128`	`128`	`InitialState: STATE_IDLE,`
`129`	`129`	`}`
`130`		`- l.proto = protocol.New(protoConfig)`
	`130`	`+ l.Protocol = protocol.New(protoConfig)`
`131`	`131`	`return l`
`132`	`132`	`}`
`133`	`133`
Original file line number	Diff line number	Diff line change
`@@ -45,7 +45,7 @@ var StateMap = protocol.StateMap{`
`45`	`45`	`}`
`46`	`46`
`47`	`47`	`type LocalTxSubmission struct {`
`48`		`- proto *protocol.Protocol`
	`48`	`+ *protocol.Protocol`
`49`	`49`	`callbackConfig *CallbackConfig`
`50`	`50`	`}`
`51`	`51`
`@@ -78,7 +78,7 @@ func New(options protocol.ProtocolOptions, callbackConfig CallbackConfig) Loca`
`78`	`78`	`StateMap: StateMap,`
`79`	`79`	`InitialState: STATE_IDLE,`
`80`	`80`	`}`
`81`		`- l.proto = protocol.New(protoConfig)`
	`81`	`+ l.Protocol = protocol.New(protoConfig)`
`82`	`82`	`return l`
`83`	`83`	`}`
`84`	`84`
`@@ -101,12 +101,12 @@ func (l *LocalTxSubmission) messageHandler(msg protocol.Message, isResponse bool`
`101`	`101`
`102`	`102`	`func (l *LocalTxSubmission) SubmitTx(eraId uint16, tx []byte) error {`
`103`	`103`	`msg := NewMsgSubmitTx(eraId, tx)`
`104`		`- return l.proto.SendMessage(msg, false)`
	`104`	`+ return l.SendMessage(msg, false)`
`105`	`105`	`}`
`106`	`106`
`107`	`107`	`func (l *LocalTxSubmission) Done(tx interface{}) error {`
`108`	`108`	`msg := NewMsgDone()`
`109`		`- return l.proto.SendMessage(msg, false)`
	`109`	`+ return l.SendMessage(msg, false)`
`110`	`110`	`}`
`111`	`111`
`112`	`112`	`func (l *LocalTxSubmission) handleSubmitTx(msgGeneric protocol.Message) error {`
Original file line number	Diff line number	Diff line change
`@@ -89,7 +89,7 @@ var StateMap = protocol.StateMap{`
`89`	`89`	`}`
`90`	`90`
`91`	`91`	`type TxSubmission struct {`
`92`		`- proto *protocol.Protocol`
	`92`	`+ *protocol.Protocol`
`93`	`93`	`callbackConfig *CallbackConfig`
`94`	`94`	`}`
`95`	`95`
`@@ -126,7 +126,7 @@ func New(options protocol.ProtocolOptions, callbackConfig CallbackConfig) TxSu`
`126`	`126`	`StateMap: StateMap,`
`127`	`127`	`InitialState: STATE_HELLO,`
`128`	`128`	`}`
`129`		`- t.proto = protocol.New(protoConfig)`
	`129`	`+ t.Protocol = protocol.New(protoConfig)`
`130`	`130`	`return t`
`131`	`131`	`}`
`132`	`132`