Struct DbStorage 

pub struct DbStorage<Database, Clock = WallClock> { /* private fields */ }

Main implementation of the Storage trait.

Implementations

impl<Database, C> DbStorage<Database, C>

where Database: KeyValueDatabase + Clone + 'static, Database::Error: Send + Sync, Database::Store: KeyValueStore + Clone + 'static, C: Clock + Clone + Send + Sync + 'static,

pub fn with_allow_application_logs(self, allow: bool) -> Self

Sets whether contract log messages should be output.

impl<Database> DbStorage<Database, WallClock>

where Database: KeyValueDatabase + Clone + 'static, Database::Error: Send + Sync, Database::Store: KeyValueStore + Clone + 'static,

pub async fn maybe_create_and_connect( config: &Database::Config, namespace: &str, wasm_runtime: Option<WasmRuntime>, cache_sizes: StorageCacheConfig, ) -> Result<Self, ViewError>

Connects to the database, creating the given namespace if it does not exist.

pub async fn connect( config: &Database::Config, namespace: &str, wasm_runtime: Option<WasmRuntime>, cache_sizes: StorageCacheConfig, ) -> Result<Self, ViewError>

Connects to an existing namespace in the database.

pub async fn list_blob_ids( config: &Database::Config, namespace: &str, ) -> Result<Vec<BlobId>, ViewError>

Lists the blob IDs of the storage.

impl<Database> DbStorage<Database, WallClock>

where Database: KeyValueDatabase + Clone + Send + Sync + 'static, Database::Error: Send + Sync,

pub async fn list_chain_ids( config: &Database::Config, namespace: &str, ) -> Result<Vec<ChainId>, ViewError>

Lists the chain IDs of the storage.

impl<Database, C> DbStorage<Database, C>

where Database: KeyValueDatabase + Clone + Send + Sync + 'static, Database::Store: KeyValueStore + Clone + Send + Sync + 'static, C: Clock + Clone + Send + Sync + 'static, Database::Error: From<Error> + Send + Sync,

pub async fn migrate_if_needed(&self) -> Result<(), ViewError>

Migrates the storage to the latest schema version if it is out of date.

pub async fn assert_is_migrated_storage(&self) -> Result<(), ViewError>

Assert that the storage is at the last version (or not yet initialized).

Trait Implementations

impl<Database: Clone, Clock: Clone> Clone for DbStorage<Database, Clock>

fn clone(&self) -> DbStorage<Database, Clock>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<Database, C> Storage for DbStorage<Database, C>

where Database: KeyValueDatabase<Store: KeyValueStore + Clone + AutoTraits + 'static, Error: Send + Sync> + Clone + AutoTraits + 'static, C: Clock + Clone + Send + Sync + 'static,

type Context = ViewContext<ChainRuntimeContext<DbStorage<Database, C>>, <Database as KeyValueDatabase>::Store>

The low-level storage implementation in use by the core protocol (chain workers etc).

type Clock = C

The clock type being used.

type BlockExporterContext = ViewContext<u32, <Database as KeyValueDatabase>::Store>

The low-level storage implementation in use by the block exporter.

fn clock(&self) -> &C

Returns the current wall clock time.

fn thread_pool(&self) -> &Arc<ThreadPool>

Returns the thread pool used to offload blocking work.

fn load_chain<'life0, 'async_trait>( &'life0 self, chain_id: ChainId, ) -> Pin<Box<dyn Future<Output = Result<ChainStateView<Self::Context>, ViewError>> + Send + 'async_trait>>

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

Loads the view of a chain state.

fn contains_blob<'life0, 'async_trait>( &'life0 self, blob_id: BlobId, ) -> Pin<Box<dyn Future<Output = Result<bool, ViewError>> + Send + 'async_trait>>

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

Tests the existence of a blob with the given blob ID.

fn missing_blobs<'life0, 'life1, 'async_trait>( &'life0 self, blob_ids: &'life1 [BlobId], ) -> Pin<Box<dyn Future<Output = Result<Vec<BlobId>, ViewError>> + Send + 'async_trait>>

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

Returns what blobs from the input are missing from storage.

fn contains_blob_state<'life0, 'async_trait>( &'life0 self, blob_id: BlobId, ) -> Pin<Box<dyn Future<Output = Result<bool, ViewError>> + Send + 'async_trait>>

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

Tests existence of a blob state with the given blob ID.

fn read_confirmed_block<'life0, 'async_trait>( &'life0 self, hash: CryptoHash, ) -> Pin<Box<dyn Future<Output = Result<Option<CacheArc<ConfirmedBlock>>, ViewError>> + Send + 'async_trait>>

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

Reads the hashed certificate value with the given hash.

fn read_confirmed_blocks<'life0, 'async_trait, I>( &'life0 self, hashes: I, ) -> Pin<Box<dyn Future<Output = Result<Vec<Option<CacheArc<ConfirmedBlock>>>, ViewError>> + Send + 'async_trait>>

where I: 'async_trait + IntoIterator<Item = CryptoHash> + Send, Self: 'async_trait, 'life0: 'async_trait,

Reads a number of confirmed blocks by their hashes.

fn read_blob<'life0, 'async_trait>( &'life0 self, blob_id: BlobId, ) -> Pin<Box<dyn Future<Output = Result<Option<CacheArc<Blob>>, ViewError>> + Send + 'async_trait>>

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

Reads the blob with the given blob ID.

fn read_blobs<'life0, 'life1, 'async_trait>( &'life0 self, blob_ids: &'life1 [BlobId], ) -> Pin<Box<dyn Future<Output = Result<Vec<Option<CacheArc<Blob>>>, ViewError>> + Send + 'async_trait>>

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

Reads the blobs with the given blob IDs.

fn read_blob_state<'life0, 'async_trait>( &'life0 self, blob_id: BlobId, ) -> Pin<Box<dyn Future<Output = Result<Option<BlobState>, ViewError>> + Send + 'async_trait>>

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

Reads the blob state with the given blob ID.

fn read_blob_states<'life0, 'life1, 'async_trait>( &'life0 self, blob_ids: &'life1 [BlobId], ) -> Pin<Box<dyn Future<Output = Result<Vec<Option<BlobState>>, ViewError>> + Send + 'async_trait>>

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

Reads the blob states with the given blob IDs.

fn write_blob<'life0, 'life1, 'async_trait>( &'life0 self, blob: &'life1 Blob, ) -> Pin<Box<dyn Future<Output = Result<(), ViewError>> + Send + 'async_trait>>

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

Writes the given blob.

fn maybe_write_blob_states<'life0, 'life1, 'async_trait>( &'life0 self, blob_ids: &'life1 [BlobId], blob_state: BlobState, ) -> Pin<Box<dyn Future<Output = Result<(), ViewError>> + Send + 'async_trait>>

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

Attempts to write the given blob state. Returns the latest Epoch to have used this blob.

fn maybe_write_blobs<'life0, 'life1, 'async_trait>( &'life0 self, blobs: &'life1 [Blob], ) -> Pin<Box<dyn Future<Output = Result<Vec<bool>, ViewError>> + Send + 'async_trait>>

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

Writes the given blobs, but only if they already have a blob state. Returns true for the blobs that were written.

fn write_blobs<'life0, 'life1, 'async_trait>( &'life0 self, blobs: &'life1 [Blob], ) -> Pin<Box<dyn Future<Output = Result<(), ViewError>> + Send + 'async_trait>>

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

Writes several blobs.

fn write_blobs_and_certificate<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, blobs: &'life1 [Blob], certificate: &'life2 ConfirmedBlockCertificate, ) -> Pin<Box<dyn Future<Output = Result<(), ViewError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Writes blobs and certificate

fn cache_certificate( &self, certificate: ConfirmedBlockCertificate, ) -> CacheArc<ConfirmedBlockCertificate>

Inserts a certificate into the in-memory dedup cache and returns the canonical Arc. If the cache already holds an Arc for this hash, the passed-in certificate is dropped and the existing Arc is returned. This must be used (rather than Arc::new) for any freshly-constructed ConfirmedBlockCertificate that should participate in the “one allocation per content” invariant.

fn cache_blob(&self, blob: Blob) -> CacheArc<Blob>

Inserts a blob into the in-memory dedup cache and returns the canonical Arc. If the cache already holds an Arc for this blob ID, the passed-in blob is dropped and the existing Arc is returned. This must be used (rather than Arc::new) for any freshly-constructed Blob that should participate in the “one allocation per content” invariant.

fn cache_confirmed_block( &self, block: ConfirmedBlock, ) -> CacheArc<ConfirmedBlock>

Inserts a confirmed block into the in-memory dedup cache and returns the canonical Arc. If the cache already holds an Arc for this hash, the passed-in block is dropped and the existing Arc is returned. This must be used (rather than Arc::new) for any freshly-constructed ConfirmedBlock that should participate in the “one allocation per content” invariant.

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

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

Tests existence of the certificate with the given hash.

fn read_certificate<'life0, 'async_trait>( &'life0 self, hash: CryptoHash, ) -> Pin<Box<dyn Future<Output = Result<Option<CacheArc<ConfirmedBlockCertificate>>, ViewError>> + Send + 'async_trait>>

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

Reads the certificate with the given hash.

fn read_certificates<'life0, 'life1, 'async_trait>( &'life0 self, hashes: &'life1 [CryptoHash], ) -> Pin<Box<dyn Future<Output = Result<Vec<Option<CacheArc<ConfirmedBlockCertificate>>>, ViewError>> + Send + 'async_trait>>

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

Reads a number of certificates

fn read_certificates_raw<'life0, 'life1, 'async_trait>( &'life0 self, hashes: &'life1 [CryptoHash], ) -> Pin<Box<dyn Future<Output = Result<Vec<Option<CacheArc<(Vec<u8>, Vec<u8>)>>>, ViewError>> + Send + 'async_trait>>

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

Reads raw certificate bytes by hashes.

fn read_certificate_hashes_by_heights<'life0, 'life1, 'async_trait>( &'life0 self, chain_id: ChainId, heights: &'life1 [BlockHeight], ) -> Pin<Box<dyn Future<Output = Result<Vec<Option<CryptoHash>>, ViewError>> + Send + 'async_trait>>

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

Returns a vector of certificate hashes for the requested chain and heights. The resulting vector maintains the order of the input heights argument. Elements are None if no certificate exists at that height.

fn read_certificates_by_heights_raw<'life0, 'life1, 'async_trait>( &'life0 self, chain_id: ChainId, heights: &'life1 [BlockHeight], ) -> Pin<Box<dyn Future<Output = Result<Vec<Option<CacheArc<(Vec<u8>, Vec<u8>)>>>, ViewError>> + Send + 'async_trait>>

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

Reads raw certificates by heights for a given chain. Returns a vector where each element corresponds to the input height. Elements are None if no certificate exists at that height. Each found certificate is returned as a tuple of (lite_certificate_bytes, confirmed_block_bytes).

fn read_certificates_by_heights<'life0, 'life1, 'async_trait>( &'life0 self, chain_id: ChainId, heights: &'life1 [BlockHeight], ) -> Pin<Box<dyn Future<Output = Result<Vec<Option<CacheArc<ConfirmedBlockCertificate>>>, ViewError>> + Send + 'async_trait>>

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

Reads certificates by heights for a given chain. Returns a vector where each element corresponds to the input height. Elements are None if no certificate exists at that height.

fn write_certificate_height_indices<'life0, 'life1, 'async_trait>( &'life0 self, chain_id: ChainId, indices: &'life1 [(BlockHeight, CryptoHash)], ) -> Pin<Box<dyn Future<Output = Result<(), ViewError>> + Send + 'async_trait>>

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

Writes certificate height index entries for a given chain. This is used to populate the height->hash index when certificates are found via alternative methods (e.g., from chain state).

fn read_event<'life0, 'async_trait>( &'life0 self, event_id: EventId, ) -> Pin<Box<dyn Future<Output = Result<Option<CacheArc<Vec<u8>>>, ViewError>> + Send + 'async_trait>>

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

Reads the event with the given ID.

fn contains_event<'life0, 'async_trait>( &'life0 self, event_id: EventId, ) -> Pin<Box<dyn Future<Output = Result<bool, ViewError>> + Send + 'async_trait>>

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

Tests existence of the event with the given ID.

fn read_events_from_index<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, chain_id: &'life1 ChainId, stream_id: &'life2 StreamId, start_index: u32, ) -> Pin<Box<dyn Future<Output = Result<Vec<IndexAndEvent>, ViewError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Lists all the events from a starting index

fn write_events<'life0, 'async_trait>( &'life0 self, events: impl 'async_trait + IntoIterator<Item = (EventId, Vec<u8>)> + Send, ) -> Pin<Box<dyn Future<Output = Result<(), ViewError>> + Send + 'async_trait>>

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

Writes a vector of events.

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

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

Reads the network description.

fn write_network_description<'life0, 'life1, 'async_trait>( &'life0 self, information: &'life1 NetworkDescription, ) -> Pin<Box<dyn Future<Output = Result<(), ViewError>> + Send + 'async_trait>>

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

Writes the network description.

fn shared_committees(&self) -> &SharedCommittees

Returns the process-global cache of committees by epoch.

fn wasm_runtime(&self) -> Option<WasmRuntime>

Selects the WebAssembly runtime to use for applications (if any).

fn block_exporter_context<'life0, 'async_trait>( &'life0 self, block_exporter_id: u32, ) -> Pin<Box<dyn Future<Output = Result<Self::BlockExporterContext, ViewError>> + Send + 'async_trait>>

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

Returns the storage context used by the block exporter with the given ID.

fn get_or_load_committee<'life0, 'async_trait>( &'life0 self, epoch: Epoch, ) -> Pin<Box<dyn Future<Output = Result<Option<StdArc<Committee>>, ViewError>> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait,

Returns the committee for epoch, consulting the shared cache first and, on a miss, loading it from the NewCommittee event on the admin chain (or from the genesis committee blob for epoch 0) plus the committee blob. Returns Ok(None) if the network description, event, or blob is not yet available locally.

fn create_chain<'life0, 'async_trait>( &'life0 self, description: ChainDescription, ) -> Pin<Box<dyn Future<Output = Result<(), ChainError>> + Send + 'async_trait>>

where ChainRuntimeContext<Self>: ExecutionRuntimeContext, Self: Sync + 'async_trait, 'life0: 'async_trait,

Initializes a chain in a simple way (used for testing and to create a genesis state).

fn load_contract<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, application_description: &'life1 ApplicationDescription, txn_tracker: &'life2 TransactionTracker, ) -> Pin<Box<dyn Future<Output = Result<UserContractCode, ExecutionError>> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Creates a UserContractCode instance using the bytecode in storage referenced by the application_description.

fn load_service<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, application_description: &'life1 ApplicationDescription, txn_tracker: &'life2 TransactionTracker, ) -> Pin<Box<dyn Future<Output = Result<UserServiceCode, ExecutionError>> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Creates a [linera-sdk::UserContract] instance using the bytecode in storage referenced by the application_description.