Enum Error 

#[non_exhaustive]
pub enum Error {
    Closed,
    #[non_exhaustive]
    ShutdownTimeout {
        timeout: Duration,
    },
    Connection(String),
    TokenSource(String),
    InvalidToken,
    InvalidRefreshInterval,
    InvalidConfig(&'static str),
    NoReadQuorum,
    NoQuorum,
    InvalidCatalog(String),
    #[non_exhaustive]
    CheckpointRegression {
        current: WalSeqNo,
        requested: WalSeqNo,
    },
    InvalidSegmentData(String),
    #[non_exhaustive]
    ConflictingPrefix {
        record_index: usize,
    },
    #[non_exhaustive]
    RecoveryPrefixTooShort {
        expected: usize,
        actual: usize,
    },
    #[non_exhaustive]
    SealDigestMismatch {
        expected: String,
        actual: String,
    },
    #[non_exhaustive]
    SealCrc32cMismatch {
        expected: u32,
        actual: u32,
    },
    InvalidManifest(String),
    SegmentDirectoryFull,
    ManifestUnavailable,
    ManifestStore(ManifestStoreError),
    PipelineClosed,
    Finalized,
    Internal(String),
    Poisoned,
    Fenced(String),
    #[non_exhaustive]
    OutOfOrder {
        expected: WalSeqNo,
        actual: WalSeqNo,
    },
    #[non_exhaustive]
    RecordTooLarge {
        max: usize,
        actual: usize,
    },
    #[non_exhaustive]
    ActiveSegmentFull {
        max: usize,
        current: usize,
        requested: usize,
    },
    SequenceExhausted,
    RecoveryIncomplete,
    #[non_exhaustive]
    Transport {
        zone: usize,
        code: TransportCode,
        message: String,
    },
}

Failure returned by every fallible chorus-client public operation.

Admission errors are definitive and may be corrected by the caller. In particular, ActiveSegmentFull does not consume the supplied sequence number: truncate retained history so rotation can proceed, then retry the same append. Use may_have_committed on an append completion error before deciding whether recovery must resolve an ambiguous outcome.

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.

Closed

The background WAL task was aborted, failed, or shut down.

#[non_exhaustive]

ShutdownTimeout

Graceful shutdown exceeded its configured deadline and aborted the remaining owned tasks.

Fields

Non-exhaustive enum variants could have additional fields added in future. Therefore, non-exhaustive enum variants cannot be constructed in external crates and cannot be matched against.

timeout: Duration

Configured graceful-shutdown deadline.

Connection(String)

A gRPC channel could not be constructed or connected.

TokenSource(String)

The configured identity provider could not issue a token.

InvalidToken

A bearer token cannot be represented in an ASCII gRPC header.

InvalidRefreshInterval

Refreshing would busy-loop because an interval was zero.

InvalidConfig(&'static str)

A WAL engine capacity or size limit was invalid or inconsistent.

NoReadQuorum

Fewer than a strict-majority quorum of replicas could be read.

NoQuorum

An operation could not reach a strict-majority replica quorum.

InvalidCatalog(String)

Listed objects or decoded finalized bytes did not form one chain.

#[non_exhaustive]

CheckpointRegression

The application supplied a checkpoint below its prior checkpoint.

Fields

Non-exhaustive enum variants could have additional fields added in future. Therefore, non-exhaustive enum variants cannot be constructed in external crates and cannot be matched against.

current: WalSeqNo

Checkpoint previously supplied to this writer.

requested: WalSeqNo

Regressing checkpoint supplied by the caller.

InvalidSegmentData(String)

Finalized bytes or inferred segment bounds disagree with record framing.

#[non_exhaustive]

ConflictingPrefix

Recovery witnesses contain different bytes at one record boundary.

Fields

Non-exhaustive enum variants could have additional fields added in future. Therefore, non-exhaustive enum variants cannot be constructed in external crates and cannot be matched against.

record_index: usize

First record index where the recovered witnesses disagree.

#[non_exhaustive]

RecoveryPrefixTooShort

Recovery did not find the committed number of records.

Fields

Non-exhaustive enum variants could have additional fields added in future. Therefore, non-exhaustive enum variants cannot be constructed in external crates and cannot be matched against.

expected: usize

Minimum record count required by the committed boundary.

actual: usize

Record count recovered from the available witnesses.

#[non_exhaustive]

SealDigestMismatch

Recovered bytes disagree with the manifest’s committed SHA-256 seal.

Fields

Non-exhaustive enum variants could have additional fields added in future. Therefore, non-exhaustive enum variants cannot be constructed in external crates and cannot be matched against.

expected: String

Digest committed by the manifest.

actual: String

Digest computed from the recovered bytes.

#[non_exhaustive]

SealCrc32cMismatch

Recovered bytes disagree with the manifest’s committed CRC32C.

Fields

Non-exhaustive enum variants could have additional fields added in future. Therefore, non-exhaustive enum variants cannot be constructed in external crates and cannot be matched against.

expected: u32

CRC32C committed by the manifest.

actual: u32

CRC32C computed from the recovered bytes.

InvalidManifest(String)

The manifest register is malformed or inconsistent with this volume.

SegmentDirectoryFull

The manifest cannot retain another sealed-segment directory entry.

ManifestUnavailable

The manifest register remained unavailable through its retry budget.

ManifestStore(ManifestStoreError)

A caller-supplied manifest register operation failed.

PipelineClosed

An internal commit notification path closed before reporting a result.

Finalized

The low-level segment writer is already finalized.

Internal(String)

An internal invariant failed without a more stable public taxonomy.

Poisoned

An indeterminate append broke the ordered commit prefix.

Fenced(String)

This writer lost ownership to a newer manifest epoch.

#[non_exhaustive]

OutOfOrder

The caller supplied a sequence number other than the next admission.

Fields

Non-exhaustive enum variants could have additional fields added in future. Therefore, non-exhaustive enum variants cannot be constructed in external crates and cannot be matched against.

expected: WalSeqNo

Exact sequence number required for the next admission.

actual: WalSeqNo

Sequence number supplied by the caller.

#[non_exhaustive]

RecordTooLarge

A record exceeded the configured application-payload limit.

Fields

Non-exhaustive enum variants could have additional fields added in future. Therefore, non-exhaustive enum variants cannot be constructed in external crates and cannot be matched against.

max: usize

Configured per-record payload-byte limit.

actual: usize

Payload bytes supplied by the caller.

#[non_exhaustive]

ActiveSegmentFull

The active object cannot admit another encoded record without crossing its configured hard ceiling.

The writer remains healthy and the sequence number was not consumed. This is backpressure, not poison: truncating old sealed segments may free manifest-directory room so the engine can rotate and resume admission. A permanently failed seal still requires restart recovery before rotation can resume.

Fields

Non-exhaustive enum variants could have additional fields added in future. Therefore, non-exhaustive enum variants cannot be constructed in external crates and cannot be matched against.

max: usize

Configured hard active-object ceiling.

current: usize

Encoded bytes already charged to the active segment.

requested: usize

Encoded bytes required by the rejected record.

SequenceExhausted

No further contiguous sequence number can be represented.

RecoveryIncomplete

Startup replay did not reach its fixed end successfully.

#[non_exhaustive]

Transport

Provider operation failed with a stable retry/fencing classification.

Fields

Non-exhaustive enum variants could have additional fields added in future. Therefore, non-exhaustive enum variants cannot be constructed in external crates and cannot be matched against.

zone: usize

Replica zone where the operation failed.

code: TransportCode

Stable protocol-facing classification.

message: String

Provider diagnostic text; correctness never matches this string.

Implementations

impl Error

pub fn may_have_committed(&self) -> bool

Whether this error can be observed after an append was admitted but before recovery determines its durable outcome.

true is deliberately conservative. Closed, Internal, and transport failures can also arise outside append completion, but callers handling an admitted append must assume it may replay after takeover. Poisoned, Fenced, and PipelineClosed always require that same treatment.

Admission and configuration errors, sequence errors, ActiveSegmentFull, NoQuorum, manifest/catalog validation errors, and low-level finalized-writer errors are definitive for the attempted append.

Trait Implementations

impl Clone for Error

fn clone(&self) -> Error

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Error

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

Formats the value using the given formatter.

impl Display for Error

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

Formats the value using the given formatter.

impl Error for Error

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<ManifestStoreError> for Error

fn from(source: ManifestStoreError) -> Self

Converts to this type from the input type.