Struct Durable 

pub struct Durable { /* private fields */ }

The durability façade: the single writer’s view of the store.

Implementations

impl Durable

pub fn new( store: SharedStore, prefix: &str, instance: &str, policy: Policy, log: Option<Logger>, ) -> Durable

pub fn with_fresh(self, fresh: bool) -> Durable

Override the --fresh intent this Durable was built with — for an embedder that drives the façade directly, and for the tests, neither of which goes through the CLI that sets the process-wide default.

pub fn with_config_digest(self, digest: BTreeMap<String, String>) -> Durable

Override the configuration digest (see with_fresh).

pub fn store_kind(&self) -> &'static str

pub fn instance(&self) -> &str

pub fn prefix(&self) -> &str

pub fn key(&self, kind: Kind, id: &str) -> String

pub fn is_degraded(&self) -> bool

Whether the store has failed persistently and the policy chose to go on.

pub fn policy(&self) -> &Policy

pub fn put( &self, kind: Kind, id: &str, state: Value, hash: Option<String>, ) -> Result<u64, StoreError>

Write an entity: allocates the next seq for its key, CAS-puts the envelope, indexes it in the manifest (debounced flush). A conflict on a key this instance already owns is fatal (StoreError::Conflict); on a key first seen now, the stored seq is adopted once (a restore gap).

pub fn get(&self, kind: Kind, id: &str) -> Result<Option<Envelope>, StoreError>

The latest envelope of an entity (tombstones read as absent).

pub fn delete(&self, kind: Kind, id: &str) -> Result<(), StoreError>

Remove an entity: delete when the store supports it, else a tombstone (a put with state: null); drops it from the manifest index.

pub fn list(&self, kind: Kind) -> Result<Vec<KeySeq>, StoreError>

The store’s list for a kind (optional).

pub fn inbox_put(&self, ev: &InboxEvent) -> Result<u64, StoreError>

Write-ahead an event (before it is acted on / acknowledged).

pub fn inbox_done(&self, id: &str) -> Result<(), StoreError>

Mark an event processed: deleted (or tombstoned) — it will not replay.

pub fn timer_arm(&self, t: &TimerRecord) -> Result<u64, StoreError>

pub fn timer_disarm(&self, id: &str) -> Result<(), StoreError>

pub fn manifest(&self) -> Manifest

pub fn manifest_update(&self, f: impl FnOnce(&mut Manifest))

Mutate the manifest (start-node state, budget counters, lifecycle) — flushed debounced.

pub fn flush(&self, force: bool) -> Result<bool, StoreError>

Flush the manifest if dirty and (forced or the debounce elapsed).

pub fn restore(&self) -> Result<Restored, StoreError>

The restore protocol (RFC 0025 §6): read the manifest, then every indexed entity (verifying envelopes), reconcile with list where supported, warm the seq map, bump the generation. A fresh instance (no manifest) writes generation 1.

Under --fresh (RFC 0033 §3.2) the middle is skipped: see restore_fresh.