Enum RuntimeError 

#[non_exhaustive]
pub enum RuntimeError {
    Identity(IdentityError),
    InputMismatch {
        id: EffectId,
    },
    KindMismatch {
        id: EffectId,
        stored: EffectKind,
        requested: EffectKind,
    },
    Input(Error),
    Output {
        id: EffectId,
        source: Error,
    },
    PolicyViolation {
        key: String,
        requirement: &'static str,
    },
    NoSuchEffect {
        key: String,
    },
    NotCompensable {
        name: &'static str,
    },
    NotRegistered {
        name: &'static str,
    },
    StoredInput {
        id: EffectId,
        source: Error,
    },
    Store(StoreError),
    Internal(String),
}

Why the runtime could not process an effect.

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.

Identity(IdentityError)

The effect name or logical key was invalid.

InputMismatch

The key was used before with a different input. Returning the earlier effect’s result would answer a question nobody asked.

Fields

id: EffectId

The existing effect.

KindMismatch

The key was used before with a different EffectKind.

Fields

id: EffectId

The existing effect.

stored: EffectKind

The kind on record.

requested: EffectKind

The kind of this call.

Input(Error)

The input could not be serialized.

Output

A committed effect’s stored output does not deserialize into the requested type, e.g. because the type changed since it was recorded.

Fields

id: EffectId

The committed effect.

source: Error

The deserialization error.

PolicyViolation

The runtime’s risk policy requires something the effect lacks, so it was refused before anything was recorded.

Fields

key: String

The effect’s name:key.

requirement: &'static str

What the policy requires, e.g. verification.

NoSuchEffect

No effect has this name and key.

Fields

key: String

The effect’s name:key.

NotCompensable

The handler is registered without .compensable(), so its effects cannot be compensated.

Fields

name: &'static str

The effect name.

NotRegistered

No handler of the submitted type is registered under its name.

Fields

name: &'static str

The effect name.

StoredInput

A stored input no longer deserializes into the handler’s input type, e.g. because the type changed since the effect was recorded.

Fields

id: EffectId

The effect.

source: Error

The deserialization error.

Store(StoreError)

The store failed. If this happens after the action ran, the effect stays in doubt and recovery will treat its outcome as unknown.

Internal(String)

The runtime’s own task failed (a bug in agent-effects).

Trait Implementations

impl Debug for RuntimeError

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

Formats the value using the given formatter.

impl Display for RuntimeError

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

Formats the value using the given formatter.

impl Error for RuntimeError

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<IdentityError> for RuntimeError

fn from(source: IdentityError) -> Self

Converts to this type from the input type.

impl From<StoreError> for RuntimeError

fn from(source: StoreError) -> Self

Converts to this type from the input type.