Enum WalError 

#[non_exhaustive]
pub enum WalError {
    Io {
        context: &'static str,
        source: Error,
    },
    RecordTooLarge {
        len: usize,
        max: u32,
    },
    Corruption {
        offset: u64,
        reason: &'static str,
    },
    Encoding {
        detail: String,
    },
}

Everything that can go wrong while appending to, syncing, or recovering a log.

The type is #[non_exhaustive]: future versions may add variants without a major bump, so a match over it must include a wildcard arm.

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.

Io

An underlying I/O operation failed.

context names the operation that was attempted (for example "open log file" or "flush to stable storage") so the message is actionable without a backtrace. The original io::Error is preserved as the source; inspect it when the OS error kind (disk full, permission denied, interrupted) drives recovery.

Fields

context: &'static str

What the log was trying to do when the I/O error occurred.

source: Error

The underlying operating-system error.

RecordTooLarge

An append was rejected because the record is larger than the configured limit.

Records are bounded by WalConfig::max_record_size so that a single oversized — or maliciously crafted — record cannot force an unbounded allocation on the recovery path. The append makes no change to the log; the caller may split the payload or raise the limit.

Fields

len: usize

The length of the rejected record, in bytes.

max: u32

The configured maximum record size, in bytes.

Corruption

Recovery reached a record that is not intact.

Either the record’s checksum did not match its bytes, or its length prefix is implausible. In an append-only log a damaged record means everything after it is untrustworthy, so iteration surfaces this once and then stops. offset is the byte position of the record where the break was detected.

Fields

offset: u64

Byte offset of the record at which recovery stopped.

reason: &'static str

A short, human-readable reason the record was rejected.

Encoding

A typed record could not be encoded or decoded.

Produced only by the typed-record API (the pack-io feature): Wal::append_typed when a value fails to serialise, or Record::decode when a record’s bytes do not deserialise into the requested type. detail carries the underlying codec error’s message.

Fields

detail: String

The underlying serialization error, as text.

Trait Implementations

impl Debug for WalError

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

Formats the value using the given formatter.

impl Display for WalError

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

Formats the value using the given formatter.

impl Error for WalError

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 ForgeError for WalError

fn is_fatal(&self) -> bool

Corruption is unrecoverable by retry: the bytes on disk are already damaged. I/O and size errors are left non-fatal for the caller to judge.

fn kind(&self) -> &'static str

Returns the kind of error, typically matching the enum variant

fn caption(&self) -> &'static str

Returns a human-readable caption for the error

fn is_retryable(&self) -> bool

Returns true if the operation can be retried

fn status_code(&self) -> u16

Returns an appropriate HTTP status code for the error

fn exit_code(&self) -> i32

Returns an appropriate process exit code for the error

fn user_message(&self) -> String

Returns a user-facing message that can be shown to end users

fn dev_message(&self) -> String

Returns a detailed technical message for developers/logs

fn backtrace(&self) -> Option<&Backtrace>

Returns a backtrace if available

fn register(&self)

Registers the error with the central error registry

impl From<Error> for WalError

A bare io::Error converts into WalError::Io with a generic context.

Call sites that know what they were doing attach a specific context instead; this exists for the ? ergonomics of code that does not.

fn from(source: Error) -> Self

Converts to this type from the input type.