Enum FailureClass 

pub enum FailureClass {
    Transient,
    Permanent,
    Ambiguous,
    RateLimited {
        retry_after: Option<Duration>,
    },
    Authentication,
    Authorization,
    Validation,
}

What kind of failure an action reported.

The classification, not the mere presence of an error, decides whether the runtime retries, fails or treats the outcome as unknown.

Variants

Transient

The request did not take effect and may succeed if repeated, e.g. a connection refused before anything was sent.

Permanent

The request did not take effect and will not succeed if repeated.

Ambiguous

The request may or may not have taken effect, e.g. a timeout after the request was sent.

RateLimited

The remote system asked the caller to slow down.

Fields

retry_after: Option<Duration>

How long the remote system asked the caller to wait, if it said.

Authentication

The credentials were missing or invalid.

Authorization

The credentials were valid but not allowed to perform the action.

Validation

The remote system rejected the request as malformed.

Implementations

impl FailureClass

pub const fn disposition(self) -> Disposition

How the runtime treats this failure.

pub const fn retry_after(self) -> Option<Duration>

The minimum delay the remote system asked for, if any.

pub const fn with_request_sent(self, request_sent: Option<bool>) -> FailureClass

Refines a classification with whether the request reached the remote system.

Knowing the request was never sent (Some(false), e.g. a refused connection or a DNS failure) turns Self::Ambiguous into Self::Transient, because nothing can have been applied. Nothing else changes: a sent request that got a definitive answer, such as a 503, is still whatever its class says.

Trait Implementations

impl Clone for FailureClass

fn clone(&self) -> FailureClass

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for FailureClass

impl Debug for FailureClass

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for FailureClass

fn deserialize<__D>( __deserializer: __D, ) -> Result<FailureClass, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for FailureClass

impl Hash for FailureClass

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

where __H: Hasher,

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 FailureClass

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for FailureClass

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for FailureClass