blockconsumer

Documentation

Index

• Constants
• func JobID(blockID flow.Identifier) module.JobID
• func JobToBlock(job module.Job) (*flow.Block, error)
• type BlockConsumer
  • func NewBlockConsumer(log zerolog.Logger, metrics module.VerificationMetrics, ...) (*BlockConsumer, uint64, error)
  • func (c *BlockConsumer) Done() <-chan struct{}
  • func (c *BlockConsumer) NotifyJobIsDone(jobID module.JobID)
  • func (c *BlockConsumer) OnBlockIncorporated(*model.Block)
  • func (c *BlockConsumer) OnDoubleProposeDetected(*model.Block, *model.Block)
  • func (c *BlockConsumer) OnFinalizedBlock(*model.Block)
  • func (c *BlockConsumer) Ready() <-chan struct{}
  • func (c *BlockConsumer) Size() uint
• type BlockJob
  • func BlockToJob(block *flow.Block) *BlockJob
  • func (j BlockJob) ID() module.JobID
• type FinalizedBlockReader
  • func NewFinalizedBlockReader(state protocol.State, blocks storage.Blocks) *FinalizedBlockReader
  • func (r FinalizedBlockReader) AtIndex(index uint64) (module.Job, error)
  • func (r FinalizedBlockReader) Head() (uint64, error)

Constants

const DefaultBlockWorkers = uint64(2)

DefaultBlockWorkers is the number of blocks processed in parallel.

Functions

func JobID

func JobID(blockID flow.Identifier) module.JobID

JobID returns the corresponding unique job id of the BlockJob for this job.

func JobToBlock

func JobToBlock(job module.Job) (*flow.Block, error)

JobToBlock converts a block job into its corresponding block.

Types

type BlockConsumer

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

BlockConsumer listens to the OnFinalizedBlock event and notifies the consumer to check in the job queue (i.e., its block reader) for new block jobs.

func NewBlockConsumer

func NewBlockConsumer(log zerolog.Logger,
	metrics module.VerificationMetrics,
	processedHeight storage.ConsumerProgress,
	blocks storage.Blocks,
	state protocol.State,
	blockProcessor assigner.FinalizedBlockProcessor,
	maxProcessing uint64) (*BlockConsumer, uint64, error)

NewBlockConsumer creates a new consumer and returns the default processed index for initializing the processed index in storage.

func (*BlockConsumer) Done

func (c *BlockConsumer) Done() <-chan struct{}

func (*BlockConsumer) NotifyJobIsDone

func (c *BlockConsumer) NotifyJobIsDone(jobID module.JobID)

NotifyJobIsDone is invoked by the worker to let the consumer know that it is done processing a (block) job.

func (*BlockConsumer) OnBlockIncorporated

func (c *BlockConsumer) OnBlockIncorporated(*model.Block)

OnBlockIncorporated is to implement FinalizationConsumer

func (*BlockConsumer) OnDoubleProposeDetected

func (c *BlockConsumer) OnDoubleProposeDetected(*model.Block, *model.Block)

OnDoubleProposeDetected is to implement FinalizationConsumer

func (*BlockConsumer) OnFinalizedBlock

func (c *BlockConsumer) OnFinalizedBlock(*model.Block)

OnFinalizedBlock implements FinalizationConsumer, and is invoked by the follower engine whenever a new block is finalized. In this implementation for block consumer, invoking OnFinalizedBlock is enough to only notify the consumer to check its internal queue and move its processing index ahead to the next height if there are workers available. The consumer retrieves the new blocks from its block reader module, hence it does not need to use the parameter of OnFinalizedBlock here.

func (*BlockConsumer) Ready

func (c *BlockConsumer) Ready() <-chan struct{}

func (*BlockConsumer) Size

func (c *BlockConsumer) Size() uint

Size returns number of in-memory block jobs that block consumer is processing.

type BlockJob

type BlockJob struct {
	Block *flow.Block
}

BlockJob implements the Job interface. It converts a Block into a Job to be used by job queue.

In current architecture, BlockJob represents a finalized block enqueued to be processed by the BlockConsumer that implements the JobQueue interface.

func BlockToJob

func BlockToJob(block *flow.Block) *BlockJob

BlockToJob converts the block to a BlockJob.

func (BlockJob) ID

func (j BlockJob) ID() module.JobID

ID converts block id into job id, which guarantees uniqueness.

type FinalizedBlockReader

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

FinalizedBlockReader provides an abstraction for consumers to read blocks as job.

func NewFinalizedBlockReader

func NewFinalizedBlockReader(state protocol.State, blocks storage.Blocks) *FinalizedBlockReader

NewFinalizedBlockReader creates and returns a FinalizedBlockReader.

func (FinalizedBlockReader) AtIndex

func (r FinalizedBlockReader) AtIndex(index uint64) (module.Job, error)

AtIndex returns the block job at the given index. The block job at an index is just the finalized block at that index (i.e., height).

func (FinalizedBlockReader) Head

func (r FinalizedBlockReader) Head() (uint64, error)

Head returns the last finalized height as job index.