blockfetch

Documentation

Index

• Constants
• Variables
• func NewMsgFromCbor(msgType uint, data []byte) (protocol.Message, error)
• type BatchDoneFunc
• type BlockFetch
  • func New(protoOptions protocol.ProtocolOptions, cfg *Config) *BlockFetch
• type BlockFunc
• type Client
  • func NewClient(protoOptions protocol.ProtocolOptions, cfg *Config) *Client
  • func (c *Client) ClientDone() error
  • func (c *Client) RequestRange(start []interface{}, end []interface{}) error
• type Config
• type MsgBatchDone
  • func NewMsgBatchDone() *MsgBatchDone
• type MsgBlock
  • func NewMsgBlock(wrappedBlock []byte) *MsgBlock
• type MsgClientDone
  • func NewMsgClientDone() *MsgClientDone
• type MsgNoBlocks
  • func NewMsgNoBlocks() *MsgNoBlocks
• type MsgRequestRange
  • func NewMsgRequestRange(start interface{}, end interface{}) *MsgRequestRange
• type MsgStartBatch
  • func NewMsgStartBatch() *MsgStartBatch
• type NoBlocksFunc
• type Server
  • func NewServer(protoOptions protocol.ProtocolOptions, cfg *Config) *Server
• type StartBatchFunc
• type WrappedBlock

Constants

const (
	PROTOCOL_NAME        = "block-fetch"
	PROTOCOL_ID   uint16 = 3
)

const (
	MESSAGE_TYPE_REQUEST_RANGE = 0
	MESSAGE_TYPE_CLIENT_DONE   = 1
	MESSAGE_TYPE_START_BATCH   = 2
	MESSAGE_TYPE_NO_BLOCKS     = 3
	MESSAGE_TYPE_BLOCK         = 4
	MESSAGE_TYPE_BATCH_DONE    = 5
)

Variables

var (
	STATE_IDLE      = protocol.NewState(1, "Idle")
	STATE_BUSY      = protocol.NewState(2, "Busy")
	STATE_STREAMING = protocol.NewState(3, "Streaming")
	STATE_DONE      = protocol.NewState(4, "Done")
)

var StateMap = protocol.StateMap{
	STATE_IDLE: protocol.StateMapEntry{
		Agency: protocol.AGENCY_CLIENT,
		Transitions: []protocol.StateTransition{
			{
				MsgType:  MESSAGE_TYPE_REQUEST_RANGE,
				NewState: STATE_BUSY,
			},
			{
				MsgType:  MESSAGE_TYPE_CLIENT_DONE,
				NewState: STATE_DONE,
			},
		},
	},
	STATE_BUSY: protocol.StateMapEntry{
		Agency: protocol.AGENCY_SERVER,
		Transitions: []protocol.StateTransition{
			{
				MsgType:  MESSAGE_TYPE_START_BATCH,
				NewState: STATE_STREAMING,
			},
			{
				MsgType:  MESSAGE_TYPE_NO_BLOCKS,
				NewState: STATE_IDLE,
			},
		},
	},
	STATE_STREAMING: protocol.StateMapEntry{
		Agency: protocol.AGENCY_SERVER,
		Transitions: []protocol.StateTransition{
			{
				MsgType:  MESSAGE_TYPE_BLOCK,
				NewState: STATE_STREAMING,
			},
			{
				MsgType:  MESSAGE_TYPE_BATCH_DONE,
				NewState: STATE_IDLE,
			},
		},
	},
	STATE_DONE: protocol.StateMapEntry{
		Agency: protocol.AGENCY_NONE,
	},
}

Functions

func NewMsgFromCbor

func NewMsgFromCbor(msgType uint, data []byte) (protocol.Message, error)

Types

type BatchDoneFunc

type BatchDoneFunc func() error

type BlockFetch

type BlockFetch struct {
	Client *Client
	Server *Server
}

func New

func New(protoOptions protocol.ProtocolOptions, cfg *Config) *BlockFetch

type BlockFunc

type BlockFunc func(uint, interface{}) error

type Client

type Client struct {
	*protocol.Protocol
	// contains filtered or unexported fields
}

func NewClient

func NewClient(protoOptions protocol.ProtocolOptions, cfg *Config) *Client

func (*Client) ClientDone

func (c *Client) ClientDone() error

func (*Client) RequestRange

func (c *Client) RequestRange(start []interface{}, end []interface{}) error

type Config

type Config struct {
	StartBatchFunc StartBatchFunc
	NoBlocksFunc   NoBlocksFunc
	BlockFunc      BlockFunc
	BatchDoneFunc  BatchDoneFunc
}

type MsgBatchDone

type MsgBatchDone struct {
	protocol.MessageBase
}

func NewMsgBatchDone

func NewMsgBatchDone() *MsgBatchDone

type MsgBlock

type MsgBlock struct {
	protocol.MessageBase
	WrappedBlock []byte
}

func NewMsgBlock

func NewMsgBlock(wrappedBlock []byte) *MsgBlock

type MsgClientDone

type MsgClientDone struct {
	protocol.MessageBase
}

func NewMsgClientDone

func NewMsgClientDone() *MsgClientDone

type MsgNoBlocks

type MsgNoBlocks struct {
	protocol.MessageBase
}

func NewMsgNoBlocks

func NewMsgNoBlocks() *MsgNoBlocks

type MsgRequestRange

type MsgRequestRange struct {
	protocol.MessageBase
	Start interface{} //point
	End   interface{} //point
}

func NewMsgRequestRange

func NewMsgRequestRange(start interface{}, end interface{}) *MsgRequestRange

type MsgStartBatch

type MsgStartBatch struct {
	protocol.MessageBase
}

func NewMsgStartBatch

func NewMsgStartBatch() *MsgStartBatch

type NoBlocksFunc

type NoBlocksFunc func() error

type Server

type Server struct {
	*protocol.Protocol
	// contains filtered or unexported fields
}

func NewServer

func NewServer(protoOptions protocol.ProtocolOptions, cfg *Config) *Server

type StartBatchFunc

type StartBatchFunc func() error

Callback function types

type WrappedBlock

type WrappedBlock struct {
	Type     uint
	RawBlock cbor.RawMessage
	// contains filtered or unexported fields
}