Enum InboxProcessError 

#[non_exhaustive]
pub enum InboxProcessError<S, H> {
    Store(S),
    Handler(H),
}

Whose fault it was. Split so the caller can tell “my handler failed” (record it, nak) from “the inbox could not be read or written” (record nothing, nak).

use reliar_inbox::InboxProcessError;

#[derive(Debug)]
struct StoreError;
impl std::fmt::Display for StoreError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str("store unavailable")
    }
}
impl std::error::Error for StoreError {}

let err: InboxProcessError<StoreError, std::convert::Infallible> =
    InboxProcessError::Store(StoreError);
assert_eq!(err.to_string(), "inbox store failed: store unavailable");

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.

Store(S)

crate::InboxStore::claim or crate::InboxStore::complete failed.

Handler(H)

The crate::InboxHandler failed.

Trait Implementations

impl<S, H> Classify for InboxProcessError<S, H>

where S: Classify,

Maps Self::Store to the store error’s own FailureKind and Self::Handler to FailureKind::Transient — a handler failure is retried by the broker’s redelivery, and the inbox has no authority to call a message permanently dead (ADR 0042 §4).

use reliar_core::{Classify, FailureKind};
use reliar_inbox::InboxProcessError;

#[derive(Debug)]
struct StoreError;
impl Classify for StoreError {
    fn kind(&self) -> FailureKind {
        FailureKind::Permanent
    }
}

#[derive(Debug)]
struct HandlerError;

// A handler failure is always `Transient`, regardless of the store error's own kind.
let err: InboxProcessError<StoreError, HandlerError> = InboxProcessError::Handler(HandlerError);
assert_eq!(err.kind(), FailureKind::Transient);

fn kind(&self) -> FailureKind

Whether the failure this error represents can succeed on retry.

impl<S: Debug, H: Debug> Debug for InboxProcessError<S, H>

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

Formats the value using the given formatter.

impl<S, H> Display for InboxProcessError<S, H>

where S: Error, H: Error,

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

Formats the value using the given formatter.

impl<S, H> Error for InboxProcessError<S, H>

where S: Error + 'static, H: Error + 'static,

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.