Documentation
¶
Index ¶
- Constants
- type AggregatedSignatures
- func (as *AggregatedSignatures) ChunksWithoutAggregatedSignature() []uint64
- func (as *AggregatedSignatures) Collect() []flow.AggregatedSignature
- func (as *AggregatedSignatures) HasSignature(chunkIndex uint64) bool
- func (as *AggregatedSignatures) PutSignature(chunkIndex uint64, aggregatedSignature flow.AggregatedSignature) (uint64, error)
- type ApprovalCollector
- func (c *ApprovalCollector) CollectMissingVerifiers() map[uint64]flow.IdentifierList
- func (c *ApprovalCollector) IncorporatedBlock() *flow.Header
- func (c *ApprovalCollector) IncorporatedBlockID() flow.Identifier
- func (c *ApprovalCollector) IncorporatedResult() *flow.IncorporatedResult
- func (c *ApprovalCollector) ProcessApproval(approval *flow.ResultApproval) error
- func (c *ApprovalCollector) SealResult() error
- type AssignmentCollector
- func (ac *AssignmentCollector) BlockID() flow.Identifier
- func (ac *AssignmentCollector) CheckEmergencySealing(observer consensus.SealingObservation, finalizedBlockHeight uint64) error
- func (ac *AssignmentCollector) ProcessApproval(approval *flow.ResultApproval) error
- func (ac *AssignmentCollector) ProcessIncorporatedResult(incorporatedResult *flow.IncorporatedResult) error
- func (ac *AssignmentCollector) RequestMissingApprovals(observation consensus.SealingObservation, maxHeightForRequesting uint64) (uint, error)
- type AssignmentCollectorTree
- func (t *AssignmentCollectorTree) FinalizeForkAtLevel(finalized *flow.Header, sealed *flow.Header) error
- func (t *AssignmentCollectorTree) GetCollector(resultID flow.Identifier) (*AssignmentCollector, bool)
- func (t *AssignmentCollectorTree) GetCollectorsByInterval(from, to uint64) []*AssignmentCollector
- func (t *AssignmentCollectorTree) GetOrCreateCollector(result *flow.ExecutionResult) (*LazyInitCollector, error)
- func (t *AssignmentCollectorTree) GetSize() uint64
- type BaseApprovalsTestSuite
- type Cache
- type ChunkApprovalCollector
- type GetCachedBlockHeight
- type LazyInitCollector
- type LruCache
- type NewCollectorFactoryMethod
- type RequestTracker
- func (rt *RequestTracker) GetAllIds() []flow.Identifier
- func (rt *RequestTracker) PruneUpToHeight(height uint64) error
- func (rt *RequestTracker) Remove(resultIDs ...flow.Identifier)
- func (rt *RequestTracker) TryUpdate(result *flow.ExecutionResult, incorporatedBlockID flow.Identifier, ...) (RequestTrackerItem, bool, error)
- type RequestTrackerItem
- type SignatureCollector
- func (c *SignatureCollector) Add(signerID flow.Identifier, signature crypto.Signature)
- func (c *SignatureCollector) BySigner(signerID flow.Identifier) (*crypto.Signature, bool)
- func (c *SignatureCollector) HasSigned(signerID flow.Identifier) bool
- func (c *SignatureCollector) NumberSignatures() uint
- func (c *SignatureCollector) ToAggregatedSignature() flow.AggregatedSignature
Constants ¶
const DefaultEmergencySealingThreshold = 400
DefaultEmergencySealingThreshold is the default number of blocks which indicates that ER should be sealed using emergency sealing.
Variables ¶
This section is empty.
Functions ¶
This section is empty.
Types ¶
type AggregatedSignatures ¶
type AggregatedSignatures struct {
// contains filtered or unexported fields
}
AggregatedSignatures is an utility struct that provides concurrency safe access to map of aggregated signatures indexed by chunk index
func NewAggregatedSignatures ¶
func NewAggregatedSignatures(chunks uint64) (*AggregatedSignatures, error)
NewAggregatedSignatures instantiates a AggregatedSignatures. Requires that number of chunks is positive integer. Errors otherwise.
func (*AggregatedSignatures) ChunksWithoutAggregatedSignature ¶ added in v0.17.6
func (as *AggregatedSignatures) ChunksWithoutAggregatedSignature() []uint64
ChunksWithoutAggregatedSignature returns indexes of chunks that don't have an aggregated signature
func (*AggregatedSignatures) Collect ¶
func (as *AggregatedSignatures) Collect() []flow.AggregatedSignature
Collect returns array with aggregated signature for each chunk
func (*AggregatedSignatures) HasSignature ¶
func (as *AggregatedSignatures) HasSignature(chunkIndex uint64) bool
HasSignature returns boolean depending if we have signature for particular chunk
func (*AggregatedSignatures) PutSignature ¶
func (as *AggregatedSignatures) PutSignature(chunkIndex uint64, aggregatedSignature flow.AggregatedSignature) (uint64, error)
PutSignature adds the AggregatedSignature from the collector to `aggregatedSignatures`. The returned int is the resulting number of approved chunks. Errors if chunk index exceeds valid range.
type ApprovalCollector ¶
type ApprovalCollector struct {
// contains filtered or unexported fields
}
ApprovalCollector is responsible for distributing work to chunk collectorTree, collecting aggregated signatures for chunks that reached seal construction threshold, creating and submitting seal candidates once signatures for every chunk are aggregated.
func NewApprovalCollector ¶
func NewApprovalCollector( log zerolog.Logger, result *flow.IncorporatedResult, incorporatedBlock *flow.Header, executedBlock *flow.Header, assignment *chunks.Assignment, seals mempool.IncorporatedResultSeals, requiredApprovalsForSealConstruction uint, ) (*ApprovalCollector, error)
func (*ApprovalCollector) CollectMissingVerifiers ¶
func (c *ApprovalCollector) CollectMissingVerifiers() map[uint64]flow.IdentifierList
CollectMissingVerifiers collects ids of verifiers who haven't provided an approval for particular chunk Returns: map { ChunkIndex -> []VerifierId }
func (*ApprovalCollector) IncorporatedBlock ¶
func (c *ApprovalCollector) IncorporatedBlock() *flow.Header
IncorporatedBlock returns the block which incorporates execution result
func (*ApprovalCollector) IncorporatedBlockID ¶
func (c *ApprovalCollector) IncorporatedBlockID() flow.Identifier
IncorporatedBlockID returns the ID of block which incorporates execution result
func (*ApprovalCollector) IncorporatedResult ¶ added in v0.18.3
func (c *ApprovalCollector) IncorporatedResult() *flow.IncorporatedResult
IncorporatedResult returns the incorporated Result this ApprovalCollector is for
func (*ApprovalCollector) ProcessApproval ¶
func (c *ApprovalCollector) ProcessApproval(approval *flow.ResultApproval) error
ProcessApproval performs processing of result approvals and bookkeeping of aggregated signatures for every chunk. Triggers sealing of execution result when processed last result approval needed for sealing. Returns: - engine.InvalidInputError - result approval is invalid - exception in case of any other error, usually this is not expected - nil on success
func (*ApprovalCollector) SealResult ¶
func (c *ApprovalCollector) SealResult() error
type AssignmentCollector ¶
type AssignmentCollector struct { ResultID flow.Identifier // ID of execution result BlockHeight uint64 // height of block targeted by execution result // contains filtered or unexported fields }
AssignmentCollector Context:
- When the same result is incorporated in multiple different forks, unique verifier assignment is determined for each fork.
- The assignment collector is intended to encapsulate the known assignments for a particular execution result.
AssignmentCollector has a strict ordering of processing, before processing approvals at least one incorporated result has to be processed. AssignmentCollector takes advantage of internal caching to speed up processing approvals for different assignments AssignmentCollector is responsible for validating approvals on result-level (checking signature, identity). TODO: currently AssignmentCollector doesn't cleanup collectorTree when blocks that incorporate results get orphaned For BFT milestone we need to ensure that this cleanup is properly implemented and all orphan collectorTree are pruned by height when fork gets orphaned
func NewAssignmentCollector ¶
func NewAssignmentCollector( logger zerolog.Logger, result *flow.ExecutionResult, state protocol.State, headers storage.Headers, assigner module.ChunkAssigner, seals mempool.IncorporatedResultSeals, sigVerifier module.Verifier, approvalConduit network.Conduit, requestTracker *RequestTracker, requiredApprovalsForSealConstruction uint, ) (*AssignmentCollector, error)
func (*AssignmentCollector) BlockID ¶
func (ac *AssignmentCollector) BlockID() flow.Identifier
BlockID returns the ID of the executed block
func (*AssignmentCollector) CheckEmergencySealing ¶
func (ac *AssignmentCollector) CheckEmergencySealing(observer consensus.SealingObservation, finalizedBlockHeight uint64) error
CheckEmergencySealing checks the managed assignments whether their result can be emergency sealed. Seals the results where possible.
func (*AssignmentCollector) ProcessApproval ¶
func (ac *AssignmentCollector) ProcessApproval(approval *flow.ResultApproval) error
func (*AssignmentCollector) ProcessIncorporatedResult ¶
func (ac *AssignmentCollector) ProcessIncorporatedResult(incorporatedResult *flow.IncorporatedResult) error
func (*AssignmentCollector) RequestMissingApprovals ¶
func (ac *AssignmentCollector) RequestMissingApprovals(observation consensus.SealingObservation, maxHeightForRequesting uint64) (uint, error)
RequestMissingApprovals traverses all collectors and requests missing approval for every chunk that didn't get enough approvals from verifiers. Returns number of requests made and error in case something goes wrong.
type AssignmentCollectorTree ¶
type AssignmentCollectorTree struct {
// contains filtered or unexported fields
}
AssignmentCollectorTree is a mempool holding assignment collectors, which is aware of the tree structure formed by the execution results. The mempool supports pruning by height: only collectors descending from the latest finalized block are relevant. Safe for concurrent access. Internally, the mempool utilizes the LevelledForrest.
func NewAssignmentCollectorTree ¶
func NewAssignmentCollectorTree(lastSealed *flow.Header, headers storage.Headers, createCollector NewCollectorFactoryMethod) *AssignmentCollectorTree
func (*AssignmentCollectorTree) FinalizeForkAtLevel ¶
func (t *AssignmentCollectorTree) FinalizeForkAtLevel(finalized *flow.Header, sealed *flow.Header) error
FinalizeForkAtLevel performs finalization of fork which is stored in leveled forest. When block is finalized we can mark other forks as orphan and stop processing approvals for it. Eventually all forks will be cleaned up by height
func (*AssignmentCollectorTree) GetCollector ¶
func (t *AssignmentCollectorTree) GetCollector(resultID flow.Identifier) (*AssignmentCollector, bool)
GetCollector returns collector by ID and whether it is processable or not
func (*AssignmentCollectorTree) GetCollectorsByInterval ¶
func (t *AssignmentCollectorTree) GetCollectorsByInterval(from, to uint64) []*AssignmentCollector
GetCollectorsByInterval returns processable collectors that satisfy interval [from; to)
func (*AssignmentCollectorTree) GetOrCreateCollector ¶
func (t *AssignmentCollectorTree) GetOrCreateCollector(result *flow.ExecutionResult) (*LazyInitCollector, error)
GetOrCreateCollector performs lazy initialization of AssignmentCollector using double-checked locking.
func (*AssignmentCollectorTree) GetSize ¶ added in v0.17.6
func (t *AssignmentCollectorTree) GetSize() uint64
type BaseApprovalsTestSuite ¶
type BaseApprovalsTestSuite struct { suite.Suite ParentBlock flow.Header // parent of sealing candidate Block flow.Header // candidate for sealing IncorporatedBlock flow.Header // block that incorporated result VerID flow.Identifier // for convenience, node id of first verifier Chunks flow.ChunkList // list of chunks of execution result ChunksAssignment *chunks.Assignment AuthorizedVerifiers map[flow.Identifier]*flow.Identity // map of authorized verifier identities for execution result IncorporatedResult *flow.IncorporatedResult }
BaseApprovalsTestSuite is a base suite for testing approvals processing related functionality At nutshell generates mock data that can be used to create approvals and provides all needed data to validate those approvals for respected execution result.
func (*BaseApprovalsTestSuite) SetupTest ¶
func (s *BaseApprovalsTestSuite) SetupTest()
type Cache ¶
type Cache struct {
// contains filtered or unexported fields
}
Cache is a utility structure that encapsulates map that stores result approvals and provides concurrent access to it.
func NewApprovalsCache ¶
func (*Cache) Get ¶
func (c *Cache) Get(approvalID flow.Identifier) *flow.ResultApproval
Get returns approval that is saved in cache
type ChunkApprovalCollector ¶
type ChunkApprovalCollector struct {
// contains filtered or unexported fields
}
ChunkApprovalCollector implements logic for checking chunks against assignments as well as accumulating signatures of already checked approvals.
func NewChunkApprovalCollector ¶
func NewChunkApprovalCollector(assignment map[flow.Identifier]struct{}, requiredApprovalsForSealConstruction uint) *ChunkApprovalCollector
func (*ChunkApprovalCollector) GetMissingSigners ¶
func (c *ChunkApprovalCollector) GetMissingSigners() flow.IdentifierList
GetMissingSigners returns ids of approvers that are present in assignment but didn't provide approvals
func (*ChunkApprovalCollector) ProcessApproval ¶
func (c *ChunkApprovalCollector) ProcessApproval(approval *flow.ResultApproval) (flow.AggregatedSignature, bool)
ProcessApproval performs processing and bookkeeping of single approval
type GetCachedBlockHeight ¶
type GetCachedBlockHeight = func(blockID flow.Identifier) (uint64, error)
helper functor that can be used to retrieve cached block height
type LazyInitCollector ¶
type LazyInitCollector struct { Collector *AssignmentCollector Processable bool // whether collector is processable Created bool // whether collector was created or retrieved from cache }
LazyInitCollector is a helper structure that is used to return collector which is lazy initialized
type LruCache ¶
type LruCache struct {
// contains filtered or unexported fields
}
LruCache is a wrapper over `simplelru.LRUCache` that provides needed api for processing result approvals Extends functionality of `simplelru.LRUCache` by introducing additional index for quicker access.
func NewApprovalsLRUCache ¶
func (*LruCache) Get ¶
func (c *LruCache) Get(approvalID flow.Identifier) *flow.ResultApproval
func (*LruCache) Peek ¶
func (c *LruCache) Peek(approvalID flow.Identifier) *flow.ResultApproval
func (*LruCache) Put ¶
func (c *LruCache) Put(approval *flow.ResultApproval)
func (*LruCache) TakeByResultID ¶
func (c *LruCache) TakeByResultID(resultID flow.Identifier) []*flow.ResultApproval
type NewCollectorFactoryMethod ¶
type NewCollectorFactoryMethod = func(result *flow.ExecutionResult) (*AssignmentCollector, error)
NewCollector is a factory method to generate an AssignmentCollector for an execution result
type RequestTracker ¶ added in v0.17.6
type RequestTracker struct {
// contains filtered or unexported fields
}
RequestTracker is an index of RequestTrackerItems indexed by execution result Index on result ID, incorporated block ID and chunk index. Is concurrency-safe.
func NewRequestTracker ¶ added in v0.17.6
func NewRequestTracker(headers storage.Headers, blackoutPeriodMin, blackoutPeriodMax int) *RequestTracker
NewRequestTracker instantiates a new RequestTracker with blackout periods between min and max seconds.
func (*RequestTracker) GetAllIds ¶ added in v0.17.6
func (rt *RequestTracker) GetAllIds() []flow.Identifier
GetAllIds returns all result IDs that we are indexing
func (*RequestTracker) PruneUpToHeight ¶ added in v0.19.0
func (rt *RequestTracker) PruneUpToHeight(height uint64) error
PruneUpToHeight remove all tracker items for blocks whose height is strictly smaller that height. Note: items for blocks at height are retained. After pruning, items for blocks below the given height are dropped.
Monotonicity Requirement: The pruned height cannot decrease, as we cannot recover already pruned elements. If `height` is smaller than the previous value, the previous value is kept and the sentinel mempool.DecreasingPruningHeightError is returned.
func (*RequestTracker) Remove ¶ added in v0.17.6
func (rt *RequestTracker) Remove(resultIDs ...flow.Identifier)
Remove removes all entries pertaining to an execution result
func (*RequestTracker) TryUpdate ¶ added in v0.19.0
func (rt *RequestTracker) TryUpdate(result *flow.ExecutionResult, incorporatedBlockID flow.Identifier, chunkIndex uint64) (RequestTrackerItem, bool, error)
TryUpdate tries to update tracker item if it's not in blackout period. Returns the tracker item for a specific chunk (creates it if it doesn't exists) and whenever request item was successfully updated or not. Since RequestTracker prunes items by height it can't accept items for height lower than cached lowest height. If height of executed block pointed by execution result is smaller than the lowest height, sentinel mempool.DecreasingPruningHeightError is returned. In case execution result points to unknown executed block exception will be returned.
type RequestTrackerItem ¶ added in v0.17.6
type RequestTrackerItem struct { Requests uint NextTimeout time.Time // contains filtered or unexported fields }
RequestTrackerItem is an object that keeps track of how many times a request has been made, as well as the time until a new request can be made. It is not concurrency-safe.
func NewRequestTrackerItem ¶ added in v0.17.6
func NewRequestTrackerItem(blackoutPeriodMin, blackoutPeriodMax int) RequestTrackerItem
NewRequestTrackerItem instantiates a new RequestTrackerItem where the NextTimeout is evaluated to the current time plus a random blackout period contained between min and max.
func (RequestTrackerItem) IsBlackout ¶ added in v0.17.6
func (i RequestTrackerItem) IsBlackout() bool
func (RequestTrackerItem) Update ¶ added in v0.17.6
func (i RequestTrackerItem) Update() RequestTrackerItem
Update increments the number of requests and recomputes the NextTimeout.
type SignatureCollector ¶ added in v0.17.6
type SignatureCollector struct {
// contains filtered or unexported fields
}
SignatureCollector contains a set of of signatures from verifiers attesting to the validity of an execution result chunk. NOT concurrency safe. TODO: this will be replaced with stateful BLS aggregation
func NewSignatureCollector ¶ added in v0.17.6
func NewSignatureCollector() SignatureCollector
NewSignatureCollector instantiates a new SignatureCollector
func (*SignatureCollector) Add ¶ added in v0.17.6
func (c *SignatureCollector) Add(signerID flow.Identifier, signature crypto.Signature)
Add appends a signature. Only the _first_ signature is retained for each signerID.
func (*SignatureCollector) BySigner ¶ added in v0.17.6
func (c *SignatureCollector) BySigner(signerID flow.Identifier) (*crypto.Signature, bool)
BySigner returns a signer's signature if it exists
func (*SignatureCollector) HasSigned ¶ added in v0.17.6
func (c *SignatureCollector) HasSigned(signerID flow.Identifier) bool
HasSigned checks if signer has already provided a signature
func (*SignatureCollector) NumberSignatures ¶ added in v0.17.6
func (c *SignatureCollector) NumberSignatures() uint
NumberSignatures returns the number of stored (distinct) signatures
func (*SignatureCollector) ToAggregatedSignature ¶ added in v0.17.6
func (c *SignatureCollector) ToAggregatedSignature() flow.AggregatedSignature
ToAggregatedSignature generates an aggregated signature from all signatures in the SignatureCollector