Enum DoOverError 

pub enum DoOverError<E> {
    Timeout,
    CircuitOpen,
    BulkheadFull,
    Inner(E),
}

Error type that wraps application errors with policy-specific failures.

DoOverError<E> allows you to distinguish between infrastructure failures (timeout, circuit open, bulkhead full) and your application’s own errors.

Type Parameter

• E - Your application’s error type

Examples

use do_over::error::DoOverError;

fn handle_error<E: std::fmt::Debug>(err: DoOverError<E>) {
    match err {
        DoOverError::Timeout => println!("Operation timed out"),
        DoOverError::CircuitOpen => println!("Circuit breaker is open"),
        DoOverError::BulkheadFull => println!("Too many concurrent requests"),
        DoOverError::Inner(e) => println!("Application error: {:?}", e),
    }
}

Variants

Timeout

The operation exceeded its configured timeout duration.

CircuitOpen

The circuit breaker is in the Open state and rejecting requests.

BulkheadFull

The bulkhead or rate limiter rejected the request due to capacity limits.

Inner(E)

An error from the underlying operation.

Trait Implementations

impl<E: Debug> Debug for DoOverError<E>

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

Formats the value using the given formatter.

impl<E> Display for DoOverError<E>

where E: Display,

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

Formats the value using the given formatter.

impl<E> Error for DoOverError<E>

where E: Error, Self: Debug + Display,

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.

impl<E> Policy<DoOverError<E>> for Bulkhead

where E: Send + Sync,

fn execute<'life0, 'async_trait, F, Fut, T>( &'life0 self, f: F, ) -> Pin<Box<dyn Future<Output = Result<T, DoOverError<E>>> + Send + 'async_trait>>

where F: Fn() -> Fut + Send + Sync + 'async_trait, Fut: Future<Output = Result<T, DoOverError<E>>> + Send + 'async_trait, T: Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

Execute an async operation with this policy’s resilience behavior.

impl<E> Policy<DoOverError<E>> for CircuitBreaker

where E: Send + Sync,

fn execute<'life0, 'async_trait, F, Fut, T>( &'life0 self, f: F, ) -> Pin<Box<dyn Future<Output = Result<T, DoOverError<E>>> + Send + 'async_trait>>

where F: Fn() -> Fut + Send + Sync + 'async_trait, Fut: Future<Output = Result<T, DoOverError<E>>> + Send + 'async_trait, T: Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

Execute an async operation with this policy’s resilience behavior.

impl<E> Policy<DoOverError<E>> for Hedge

where E: Send + Sync,

fn execute<'life0, 'async_trait, F, Fut, T>( &'life0 self, f: F, ) -> Pin<Box<dyn Future<Output = Result<T, DoOverError<E>>> + Send + 'async_trait>>

where F: Fn() -> Fut + Send + Sync + 'async_trait, Fut: Future<Output = Result<T, DoOverError<E>>> + Send + 'async_trait, T: Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

Execute an async operation with this policy’s resilience behavior.

impl<E> Policy<DoOverError<E>> for RateLimiter

where E: Send + Sync,

fn execute<'life0, 'async_trait, F, Fut, T>( &'life0 self, f: F, ) -> Pin<Box<dyn Future<Output = Result<T, DoOverError<E>>> + Send + 'async_trait>>

where F: Fn() -> Fut + Send + Sync + 'async_trait, Fut: Future<Output = Result<T, DoOverError<E>>> + Send + 'async_trait, T: Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

Execute an async operation with this policy’s resilience behavior.

impl<E> Policy<DoOverError<E>> for TimeoutPolicy

where E: Send + Sync,

fn execute<'life0, 'async_trait, F, Fut, T>( &'life0 self, f: F, ) -> Pin<Box<dyn Future<Output = Result<T, DoOverError<E>>> + Send + 'async_trait>>

where F: Fn() -> Fut + Send + Sync + 'async_trait, Fut: Future<Output = Result<T, DoOverError<E>>> + Send + 'async_trait, T: Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

Execute an async operation with this policy’s resilience behavior.