Struct Shared 

pub struct Shared<DB>(/* private fields */);

A database shared across tasks.

Owned mutations (apply, finalize, prune, rewind) take the database out of the cell under the write lock (Self::write) and put it back on success (WriteSlot::put). A failure, panic, or cancellation mid-operation leaves the cell empty permanently, and every later Self::read or Self::write panics. A lost database is fatal here by design and requires a restart. Serve calls instead report the source as missing, so remote sync degrades without crashing.

Implementations

impl<DB> Shared<DB>

pub fn new(label: &'static str, db: DB) -> Self

Create a cell holding db, identified by label in lock traces.

pub async fn read(&self) -> ReadGuard<'_, DB>

Acquire shared read access to the database.

The lock is write-preferring: once a writer is queued, new readers wait behind it. Holding a guard across an await that acquires this cell again therefore deadlocks once a writer arrives in between.

Panics

Panics if the database was lost by an earlier failed or interrupted mutation.

pub async fn write(&self) -> (WriteSlot<'_, DB>, DB)

Take the database out for a by-value mutation.

The returned WriteSlot holds the cell locked and empty until WriteSlot::put restores the database. Dropping the slot without a put leaves the database lost.

Panics

Panics if the database was lost by an earlier failed or interrupted mutation.

Trait Implementations

impl<DB> Clone for Shared<DB>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<E: Send + Sync, T: ManagedDb<E> + 'static> DatabaseSet<E> for Shared<T>

Implement DatabaseSet for a single ManagedDb behind a lock.

type Unmerkleized = <T as ManagedDb<E>>::Unmerkleized

Tuple of ManagedDb::Unmerkleized for every database in the set.

type Merkleized = <T as ManagedDb<E>>::Merkleized

Tuple of ManagedDb::Merkleized for every database in the set. Cloning must preserve the same sealed branch state and should be cheap.

type Readers = Reader<T>

Read-only handles for observing the applied database state.

type Config = <T as ManagedDb<E>>::Config

Configuration needed to construct every database in the set.

type SyncTargets = <T as ManagedDb<E>>::SyncTarget

Per-database sync targets extracted from a finalized block.

async fn init(context: E, config: Self::Config) -> Self

Construct the database set from its configuration.

fn initial_sync_targets() -> Self::SyncTargets

Return the sync targets produced by a newly initialized database set.

async fn new_batches(&self) -> Self::Unmerkleized

Create unmerkleized batches from each database’s applied state.

fn fork_batches(parent: &Self::Merkleized) -> Self::Unmerkleized

Create child unmerkleized batches from a pending merkleized parent.

fn matches_sync_targets( batches: &Self::Merkleized, targets: &Self::SyncTargets, ) -> bool

Return true if merkleized batches match the sync targets.

fn readers(&self) -> Self::Readers

Return read-only handles for every database in the set.

async fn apply(&self, batches: Self::Merkleized)

Apply each merkleized batch’s changeset.

async fn finalize(&self) -> Barrier

Begin persisting every checkpoint applied before this call.

async fn prune(&self, target: &Self::SyncTargets)

Prune each database to the provided per-database targets.

async fn committed_targets(&self) -> Self::SyncTargets

Return the latest applied recovery targets.

async fn rewind_to_targets(&self, target: Self::SyncTargets)

Rewind the set to the provided per-database targets.

impl<DB> Source for Shared<DB>

where DB: Send + Sync + 'static, Arc<TracedAsyncRwLock<Option<DB>>>: Source,

type Family = <Arc<TracedAsyncRwLock<Option<DB>>> as Source>::Family

The merkle family backing this source’s proofs.

type Digest = <Arc<TracedAsyncRwLock<Option<DB>>> as Source>::Digest

The digest type used in this source’s proofs.

type Op = <Arc<TracedAsyncRwLock<Option<DB>>> as Source>::Op

The type of operations this source yields.

type Error = <Arc<TracedAsyncRwLock<Option<DB>>> as Source>::Error

Why this source could not answer.

async fn serve( &self, request: Request<Self::Family>, ) -> Result<(Response<Self::Family, Self::Op, Self::Digest>, FeedbackTx), Self::Error>

Serve a request.

impl<E, T, R, D> StateSyncSet<E, R, D> for Shared<T>

where E: Send + Sync + Metrics, T: StateSyncDb<E, R> + 'static, R: Send + 'static, D: Digest,

type Error = <T as StateSyncDb<E, R>>::SyncError

Error returned if any database in the set fails state sync.

async fn sync( context: E, config: Self::Config, source: R, anchor: Anchor<D>, target: Self::SyncTargets, tip_updates: Receiver<TipUpdate<D, Self::SyncTargets>>, sync_config: SyncEngineConfig, ) -> Result<(Self, Anchor<D>), Self::Error>

Run one-time state sync and return the initialized set together with the anchor all databases converged on.