Enum StoreError 

pub enum StoreError {
    Io(String),
    Database(String),
    Blob(BlobStoreError),
    BlobHashMismatch,
    SequenceGap {
        expected: u64,
        actual: u64,
    },
    AuthorChainMissing {
        previous: CommitId,
    },
    SnapshotBaselineMissing {
        frontier: CommitId,
    },
    AuthorEquivocation {
        author: AuthorId,
        sequence: u64,
        first: CommitId,
        second: CommitId,
    },
    QuarantinedCommit(CommitId),
    QuarantinedAuthor {
        author: AuthorId,
        from_sequence: u64,
    },
    MissingDependency(CommitId),
    UnsupportedFormat,
    AlreadyOpen,
    MissingCommitBlob(CommitId),
    CommitCodec(CommitCodecError),
    Schema(SchemaError),
    Migration(MigrationCodecError),
    InvalidMigration(String),
    SchemaMigrationFork {
        collection_id: CollectionId,
    },
    SchemaMismatch {
        collection_id: CollectionId,
        version: u32,
    },
    InvalidIndex {
        collection_id: CollectionId,
        field_id: u32,
    },
    CorruptDerivedMetadata(String),
    InvalidSnapshotMetadata(String),
    InvalidAuthority(String),
    ControlFork {
        domain: DomainId,
        first: [u8; 32],
        second: [u8; 32],
    },
}

A local durable-store failure.

Variants

Io(String)

A filesystem operation failed.

Database(String)

The redb metadata operation failed.

Blob(BlobStoreError)

The immutable blob repository failed.

BlobHashMismatch

The blob repository returned a hash other than the bytes’ expected hash.

SequenceGap

A commit skipped or repeated an author’s required next sequence.

Fields

expected: u64

The only sequence accepted next.

actual: u64

The sequence supplied by the commit.

AuthorChainMissing

The next author sequence did not causally extend that author’s accepted head.

Fields

previous: CommitId

The accepted author commit that must be in dependency ancestry.

SnapshotBaselineMissing

A post-snapshot author commit did not extend the complete installed frontier.

Fields

frontier: CommitId

A current frontier commit absent from incoming dependency ancestry.

AuthorEquivocation

Two different immutable commits claim one author-local sequence.

Fields

author: AuthorId

The signing author that reused a sequence.

sequence: u64

The reused author-local sequence.

first: CommitId

Lexicographically first conflicting commit ID.

second: CommitId

Lexicographically second conflicting commit ID.

QuarantinedCommit(CommitId)

A commit is immutable evidence in a quarantined equivocation branch.

QuarantinedAuthor

An author’s signing key equivocated and cannot extend that branch.

Fields

author: AuthorId

The equivocated author identity.

from_sequence: u64

The first sequence no longer accepted from this author.

MissingDependency(CommitId)

A declared causal dependency is not accepted locally.

UnsupportedFormat

The directory has an incompatible format marker.

AlreadyOpen

Another process already holds the exclusive writer lock.

MissingCommitBlob(CommitId)

A stored commit blob was missing.

CommitCodec(CommitCodecError)

Stored immutable bytes were not a canonical commit.

Schema(SchemaError)

A stored schema descriptor could not be decoded.

Migration(MigrationCodecError)

A canonical schema migration object was invalid.

InvalidMigration(String)

Migration-derived state did not match its immutable commit history.

SchemaMigrationFork

Two activation commits attempted different successors for one schema.

Fields

collection_id: CollectionId

SchemaMismatch

The same domain, collection and version was registered with different bytes.

Fields

collection_id: CollectionId

Stable collection identifier.

version: u32

Application schema version.

InvalidIndex

A supplied index was absent from the schema or was not declared indexed.

Fields

collection_id: CollectionId

Stable collection identifier.

field_id: u32

Stable field identifier.

CorruptDerivedMetadata(String)

Stored derived metadata was structurally corrupt.

InvalidSnapshotMetadata(String)

A snapshot supplied a noncanonical or inconsistent causal baseline.

InvalidAuthority(String)

A signed domain authority object failed validation or conflicted with durable state.

ControlFork

The designated controller signed two different successors for one control slot.

Fields

domain: DomainId

Security domain whose controller equivocated.

first: [u8; 32]

Lexicographically first transition ID.

second: [u8; 32]

Lexicographically second transition ID.

Trait Implementations

impl Clone for StoreError

fn clone(&self) -> StoreError

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for StoreError

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

Formats the value using the given formatter.

impl Display for StoreError

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

Formats the value using the given formatter.

impl Error for StoreError

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 StoreError

fn from(source: BlobStoreError) -> Self

Converts to this type from the input type.

impl From<CommitCodecError> for StoreError

fn from(source: CommitCodecError) -> Self

Converts to this type from the input type.

impl From<MigrationCodecError> for StoreError

fn from(source: MigrationCodecError) -> Self

Converts to this type from the input type.

impl From<SchemaError> for StoreError

fn from(source: SchemaError) -> Self

Converts to this type from the input type.

impl PartialEq for StoreError

fn eq(&self, other: &StoreError) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for StoreError

impl StructuralPartialEq for StoreError