Struct linera_execution::ExecutionStateView

pub struct ExecutionStateView<C> {
    pub system: SystemExecutionStateView<C>,
    pub users: HashedReentrantCollectionView<C, UserApplicationId, KeyValueStoreView<C>>,
}

A view accessing the execution state of a chain.

Fields

system: SystemExecutionStateView<C>

System application.

users: HashedReentrantCollectionView<C, UserApplicationId, KeyValueStoreView<C>>

User applications.

Implementations

impl ExecutionStateView<MemoryContext<TestExecutionRuntimeContext>>

where MemoryContext<TestExecutionRuntimeContext>: Context + Clone + Send + Sync + 'static,

pub async fn simulate_instantiation( &mut self, contract: UserContractCode, local_time: Timestamp, application_description: UserApplicationDescription, instantiation_argument: Vec<u8>, contract_blob: Blob, service_blob: Blob, ) -> Result<(), ExecutionError>

Simulates the instantiation of an application.

impl<C> ExecutionStateView<C>

where C: Context + Clone + Send + Sync + 'static, C::Extra: ExecutionRuntimeContext,

pub async fn update_execution_outcomes_with_app_registrations( &self, txn_tracker: &mut TransactionTracker, ) -> Result<(), ExecutionError>

Schedules application registration messages when needed.

Ensures that the outgoing messages in results are preceded by a system message that registers the application that will handle the messages.

pub async fn execute_operation( &mut self, context: OperationContext, local_time: Timestamp, operation: Operation, txn_tracker: &mut TransactionTracker, resource_controller: &mut ResourceController<Option<Owner>>, ) -> Result<(), ExecutionError>

pub async fn execute_message( &mut self, context: MessageContext, local_time: Timestamp, message: Message, grant: Option<&mut Amount>, txn_tracker: &mut TransactionTracker, resource_controller: &mut ResourceController<Option<Owner>>, ) -> Result<(), ExecutionError>

pub async fn bounce_message( &self, context: MessageContext, grant: Amount, message: Message, txn_tracker: &mut TransactionTracker, ) -> Result<(), ExecutionError>

pub async fn send_refund( &self, context: MessageContext, amount: Amount, account: Account, txn_tracker: &mut TransactionTracker, ) -> Result<(), ExecutionError>

pub async fn query_application( &mut self, context: QueryContext, query: Query, endpoint: Option<&mut ServiceRuntimeEndpoint>, ) -> Result<QueryOutcome, ExecutionError>

pub async fn list_applications( &self, ) -> Result<Vec<(UserApplicationId, UserApplicationDescription)>, ExecutionError>

Trait Implementations

impl<C> ClonableView<C> for ExecutionStateView<C>

where C: Context + Send + Sync + Clone + 'static,

fn clone_unchecked(&mut self) -> Result<Self, ViewError>

Creates a clone of this view, sharing the underlying storage context but prone to data races which can corrupt the view state.

impl<C: Send + Sync + Context> ContainerType for ExecutionStateView<C>

async fn resolve_field(&self, ctx: &Context<'_>) -> ServerResult<Option<Value>>

Resolves a field value and outputs it as a json value async_graphql::Value.

async fn find_entity( &self, ctx: &Context<'_>, params: &Value, ) -> ServerResult<Option<Value>>

Find the GraphQL entity with the given name from the parameter.

fn collect_all_fields<'a>( &'a self, ctx: &ContextBase<'a, &'a Positioned<SelectionSet>>, fields: &mut Fields<'a>, ) -> Result<(), ServerError>

where Self: Send + Sync,

Collect all the fields of the container that are queried in the selection set.

impl<C> CryptoHashView<C> for ExecutionStateView<C>

where C: Context + Send + Sync + Clone + 'static,

fn crypto_hash<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<CryptoHash, ViewError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Computing the hash and attributing the type to it.

fn crypto_hash_mut<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<CryptoHash, ViewError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Computing the hash and attributing the type to it.

impl<C: Debug> Debug for ExecutionStateView<C>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<C> HashableView<C> for ExecutionStateView<C>

where C: Context + Send + Sync + Clone + 'static,

type Hasher = CoreWrapper<Sha3_256Core>

How to compute hashes.

fn hash_mut<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<<Self::Hasher as Hasher>::Output, ViewError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Computes the hash of the values.

fn hash<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<<Self::Hasher as Hasher>::Output, ViewError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Computes the hash of the values.

impl<C: Send + Sync + Context> OutputType for ExecutionStateView<C>

fn type_name() -> Cow<'static, str>

Type the name.

fn create_type_info(registry: &mut Registry) -> String

Create type information in the registry and return qualified typename.

async fn resolve( &self, ctx: &ContextSelectionSet<'_>, _field: &Positioned<Field>, ) -> ServerResult<Value>

Resolve an output value to async_graphql::Value.

fn qualified_type_name() -> String

Qualified typename.

fn introspection_type_name(&self) -> Cow<'static, str>

Introspection type name

impl<C> RegisterMockApplication for ExecutionStateView<C>

where C: Context + Clone + Send + Sync + 'static, C::Extra: ExecutionRuntimeContext,

fn creator_chain_id(&self) -> ChainId

Returns the chain to use for the creation of the application.

async fn registered_application_count(&self) -> Result<usize>

Returns the amount of known registered applications.

async fn register_mock_application_with( &mut self, description: UserApplicationDescription, contract: Blob, service: Blob, ) -> Result<(UserApplicationId, MockApplication)>

Registers a new MockApplication associated with a UserApplicationDescription and its bytecode Blobs.

async fn register_mock_application( &mut self, ) -> Result<(UserApplicationId, MockApplication)>

Registers a new MockApplication and returns it with the UserApplicationId that was used for it.

impl<C> View<C> for ExecutionStateView<C>

where C: Context + Send + Sync + Clone + 'static,

const NUM_INIT_KEYS: usize = 23usize

The number of keys used for the initialization

fn context(&self) -> &C

Obtains a mutable reference to the internal context.

fn pre_load(context: &C) -> Result<Vec<Vec<u8>>, ViewError>

Creates the keys needed for loading the view

fn post_load(context: C, values: &[Option<Vec<u8>>]) -> Result<Self, ViewError>

Loads a view from the values

fn load<'async_trait>( context: C, ) -> Pin<Box<dyn Future<Output = Result<Self, ViewError>> + Send + 'async_trait>>

where Self: 'async_trait,

Loads a view

fn rollback(&mut self)

Discards all pending changes. After that flush should have no effect to storage.

fn has_pending_changes<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = bool> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns true if flushing this view would result in changes to the persistent storage.

fn flush(&mut self, batch: &mut Batch) -> Result<bool, ViewError>

Persists changes to storage. This leaves the view still usable and is essentially neutral to the program running. Crash-resistant storage implementations are expected to accumulate the desired changes in the batch variable first. If the view is dropped without calling flush, staged changes are simply lost. The returned boolean indicates whether the operation removes the view or not.

fn clear(&mut self)

Clears the view. That can be seen as resetting to default. If the clear is followed by a flush then all the relevant data is removed on the storage.

fn new(context: C) -> Result<Self, ViewError>

Builds a trivial view that is already deleted

impl<C: Send + Sync + Context> ObjectType for ExecutionStateView<C>