Struct reqwest_retry::RetryTransientMiddleware

pub struct RetryTransientMiddleware<T: RetryPolicy + Send + Sync + 'static> { /* private fields */ }

RetryTransientMiddleware offers retry logic for requests that fail in a transient manner and can be safely executed again.

Currently, it allows setting a RetryPolicy algorithm for calculating the wait_time between each request retry.

     use reqwest_middleware::ClientBuilder;
     use reqwest_retry::{RetryTransientMiddleware, policies::ExponentialBackoff};
     use reqwest::Client;

     // We create a ExponentialBackoff retry policy which implements `RetryPolicy`.
     let retry_policy = ExponentialBackoff {
         /// How many times the policy will tell the middleware to retry the request.
         max_n_retries: 3,
         max_retry_interval: std::time::Duration::from_millis(30),
         min_retry_interval: std::time::Duration::from_millis(100),
         backoff_exponent: 2,
     };

     let retry_transient_middleware = RetryTransientMiddleware::new_with_policy(retry_policy);
     let client = ClientBuilder::new(Client::new()).with(retry_transient_middleware).build();

Implementations

impl<T: RetryPolicy + Send + Sync> RetryTransientMiddleware<T>

pub fn new_with_policy(retry_policy: T) -> Self

Construct RetryTransientMiddleware with a retry_policy.

Trait Implementations

impl<T: RetryPolicy + Send + Sync> Middleware for RetryTransientMiddleware<T>

fn handle<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    req: Request,
    extensions: &'life1 mut Extensions,
    next: Next<'life2>
) -> Pin<Box<dyn Future<Output = Result<Response>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: 'async_trait, 

Invoked with a request before sending it. If you want to continue processing the request, you should explicitly call next.run(req, extensions).