Struct RedbBackend 

pub struct RedbBackend { /* private fields */ }

On-disk EventStore backed by a per-run [redb] file.

One backend instance owns at most one open run at a time. Opening a fresh run creates <base>/<instance_id>/<run_id>.redb and writes the manifest with status RunStatus::Running before returning. Reopening a path whose manifest is still RunStatus::Running returns EventStoreError::CrashedPredecessor; the caller seals it as RunStatus::CrashedRecovered (or RunStatus::Quarantined) and then opens a new run, mirroring the in-memory backend’s contract.

Implementations

impl RedbBackend

pub fn new(base_dir: impl Into<PathBuf>) -> Self

Creates a new RedbBackend rooted at base_dir.

The backend creates <base_dir>/<instance_id>/ lazily on the first EventStore::open_run call.

pub fn run_dir(&self, instance_id: &str) -> PathBuf

Returns the directory the backend writes run files to for instance_id.

pub fn run_path(&self, instance_id: &str, run_id: &str) -> PathBuf

Returns the on-disk path the backend uses for (instance_id, run_id).

pub fn current_path(&self) -> Result<&Path, EventStoreError>

Returns the path of the currently open run file.

Errors

Returns EventStoreError::Backend when no run is open.

pub fn open_sealed( base_dir: impl Into<PathBuf>, instance_id: &str, run_id: &str, ) -> Result<Self, EventStoreError>

Opens the sealed run file at <base>/<instance_id>/<run_id>.redb for read-only replay.

Design

The standard EventStore::open_run path rejects sealed files: that is the crash-recovery guard, a successor must not silently reopen a predecessor’s log without going through seal. Event-store replay is the legitimate case for touching a sealed file, so the reader uses this constructor instead.

The shared EventStore trait is held intentionally narrow and is locked by design; adding a sealed-open method to it would force the in-memory backend (whose sealed runs stay readable in place without a reopen step) to carry a useless second entry point, and would conflate the writer’s open-or-recover lifecycle with the reader’s pure read-only path. The sealed-open path therefore lives as a backend-specific constructor: each backend adds the entry points it actually needs. The resulting RedbBackend still implements EventStore, so the reader composes over the locked trait without pulling in writer-only methods. crate::backend::MemoryBackend has no equivalent constructor: a sealed in-memory run keeps its state accessible to any reader holding the backend instance, and the reader receives that instance directly.

The returned backend holds a read-only database handle, rejects EventStore::append_batch with EventStoreError::Closed (the manifest is already sealed), and exposes every read path: EventStore::scan_range, EventStore::scan_seq, EventStore::lookup, and EventStore::manifest.

Errors

Returns EventStoreError::Backend when the run file does not exist or its status is not a sealed terminal state (use EventStore::open_run for that path); EventStoreError::Corrupted when the run file lacks a manifest or fails to decode.

pub fn open_sealed_file( path: impl Into<PathBuf>, ) -> Result<Self, EventStoreError>

Opens a sealed redb run file directly by path for read-only replay or verification.

Errors

Returns EventStoreError::Backend when the run file does not exist or its status is not a sealed terminal state (use EventStore::open_run for that path); EventStoreError::Corrupted when the run file lacks a manifest or fails to decode.

pub fn list_runs( base_dir: &Path, instance_id: &str, ) -> Result<Vec<RunManifest>, EventStoreError>

Lists the manifests of every run file under <base_dir>/<instance_id>/*.redb.

Used by the reader for forensics navigation across runs without requiring an active backend instance per run. The result is sorted by start_ts_init so chronologically-newer runs appear last.

Opens each run file with a read-only database handle. A run file whose process died hard (kill, OOM, power loss) lacks redb’s allocator-state table and refuses the read-only open; the listing falls back to a writable open, which performs redb’s repair pass and leaves the file readable again. Files that still cannot be opened or that lack a manifest are skipped with a logged error so one current-format damaged file cannot block recovery or retention over the healthy runs; such files never become recovery parents or reclaim candidates and are left in place for manual inspection. Unsupported store formats are returned as errors rather than skipped because they require operator action.

Errors

Returns EventStoreError::Backend when the directory iterator fails, or EventStoreError::Corrupted when a run file uses an unsupported store format.

Trait Implementations

impl Debug for RedbBackend

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

Formats the value using the given formatter.

impl EventStore for RedbBackend

fn open_run(&mut self, manifest: RunManifest) -> Result<(), EventStoreError>

Opens an existing run or creates a new one with the supplied manifest.

fn append_batch( &mut self, entries: &[AppendEntry], ) -> Result<u64, EventStoreError>

Appends a batch of (entry, index_keys) pairs in a single backend transaction.

fn scan_range( &self, from: u64, to: u64, direction: ScanDirection, ) -> Result<Vec<EventStoreEntry>, EventStoreError>

Scans entries by seq over the inclusive range [from, to].

fn scan_seq(&self, seq: u64) -> Result<Option<EventStoreEntry>, EventStoreError>

Reads a single entry by seq.

fn lookup( &self, kind: IndexKind, key: &str, ) -> Result<Option<u64>, EventStoreError>

Looks up the first seq recorded under the given index key.

fn iter_index_keys( &self, kind: IndexKind, ) -> Result<Vec<(String, u64)>, EventStoreError>

Enumerates every (key, seq) pair stored under the given secondary index.

fn record_snapshot_anchor( &mut self, anchor: SnapshotAnchor, ) -> Result<(), EventStoreError>

Records the latest cache snapshot anchor for the open run.

fn latest_snapshot_anchor( &self, ) -> Result<Option<SnapshotAnchor>, EventStoreError>

Returns the latest recorded snapshot anchor for the open run.

fn seal(&mut self, status: RunStatus) -> Result<(), EventStoreError>

Seals the open run with the given final status and persists the manifest update.

fn manifest(&self) -> Result<RunManifest, EventStoreError>

Returns the current manifest snapshot.

fn high_watermark(&self) -> Result<u64, EventStoreError>

Returns the largest seq durably acknowledged for the open run.