syncmanager

Documentation

Index

• type Config
• type PeerNotifier
• type SyncManager
  • func New(config *Config) (*SyncManager, error)
  • func (sm *SyncManager) DonePeer(peer *peer.Peer)
  • func (sm *SyncManager) IsCurrent() bool
  • func (sm *SyncManager) NewPeer(peer *peer.Peer)
  • func (sm *SyncManager) Pause() chan<- struct{}
  • func (sm *SyncManager) QueueBlock(block *block.Block, buf []byte, peer *peer.Peer, done chan<- struct{})
  • func (sm *SyncManager) QueueGetBlocks(getblocks *wire.MsgGetBlocks, peer *peer.Peer, done chan<- struct{})
  • func (sm *SyncManager) QueueGetData(getdata *wire.MsgGetData, peer *peer.Peer, done chan<- struct{})
  • func (sm *SyncManager) QueueHeaders(headers *wire.MsgHeaders, peer *peer.Peer)
  • func (sm *SyncManager) QueueInv(inv *wire.MsgInv, peer *peer.Peer)
  • func (sm *SyncManager) QueueMessgePool(pool *wire.MsgMemPool, peer *peer.Peer, done chan<- struct{})
  • func (sm *SyncManager) QueueMinedBlock(block *block.Block, done chan error)
  • func (sm *SyncManager) QueueTx(tx *tx.Tx, peer *peer.Peer, done chan<- struct{})
  • func (sm *SyncManager) Start()
  • func (sm *SyncManager) Stop() error
  • func (sm *SyncManager) SyncPeerID() int32

Types

type Config

type Config struct {
	PeerNotifier PeerNotifier
	ChainParams  *model.BitcoinParams

	DisableCheckpoints bool
	MaxPeers           int
}

Config is a configuration struct used to initialize a new SyncManager.

type PeerNotifier

type PeerNotifier interface {
	AnnounceNewTransactions(newTxs []*mempool.TxEntry)

	UpdatePeerHeights(latestBlkHash *util.Hash, latestHeight int32, updateSource *peer.Peer)

	RelayInventory(invVect *wire.InvVect, data interface{})

	RelayUpdatedTipBlocks(event *chain.TipUpdatedEvent)

	TransactionConfirmed(tx *tx.Tx)
}

PeerNotifier exposes methods to notify peers of status changes to transactions, blocks, etc. Currently server (in the main package) implements this interface.

type SyncManager

type SyncManager struct {

	// callback for transaction And block process
	ProcessTransactionCallBack func(*tx.Tx, map[util.Hash]struct{}, int64) ([]*tx.Tx, []util.Hash, []util.Hash, error)
	ProcessBlockCallBack       func(*block.Block, bool) (bool, error)
	ProcessBlockHeadCallBack   func([]*block.BlockHeader, *blockindex.BlockIndex) error
	AddBanScoreCallBack        func(string, uint32, uint32, string)
	// contains filtered or unexported fields
}

SyncManager is used to communicate block related messages with peers. The SyncManager is started as by executing Start() in a goroutine. Once started, it selects peers to sync from and starts the initial block download. Once the chain is in sync, the SyncManager handles incoming block and header notifications and relays announcements of new blocks to peers.

func New

func New(config *Config) (*SyncManager, error)

New constructs a new SyncManager. Use Start to begin processing asynchronous block, tx, and inv updates.

func (*SyncManager) DonePeer

func (sm *SyncManager) DonePeer(peer *peer.Peer)

DonePeer informs the blockmanager that a peer has disconnected.

func (*SyncManager) IsCurrent

func (sm *SyncManager) IsCurrent() bool

IsCurrent returns whether or not the sync manager believes it is synced with the connected peers.

func (*SyncManager) NewPeer

func (sm *SyncManager) NewPeer(peer *peer.Peer)

NewPeer informs the sync manager of a newly active peer.

func (*SyncManager) Pause

func (sm *SyncManager) Pause() chan<- struct{}

Pause pauses the sync manager until the returned channel is closed.

Note that while paused, all peer and block processing is halted. The message sender should avoid pausing the sync manager for long durations.

func (*SyncManager) QueueBlock

func (sm *SyncManager) QueueBlock(block *block.Block, buf []byte, peer *peer.Peer, done chan<- struct{})

QueueBlock adds the passed block message and peer to the block handling queue. Responds to the done channel argument after the block message is processed.

func (*SyncManager) QueueGetBlocks

func (sm *SyncManager) QueueGetBlocks(getblocks *wire.MsgGetBlocks, peer *peer.Peer, done chan<- struct{})

func (*SyncManager) QueueGetData

func (sm *SyncManager) QueueGetData(getdata *wire.MsgGetData, peer *peer.Peer, done chan<- struct{})

func (*SyncManager) QueueHeaders

func (sm *SyncManager) QueueHeaders(headers *wire.MsgHeaders, peer *peer.Peer)

QueueHeaders adds the passed headers message and peer to the block handling queue.

func (*SyncManager) QueueInv

func (sm *SyncManager) QueueInv(inv *wire.MsgInv, peer *peer.Peer)

QueueInv adds the passed inv message and peer to the block handling queue.

func (*SyncManager) QueueMessgePool

func (sm *SyncManager) QueueMessgePool(pool *wire.MsgMemPool, peer *peer.Peer, done chan<- struct{})

func (*SyncManager) QueueMinedBlock

func (sm *SyncManager) QueueMinedBlock(block *block.Block, done chan error)

func (*SyncManager) QueueTx

func (sm *SyncManager) QueueTx(tx *tx.Tx, peer *peer.Peer, done chan<- struct{})

QueueTx adds the passed transaction message and peer to the block handling queue. Responds to the done channel argument after the tx message is processed.

func (*SyncManager) Start

func (sm *SyncManager) Start()

Start begins the core block handler which processes block and inv messages.

func (*SyncManager) Stop

func (sm *SyncManager) Stop() error

Stop gracefully shuts down the sync manager by stopping all asynchronous handlers and waiting for them to finish.

func (*SyncManager) SyncPeerID

func (sm *SyncManager) SyncPeerID() int32

SyncPeerID returns the ID of the current sync peer, or 0 if there is none.