assigner

Documentation

Index

• type Engine
  • func New(log zerolog.Logger, metrics module.VerificationMetrics, tracer module.Tracer, ...) *Engine
  • func (e *Engine) Done() <-chan struct{}
  • func (e *Engine) ProcessFinalizedBlock(block *flow.Block)
  • func (e *Engine) Ready() <-chan struct{}
  • func (e *Engine) WithBlockConsumerNotifier(notifier module.ProcessingNotifier)
• type FinalizedBlockProcessor

Types

type Engine

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

The Assigner engine reads the receipts from each finalized block. For each receipt, it reads its result and find the chunks the assigned to me to verify, and then save it to the chunks job queue for the fetcher engine to process.

func New

func New(
	log zerolog.Logger,
	metrics module.VerificationMetrics,
	tracer module.Tracer,
	me module.Local,
	state protocol.State,
	assigner module.ChunkAssigner,
	chunksQueue storage.ChunksQueue,
	newChunkListener module.NewJobListener,
) *Engine

func (*Engine) Done

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

func (*Engine) ProcessFinalizedBlock

func (e *Engine) ProcessFinalizedBlock(block *flow.Block)

ProcessFinalizedBlock is the entry point of assigner engine. It pushes the block down the pipeline with tracing on it enabled. Through the pipeline the execution receipts included in the block are indexed, and their chunk assignments are done, and the assigned chunks are pushed to the chunks queue, which is the output stream of this engine. Once the assigner engine is done handling all the receipts in the block, it notifies the block consumer.

func (*Engine) Ready

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

func (*Engine) WithBlockConsumerNotifier

func (e *Engine) WithBlockConsumerNotifier(notifier module.ProcessingNotifier)

type FinalizedBlockProcessor

type FinalizedBlockProcessor interface {
	// ProcessFinalizedBlock receives a finalized block and processes all of its constituent execution receipts.
	// Note: it should be implemented in a non-blocking way.
	ProcessFinalizedBlock(*flow.Block)

	// WithBlockConsumerNotifier sets the notifier of this finalized block processor.
	// The notifier is called by the internal logic of the processor to let the consumer know that
	// the processor is done by processing a block so that the next block may be passed to the processor
	// by the consumer through invoking ProcessFinalizedBlock of this processor.
	WithBlockConsumerNotifier(module.ProcessingNotifier)
}

FinalizedBlockProcessor should be implemented by the verification node engine responsible for processing execution receipts included in a finalized block.

In the current version, the assigner engine is responsible of processing execution receipts included in a finalized block. From the architectural perspective, FinalizedBlockProcessor aligns as following on the verification pipeline: ----------------------------- ------------------ -------------------------- | Consensus Follower Engine | ---> finalized blocks --> | Block Consumer | ---> finalized block workers --> | FinalizedBlockProcessor| ----------------------------- ------------------ --------------------------