storehouse

package
v0.33.36-pebble-util Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jul 10, 2024 License: AGPL-3.0 Imports: 14 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var ErrNotExecuted = fmt.Errorf("block is not executed")

Functions

func NewPrunedError 

func NewPrunedError(height uint64, prunedHeight uint64, prunedID flow.Identifier) error

Types

type BlockEndStateSnapshot 

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

BlockEndStateSnapshot represents the storage at the end of a block.

func NewBlockEndStateSnapshot 

func NewBlockEndStateSnapshot(
	storage execution.RegisterStore,
	blockID flow.Identifier,
	height uint64,
) *BlockEndStateSnapshot

the caller must ensure the block height is for the given block

func (*BlockEndStateSnapshot) Get 

func (s *BlockEndStateSnapshot) Get(id flow.RegisterID) (flow.RegisterValue, error)

Get returns the value of the register with the given register ID. It returns: - (value, nil) if the register exists - (nil, nil) if the register does not exist - (nil, storage.ErrHeightNotIndexed) if the height is below the first height that is indexed. - (nil, storehouse.ErrNotExecuted) if the block is not executed yet - (nil, storehouse.ErrNotExecuted) if the block is conflicting with finalized block - (nil, err) for any other exceptions

type ExecutingBlockSnapshot 

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

ExecutingBlockSnapshot is a snapshot of the storage at an executed collection. It starts with a storage snapshot at the end of previous block, The register updates at the executed collection at baseHeight + 1 are cached in a map, such that retrieving register values at the snapshot will first check the cache, and then the storage.

func NewExecutingBlockSnapshot 

func NewExecutingBlockSnapshot(
	previous snapshot.StorageSnapshot,

	commitment flow.StateCommitment,
) *ExecutingBlockSnapshot

create a new storage snapshot for an executed collection at the base block at height h - 1

func (*ExecutingBlockSnapshot) Commitment 

func (s *ExecutingBlockSnapshot) Commitment() flow.StateCommitment

func (*ExecutingBlockSnapshot) Extend 

func (s *ExecutingBlockSnapshot) Extend(newCommit flow.StateCommitment, updates map[flow.RegisterID]flow.RegisterValue) execution.ExtendableStorageSnapshot

Extend returns a new storage snapshot at the same block but but for a different state commitment, which contains the given registerUpdates Usually it's used to create a new storage snapshot at the next executed collection. The registerUpdates contains the register updates at the executed collection.

func (*ExecutingBlockSnapshot) Get 

func (s *ExecutingBlockSnapshot) Get(id flow.RegisterID) (flow.RegisterValue, error)

Get returns the register value at the snapshot.

type InMemoryRegisterStore 

type InMemoryRegisterStore struct {
	sync.RWMutex
	// contains filtered or unexported fields
}

func NewInMemoryRegisterStore 

func NewInMemoryRegisterStore(lastHeight uint64, lastID flow.Identifier) *InMemoryRegisterStore

func (*InMemoryRegisterStore) GetRegister 

func (s *InMemoryRegisterStore) GetRegister(height uint64, blockID flow.Identifier, register flow.RegisterID) (flow.RegisterValue, error)

GetRegister will return the latest updated value of the given register since the pruned height. It returns PrunedError if the register is unknown or not updated since the pruned height Can't return ErrNotFound, since we can't distinguish between not found or not updated since the pruned height

func (*InMemoryRegisterStore) GetUpdatedRegisters 

func (s *InMemoryRegisterStore) GetUpdatedRegisters(height uint64, blockID flow.Identifier) (flow.RegisterEntries, error)

GetUpdatedRegisters returns the updated registers of a block

func (*InMemoryRegisterStore) IsBlockExecuted 

func (s *InMemoryRegisterStore) IsBlockExecuted(height uint64, blockID flow.Identifier) (bool, error)

func (*InMemoryRegisterStore) Prune 

func (s *InMemoryRegisterStore) Prune(height uint64, blockID flow.Identifier) error

Prune prunes the register store to the given height The pruned height must be an executed block, the caller should ensure that by calling SaveRegisters before.

Pruning is done by walking up the finalized fork from `s.prunedHeight` to `height`. At each height, prune all other forks that begin at that height. This ensures that data for all conflicting forks are freed

TODO: It does not block the caller, the pruning work is done async

func (*InMemoryRegisterStore) PrunedHeight 

func (s *InMemoryRegisterStore) PrunedHeight() uint64

func (*InMemoryRegisterStore) SaveRegisters 

func (s *InMemoryRegisterStore) SaveRegisters(
	height uint64,
	blockID flow.Identifier,
	parentID flow.Identifier,
	registers flow.RegisterEntries,
) error

SaveRegisters saves the registers of a block to InMemoryRegisterStore It needs to ensure the block is above the pruned height and is connected to the pruned block

type NoopNotifier 

type NoopNotifier struct{}

func NewNoopNotifier 

func NewNoopNotifier() *NoopNotifier

func (*NoopNotifier) OnFinalizedAndExecutedHeightUpdated 

func (n *NoopNotifier) OnFinalizedAndExecutedHeightUpdated(height uint64)

type PrunedError 

type PrunedError struct {
	PrunedHeight uint64
	PrunedID     flow.Identifier
	Height       uint64
}

func IsPrunedError 

func IsPrunedError(err error) (PrunedError, bool)

func (PrunedError) Error 

func (e PrunedError) Error() string

type RegisterEngine 

type RegisterEngine struct {
	*component.ComponentManager
	// contains filtered or unexported fields
}

RegisterEngine is a wrapper for RegisterStore in order to make Block Finalization process non-blocking.

func NewRegisterEngine 

func NewRegisterEngine(store *RegisterStore) *RegisterEngine

func (*RegisterEngine) OnBlockFinalized 

func (e *RegisterEngine) OnBlockFinalized(*model.Block)

OnBlockFinalized will create a single goroutine to notify register store when a block is finalized. This call is non-blocking in order to avoid blocking the consensus

type RegisterStore 

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

func NewRegisterStore 

func NewRegisterStore(
	diskStore execution.OnDiskRegisterStore,
	wal execution.ExecutedFinalizedWAL,
	finalized execution.FinalizedReader,
	log zerolog.Logger,
	notifier execution.RegisterStoreNotifier,
) (*RegisterStore, error)

func (*RegisterStore) GetRegister 

func (r *RegisterStore) GetRegister(height uint64, blockID flow.Identifier, register flow.RegisterID) (flow.RegisterValue, error)

GetRegister first try to get the register from InMemoryRegisterStore, then OnDiskRegisterStore 1. below pruned height, and is conflicting 2. below pruned height, and is finalized 3. above pruned height, and is not executed 4. above pruned height, and is executed, and register is updated 5. above pruned height, and is executed, but register is not updated since pruned height It returns:

  • (value, nil) if the register value is found at the given block
  • (nil, nil) if the register is not found
  • (nil, storage.ErrHeightNotIndexed) if the height is below the first height that is indexed.
  • (nil, storehouse.ErrNotExecuted) if the block is not executed yet
  • (nil, storehouse.ErrNotExecuted) if the block is conflicting iwth finalized block
  • (nil, err) for any other exceptions

func (*RegisterStore) IsBlockExecuted 

func (r *RegisterStore) IsBlockExecuted(height uint64, blockID flow.Identifier) (bool, error)

IsBlockExecuted returns true if the block is executed, false if not executed Note: it returns (true, nil) even if the block has been pruned from on disk register store,

func (*RegisterStore) LastFinalizedAndExecutedHeight 

func (r *RegisterStore) LastFinalizedAndExecutedHeight() uint64

LastFinalizedAndExecutedHeight returns the height of the last finalized and executed block, which has been saved in OnDiskRegisterStore

func (*RegisterStore) OnBlockFinalized 

func (r *RegisterStore) OnBlockFinalized() error

Depend on FinalizedReader's FinalizedBlockIDAtHeight Depend on ExecutedFinalizedWAL.Append Depend on OnDiskRegisterStore.SaveRegisters OnBlockFinalized trigger the check of whether a block at the next height becomes finalized and executed. the next height is the existing finalized and executed block's height + 1. If a block at next height becomes finalized and executed, then: 1. write the registers to write ahead logs 2. save the registers of the block to OnDiskRegisterStore 3. prune the height in InMemoryRegisterStore

func (*RegisterStore) SaveRegisters 

func (r *RegisterStore) SaveRegisters(header *flow.Header, registers flow.RegisterEntries) error

SaveRegisters saves to InMemoryRegisterStore first, then trigger the same check as OnBlockFinalized Depend on InMemoryRegisterStore.SaveRegisters It returns: - nil if the registers are saved successfully - exception is the block is above the pruned height but does not connect to the pruned height (conflicting block). - exception if the block is below the pruned height - exception if the save block is saved again - exception for any other exception

type RegisterStoreMetrics 

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

func NewRegisterStoreMetrics 

func NewRegisterStoreMetrics(collector module.ExecutionMetrics) *RegisterStoreMetrics

func (*RegisterStoreMetrics) OnFinalizedAndExecutedHeightUpdated 

func (m *RegisterStoreMetrics) OnFinalizedAndExecutedHeightUpdated(height uint64)

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.