Struct Retry

pub struct Retry<'a, E> {
    pub on_retry: Option<Arc<Box<dyn Fn(RetryInfo<E>) -> Option<E> + 'a>>>,
    pub until: RetryUntil,
    pub backoff: Backoff,
}

The retry builder.

Fields

on_retry: Option<Arc<Box<dyn Fn(RetryInfo<E>) -> Option<E> + 'a>>>

UNSTABLE“ ONLY PUBLIC FOR MACRO USE. Using the ’a to avoid needing everything to be static.

until: RetryUntil

UNSTABLE“ ONLY PUBLIC FOR MACRO USE.

backoff: Backoff

UNSTABLE“ ONLY PUBLIC FOR MACRO USE.

Implementations

impl<'a, E> Retry<'a, E>

pub fn until_total_attempts(self, attempts: usize) -> Self

Stop retrying after the given number of attempts.

pub fn until_forever(self) -> Self

Never stop retrying.

pub fn until_total_delay(self, max_total_delay: Duration) -> Self

Stop retrying after the total delay reaches the given duration.

pub fn until_delay(self, max_delay: Duration) -> Self

Stop retrying when the next delay is greater than the given duration.

pub fn on_retry(self, on_retry: impl Fn(RetryInfo<E>) -> Option<E> + 'a) -> Self

Will be executed each time the fallible function fails and a new one is pending. If clear won’t succeed, return Some(E) to indicate should raise with this error and not continue retrying.

pub async fn call<R, Fut: Future<Output = Result<R, E>>>( self, fallible: impl Fn() -> Fut, ) -> Result<R, E>

Will run and retry as required.

Note use underlying macro retry_flexi for better compiler support.

Arguments

• fallible - The async function that will be executed.

impl<'a, E> Retry<'a, E>

pub fn no_delay() -> Self

No delay between retries.

pub fn exponential(initial_delay: Duration, factor: f64) -> Self

EXPONENTIAL: Each retry increases the delay since the last exponentially.

Creates a new exponential backoff using the given millisecond duration as the initial delay and the given exponential backoff factor (e.g. factor of 2.0 is just squared).

pub fn fibonacci(initial_delay: Duration) -> Self

FIBONACCI: Each retry uses a delay which is the sum of the two previous delays.

Depending on the problem at hand, a fibonacci delay strategy might perform better and lead to better throughput than the [Exponential] strategy.

See “A Performance Comparison of Different Backoff Algorithms under Different Rebroadcast Probabilities for MANETs” for more details.

Create a new fibonacci backoff using the given duration in milliseconds.

pub fn fixed(fixed_delay: Duration) -> Self

FIXED: Each retry uses a fixed delay.

Create a new fixed backoff using the given duration in milliseconds.

Trait Implementations

impl<'a, E> Clone for Retry<'a, E>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a, E> Send for Retry<'a, E>