finder

Documentation

Index

• type Engine
  • func New(log zerolog.Logger, metrics module.VerificationMetrics, tracer module.Tracer, ...) (*Engine, error)
  • func (e *Engine) Done() <-chan struct{}
  • func (e *Engine) OnBlockIncorporated(*model.Block)
  • func (e *Engine) OnDoubleProposeDetected(*model.Block, *model.Block)
  • func (e *Engine) OnFinalizedBlock(block *model.Block)
  • func (e *Engine) Process(originID flow.Identifier, event interface{}) error
  • func (e *Engine) ProcessLocal(event interface{}) error
  • func (e *Engine) Ready() <-chan struct{}
  • func (e *Engine) Submit(originID flow.Identifier, event interface{})
  • func (e *Engine) SubmitLocal(event interface{})

Types

type Engine

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

Engine receives receipts and passes them to the match engine if the block of the receipt is available and the verification node is staked at the block ID of the result part of receipt.

A receipt follows a lifecycle in this engine: cached: the receipt is received but not handled yet. pending: the receipt is handled, but its corresponding block has not received at this node yet. discarded: the receipt's block has received, but this verification node has not staked at block of the receipt. ready: the receipt's block has received, and this verification node is staked for that block, hence receipt's result is ready to be forwarded to match engine processed: the receipt's result has been forwarded to matching engine.

This engine ensures that each (ready) result is passed to match engine only once. Hence, among concurrent ready receipts with shared result, only one instance of result is passed to match engine.

func New

func New(
	log zerolog.Logger,
	metrics module.VerificationMetrics,
	tracer module.Tracer,
	net module.Network,
	me module.Local,
	state protocol.State,
	match network.Engine,
	cachedReceipts mempool.ReceiptDataPacks,
	pendingReceipts mempool.ReceiptDataPacks,
	readyReceipts mempool.ReceiptDataPacks,
	headerStorage storage.Headers,
	processedResultIDs mempool.Identifiers,
	discardedResultIDs mempool.Identifiers,
	pendingReceiptIDsByBlock mempool.IdentifierMap,
	receiptsIDsByResult mempool.IdentifierMap,
	blockIDsCache mempool.Identifiers,
	processInterval time.Duration,
) (*Engine, error)

func (*Engine) Done

func (e *Engine) Done() <-chan struct{}

Done returns a channel that is closed when the verifier engine is done.

func (*Engine) OnBlockIncorporated

func (e *Engine) OnBlockIncorporated(*model.Block)

To implement FinalizationConsumer

func (*Engine) OnDoubleProposeDetected

func (e *Engine) OnDoubleProposeDetected(*model.Block, *model.Block)

To implement FinalizationConsumer

func (*Engine) OnFinalizedBlock

func (e *Engine) OnFinalizedBlock(block *model.Block)

OnFinalizedBlock is part of implementing FinalizationConsumer interface On receiving a block, it caches the block ID to be checked in the next onTimer loop.

OnFinalizedBlock notifications are produced by the Finalization Logic whenever a block has been finalized. They are emitted in the order the blocks are finalized. Prerequisites: Implementation must be concurrency safe; Non-blocking; and must handle repetition of the same events (with some processing overhead).

func (*Engine) Process

func (e *Engine) Process(originID flow.Identifier, event interface{}) error

Process processes the given event from the node with the given origin ID in a blocking manner. It returns the potential processing error when done.

func (*Engine) ProcessLocal

func (e *Engine) ProcessLocal(event interface{}) error

ProcessLocal processes an event originating on the local node.

func (*Engine) Ready

func (e *Engine) Ready() <-chan struct{}

Ready returns a channel that is closed when the finder engine is ready.

func (*Engine) Submit

func (e *Engine) Submit(originID flow.Identifier, event interface{})

Submit submits the given event from the node with the given origin ID for processing in a non-blocking manner. It returns instantly and logs a potential processing error internally when done.

func (*Engine) SubmitLocal

func (e *Engine) SubmitLocal(event interface{})

SubmitLocal submits an event originating on the local node.