[−][src]Trait futures_retry::ErrorHandler

pub trait ErrorHandler<InError> {
    type OutError;
    fn handle(
        &mut self, 
        attempt: usize, 
        _: InError
    ) -> RetryPolicy<Self::OutError>;

    fn ok(&mut self, _attempt: usize) { ... }
}

An error handler trait.

Please note that this trait is implemented for any FnMut closure with a compatible signature, so for some simple cases you might simply use a closure instead of creating your own type and implementing this trait for it.

Here's an example of an error handler that counts consecutive error attempts.

use futures_retry::{ErrorHandler, RetryPolicy};
use std::io;
use std::time::Duration;

pub struct CustomHandler {
    max_attempts: usize,
}

impl CustomHandler {

    pub fn new(attempts: usize) -> Self {
        Self {
            max_attempts: attempts,
        }
    }
}

impl ErrorHandler<io::Error> for CustomHandler {
    type OutError = io::Error;

    fn handle(&mut self, attempt: usize, e: io::Error) -> RetryPolicy<io::Error> {
        if attempt == self.max_attempts {
            eprintln!("No attempts left");
            return RetryPolicy::ForwardError(e);
        }
        match e.kind() {
            io::ErrorKind::ConnectionRefused => RetryPolicy::WaitRetry(Duration::from_secs(1)),
            io::ErrorKind::TimedOut => RetryPolicy::Repeat,
            _ => RetryPolicy::ForwardError(e),
        }
    }
}

Associated Types

type OutError

An error that the handle function will produce.

Loading content...

Required methods

fn handle(&mut self, attempt: usize, _: InError) -> RetryPolicy<Self::OutError>

Handles an error.

Refer to the RetryPolicy type to understand what this method might return.

Loading content...

Provided methods

fn ok(&mut self, _attempt: usize)

This method is called on a successful execution (before returning an item) of the underlying future/stream.

One can use this method to reset an internal state.

By default the method is a no-op.

Loading content...

Implementors

impl<InError, F, OutError> ErrorHandler<InError> for F where
    F: Unpin + FnMut(InError) -> RetryPolicy<OutError>, [src]

type OutError = OutError

Loading content...