Struct retry_future::ExponentialRetryStrategy

pub struct ExponentialRetryStrategy {
    pub base: usize,
    pub max_attempts: usize,
    pub initial_delay: Duration,
    pub retry_early_returned_errors: bool,
}

Retry futures exponentially.

Examples

use retry_future::RetryStrategy;
use retry_future::ExponentialRetryStrategy;
use std::time::Duration;

let mut strategy = ExponentialRetryStrategy {
    base: 3,
    max_attempts: 5,
    initial_delay: Duration::from_secs(1),
    ..Default::default()
};

assert_eq!(strategy.check_attempt(0).unwrap(), Duration::from_secs(1));
assert_eq!(strategy.check_attempt(1).unwrap(), Duration::from_secs(3));
assert_eq!(strategy.check_attempt(2).unwrap(), Duration::from_secs(9));
assert_eq!(strategy.check_attempt(3).unwrap(), Duration::from_secs(27));
assert_eq!(strategy.check_attempt(4).unwrap(), Duration::from_secs(81));

assert!(strategy.check_attempt(5).is_err());

Fields

base: usize

max_attempts: usize

initial_delay: Duration

retry_early_returned_errors: bool

See RetryStrategy::retry_early_returned_errors

Implementations

impl ExponentialRetryStrategy

pub fn new() -> Self

pub fn max_attempts(self, max_attempts: usize) -> Self

pub fn initial_delay(self, initial_delay: Duration) -> Self

pub fn retry_early_returned_errors(
    self,
    retry_early_returned_errors: bool
) -> Self

See RetryStrategy::retry_early_returned_errors

Trait Implementations

impl Clone for ExponentialRetryStrategy

fn clone(&self) -> ExponentialRetryStrategy

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ExponentialRetryStrategy

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

Formats the value using the given formatter.

impl Default for ExponentialRetryStrategy

fn default() -> Self

Returns the “default value” for a type.

impl RetryStrategy for ExponentialRetryStrategy

fn check_attempt(
    &mut self,
    attempts_before: usize
) -> Result<Duration, TooManyAttempts>

attempts_before means how many attempts a future was trying to resolve to Ok(_) after returning Err(_).

fn retry_early_returned_errors(&self) -> bool

If true, errors propagated using ? inside a future will be retried.

impl Copy for ExponentialRetryStrategy