exchange

Documentation

Overview

Package exchange contains the ChainExchange server and client components.

ChainExchange is the basic chain synchronization protocol of Filecoin. ChainExchange is an RPC-oriented protocol, with a single operation to request blocks for now.

A request contains a start anchor block (referred to with a CID), and a amount of blocks requested beyond the anchor (including the anchor itself).

A client can also pass options, encoded as a 64-bit bitfield. Lotus supports two options at the moment:

• include block contents
• include block messages

The response will include a status code, an optional message, and the response payload in case of success. The payload is a slice of serialized tipsets.

Index

• Constants
• Variables
• func GatherMessages(ctx context.Context, cr chainReader, mr messageStore, ts *types.TipSet) ([]*types.Message, [][]uint64, []*types.SignedMessage, [][]uint64, error)
• func NewInct(rd ReaderDeadline, minSpeed int64, maxWait time.Duration) io.Reader
• type BSTipSet
  • func (t *BSTipSet) MarshalCBOR(w io.Writer) error
  • func (t *BSTipSet) UnmarshalCBOR(r io.Reader) error
• type Client
  • func NewClient(host host.Host, pmgr net.IPeerMgr) Client
• type CompactedMessages
  • func (t *CompactedMessages) MarshalCBOR(w io.Writer) error
  • func (t *CompactedMessages) UnmarshalCBOR(r io.Reader) error
• type ReaderDeadline
• type Request
  • func (t *Request) MarshalCBOR(w io.Writer) error
  • func (t *Request) UnmarshalCBOR(r io.Reader) error
• type Response
  • func (t *Response) MarshalCBOR(w io.Writer) error
  • func (t *Response) UnmarshalCBOR(r io.Reader) error
• type Server
  • func NewServer(cr chainReader, mr messageStore, h host.Host) Server

Constants

const (
	// BlockSyncProtocolID is the protocol ID of the former blocksync protocol.
	// Deprecated.
	BlockSyncProtocolID = "/fil/sync/blk/0.0.1"

	// ChainExchangeProtocolID is the protocol ID of the chain exchange
	// protocol.
	ChainExchangeProtocolID = "/fil/chain/xchg/0.0.1"
)

const (
	// Extracted constants from the code.
	// FIXME: Should be reviewed and confirmed.
	SuccessPeerTagValue = 25
	WriteReqDeadline    = 5 * time.Second
	ReadResDeadline     = WriteReqDeadline
	ReadResMinSpeed     = 50 << 10
	ShufflePeersPrefix  = 16
	WriteResDeadline    = 60 * time.Second
)

const (
	Headers = 1 << iota
	Messages
)

Request options. When fetching the chain segment we can fetch either block headers, messages, or both.

const (
	Ok status = 0
	// We could not fetch all blocks requested (but at least we returned
	// the `Head` requested). Not considered an error.
	Partial = 101

	// Errors
	NotFound      = 201
	GoAway        = 202
	InternalError = 203
	BadRequest    = 204
)

Variables

var MaxRequestLength = uint64(policy.ChainFinality)

FIXME: Bumped from original 800 to this to accommodate `syncFork()`

use of `GetBlocks()`. It seems the expectation of that API is to
fetch any amount of blocks leaving it to the internal logic here
to partition and reassemble the requests if they go above the maximum.
(Also as a consequence of this temporarily removing the `const`
 qualifier to avoid "const initializer [...] is not a constant" error.)

Functions

func GatherMessages

func GatherMessages(ctx context.Context, cr chainReader, mr messageStore, ts *types.TipSet) ([]*types.Message, [][]uint64, []*types.SignedMessage, [][]uint64, error)

func NewInct

func NewInct(rd ReaderDeadline, minSpeed int64, maxWait time.Duration) io.Reader

New creates an Incremental Reader Timeout, with minimum sustained speed of minSpeed bytes per second and with maximum wait of maxWait

Types

type BSTipSet

type BSTipSet struct {
	// List of blocks belonging to a single tipset to which the
	// `CompactedMessages` are linked.
	Blocks   []*types.BlockHeader
	Messages *CompactedMessages
}

FIXME: Rename.

func (*BSTipSet) MarshalCBOR

func (t *BSTipSet) MarshalCBOR(w io.Writer) error

func (*BSTipSet) UnmarshalCBOR

func (t *BSTipSet) UnmarshalCBOR(r io.Reader) error

type Client

type Client interface {
	// GetBlocks fetches block headers from the network, from the provided
	// tipset *backwards*, returning as many tipsets as the count parameter,
	// or less.
	GetBlocks(ctx context.Context, tsk types.TipSetKey, count int) ([]*types.TipSet, error)

	// GetChainMessages fetches messages from the network, starting from the first provided tipset
	// and returning messages from as many tipsets as requested or less.
	GetChainMessages(ctx context.Context, tipsets []*types.TipSet) ([]*CompactedMessages, error)

	// GetFullTipSet fetches a full tipset from a given peer. If successful,
	// the fetched object contains block headers and all messages in full form.
	GetFullTipSet(ctx context.Context, peer []peer.ID, tsk types.TipSetKey) (*types.FullTipSet, error)

	// AddPeer adds a peer to the pool of peers that the Client requests
	// data from.
	AddPeer(peer peer.ID)

	// RemovePeer removes a peer from the pool of peers that the Client
	// requests data from.
	RemovePeer(peer peer.ID)
}

Client is the requesting side of the ChainExchange protocol. It acts as a proxy for other components to request chain data from peers. It is chiefly used by the Syncer.

func NewClient

func NewClient(host host.Host, pmgr net.IPeerMgr) Client

NewClient creates a new libp2p-based exchange.Client that uses the libp2p ChainExhange protocol as the fetching mechanism.

type CompactedMessages

type CompactedMessages struct {
	Bls         []*types.Message
	BlsIncludes [][]uint64

	Secpk         []*types.SignedMessage
	SecpkIncludes [][]uint64
}

All messages of a single tipset compacted together instead of grouped by block to save space, since there are normally many repeated messages per tipset in different blocks.

`BlsIncludes`/`SecpkIncludes` matches `Bls`/`Secpk` messages to blocks in the tipsets with the format: `BlsIncludes[BI][MI]`

• BI: block index in the tipset.
• MI: message index in `Bls` list

FIXME: The logic to decompress this structure should belong

to itself, not to the consumer.

func (*CompactedMessages) MarshalCBOR

func (t *CompactedMessages) MarshalCBOR(w io.Writer) error

func (*CompactedMessages) UnmarshalCBOR

func (t *CompactedMessages) UnmarshalCBOR(r io.Reader) error

type ReaderDeadline

type ReaderDeadline interface {
	Read([]byte) (int, error)
	SetReadDeadline(time.Time) error
}

type Request

type Request struct {
	// List of ordered CIDs comprising a `TipSetKey` from where to start
	// fetching backwards.
	// FIXME: Consider using `TipSetKey` now (introduced after the creation
	//  of this protocol) instead of converting back and forth.
	Head []cid.Cid
	// Number of block sets to fetch from `Head` (inclusive, should always
	// be in the range `[1, MaxRequestLength]`).
	Length uint64
	// Request options, see `Options` type for more details. Compressed
	// in a single `uint64` to save space.
	Options uint64
}

FIXME: Rename. Make private.

func (*Request) MarshalCBOR

func (t *Request) MarshalCBOR(w io.Writer) error

func (*Request) UnmarshalCBOR

func (t *Request) UnmarshalCBOR(r io.Reader) error

type Response

type Response struct {
	Status status
	// String that complements the error status when converting to an
	// internal error (see `statusToError()`).
	ErrorMessage string

	Chain []*BSTipSet
}

FIXME: Rename. Make private.

func (*Response) MarshalCBOR

func (t *Response) MarshalCBOR(w io.Writer) error

func (*Response) UnmarshalCBOR

func (t *Response) UnmarshalCBOR(r io.Reader) error

type Server

type Server interface {
	Register()
}

Server is the responder side of the ChainExchange protocol. It accepts requests from clients and services them by returning the requested chain data.

func NewServer

func NewServer(cr chainReader, mr messageStore, h host.Host) Server

NewServer creates a new libp2p-based exchange.Server. It services requests for the libp2p ChainExchange protocol.