Enum StateError 

pub enum StateError {
    Io(Error),
    Store(StoreError),
    Node(NodeError),
    Tree(TreeError),
    BranchCommit(BranchCommitError),
    BranchPolicy(BranchPolicyError),
    Merge(MergeError),
    BranchRef(BranchRefError),
    Branch(BranchError),
    Snapshot(SnapshotError),
    Checkout(CheckoutError),
    CapabilityBinding {
        handle_component: ComponentId,
        checker_component: ComponentId,
    },
    CapabilityDenied(CapabilityDenied),
    CapabilityCheck(CapabilityCheckError),
    DanglingReference {
        target: ComponentId,
        state: ReferenceTargetState,
    },
    SynchronizationPoisoned,
    SchemaNotDeclared {
        component: ComponentId,
    },
    SchemaAlreadyDeclared {
        component: ComponentId,
    },
    UnsupportedPolicy {
        policy: MergePolicy,
    },
    ResolverNotRegistered {
        name: String,
    },
    ResolverAlreadyRegistered {
        name: String,
    },
    InstallInProgress {
        component: ComponentId,
    },
    ArchiveInProgress {
        component: ComponentId,
    },
    WorkInProgress {
        component: ComponentId,
    },
    AlreadyActive {
        component: ComponentId,
    },
    NotActive {
        component: ComponentId,
    },
    StaleHandle {
        component: ComponentId,
        held: u64,
        current: u64,
    },
    WorkNotFound {
        branch: String,
    },
    ForeignWorkHandle,
    CorruptRecord {
        detail: String,
    },
    Reconcile(ReconcileInconsistency),
}

Typed failures from component storage, preserving every substrate error.

Variants

Io(Error)

Filesystem setup failed outside a haematite operation.

Store(StoreError)

Node-store operation failed.

Node(NodeError)

Empty-node construction failed.

Tree(TreeError)

Tree traversal failed.

BranchCommit(BranchCommitError)

Branch commit/lifecycle failed outside a more specific category.

BranchPolicy(BranchPolicyError)

Engine namespace policy refused an operation, retaining names and kinds.

Merge(MergeError)

Engine content merge failed.

BranchRef(BranchRefError)

Durable branch-ref operation failed.

Branch(BranchError)

Branch handle operation failed.

Snapshot(SnapshotError)

Snapshot registry operation failed.

Checkout(CheckoutError)

Historical checkout failed.

CapabilityBinding

The supplied checker belongs to a different component than the handle.

Fields

handle_component: ComponentId

Component incarnation represented by the storage handle.

checker_component: ComponentId

Component whose authority the supplied checker would evaluate.

CapabilityDenied(CapabilityDenied)

A fresh check denied this resolution, preserved verbatim from frame-core.

CapabilityCheck(CapabilityCheckError)

A fresh check could not produce or publish its verdict.

DanglingReference

The named target has no active namespace to resolve.

Fields

target: ComponentId

Component named by the link.

state: ReferenceTargetState

Durable target state observed after authority was granted.

SynchronizationPoisoned

Internal synchronization was poisoned by a prior panic.

SchemaNotDeclared

No schema was declared before install.

Fields

component: ComponentId

Component whose install lacks a declaration.

SchemaAlreadyDeclared

A schema was already fixed for this component’s current lifecycle.

Fields

component: ComponentId

Component whose pending declaration would be replaced.

UnsupportedPolicy

The published engine cannot execute the declared vocabulary entry.

Fields

policy: MergePolicy

Policy refused at schema declaration.

ResolverNotRegistered

A custom policy named a resolver absent at declaration time.

Fields

name: String

Stable resolver name that was not registered.

ResolverAlreadyRegistered

A resolver registration would silently replace an existing function.

Fields

name: String

Stable resolver name already bound in this process.

InstallInProgress

An install is already executing for this identity.

Fields

component: ComponentId

Component with an active install transition.

ArchiveInProgress

An archive is already executing for this identity.

Fields

component: ComponentId

Component with an active archive transition.

WorkInProgress

A fork or merge is already executing for this identity.

Fields

component: ComponentId

Component with an active Work operation.

AlreadyActive

Install was requested for an active namespace.

Fields

component: ComponentId

Component whose namespace is already Active.

NotActive

The component has no active namespace.

Fields

component: ComponentId

Component for which active storage was required.

StaleHandle

A handle’s captured incarnation no longer owns the branch name.

Fields

component: ComponentId

Component whose name was reused.

held: u64

Incarnation captured by the handle.

current: u64

Durable current incarnation.

WorkNotFound

A requested Work branch is not outstanding.

Fields

branch: String

Durable Work branch name that was absent.

ForeignWorkHandle

A Work handle came from another store, component, or incarnation.

CorruptRecord

A branch/archive key did not have Frame’s fixed-width encoding.

Fields

detail: String

Exact codec or durable-invariant failure.

Reconcile(ReconcileInconsistency)

Boot found a durable state it cannot safely repair.

Trait Implementations

impl Debug for StateError

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

Formats the value using the given formatter.

impl Display for StateError

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

Formats the value using the given formatter.

impl Error for StateError

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<BranchCommitError> for StateError

fn from(error: BranchCommitError) -> Self

Converts to this type from the input type.

impl From<BranchError> for StateError

fn from(error: BranchError) -> Self

Converts to this type from the input type.

impl From<BranchRefError> for StateError

fn from(error: BranchRefError) -> Self

Converts to this type from the input type.

impl From<CapabilityCheckError> for StateError

fn from(error: CapabilityCheckError) -> Self

Converts to this type from the input type.

impl From<CheckoutError> for StateError

fn from(error: CheckoutError) -> Self

Converts to this type from the input type.

impl From<Error> for StateError

fn from(error: Error) -> Self

Converts to this type from the input type.

impl From<NodeError> for StateError

fn from(error: NodeError) -> Self

Converts to this type from the input type.

impl From<ReconcileInconsistency> for StateError

fn from(error: ReconcileInconsistency) -> Self

Converts to this type from the input type.

impl From<SnapshotError> for StateError

fn from(error: SnapshotError) -> Self

Converts to this type from the input type.

impl From<StoreError> for StateError

fn from(error: StoreError) -> Self

Converts to this type from the input type.

impl From<TreeError> for StateError

fn from(error: TreeError) -> Self

Converts to this type from the input type.