Struct RetryWithContext 

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

Retry struct generated by RetryableWithContext.

Implementations

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

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

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

where SN: Sleeper,

Set the sleeper for retrying.

The sleeper should implement the Sleeper trait. The simplest way is to use a closure that returns a Future.

If not specified, we use the DefaultSleeper.

pub fn context( self, context: Ctx, ) -> RetryWithContext<B, T, E, Ctx, Fut, FutureFn, SF, RF, NF>

Set the context for retrying.

Context is used to capture ownership manually to prevent lifetime issues.

pub fn when<RN>( self, retryable: RN, ) -> RetryWithContext<B, T, E, Ctx, Fut, FutureFn, SF, RN, NF>

where RN: FnMut(&E) -> bool,

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>( self, notify: NN, ) -> RetryWithContext<B, T, E, Ctx, Fut, FutureFn, SF, RF, NN>

where NN: FnMut(&E, Duration),

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, Ctx, Fut, FutureFn, SF, RF, NF> Future for RetryWithContext<B, T, E, Ctx, Fut, FutureFn, SF, RF, NF>

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

type Output = (Ctx, Result<T, E>)

The type of value produced on completion.

fn poll( self: Pin<&mut RetryWithContext<B, T, E, Ctx, Fut, FutureFn, SF, RF, NF>>, cx: &mut Context<'_>, ) -> Poll<<RetryWithContext<B, T, E, Ctx, Fut, FutureFn, SF, RF, NF> as Future>::Output>

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