Struct backon::Retry

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

Retry struct generated by Retryable.

Implementations

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

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

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

Set the conditions for retrying.

If not specified, we treat all errors as 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, RF, NN>

Set to notify for everything retrying.

If not specified, this is a no-op.

Examples

use std::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, RF, NF> Future for Retry<B, T, E, Fut, FutureFn, RF, NF>

where B: Backoff, Fut: Future<Output = Result<T, E>>, FutureFn: FnMut() -> Fut, 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>

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

impl<'pin, B: Backoff, T, E, Fut: Future<Output = Result<T, E>>, FutureFn: FnMut() -> Fut, RF, NF> Unpin for Retry<B, T, E, Fut, FutureFn, RF, NF>

where __Retry<'pin, B, T, E, Fut, FutureFn, RF, NF>: Unpin,