backend

package
v0.34.0-crescendo-prev... Latest Latest
Warning

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

Go to latest
Published: Feb 27, 2024 License: AGPL-3.0 Imports: 39 Imported by: 4

Documentation

Index

Constants

View Source
const DefaultConnectionPoolSize = 250

DefaultConnectionPoolSize is the default size for the connection pool to collection and execution nodes

View Source
const DefaultLoggedScriptsCacheSize = 1_000_000

DefaultLoggedScriptsCacheSize is the default size of the lookup cache used to dedupe logs of scripts sent to ENs limiting cache size to 16MB and does not affect script execution, only for keeping logs tidy

View Source
const DefaultMaxHeightRange = 250

DefaultMaxHeightRange is the default maximum size of range requests.

View Source
const DefaultSnapshotHistoryLimit = 500

DefaultSnapshotHistoryLimit the amount of blocks to look back in state when recursively searching for a valid snapshot

Variables

View Source
var ErrSnapshotPhaseMismatch = errors.New("snapshot does not contain a valid sealing segment")

ErrSnapshotPhaseMismatch indicates that a valid sealing segment cannot be build for a snapshot because the snapshot requested spans either an epoch transition or phase transition.

View Source
var SnapshotHistoryLimitErr = fmt.Errorf("reached the snapshot history limit")

Functions

func IsInsufficientExecutionReceipts added in v0.30.0

func IsInsufficientExecutionReceipts(err error) bool

func NewNetworkAPI added in v0.28.0

func NewNetworkAPI(
	state protocol.State,
	chainID flow.ChainID,
	headers storage.Headers,
	snapshotHistoryLimit int,
) *backendNetwork

NetworkAPI func

The observer and access nodes need to be able to handle GetNetworkParameters and GetLatestProtocolStateSnapshot RPCs so this logic was split into the backendNetwork so that we can ignore the rest of the backend logic

Types

type Backend

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

Backend implements the Access API.

It is composed of several sub-backends that implement part of the Access API.

Script related calls are handled by backendScripts. Transaction related calls are handled by backendTransactions. Block Header related calls are handled by backendBlockHeaders. Block details related calls are handled by backendBlockDetails. Event related calls are handled by backendEvents. Account related calls are handled by backendAccounts.

All remaining calls are handled by the base Backend in this file.

func New

func New(params Params) (*Backend, error)

New creates backend instance

func (*Backend) ExecuteScriptAtBlockHeight

func (b *Backend) ExecuteScriptAtBlockHeight(
	ctx context.Context,
	blockHeight uint64,
	script []byte,
	arguments [][]byte,
) ([]byte, error)

ExecuteScriptAtBlockHeight executes provided script at the provided block height.

func (*Backend) ExecuteScriptAtBlockID

func (b *Backend) ExecuteScriptAtBlockID(
	ctx context.Context,
	blockID flow.Identifier,
	script []byte,
	arguments [][]byte,
) ([]byte, error)

ExecuteScriptAtBlockID executes provided script at the provided block ID.

func (*Backend) ExecuteScriptAtLatestBlock

func (b *Backend) ExecuteScriptAtLatestBlock(
	ctx context.Context,
	script []byte,
	arguments [][]byte,
) ([]byte, error)

ExecuteScriptAtLatestBlock executes provided script at the latest sealed block.

func (*Backend) GetAccount

func (b *Backend) GetAccount(ctx context.Context, address flow.Address) (*flow.Account, error)

GetAccount returns the account details at the latest sealed block. Alias for GetAccountAtLatestBlock

func (*Backend) GetAccountAtBlockHeight

func (b *Backend) GetAccountAtBlockHeight(
	ctx context.Context,
	address flow.Address,
	height uint64,
) (*flow.Account, error)

GetAccountAtBlockHeight returns the account details at the given block height

func (*Backend) GetAccountAtLatestBlock

func (b *Backend) GetAccountAtLatestBlock(ctx context.Context, address flow.Address) (*flow.Account, error)

GetAccountAtLatestBlock returns the account details at the latest sealed block.

func (*Backend) GetBlockByHeight

func (b *Backend) GetBlockByHeight(ctx context.Context, height uint64) (*flow.Block, flow.BlockStatus, error)

func (*Backend) GetBlockByID

func (b *Backend) GetBlockByID(ctx context.Context, id flow.Identifier) (*flow.Block, flow.BlockStatus, error)

func (*Backend) GetBlockHeaderByHeight

func (b *Backend) GetBlockHeaderByHeight(ctx context.Context, height uint64) (*flow.Header, flow.BlockStatus, error)

func (*Backend) GetBlockHeaderByID

func (b *Backend) GetBlockHeaderByID(ctx context.Context, id flow.Identifier) (*flow.Header, flow.BlockStatus, error)

func (*Backend) GetCollectionByID

func (b *Backend) GetCollectionByID(_ context.Context, colID flow.Identifier) (*flow.LightCollection, error)

func (*Backend) GetEventsForBlockIDs

func (b *Backend) GetEventsForBlockIDs(
	ctx context.Context,
	eventType string,
	blockIDs []flow.Identifier,
	requiredEventEncodingVersion entities.EventEncodingVersion,
) ([]flow.BlockEvents, error)

GetEventsForBlockIDs retrieves events for all the specified block IDs that have the given type

func (*Backend) GetEventsForHeightRange

func (b *Backend) GetEventsForHeightRange(
	ctx context.Context,
	eventType string,
	startHeight, endHeight uint64,
	requiredEventEncodingVersion entities.EventEncodingVersion,
) ([]flow.BlockEvents, error)

GetEventsForHeightRange retrieves events for all sealed blocks between the start block height and the end block height (inclusive) that have the given type.

func (*Backend) GetExecutionResultByID added in v0.23.5

func (b *Backend) GetExecutionResultByID(ctx context.Context, id flow.Identifier) (*flow.ExecutionResult, error)

GetExecutionResultByID gets an execution result by its ID.

func (*Backend) GetExecutionResultForBlockID added in v0.21.0

func (b *Backend) GetExecutionResultForBlockID(ctx context.Context, blockID flow.Identifier) (*flow.ExecutionResult, error)

func (*Backend) GetLatestBlock

func (b *Backend) GetLatestBlock(ctx context.Context, isSealed bool) (*flow.Block, flow.BlockStatus, error)

func (*Backend) GetLatestBlockHeader

func (b *Backend) GetLatestBlockHeader(ctx context.Context, isSealed bool) (*flow.Header, flow.BlockStatus, error)

func (*Backend) GetLatestProtocolStateSnapshot added in v0.15.0

func (b *Backend) GetLatestProtocolStateSnapshot(_ context.Context) ([]byte, error)

GetLatestProtocolStateSnapshot returns the latest finalized snapshot

func (*Backend) GetNetworkParameters

func (b *Backend) GetNetworkParameters(_ context.Context) access.NetworkParameters

func (*Backend) GetNodeVersionInfo added in v0.31.0

func (b *Backend) GetNodeVersionInfo(_ context.Context) (*access.NodeVersionInfo, error)

GetNodeVersionInfo returns node version information such as semver, commit, sporkID, protocolVersion, etc

func (*Backend) GetProtocolStateSnapshotByBlockID added in v0.33.1

func (b *Backend) GetProtocolStateSnapshotByBlockID(_ context.Context, blockID flow.Identifier) ([]byte, error)

GetProtocolStateSnapshotByBlockID returns serializable Snapshot for a block, by blockID. The requested block must be finalized, otherwise an error is returned. Expected errors during normal operation:

  • status.Error[codes.NotFound] - No block with the given ID was found
  • status.Error[codes.InvalidArgument] - Block ID will never have a valid snapshot: 1. A block was found, but it is not finalized and is below the finalized height, so it will never be finalized. 2. A block was found, however its sealing segment spans an epoch phase transition, yielding an invalid snapshot.
  • status.Error[codes.FailedPrecondition] - A block was found, but it is not finalized and is above the finalized height. The block may or may not be finalized in the future; the client can retry later.

func (*Backend) GetProtocolStateSnapshotByHeight added in v0.33.1

func (b *Backend) GetProtocolStateSnapshotByHeight(_ context.Context, blockHeight uint64) ([]byte, error)

GetProtocolStateSnapshotByHeight returns serializable Snapshot by block height. The block must be finalized (otherwise the by-height query is ambiguous). Expected errors during normal operation:

  • status.Error[codes.NotFound] - No block with the given height was found. The block height may or may not be finalized in the future; the client can retry later.
  • status.Error[codes.InvalidArgument] - A block was found, however its sealing segment spans an epoch phase transition, yielding an invalid snapshot. Therefore we will never return a snapshot for this block height.

func (*Backend) GetSystemTransaction added in v0.33.1

func (b *Backend) GetSystemTransaction(ctx context.Context, _ flow.Identifier) (*flow.TransactionBody, error)

GetSystemTransaction returns system transaction

func (*Backend) GetSystemTransactionResult added in v0.33.1

func (b *Backend) GetSystemTransactionResult(ctx context.Context, blockID flow.Identifier, requiredEventEncodingVersion entities.EventEncodingVersion) (*access.TransactionResult, error)

GetSystemTransactionResult returns system transaction result

func (*Backend) GetTransaction

func (b *Backend) GetTransaction(ctx context.Context, txID flow.Identifier) (*flow.TransactionBody, error)

func (*Backend) GetTransactionResult

func (b *Backend) GetTransactionResult(
	ctx context.Context,
	txID flow.Identifier,
	blockID flow.Identifier,
	collectionID flow.Identifier,
	requiredEventEncodingVersion entities.EventEncodingVersion,
) (*access.TransactionResult, error)

func (*Backend) GetTransactionResultByIndex added in v0.24.8

func (b *Backend) GetTransactionResultByIndex(
	ctx context.Context,
	blockID flow.Identifier,
	index uint32,
	requiredEventEncodingVersion entities.EventEncodingVersion,
) (*access.TransactionResult, error)

GetTransactionResultByIndex returns transactions Results for an index in a block that is executed, pending or finalized transactions return errors

func (*Backend) GetTransactionResultsByBlockID added in v0.24.11

func (b *Backend) GetTransactionResultsByBlockID(
	ctx context.Context,
	blockID flow.Identifier,
	requiredEventEncodingVersion entities.EventEncodingVersion,
) ([]*access.TransactionResult, error)

func (*Backend) GetTransactionsByBlockID added in v0.24.11

func (b *Backend) GetTransactionsByBlockID(
	_ context.Context,
	blockID flow.Identifier,
) ([]*flow.TransactionBody, error)

func (*Backend) Ping

func (b *Backend) Ping(ctx context.Context) error

Ping responds to requests when the server is up.

func (*Backend) ProcessFinalizedBlockHeight added in v0.33.1

func (b *Backend) ProcessFinalizedBlockHeight(height uint64) error

ATTENTION: might be a source of problems in future. We run this code on finalization gorotuine, potentially lagging finalization events if operations take long time. We might need to move this logic on dedicated goroutine and provide a way to skip finalization events if they are delivered too often for this engine. An example of similar approach - https://github.com/onflow/flow-go/blob/10b0fcbf7e2031674c00f3cdd280f27bd1b16c47/engine/common/follower/compliance_engine.go#L201.. No errors expected during normal operations.

func (*Backend) SendRawTransaction

func (b *Backend) SendRawTransaction(
	ctx context.Context,
	tx *flow.TransactionBody,
) error

SendRawTransaction sends a raw transaction to the collection node

func (*Backend) SendTransaction

func (b *Backend) SendTransaction(
	ctx context.Context,
	tx *flow.TransactionBody,
) error

SendTransaction forwards the transaction to the collection node

type Communicator added in v0.32.0

type Communicator interface {
	CallAvailableNode(

		nodes flow.IdentitySkeletonList,

		call func(node *flow.IdentitySkeleton) error,

		shouldTerminateOnError func(node *flow.IdentitySkeleton, err error) bool,
	) error
}

type Config added in v0.32.0

type Config struct {
	ExecutionClientTimeout    time.Duration                   // execution API GRPC client timeout
	CollectionClientTimeout   time.Duration                   // collection API GRPC client timeout
	ConnectionPoolSize        uint                            // size of the cache for storing collection and execution connections
	MaxHeightRange            uint                            // max size of height range requests
	PreferredExecutionNodeIDs []string                        // preferred list of upstream execution node IDs
	FixedExecutionNodeIDs     []string                        // fixed list of execution node IDs to choose from if no node ID can be chosen from the PreferredExecutionNodeIDs
	CircuitBreakerConfig      connection.CircuitBreakerConfig // the configuration for circuit breaker
	ScriptExecutionMode       string                          // the mode in which scripts are executed
	EventQueryMode            string                          // the mode in which events are queried
}

Config defines the configurable options for creating Backend

type EventsIndex added in v0.33.9

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

func NewEventsIndex added in v0.33.9

func NewEventsIndex(events storage.Events) *EventsIndex

func (*EventsIndex) GetEvents added in v0.33.9

func (e *EventsIndex) GetEvents(blockID flow.Identifier, height uint64) ([]flow.Event, error)

func (*EventsIndex) HighestIndexedHeight added in v0.33.9

func (e *EventsIndex) HighestIndexedHeight() (uint64, error)

HighestIndexedHeight returns the highest height indexed by the execution state indexer. Expected errors: - indexer.ErrIndexNotInitialized: if the EventsIndex has not been initialized

func (*EventsIndex) Initialize added in v0.33.9

func (e *EventsIndex) Initialize(indexReporter state_synchronization.IndexReporter) error

func (*EventsIndex) LowestIndexedHeight added in v0.33.9

func (e *EventsIndex) LowestIndexedHeight() (uint64, error)

LowestIndexedHeight returns the lowest height indexed by the execution state indexer. Expected errors: - indexer.ErrIndexNotInitialized: if the EventsIndex has not been initialized

type IndexQueryMode added in v0.33.1

type IndexQueryMode int
const (
	// IndexQueryModeLocalOnly executes scripts and gets accounts using only local storage
	IndexQueryModeLocalOnly IndexQueryMode = iota + 1

	// IndexQueryModeExecutionNodesOnly executes scripts and gets accounts using only
	// execution nodes
	IndexQueryModeExecutionNodesOnly

	// IndexQueryModeFailover executes scripts and gets accounts using local storage first,
	// then falls back to execution nodes if data is not available for the height or if request
	// failed due to a non-user error.
	IndexQueryModeFailover

	// IndexQueryModeCompare executes scripts and gets accounts using both local storage and
	// execution nodes and compares the results. The execution node result is always returned.
	IndexQueryModeCompare
)

func ParseIndexQueryMode added in v0.33.1

func ParseIndexQueryMode(s string) (IndexQueryMode, error)

func (IndexQueryMode) String added in v0.33.1

func (m IndexQueryMode) String() string

type InsufficientExecutionReceipts added in v0.17.0

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

InsufficientExecutionReceipts indicates that no execution receipt were found for a given block ID

func (InsufficientExecutionReceipts) Error added in v0.17.0

type MainNodeSelector added in v0.32.0

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

MainNodeSelector is a specific implementation of the node selector. Which performs in-order node selection using fixed list of pre-defined nodes.

func NewMainNodeSelector added in v0.32.0

func NewMainNodeSelector(nodes flow.IdentitySkeletonList) *MainNodeSelector

func (*MainNodeSelector) HasNext added in v0.32.0

func (e *MainNodeSelector) HasNext() bool

HasNext returns true if next node is available.

func (*MainNodeSelector) Next added in v0.32.0

Next returns the next node in the selector.

type NodeCommunicator added in v0.32.0

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

NodeCommunicator is responsible for calling available nodes in the backend.

func NewNodeCommunicator added in v0.32.0

func NewNodeCommunicator(circuitBreakerEnabled bool) *NodeCommunicator

NewNodeCommunicator creates a new instance of NodeCommunicator.

func (*NodeCommunicator) CallAvailableNode added in v0.32.0

func (b *NodeCommunicator) CallAvailableNode(

	nodes flow.IdentitySkeletonList,

	call func(id *flow.IdentitySkeleton) error,

	shouldTerminateOnError func(node *flow.IdentitySkeleton, err error) bool,
) error

CallAvailableNode calls the provided function on the available nodes. It iterates through the nodes and executes the function. If an error occurs, it applies the custom error terminator (if provided) and keeps track of the errors. If the error occurs in circuit breaker, it continues to the next node. If the maximum failed request count is reached, it returns the accumulated errors.

type NodeSelector added in v0.32.0

type NodeSelector interface {
	Next() *flow.IdentitySkeleton
	HasNext() bool
}

NodeSelector is an interface that represents the ability to select node identities that the access node is trying to reach. It encapsulates the internal logic of node selection and provides a way to change implementations for different types of nodes. Implementations of this interface should define the Next method, which returns the next node identity to be selected. HasNext checks if there is next node available.

type NodeSelectorFactory added in v0.32.0

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

NodeSelectorFactory is a factory for creating node selectors based on factory configuration and node type. Supported configurations: circuitBreakerEnabled = true - nodes will be pseudo-randomly sampled and picked in-order. circuitBreakerEnabled = false - nodes will be picked from proposed list in-order without any changes.

func (*NodeSelectorFactory) SelectNodes added in v0.32.0

SelectNodes selects the configured number of node identities from the provided list of nodes and returns the node selector to iterate through them.

type Params added in v0.32.0

type Params struct {
	State                     protocol.State
	CollectionRPC             accessproto.AccessAPIClient
	HistoricalAccessNodes     []accessproto.AccessAPIClient
	Blocks                    storage.Blocks
	Headers                   storage.Headers
	Collections               storage.Collections
	Transactions              storage.Transactions
	ExecutionReceipts         storage.ExecutionReceipts
	ExecutionResults          storage.ExecutionResults
	LightTransactionResults   storage.LightTransactionResults
	ChainID                   flow.ChainID
	AccessMetrics             module.AccessMetrics
	ConnFactory               connection.ConnectionFactory
	RetryEnabled              bool
	MaxHeightRange            uint
	PreferredExecutionNodeIDs []string
	FixedExecutionNodeIDs     []string
	Log                       zerolog.Logger
	SnapshotHistoryLimit      int
	Communicator              Communicator
	TxResultCacheSize         uint
	TxErrorMessagesCacheSize  uint
	ScriptExecutor            execution.ScriptExecutor
	ScriptExecutionMode       IndexQueryMode
	EventQueryMode            IndexQueryMode
	EventsIndex               *EventsIndex
}

type Retry

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

Retry implements a simple retry mechanism for transaction submission.

func (*Retry) Activate

func (r *Retry) Activate() *Retry

func (*Retry) IsActive

func (r *Retry) IsActive() bool

func (*Retry) RegisterTransaction

func (r *Retry) RegisterTransaction(height uint64, tx *flow.TransactionBody)

RegisterTransaction adds a transaction that could possibly be retried

func (*Retry) Retry

func (r *Retry) Retry(height uint64) error

Retry attempts to resend transactions for a specified block height. It performs cleanup operations, including pruning old transactions, and retries sending transactions that are still pending. The method takes a block height as input. If the provided height is lower than flow.DefaultTransactionExpiry, no retries are performed, and the method returns nil. No errors expected during normal operations.

func (*Retry) SetBackend

func (r *Retry) SetBackend(b *Backend) *Retry

type ScriptExecutor added in v0.32.2

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

func NewScriptExecutor added in v0.32.2

func NewScriptExecutor(log zerolog.Logger, minHeight, maxHeight uint64) *ScriptExecutor

func (*ScriptExecutor) ExecuteAtBlockHeight added in v0.32.2

func (s *ScriptExecutor) ExecuteAtBlockHeight(ctx context.Context, script []byte, arguments [][]byte, height uint64) ([]byte, error)

ExecuteAtBlockHeight executes provided script at the provided block height against a local execution state.

Expected errors:

  • storage.ErrNotFound if the register or block height is not found
  • storage.ErrHeightNotIndexed if the data for the block height is not available. this could be because the height is not within the index block range, or the index is not ready.

func (*ScriptExecutor) GetAccountAtBlockHeight added in v0.32.2

func (s *ScriptExecutor) GetAccountAtBlockHeight(ctx context.Context, address flow.Address, height uint64) (*flow.Account, error)

GetAccountAtBlockHeight returns the account at the provided block height from a local execution state.

Expected errors:

  • storage.ErrNotFound if the account or block height is not found
  • storage.ErrHeightNotIndexed if the data for the block height is not available. this could be because the height is not within the index block range, or the index is not ready.

func (*ScriptExecutor) Initialize added in v0.33.9

func (s *ScriptExecutor) Initialize(indexReporter state_synchronization.IndexReporter, scriptExecutor *execution.Scripts) error

Initialize initializes the indexReporter and script executor This method can be called at any time after the ScriptExecutor object is created. Any requests made to the other methods will return storage.ErrHeightNotIndexed until this method is called.

func (*ScriptExecutor) SetMaxCompatibleHeight added in v0.32.10

func (s *ScriptExecutor) SetMaxCompatibleHeight(height uint64)

SetMaxCompatibleHeight sets the highest block height (inclusive) that can be queried using local execution Use this to limit the executable block range supported by the node's current software version.

func (*ScriptExecutor) SetMinCompatibleHeight added in v0.32.10

func (s *ScriptExecutor) SetMinCompatibleHeight(height uint64)

SetMinCompatibleHeight sets the lowest block height (inclusive) that can be queried using local execution Use this to limit the executable block range supported by the node's current software version.

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL