compliance

Documentation

Index

• type Core
  • func NewCore(log zerolog.Logger, collector module.EngineMetrics, ...) (*Core, error)
  • func (c *Core) OnBlockProposal(originID flow.Identifier, proposal *messages.ClusterBlockProposal) error
  • func (c *Core) OnBlockVote(originID flow.Identifier, vote *messages.ClusterBlockVote) error
  • func (c *Core) ProcessFinalizedView(finalizedView uint64)
• type Engine
  • func NewEngine(log zerolog.Logger, net network.Network, me module.Local, state protocol.State, ...) (*Engine, error)
  • func (e *Engine) BroadcastProposal(header *flow.Header) error
  • func (e *Engine) BroadcastProposalWithDelay(header *flow.Header, delay time.Duration) error
  • func (e *Engine) Done() <-chan struct{}
  • func (e *Engine) OnFinalizedBlock(block *model.Block)
  • func (e *Engine) Process(channel network.Channel, originID flow.Identifier, event interface{}) error
  • func (e *Engine) ProcessLocal(event interface{}) error
  • func (e *Engine) Ready() <-chan struct{}
  • func (e *Engine) SendVote(blockID flow.Identifier, view uint64, sigData []byte, ...) error
  • func (e *Engine) Submit(channel network.Channel, originID flow.Identifier, event interface{})
  • func (e *Engine) SubmitLocal(event interface{})
  • func (e *Engine) WithConsensus(hot module.HotStuff) *Engine
  • func (e *Engine) WithSync(sync module.BlockRequester) *Engine

Types

type Core

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

Core contains the central business logic for the collector clusters' compliance engine. It is responsible for handling communication for the embedded consensus algorithm. NOTE: Core is designed to be non-thread safe and cannot be used in concurrent environment user of this object needs to ensure single thread access.

func NewCore

func NewCore(
	log zerolog.Logger,
	collector module.EngineMetrics,
	mempool module.MempoolMetrics,
	collectionMetrics module.CollectionMetrics,
	headers storage.Headers,
	state clusterkv.MutableState,
	pending module.PendingClusterBlockBuffer,
	voteAggregator hotstuff.VoteAggregator,
) (*Core, error)

NewCore instantiates the business logic for the collector clusters' compliance engine.

func (*Core) OnBlockProposal

func (c *Core) OnBlockProposal(originID flow.Identifier, proposal *messages.ClusterBlockProposal) error

OnBlockProposal handles incoming block proposals.

func (*Core) OnBlockVote

func (c *Core) OnBlockVote(originID flow.Identifier, vote *messages.ClusterBlockVote) error

OnBlockVote handles votes for blocks by passing them to the core consensus algorithm

func (*Core) ProcessFinalizedView

func (c *Core) ProcessFinalizedView(finalizedView uint64)

ProcessFinalizedView performs pruning of stale data based on finalization event removes pending blocks below the finalized view

type Engine

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

Engine is a wrapper struct for `Core` which implements cluster consensus algorithm. Engine is responsible for handling incoming messages, queueing for processing, broadcasting proposals.

func NewEngine

func NewEngine(
	log zerolog.Logger,
	net network.Network,
	me module.Local,
	state protocol.State,
	payloads storage.ClusterPayloads,
	core *Core,
) (*Engine, error)

func (*Engine) BroadcastProposal

func (e *Engine) BroadcastProposal(header *flow.Header) error

BroadcastProposal will propagate a block proposal to all non-local consensus nodes. Note the header has incomplete fields, because it was converted from a hotstuff.

func (*Engine) BroadcastProposalWithDelay

func (e *Engine) BroadcastProposalWithDelay(header *flow.Header, delay time.Duration) error

BroadcastProposalWithDelay submits a cluster block proposal (effectively a proposal for the next collection) to all the collection nodes in our cluster.

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 consensus engine, we wait for hotstuff to finish.

func (*Engine) OnFinalizedBlock

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

OnFinalizedBlock implements the `OnFinalizedBlock` callback from the `hotstuff.FinalizationConsumer`

(1) Informs sealing.Core about finalization of respective block.

CAUTION: the input to this callback is treated as trusted; precautions should be taken that messages from external nodes cannot be considered as inputs to this function

func (*Engine) Process

func (e *Engine) Process(channel network.Channel, 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 consensus engine, this is true once the underlying consensus algorithm has started.

func (*Engine) SendVote

func (e *Engine) SendVote(blockID flow.Identifier, view uint64, sigData []byte, recipientID flow.Identifier) error

SendVote will send a vote to the desired node.

func (*Engine) Submit

func (e *Engine) Submit(channel network.Channel, 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.

func (*Engine) WithConsensus

func (e *Engine) WithConsensus(hot module.HotStuff) *Engine

WithConsensus adds the consensus algorithm to the engine. This must be called before the engine can start.

func (*Engine) WithSync

func (e *Engine) WithSync(sync module.BlockRequester) *Engine

WithSync adds the block requester to the engine. This must be called before the engine can start.