fetcher

Jul 14, 2021

Changes in this version

+ func TransactionOffsetForChunk(chunks flow.ChunkList, chunkIndex uint64) (uint32, error)

May 18, 2021

Changes in this version

+ func IsChunkDataPackValidationError(err error) bool

+ func NewChunkDataPackValidationError(originID flow.Identifier, chunkDataPackID flow.Identifier, ...) error

+ type ChunkDataPackValidationError struct

+ func (c ChunkDataPackValidationError) Error() string

May 12, 2021

Changes in this version

+ func EndStateCommitment(result *flow.ExecutionResult, chunkIndex uint64, systemChunk bool) (flow.StateCommitment, error)

type ChunkDataPackRequester

+ WithChunkDataPackHandler func(handler ChunkDataPackHandler)

type Engine

+ func (e *Engine) NotifyChunkDataPackSealed(chunkID flow.Identifier)

+ func (e *Engine) ProcessAssignedChunk(locator *chunks.Locator)

Apr 5, 2021

Changes in this version

+ type AssignedChunkProcessor interface

+ ProcessAssignedChunk func(locator *chunks.Locator)

+ WithChunkConsumerNotifier func(notifier module.ProcessingNotifier)

+ type ChunkDataPackHandler interface

+ HandleChunkDataPack func(originID flow.Identifier, chunkDataPack *flow.ChunkDataPack, ...)

+ NotifyChunkDataPackSealed func(chunkID flow.Identifier)

+ type ChunkDataPackRequester interface

+ Request func(chunkID flow.Identifier, executorID flow.Identifier) error

type Engine

+ func (e *Engine) HandleChunkDataPack(originID flow.Identifier, chunkDataPack *flow.ChunkDataPack, ...) error

+ func (e *Engine) WithChunkConsumerNotifier(notifier module.ProcessingNotifier)

Mar 17, 2021

Changes in this version

+ const DefaultJobIndex

+ func CanTry(maxAttempt int, chunk *ChunkStatus) bool

+ func IsSystemChunk(chunkIndex uint64, result *flow.ExecutionResult) bool

+ func JobToChunkLocator(job module.Job) *chunks.Locator

+ type ChunkConsumer struct

+ func NewChunkConsumer(log zerolog.Logger, processedIndex storage.ConsumerProgress, ...) *ChunkConsumer

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

+ func (c *ChunkConsumer) NotifyJobIsDone(jobID module.JobID)

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

+ func (c ChunkConsumer) Check()

+ type ChunkJob struct

+ ChunkLocator *chunks.Locator

+ func ChunkLocatorToJob(locator *chunks.Locator) *ChunkJob

+ func (j ChunkJob) ID() module.JobID

+ type ChunkJobs struct

+ func (j *ChunkJobs) AtIndex(index int64) (module.Job, error)

+ func (j *ChunkJobs) Head() (int64, error)

+ type ChunkStatus struct

+ Agrees []flow.Identifier

+ Attempt int

+ Chunk *flow.Chunk

+ Disagrees []flow.Identifier

+ ExecutionResultID flow.Identifier

+ Height uint64

+ LastAttempt time.Time

+ func NewChunkStatus(chunk *flow.Chunk, resultID flow.Identifier, height uint64, ...) *ChunkStatus

+ func (s ChunkStatus) Checksum() flow.Identifier

+ func (s ChunkStatus) ID() flow.Identifier

+ type Chunks struct

+ func NewChunks(limit uint) *Chunks

+ func (cs *Chunks) Add(chunk *ChunkStatus) bool

+ func (cs *Chunks) All() []*ChunkStatus

+ func (cs *Chunks) ByID(chunkID flow.Identifier) (*ChunkStatus, bool)

+ func (cs *Chunks) IncrementAttempt(chunkID flow.Identifier) bool

+ func (cs *Chunks) Rem(chunkID flow.Identifier) bool

+ type Engine struct

+ func New(log zerolog.Logger, metrics module.VerificationMetrics, tracer module.Tracer, ...) (*Engine, error)

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

+ func (e *Engine) Process(originID flow.Identifier, event interface{}) error

+ func (e *Engine) ProcessLocal(event interface{}) error

+ func (e *Engine) ProcessMyChunk(c *flow.Chunk, resultID flow.Identifier)

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

+ func (e *Engine) Submit(originID flow.Identifier, event interface{})

+ func (e *Engine) SubmitLocal(event interface{})

+ func (e *Engine) WithFinishProcessing(finishProcessing FinishProcessing)

+ type EngineWorker interface

+ ProcessMyChunk func(locator *chunks.Locator)

+ WithFinishProcessing func(finishProcessing FinishProcessing)

+ type FinishProcessing interface

+ Notify func(chunkID flow.Identifier)

+ type Worker struct

+ func NewWorker(engine EngineWorker) *Worker

+ func (w *Worker) Notify(chunkID flow.Identifier)

+ func (w *Worker) Run(job module.Job)