Struct Retry

pub struct Retry<B: Backoff, T, E, Fut: Future<Output = Result<T, E>>, FutureFn: FnMut() -> Fut, SF: MaybeSleeper = DefaultSleeper, RF = fn(_: &E) -> bool, NF = fn(_: &E, _: Duration)> { /* private fields */ }

Struct generated by Retryable.

Implementations

impl<B, T, E, Fut, FutureFn, SF, RF, NF> Retry<B, T, E, Fut, FutureFn, SF, RF, NF>

where B: Backoff, Fut: Future<Output = Result<T, E>>, FutureFn: FnMut() -> Fut, SF: MaybeSleeper, RF: FnMut(&E) -> bool, NF: FnMut(&E, Duration),

pub fn sleep<SN: Sleeper>( self, sleep_fn: SN, ) -> Retry<B, T, E, Fut, FutureFn, SN, RF, NF>

Set the sleeper for retrying.

The sleeper should implement the Sleeper trait. The simplest way is to use a closure that returns a Future<Output=()>.

If not specified, we use the DefaultSleeper.

use anyhow::Result;
use backon::ExponentialBuilder;
use backon::Retryable;
use std::future::ready;

async fn fetch() -> Result<String> {
    Ok(reqwest::get("https://www.rust-lang.org")
        .await?
        .text()
        .await?)
}

#[tokio::main(flavor = "current_thread")]
async fn main() -> Result<()> {
    let content = fetch
        .retry(ExponentialBuilder::default())
        .sleep(|_| ready(()))
        .await?;
    println!("fetch succeeded: {}", content);

    Ok(())
}

pub fn when<RN: FnMut(&E) -> bool>( self, retryable: RN, ) -> Retry<B, T, E, Fut, FutureFn, SF, RN, NF>

Set the conditions for retrying.

If not specified, all errors are considered retryable.

Examples

use anyhow::Result;
use backon::ExponentialBuilder;
use backon::Retryable;

async fn fetch() -> Result<String> {
    Ok(reqwest::get("https://www.rust-lang.org")
        .await?
        .text()
        .await?)
}

#[tokio::main(flavor = "current_thread")]
async fn main() -> Result<()> {
    let content = fetch
        .retry(ExponentialBuilder::default())
        .when(|e| e.to_string() == "EOF")
        .await?;
    println!("fetch succeeded: {}", content);

    Ok(())
}

pub fn notify<NN: FnMut(&E, Duration)>( self, notify: NN, ) -> Retry<B, T, E, Fut, FutureFn, SF, RF, NN>

Set to notify for all retry attempts.

When a retry happens, the input function will be invoked with the error and the sleep duration before pausing.

If not specified, this operation does nothing.

Examples

use core::time::Duration;

use anyhow::Result;
use backon::ExponentialBuilder;
use backon::Retryable;

async fn fetch() -> Result<String> {
    Ok(reqwest::get("https://www.rust-lang.org")
        .await?
        .text()
        .await?)
}

#[tokio::main(flavor = "current_thread")]
async fn main() -> Result<()> {
    let content = fetch
        .retry(ExponentialBuilder::default())
        .notify(|err: &anyhow::Error, dur: Duration| {
            println!("retrying error {:?} with sleeping {:?}", err, dur);
        })
        .await?;
    println!("fetch succeeded: {}", content);

    Ok(())
}

Trait Implementations

impl<B, T, E, Fut, FutureFn, SF, RF, NF> Future for Retry<B, T, E, Fut, FutureFn, SF, RF, NF>

where B: Backoff, Fut: Future<Output = Result<T, E>>, FutureFn: FnMut() -> Fut, SF: Sleeper, RF: FnMut(&E) -> bool, NF: FnMut(&E, Duration),

type Output = Result<T, E>

The type of value produced on completion.

fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>

Attempts to resolve the future to a final value, registering the current task for wakeup if the value is not yet available.