Skip to content

Commit d838151

Browse files
agaffneyagaffney
authored
Merge pull request #34 from cloudstruct/feature/refactor-expose-protocols
Minor refactor to make library more composable
2 parents 88740b0 + 93d9413 commit d838151

File tree

10 files changed

+147
-137
lines changed

10 files changed

+147
-137
lines changed

‎protocol/blockfetch/blockfetch.go‎

Lines changed: 9 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -19,7 +19,7 @@ var (
1919
STATE_DONE = protocol.NewState(4, "Done")
2020
)
2121

22-
var stateMap = protocol.StateMap{
22+
var StateMap = protocol.StateMap{
2323
STATE_IDLE: protocol.StateMapEntry{
2424
Agency: protocol.AGENCY_CLIENT,
2525
Transitions: []protocol.StateTransition{
@@ -95,7 +95,7 @@ func New(options protocol.ProtocolOptions, callbackConfig *BlockFetchCallbackCon
9595
Role: options.Role,
9696
MessageHandlerFunc: b.messageHandler,
9797
MessageFromCborFunc: NewMsgFromCbor,
98-
StateMap: stateMap,
98+
StateMap: StateMap,
9999
InitialState: STATE_IDLE,
100100
}
101101
b.proto = protocol.New(protoConfig)
@@ -120,12 +120,12 @@ func (b *BlockFetch) messageHandler(msg protocol.Message) error {
120120
}
121121

122122
func (b *BlockFetch) RequestRange(start []interface{}, end []interface{}) error {
123-
msg := newMsgRequestRange(start, end)
123+
msg := NewMsgRequestRange(start, end)
124124
return b.proto.SendMessage(msg, false)
125125
}
126126

127127
func (b *BlockFetch) ClientDone() error {
128-
msg := newMsgClientDone()
128+
msg := NewMsgClientDone()
129129
return b.proto.SendMessage(msg, false)
130130
}
131131

@@ -149,18 +149,18 @@ func (b *BlockFetch) handleBlock(msgGeneric protocol.Message) error {
149149
if b.callbackConfig.BlockFunc == nil {
150150
return fmt.Errorf("received block-fetch Block message but no callback function is defined")
151151
}
152-
msg := msgGeneric.(*msgBlock)
152+
msg := msgGeneric.(*MsgBlock)
153153
// Decode only enough to get the block type value
154-
var wrapBlock wrappedBlock
155-
if _, err := utils.CborDecode(msg.WrappedBlock, &wrapBlock); err != nil {
154+
var wrappedBlock WrappedBlock
155+
if _, err := utils.CborDecode(msg.WrappedBlock, &wrappedBlock); err != nil {
156156
return fmt.Errorf("%s: decode error: %s", PROTOCOL_NAME, err)
157157
}
158-
blk, err := block.NewBlockFromCbor(wrapBlock.Type, wrapBlock.RawBlock)
158+
blk, err := block.NewBlockFromCbor(wrappedBlock.Type, wrappedBlock.RawBlock)
159159
if err != nil {
160160
return err
161161
}
162162
// Call the user callback function
163-
return b.callbackConfig.BlockFunc(wrapBlock.Type, blk)
163+
return b.callbackConfig.BlockFunc(wrappedBlock.Type, blk)
164164
}
165165

166166
func (b *BlockFetch) handleBatchDone() error {

‎protocol/blockfetch/messages.go‎

Lines changed: 17 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -20,17 +20,17 @@ func NewMsgFromCbor(msgType uint, data []byte) (protocol.Message, error) {
2020
var ret protocol.Message
2121
switch msgType {
2222
case MESSAGE_TYPE_REQUEST_RANGE:
23-
ret = &msgRequestRange{}
23+
ret = &MsgRequestRange{}
2424
case MESSAGE_TYPE_CLIENT_DONE:
25-
ret = &msgClientDone{}
25+
ret = &MsgClientDone{}
2626
case MESSAGE_TYPE_START_BATCH:
27-
ret = &msgStartBatch{}
27+
ret = &MsgStartBatch{}
2828
case MESSAGE_TYPE_NO_BLOCKS:
29-
ret = &msgNoBlocks{}
29+
ret = &MsgNoBlocks{}
3030
case MESSAGE_TYPE_BLOCK:
31-
ret = &msgBlock{}
31+
ret = &MsgBlock{}
3232
case MESSAGE_TYPE_BATCH_DONE:
33-
ret = &msgBatchDone{}
33+
ret = &MsgBatchDone{}
3434
}
3535
if _, err := utils.CborDecode(data, ret); err != nil {
3636
return nil, fmt.Errorf("%s: decode error: %s", PROTOCOL_NAME, err)
@@ -42,14 +42,14 @@ func NewMsgFromCbor(msgType uint, data []byte) (protocol.Message, error) {
4242
return ret, nil
4343
}
4444

45-
type msgRequestRange struct {
45+
type MsgRequestRange struct {
4646
protocol.MessageBase
4747
Start interface{} //point
4848
End interface{} //point
4949
}
5050

51-
func newMsgRequestRange(start interface{}, end interface{}) *msgRequestRange {
52-
m := &msgRequestRange{
51+
func NewMsgRequestRange(start interface{}, end interface{}) *MsgRequestRange {
52+
m := &MsgRequestRange{
5353
MessageBase: protocol.MessageBase{
5454
MessageType: MESSAGE_TYPE_REQUEST_RANGE,
5555
},
@@ -59,33 +59,33 @@ func newMsgRequestRange(start interface{}, end interface{}) *msgRequestRange {
5959
return m
6060
}
6161

62-
type msgClientDone struct {
62+
type MsgClientDone struct {
6363
protocol.MessageBase
6464
}
6565

66-
func newMsgClientDone() *msgClientDone {
67-
m := &msgClientDone{
66+
func NewMsgClientDone() *MsgClientDone {
67+
m := &MsgClientDone{
6868
MessageBase: protocol.MessageBase{
6969
MessageType: MESSAGE_TYPE_CLIENT_DONE,
7070
},
7171
}
7272
return m
7373
}
7474

75-
type msgStartBatch struct {
75+
type MsgStartBatch struct {
7676
protocol.MessageBase
7777
}
7878

79-
type msgNoBlocks struct {
79+
type MsgNoBlocks struct {
8080
protocol.MessageBase
8181
}
8282

83-
type msgBlock struct {
83+
type MsgBlock struct {
8484
protocol.MessageBase
8585
WrappedBlock []byte
8686
}
8787

88-
type msgBatchDone struct {
88+
type MsgBatchDone struct {
8989
protocol.MessageBase
9090
}
9191

@@ -97,7 +97,7 @@ type point struct {
9797
}
9898
*/
9999

100-
type wrappedBlock struct {
100+
type WrappedBlock struct {
101101
// Tells the CBOR decoder to convert to/from a struct and a CBOR array
102102
_ struct{} `cbor:",toarray"`
103103
Type uint

‎protocol/chainsync/chainsync.go‎

Lines changed: 20 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -21,7 +21,7 @@ var (
2121
STATE_DONE = protocol.NewState(5, "Done")
2222
)
2323

24-
var stateMap = protocol.StateMap{
24+
var StateMap = protocol.StateMap{
2525
STATE_IDLE: protocol.StateMapEntry{
2626
Agency: protocol.AGENCY_CLIENT,
2727
Transitions: []protocol.StateTransition{
@@ -112,9 +112,11 @@ type ChainSyncDoneFunc func() error
112112
func New(options protocol.ProtocolOptions, callbackConfig *ChainSyncCallbackConfig) *ChainSync {
113113
// Use node-to-client protocol ID
114114
protocolId := PROTOCOL_ID_NTC
115+
msgFromCborFunc := NewMsgFromCborNtC
115116
if options.Mode == protocol.ProtocolModeNodeToNode {
116117
// Use node-to-node protocol ID
117118
protocolId = PROTOCOL_ID_NTN
119+
msgFromCborFunc = NewMsgFromCborNtN
118120
}
119121
c := &ChainSync{
120122
callbackConfig: callbackConfig,
@@ -127,8 +129,8 @@ func New(options protocol.ProtocolOptions, callbackConfig *ChainSyncCallbackConf
127129
Mode: options.Mode,
128130
Role: options.Role,
129131
MessageHandlerFunc: c.messageHandler,
130-
MessageFromCborFunc: c.NewMsgFromCbor,
131-
StateMap: stateMap,
132+
MessageFromCborFunc: msgFromCborFunc,
133+
StateMap: StateMap,
132134
InitialState: STATE_IDLE,
133135
}
134136
c.proto = protocol.New(protoConfig)
@@ -157,12 +159,12 @@ func (c *ChainSync) messageHandler(msg protocol.Message) error {
157159
}
158160

159161
func (c *ChainSync) RequestNext() error {
160-
msg := newMsgRequestNext()
162+
msg := NewMsgRequestNext()
161163
return c.proto.SendMessage(msg, false)
162164
}
163165

164166
func (c *ChainSync) FindIntersect(points []interface{}) error {
165-
msg := newMsgFindIntersect(points)
167+
msg := NewMsgFindIntersect(points)
166168
return c.proto.SendMessage(msg, false)
167169
}
168170

@@ -179,19 +181,19 @@ func (c *ChainSync) handleRollForward(msgGeneric protocol.Message) error {
179181
return fmt.Errorf("received chain-sync RollForward message but no callback function is defined")
180182
}
181183
if c.proto.Mode() == protocol.ProtocolModeNodeToNode {
182-
msg := msgGeneric.(*msgRollForwardNtN)
184+
msg := msgGeneric.(*MsgRollForwardNtN)
183185
var blockHeader interface{}
184186
var blockType uint
185187
blockHeaderType := msg.WrappedHeader.Type
186188
switch blockHeaderType {
187189
case block.BLOCK_HEADER_TYPE_BYRON:
188-
var wrapHeaderByron wrappedHeaderByron
189-
if _, err := utils.CborDecode(msg.WrappedHeader.RawData, &wrapHeaderByron); err != nil {
190+
var wrappedHeaderByron WrappedHeaderByron
191+
if _, err := utils.CborDecode(msg.WrappedHeader.RawData, &wrappedHeaderByron); err != nil {
190192
return fmt.Errorf("%s: decode error: %s", PROTOCOL_NAME, err)
191193
}
192-
blockType = wrapHeaderByron.Unknown.Type
194+
blockType = wrappedHeaderByron.Unknown.Type
193195
var err error
194-
blockHeader, err = block.NewBlockHeaderFromCbor(blockType, wrapHeaderByron.RawHeader)
196+
blockHeader, err = block.NewBlockHeaderFromCbor(blockType, wrappedHeaderByron.RawHeader)
195197
if err != nil {
196198
return err
197199
}
@@ -218,26 +220,26 @@ func (c *ChainSync) handleRollForward(msgGeneric protocol.Message) error {
218220
// Call the user callback function
219221
return c.callbackConfig.RollForwardFunc(blockType, blockHeader)
220222
} else {
221-
msg := msgGeneric.(*msgRollForwardNtC)
223+
msg := msgGeneric.(*MsgRollForwardNtC)
222224
// Decode only enough to get the block type value
223-
var wrapBlock wrappedBlock
224-
if _, err := utils.CborDecode(msg.WrappedData, &wrapBlock); err != nil {
225+
var wrappedBlock WrappedBlock
226+
if _, err := utils.CborDecode(msg.WrappedData, &wrappedBlock); err != nil {
225227
return fmt.Errorf("%s: decode error: %s", PROTOCOL_NAME, err)
226228
}
227-
blk, err := block.NewBlockFromCbor(wrapBlock.Type, wrapBlock.RawBlock)
229+
blk, err := block.NewBlockFromCbor(wrappedBlock.Type, wrappedBlock.RawBlock)
228230
if err != nil {
229231
return err
230232
}
231233
// Call the user callback function
232-
return c.callbackConfig.RollForwardFunc(wrapBlock.Type, blk)
234+
return c.callbackConfig.RollForwardFunc(wrappedBlock.Type, blk)
233235
}
234236
}
235237

236238
func (c *ChainSync) handleRollBackward(msgGeneric protocol.Message) error {
237239
if c.callbackConfig.RollBackwardFunc == nil {
238240
return fmt.Errorf("received chain-sync RollBackward message but no callback function is defined")
239241
}
240-
msg := msgGeneric.(*msgRollBackward)
242+
msg := msgGeneric.(*MsgRollBackward)
241243
// Call the user callback function
242244
return c.callbackConfig.RollBackwardFunc(msg.Point, msg.Tip)
243245
}
@@ -246,7 +248,7 @@ func (c *ChainSync) handleIntersectFound(msgGeneric protocol.Message) error {
246248
if c.callbackConfig.IntersectFoundFunc == nil {
247249
return fmt.Errorf("received chain-sync IntersectFound message but no callback function is defined")
248250
}
249-
msg := msgGeneric.(*msgIntersectFound)
251+
msg := msgGeneric.(*MsgIntersectFound)
250252
// Call the user callback function
251253
return c.callbackConfig.IntersectFoundFunc(msg.Point, msg.Tip)
252254
}
@@ -255,7 +257,7 @@ func (c *ChainSync) handleIntersectNotFound(msgGeneric protocol.Message) error {
255257
if c.callbackConfig.IntersectNotFoundFunc == nil {
256258
return fmt.Errorf("received chain-sync IntersectNotFound message but no callback function is defined")
257259
}
258-
msg := msgGeneric.(*msgIntersectNotFound)
260+
msg := msgGeneric.(*MsgIntersectNotFound)
259261
// Call the user callback function
260262
return c.callbackConfig.IntersectNotFoundFunc(msg.Tip)
261263
}

0 commit comments

Comments
 (0)