Enum Transition 

#[non_exhaustive]
pub enum Transition {
    RequestApproval,
    Approve,
    Deny,
    PreconditionRejected,
    StartAttempt,
    Succeeded,
    FailedDefinitively,
    ScheduleRetry,
    OutcomeUnknown,
    LeaseExpired,
    StartVerification,
    VerificationConfirmed,
    VerificationNotApplied,
    VerificationConflict,
    Escalate,
    ResolvedApplied,
    ResolvedNotApplied,
    ResolvedRetry,
    StartCompensation,
    ScheduleCompensationRetry,
    StartCompensationRetry,
    CompensationSucceeded,
    CompensationFailed,
    ResolvedCompensated,
}

Something that happens to an effect and may change its status.

Each variant is also an audit event; see Transition::as_str.

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.

RequestApproval

Policy requires approval before the first attempt.

Approve

Approval was granted.

Deny

Approval was refused.

PreconditionRejected

A precondition permanently refused the effect.

StartAttempt

An attempt begins. Persisted before the action is invoked.

Succeeded

The action succeeded and no verification is configured.

FailedDefinitively

The action failed and the effect definitely did not apply, with no retry left or allowed.

ScheduleRetry

Another attempt is scheduled, because the effect definitely did not apply or re-executing it is known to be safe.

OutcomeUnknown

The attempt ended without a definitive answer.

LeaseExpired

The lease holder disappeared mid-attempt (recovery).

StartVerification

Verification begins, after a success or to reconcile an unknown outcome.

VerificationConfirmed

Verification found the effect applied.

VerificationNotApplied

Verification found, authoritatively, that the effect did not apply, and it will not be retried.

VerificationConflict

Verification found remote state that contradicts the effect.

Escalate

The runtime gave up resolving an unknown outcome on its own.

ResolvedApplied

An operator confirmed the effect applied.

ResolvedNotApplied

An operator confirmed the effect did not apply.

ResolvedRetry

An operator asserted it is safe to run the effect again, or to try its failed compensation again.

StartCompensation

Undoing a committed effect begins. Persisted before the first compensation attempt.

ScheduleCompensationRetry

Another compensation attempt is scheduled, after a failed attempt.

StartCompensationRetry

Another compensation attempt begins: a scheduled retry, or a rerun of an attempt a crash interrupted. Persisted before it runs.

CompensationSucceeded

The compensation succeeded.

CompensationFailed

The compensation failed for good.

ResolvedCompensated

An operator undid the effect by hand.

Implementations

impl Transition

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

Parses the audit-event name produced by Self::as_str.

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

The stable audit-event name, e.g. effect.attempt_started.

Trait Implementations

impl Clone for Transition

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 Transition

impl Debug for Transition

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Transition

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Transition

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

Formats the value using the given formatter.

impl Eq for Transition

impl Hash for Transition

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 Transition

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Transition

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 Transition