Enum EffectStatus 

#[non_exhaustive]
pub enum EffectStatus {
    Pending,
    AwaitingApproval,
    Executing,
    Unknown,
    Verifying,
    Committed,
    Failed,
    Rejected,
    NeedsIntervention,
    Compensating,
    Compensated,
    CompensationFailed,
}

Where an effect is in its lifecycle.

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.

Pending

Recorded and waiting to run, either for the first time or for a scheduled retry.

AwaitingApproval

Waiting for a human or policy decision before it may run.

Executing

An attempt is in flight under a lease.

Unknown

An attempt may or may not have applied.

Verifying

Checking the remote system for the effect’s outcome.

Committed

The effect applied. Final, unless it is later compensated.

Failed

The effect definitely did not apply and will not be retried. Terminal.

Rejected

A precondition or approval decision refused the effect before it ran. Terminal.

NeedsIntervention

The runtime cannot resolve the outcome on its own; an operator must.

Compensating

A committed effect is being undone. Attempts are retried; the compensation must be idempotent.

Compensated

The effect was undone. Terminal.

CompensationFailed

Undoing the effect failed for good; an operator must finish it or order a retry.

Implementations

impl EffectStatus

pub const fn is_terminal(self) -> bool

Whether no further transition is possible.

Committed is not terminal: compensation can start from it.

pub const fn is_settled(self) -> bool

Whether nothing is left to do without a new request: the effect committed, failed, was rejected or was undone. Only settled records may be pruned (PruneQuery).

Unlike Self::is_terminal this includes Committed, whose compensation would be a new request. CompensationFailed is not settled: it waits for an operator.

pub const fn is_in_doubt(self) -> bool

Whether the effect may have changed the outside world without the runtime knowing the result, so it must not simply be started again.

pub const fn as_str(self) -> &'static str

The stable storage representation.

pub fn parse(s: &str) -> Option<Self>

Parses the storage representation produced by Self::as_str.

pub const fn apply(self, event: Transition) -> Result<Self, InvalidTransition>

The status after event, or an error if the event is not legal here.

Errors

Returns InvalidTransition for any pair not in the transition table.

Trait Implementations

impl Clone for EffectStatus

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for EffectStatus

impl Debug for EffectStatus

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for EffectStatus

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for EffectStatus

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

Formats the value using the given formatter.

impl Eq for EffectStatus

impl Hash for EffectStatus

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for EffectStatus

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for EffectStatus

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for EffectStatus