Enum DurableBackendEnum 

#[non_exhaustive]
pub enum DurableBackendEnum {
    Local(Arc<LocalBackend>),
}

Closed enum dispatch over the compiled-in backends.

Construct it from a concrete backend and hand it across the crate boundary behind an Arc; callers invoke the Journal and ExecutionBackend methods on the enum and the dispatch resolves to the active variant with a single match. The enum is #[non_exhaustive]: the feature-gated Restate variant joins it with the restate feature without breaking in-crate matches.

Examples

use std::sync::Arc;
use zeph_durable::{BackendCapabilities, DurableBackendEnum};

fn max_payload(backend: &DurableBackendEnum) -> usize {
    use zeph_durable::ExecutionBackend as _;
    backend.capabilities().max_payload
}

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Local(Arc<LocalBackend>)

The always-compiled local backend journaling to a dedicated durable.db.

Held behind an Arc so the same backing instance can be shared with the JournalWriter (which owns the write path) while this enum serves the read path consumed by the ReplayCursor — both observe one durable.db pool.

Trait Implementations

impl Debug for DurableBackendEnum

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

Formats the value using the given formatter.

impl ExecutionBackend for DurableBackendEnum

fn capabilities(&self) -> BackendCapabilities

Return this backend’s stable capability description.

async fn lookup_committed_result( &self, id: ExecutionId, idem_key: IdempotencyKey, ) -> Result<Option<JournalEntry>, DurableError>

Look up a committed StepResult anywhere in an execution by its IdempotencyKey.

impl Journal for DurableBackendEnum

async fn append(&self, entry: JournalEntry) -> Result<JournalSeq, DurableError>

Append an entry and return its database-assigned global sequence number.

async fn read_execution( &self, id: ExecutionId, ) -> Result<Vec<JournalEntry>, DurableError>

Read every entry of an execution in append order.

async fn read_execution_range( &self, id: ExecutionId, from_step_id: u32, limit: usize, ) -> Result<Vec<JournalEntry>, DurableError>

Read up to limit entries of an execution starting at from_step_id.

async fn finalize( &self, id: ExecutionId, status: ExecutionStatus, ) -> Result<(), DurableError>

Transition an execution to a terminal status.

async fn prune(&self, policy: &RetentionPolicy) -> Result<u64, DurableError>

Prune terminal executions according to policy and return the number of rows deleted.