Enum CommitError 

#[non_exhaustive]
pub enum CommitError {
    Plan(CommitPlanError),
    Binding {
        reserved_transaction: TransactionId,
        plan_transaction: TransactionId,
    },
    BaseSnapshotBinding,
    DependencyLimit {
        observed: usize,
        maximum: usize,
    },
    PlanSize {
        observed: usize,
        maximum: usize,
    },
    TransactionWorkspaceExists {
        transaction: TransactionId,
    },
    UnsafeBlobStore {
        workspace_root: PathBuf,
        blobs_directory: PathBuf,
    },
    Host(HostError),
    Store(TransactionStoreError),
    Blob(BlobStoreError),
    DataDirectory(DataDirectoryError),
    Journal(JournalError),
    PlanDecode(PlanDecodeError),
    InternalIo {
        operation: &'static str,
        source: Error,
    },
    Stale {
        conflicts: Vec<RevalidationConflict>,
    },
    Verification(Box<VerificationFailure>),
    FaultInjected {
        point: FaultPoint,
    },
    RecoveryRequired {
        transaction: TransactionId,
        cause: String,
    },
    RecoveryConflict(RecoveryConflict),
    InvalidRecoveryState {
        transaction: TransactionId,
        state: TransactionState,
    },
}

Trusted-commit, revalidation, or recovery failure.

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.

Plan(CommitPlanError)

The immutable commit artifact is internally inconsistent.

Binding

The single-use reservation covers another transaction.

Fields

reserved_transaction: TransactionId

Transaction consumed from the store.

plan_transaction: TransactionId

Transaction derived from the supplied artifact.

BaseSnapshotBinding

Reservation and artifact cover different base snapshots.

DependencyLimit

The combined dependency set exceeds its configured bound.

Fields

observed: usize

Observed dependency count.

maximum: usize

Configured maximum.

PlanSize

An encoded plan or recovery journal exceeds its configured bound.

Fields

observed: usize

Observed byte length.

maximum: usize

Configured maximum.

TransactionWorkspaceExists

A durable workspace already exists and must be recovered first.

Fields

transaction: TransactionId

Affected transaction.

UnsafeBlobStore

A caller-supplied blob store overlaps the untrusted workspace namespace.

Fields

workspace_root: PathBuf

Canonical workspace authority root.

blobs_directory: PathBuf

Canonical immutable blob directory.

Host(HostError)

Capability-scoped host observation or mutation failed.

Store(TransactionStoreError)

Atomic transaction-state persistence failed.

Blob(BlobStoreError)

Immutable blob loading or verification failed.

DataDirectory(DataDirectoryError)

The protected workspace data capability could not be established.

Journal(JournalError)

Durable journal validation failed.

PlanDecode(PlanDecodeError)

Durable plan decoding failed.

InternalIo

Internal capability-directory I/O failed.

Fields

operation: &'static str

Stable operation label.

source: Error

Underlying host error.

Stale

Revalidation detected stale dependencies before mutation.

Fields

conflicts: Vec<RevalidationConflict>

Bounded set of exact conflicts.

Verification(Box<VerificationFailure>)

An operation or post-commit final-state check failed.

FaultInjected

Test-only simulated crash point fired.

Fields

point: FaultPoint

Fired boundary.

RecoveryRequired

Mutation may have begun and the durable journal must be recovered.

Fields

transaction: TransactionId

Affected transaction.

cause: String

Original failure rendered without leaking file content.

RecoveryConflict(RecoveryConflict)

Recovery could not prove ownership and left host data untouched.

InvalidRecoveryState

Store state is incompatible with the durable recovery artifact.

Fields

transaction: TransactionId

Affected transaction.

state: TransactionState

Unexpected persisted state.

Trait Implementations

impl Debug for CommitError

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

Formats the value using the given formatter.

impl Display for CommitError

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

Formats the value using the given formatter.

impl Error for CommitError

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<BlobStoreError> for CommitError

fn from(source: BlobStoreError) -> CommitError

Converts to this type from the input type.

impl From<CommitError> for VshError

fn from(source: CommitError) -> Self

Converts to this type from the input type.

impl From<CommitPlanError> for CommitError

fn from(source: CommitPlanError) -> CommitError

Converts to this type from the input type.

impl From<DataDirectoryError> for CommitError

fn from(source: DataDirectoryError) -> CommitError

Converts to this type from the input type.

impl From<HostError> for CommitError

fn from(source: HostError) -> CommitError

Converts to this type from the input type.

impl From<JournalError> for CommitError

fn from(source: JournalError) -> CommitError

Converts to this type from the input type.

impl From<PlanDecodeError> for CommitError

fn from(source: PlanDecodeError) -> CommitError

Converts to this type from the input type.

impl From<TransactionStoreError> for CommitError

fn from(source: TransactionStoreError) -> CommitError

Converts to this type from the input type.