Enum DurabilityError 

pub enum DurabilityError {
    EmptyOperationBatch,
    BatchUnsupported {
        store: &'static str,
    },
    AppendUnresolved {
        stream_key: String,
        sequence: u64,
        cause: String,
    },
    PendingAppendUnreadable {
        stream_key: String,
        sequence: u64,
        append_error: String,
        read_error: String,
    },
    OutcomeUnknown {
        pid: u64,
    },
    NotStarted {
        pid: u64,
    },
    StoreError(ApiError),
    SequenceConflict {
        expected: u64,
        actual: u64,
    },
    CursorRegression {
        stored: u64,
        attempted: u64,
    },
    DedupCollision {
        key: String,
    },
    ConfigError(String),
    EphemeralStoreOpen(String),
    EphemeralStoreDetached,
    TruncateUnsupported {
        store: &'static str,
        stream_key: String,
        before_seq: u64,
    },
    RoutedScanUnsupported {
        store: &'static str,
        route_key: String,
    },
    RoutedRemoveUnsupported {
        store: &'static str,
        route_key: String,
    },
    EnvelopeError(String),
}

Error taxonomy for haematite-backed durability operations.

Variants

EmptyOperationBatch

A logical operation has no staged rows to commit.

BatchUnsupported

A store does not implement atomic routed storage.

Fields

store: &'static str

The store’s type.

AppendUnresolved

The store did not establish whether a sent append committed.

Fields

stream_key: String

Partition stream receiving the append.

sequence: u64

Reserved sequence of the sent bytes.

cause: String

Original append failure, never used to classify the outcome.

PendingAppendUnreadable

The authoritative read of an earlier uncertain append failed.

Fields

stream_key: String

Partition stream that must be reconciled.

sequence: u64

Reserved sequence of the sent bytes.

append_error: String

Original append error, retained across every failed read.

read_error: String

The latest authoritative read error.

OutcomeUnknown

A write the store had started when its caller stopped waiting: it may have been applied. It is never treated as not written: the caller reads the position back to settle it (settle), or refuses by this name.

Fields

pid: u64

The shard that had started the write.

NotStarted

A write withdrawn before the store started it: nothing was written, and it may be sent again.

Fields

pid: u64

The shard the write was queued for.

StoreError(ApiError)

Haematite returned a store-level failure.

The umbrella From<haematite::ApiError> conversion lives in super::store because it routes the optimistic-concurrency variants to their dedicated cases rather than wrapping them here.

SequenceConflict

An append observed a different stream sequence than the caller expected.

Fields

expected: u64

Caller-provided expected stream sequence.

actual: u64

Actual stream sequence reported by haematite.

CursorRegression

A cursor checkpoint attempted to move from a stale stored value.

Fields

stored: u64

Current value stored for the cursor.

attempted: u64

Value the caller attempted to checkpoint from.

DedupCollision

A producer idempotency key collided with an existing dedup entry.

Fields

key: String

Idempotency key that collided.

ConfigError(String)

Durability configuration failed validation.

EphemeralStoreOpen(String)

An ephemeral durable store could not be opened on disk.

Raised only on the construction path of a self-owned ephemeral store (see super::EphemeralRoot::open_store); the guarding temporary directory is already removed by the time this surfaces.

EphemeralStoreDetached

An operation reached an ephemeral store whose backing database was already detached by teardown.

Unreachable by construction: the store is detached only inside the ephemeral guard’s Drop, which cannot overlap a live handle’s call. The variant exists because that detachment is expressed through an Option the compiler cannot see through, and the fallback must be a typed refusal rather than a panic.

TruncateUnsupported

A store that cannot delete entries was asked to truncate a stream.

Fields

store: &'static str

The store’s type.

stream_key: String

The stream it was asked to cut.

before_seq: u64

The sequence it was asked to cut below.

RoutedScanUnsupported

A store that cannot list a routed key window was asked to scan one.

Fields

store: &'static str

The store’s type.

route_key: String

The route it was asked to scan.

RoutedRemoveUnsupported

A store that cannot delete a routed key window in one commit was asked to remove routed rows.

Composing the window from single deletes is never done in its place (DUR-018 R3): each would be its own commit.

Fields

store: &'static str

The store’s type.

route_key: String

The route it was asked to cut.

EnvelopeError(String)

Persisted envelope bytes could not be encoded or decoded.

Trait Implementations

impl Debug for DurabilityError

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

Formats the value using the given formatter.

impl Display for DurabilityError

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

Formats the value using the given formatter.

impl Error for DurabilityError

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl From<Api> for DurabilityError

Maps a real-engine ApiError onto liminal’s DurabilityError.

The optimistic-concurrency variants route to their dedicated DurabilityError cases (SequenceConflict, CursorRegression); everything else is a store-level failure carried verbatim.

fn from(error: ApiError) -> Self

Converts to this type from the input type.

impl From<CasMismatch> for DurabilityError

fn from(error: CasMismatch) -> Self

Converts to this type from the input type.

impl From<SequenceConflict> for DurabilityError

fn from(error: SequenceConflict) -> Self

Converts to this type from the input type.