ingestion

Documentation

Index

• type Engine
  • func New(log zerolog.Logger, net module.Network, state protocol.State, me module.Local, ...) (*Engine, error)
  • func (e *Engine) Done() <-chan struct{}
  • func (e *Engine) OnBlockIncorporated(*model.Block)
  • func (e *Engine) OnCollection(originID flow.Identifier, entity flow.Entity)
  • func (e *Engine) OnDoubleProposeDetected(*model.Block, *model.Block)
  • func (e *Engine) OnFinalizedBlock(hb *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 represents the ingestion engine, used to funnel data from other nodes to a centralized location that can be queried by a user

func New

func New(
	log zerolog.Logger,
	net module.Network,
	state protocol.State,
	me module.Local,
	request module.Requester,
	blocks storage.Blocks,
	headers storage.Headers,
	collections storage.Collections,
	transactions storage.Transactions,
	executionReceipts storage.ExecutionReceipts,
	transactionMetrics module.TransactionMetrics,
	collectionsToMarkFinalized *stdmap.Times,
	collectionsToMarkExecuted *stdmap.Times,
	blocksToMarkExecuted *stdmap.Times,
	rpcEngine *rpc.Engine,
) (*Engine, error)

New creates a new access ingestion engine

func (*Engine) Done

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

Done returns a done channel that is closed once the engine has fully stopped. For the ingestion engine, it only waits for all submit goroutines to end.

func (*Engine) OnBlockIncorporated

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

OnBlockIncorporated is a noop for this engine since access node is only dealing with finalized blocks

func (*Engine) OnCollection

func (e *Engine) OnCollection(originID flow.Identifier, entity flow.Entity)

func (*Engine) OnDoubleProposeDetected

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

OnDoubleProposeDetected is a noop for this engine since access node is only dealing with finalized blocks

func (*Engine) OnFinalizedBlock

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

OnFinalizedBlock is called by the follower engine after a block has been finalized and the state has been updated

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 ready channel that is closed once the engine has fully started. For the ingestion engine, we consider the engine up and running upon syncing all the missing collections

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.