Documentation

Index

Constants

View Source
const (
	// BlockchainChannel is a channel for blocks and status updates (`BlockStore` height)
	BlockchainChannel = byte(0x40)
)

Variables

This section is empty.

Functions

func RegisterBlockchainMessages

func RegisterBlockchainMessages(cdc *amino.Codec)

Types

type BlockPool

type BlockPool struct {
	cmn.BaseService
	// contains filtered or unexported fields
}

func NewBlockPool

func NewBlockPool(start int64, requestsCh chan<- BlockRequest, errorsCh chan<- peerError) *BlockPool

    NewBlockPool returns a new BlockPool with the height equal to start. Block requests and errors will be sent to requestsCh and errorsCh accordingly.

    func (*BlockPool) AddBlock

    func (pool *BlockPool) AddBlock(peerID p2p.ID, block *types.Block, blockSize int)

      TODO: ensure that blocks come in order for each peer.

      func (*BlockPool) GetStatus

      func (pool *BlockPool) GetStatus() (height int64, numPending int32, lenRequesters int)

        GetStatus returns pool's height, numPending requests and the number of requesters.

        func (*BlockPool) IsCaughtUp

        func (pool *BlockPool) IsCaughtUp() bool

          IsCaughtUp returns true if this node is caught up, false - otherwise. TODO: relax conditions, prevent abuse.

          func (*BlockPool) MaxPeerHeight

          func (pool *BlockPool) MaxPeerHeight() int64

            MaxPeerHeight returns the highest reported height.

            func (*BlockPool) OnStart

            func (pool *BlockPool) OnStart() error

              OnStart implements cmn.Service by spawning requesters routine and recording pool's start time.

              func (*BlockPool) PeekTwoBlocks

              func (pool *BlockPool) PeekTwoBlocks() (first *types.Block, second *types.Block)

                We need to see the second block's Commit to validate the first block. So we peek two blocks at a time. The caller will verify the commit.

                func (*BlockPool) PopRequest

                func (pool *BlockPool) PopRequest()

                  Pop the first block at pool.height It must have been validated by 'second'.Commit from PeekTwoBlocks().

                  func (*BlockPool) RedoRequest

                  func (pool *BlockPool) RedoRequest(height int64) p2p.ID

                    Invalidates the block at pool.height, Remove the peer and redo request from others. Returns the ID of the removed peer.

                    func (*BlockPool) RemovePeer

                    func (pool *BlockPool) RemovePeer(peerID p2p.ID)

                      RemovePeer removes the peer with peerID from the pool. If there's no peer with peerID, function is a no-op.

                      func (*BlockPool) SetPeerHeight

                      func (pool *BlockPool) SetPeerHeight(peerID p2p.ID, height int64)

                        SetPeerHeight sets the peer's alleged blockchain height.

                        type BlockRequest

                        type BlockRequest struct {
                        	Height int64
                        	PeerID p2p.ID
                        }

                        type BlockStore

                        type BlockStore struct {
                        	// contains filtered or unexported fields
                        }

                          BlockStore is a simple low level store for blocks.

                          There are three types of information stored:

                          - BlockMeta:   Meta information about each block
                          - Block part:  Parts of each block, aggregated w/ PartSet
                          - Commit:      The commit part of each block, for gossiping precommit votes
                          

                          Currently the precommit signatures are duplicated in the Block parts as well as the Commit. In the future this may change, perhaps by moving the Commit data outside the Block. (TODO)

                          // NOTE: BlockStore methods will panic if they encounter errors // deserializing loaded data, indicating probable corruption on disk.

                          func NewBlockStore

                          func NewBlockStore(db dbm.DB) *BlockStore

                            NewBlockStore returns a new BlockStore with the given DB, initialized to the last height that was committed to the DB.

                            func (*BlockStore) Height

                            func (bs *BlockStore) Height() int64

                              Height returns the last known contiguous block height.

                              func (*BlockStore) LoadBlock

                              func (bs *BlockStore) LoadBlock(height int64) *types.Block

                                LoadBlock returns the block with the given height. If no block is found for that height, it returns nil.

                                func (*BlockStore) LoadBlockCommit

                                func (bs *BlockStore) LoadBlockCommit(height int64) *types.Commit

                                  LoadBlockCommit returns the Commit for the given height. This commit consists of the +2/3 and other Precommit-votes for block at `height`, and it comes from the block.LastCommit for `height+1`. If no commit is found for the given height, it returns nil.

                                  func (*BlockStore) LoadBlockMeta

                                  func (bs *BlockStore) LoadBlockMeta(height int64) *types.BlockMeta

                                    LoadBlockMeta returns the BlockMeta for the given height. If no block is found for the given height, it returns nil.

                                    func (*BlockStore) LoadBlockPart

                                    func (bs *BlockStore) LoadBlockPart(height int64, index int) *types.Part

                                      LoadBlockPart returns the Part at the given index from the block at the given height. If no part is found for the given height and index, it returns nil.

                                      func (*BlockStore) LoadSeenCommit

                                      func (bs *BlockStore) LoadSeenCommit(height int64) *types.Commit

                                        LoadSeenCommit returns the locally seen Commit for the given height. This is useful when we've seen a commit, but there has not yet been a new block at `height + 1` that includes this commit in its block.LastCommit.

                                        func (*BlockStore) SaveBlock

                                        func (bs *BlockStore) SaveBlock(block *types.Block, blockParts *types.PartSet, seenCommit *types.Commit)

                                          SaveBlock persists the given block, blockParts, and seenCommit to the underlying db. blockParts: Must be parts of the block seenCommit: The +2/3 precommits that were seen which committed at height.

                                          If all the nodes restart after committing a block,
                                          we need this to reload the precommits to catch-up nodes to the
                                          most recent height.  Otherwise they'd stall at H-1.
                                          

                                          type BlockStoreStateJSON

                                          type BlockStoreStateJSON struct {
                                          	Height int64 `json:"height"`
                                          }

                                          func LoadBlockStoreStateJSON

                                          func LoadBlockStoreStateJSON(db dbm.DB) BlockStoreStateJSON

                                            LoadBlockStoreStateJSON returns the BlockStoreStateJSON as loaded from disk. If no BlockStoreStateJSON was previously persisted, it returns the zero value.

                                            func (BlockStoreStateJSON) Save

                                            func (bsj BlockStoreStateJSON) Save(db dbm.DB)

                                              Save persists the blockStore state to the database as JSON.

                                              type BlockchainMessage

                                              type BlockchainMessage interface {
                                              	ValidateBasic() error
                                              }

                                                BlockchainMessage is a generic message for this reactor.

                                                type BlockchainReactor

                                                type BlockchainReactor struct {
                                                	p2p.BaseReactor
                                                	// contains filtered or unexported fields
                                                }

                                                  BlockchainReactor handles long-term catchup syncing.

                                                  func NewBlockchainReactor

                                                  func NewBlockchainReactor(state sm.State, blockExec *sm.BlockExecutor, store *BlockStore,
                                                  	fastSync bool) *BlockchainReactor

                                                    NewBlockchainReactor returns new reactor instance.

                                                    func (*BlockchainReactor) AddPeer

                                                    func (bcR *BlockchainReactor) AddPeer(peer p2p.Peer)

                                                      AddPeer implements Reactor by sending our state to peer.

                                                      func (*BlockchainReactor) BroadcastStatusRequest

                                                      func (bcR *BlockchainReactor) BroadcastStatusRequest() error

                                                        BroadcastStatusRequest broadcasts `BlockStore` height.

                                                        func (*BlockchainReactor) GetChannels

                                                        func (bcR *BlockchainReactor) GetChannels() []*p2p.ChannelDescriptor

                                                          GetChannels implements Reactor

                                                          func (*BlockchainReactor) OnStart

                                                          func (bcR *BlockchainReactor) OnStart() error

                                                            OnStart implements cmn.Service.

                                                            func (*BlockchainReactor) OnStop

                                                            func (bcR *BlockchainReactor) OnStop()

                                                              OnStop implements cmn.Service.

                                                              func (*BlockchainReactor) Receive

                                                              func (bcR *BlockchainReactor) Receive(chID byte, src p2p.Peer, msgBytes []byte)

                                                                Receive implements Reactor by handling 4 types of messages (look below).

                                                                func (*BlockchainReactor) RemovePeer

                                                                func (bcR *BlockchainReactor) RemovePeer(peer p2p.Peer, reason interface{})

                                                                  RemovePeer implements Reactor by removing peer from the pool.

                                                                  func (*BlockchainReactor) SetLogger

                                                                  func (bcR *BlockchainReactor) SetLogger(l log.Logger)

                                                                    SetLogger implements cmn.Service by setting the logger on reactor and pool.