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.

Implementations

impl DurableBackendEnum

Promise, timer, and retention dispatch.

These methods back the DurablePromise / DurableTimerService / DurableRetentionService surfaces. They are inherent on the enum rather than on the sealed ExecutionBackend trait because they are implemented through the local backend’s dedicated durable_promises / durable_timers tables; a future cross-process backend (Restate) would satisfy the same surface through its own SDK primitives, so the closed match here gains a new arm at that point — a compile-time prompt rather than a silent gap.

pub async fn cancel_execution( &self, id: ExecutionId, ) -> Result<CancelOutcome, DurableError>

Cancel a running execution so it is never resumed. See LocalBackend::cancel_execution.

A plain in-process-callable primitive (#6362 trimmed US-002): no CLI or orchestration coupling, just a dispatch to the active backend.

Errors

Returns any DurableError LocalBackend::cancel_execution can return.

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.

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

Crash-orphan reclamation (#6254): flock-verify and hard-abort stale running rows.