Enum FaultDecision 

#[non_exhaustive]
pub enum FaultDecision {
    Retry {
        ordinal: RetryOrdinal,
        delay: Duration,
    },
    Skip {
        disposition: RollbackDisposition,
    },
    FailAndRollback,
    Unknown,
    Stop,
}

The authoritative policy outcome for one fault.

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.

Retry

Roll back, reserve ordinal durably, wait delay, then re-invoke.

Fields

ordinal: RetryOrdinal

The retry ordinal to reserve.

delay: Duration

The deterministic delay preceding re-invocation.

Skip

Record one committed skip with the accepted disposition.

Fields

disposition: RollbackDisposition

How the failed unit is separated from committed work.

FailAndRollback

Roll back and fail the step.

Unknown

The commit outcome is unknown and must never be guessed.

Stop

Cooperative stop governs the outcome.

Implementations

impl FaultDecision

pub const fn is_retry(self) -> bool

Returns whether the decision re-invokes the failed component.

pub const fn skip_disposition(self) -> Option<RollbackDisposition>

Returns the accepted skip disposition, when the decision skips.

Trait Implementations

impl Clone for FaultDecision

fn clone(&self) -> FaultDecision

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for FaultDecision

impl Debug for FaultDecision

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

Formats the value using the given formatter.

impl Eq for FaultDecision

impl Hash for FaultDecision

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 FaultDecision

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for FaultDecision