Struct RetryPolicy 

pub struct RetryPolicy { /* private fields */ }

Available on crate feature retry only.

Retries 429 Too Many Requests, 408 Request Timeout and 5xx responses, and failures to connect.

• It waits as long as the server asks, with retry-after-ms (milliseconds) or Retry-After (seconds or an HTTP date), up to RetryPolicy::max_retry_after (60 s by default). The wait is read once into a deadline, counted from when the response arrived, and the policy sleeps until it: time spent in between (reading a 429 body for RetryLayer::permanent_429) is not added. A server that asks for longer than max_retry_after gets its response returned at once: waiting less than it asked would likely fail again, and waiting an hour is rarely what a caller wants. A date in the past means retry now.
• With RetryPolicy::server_directed_429, a 429 is retried only when the server says when.
• Without those headers it backs off exponentially from RetryPolicy::base_delay (200 ms), doubling on each retry up to RetryPolicy::max_delay (8 s), with jitter: each delay is picked at random between half and all of it, so that clients that failed together do not retry together. RetryPolicy::jitter turns that off.
• A request that timed out (a TimeoutLayer inside the retries, or a reqwest timeout) is retried only with RetryPolicy::retry_timeouts: it may have reached the server.
• It never retries a response marked Permanent (see RetryLayer::permanent_429), nor a request whose body is a stream (a streamed file upload), which cannot be sent again.

Implementations

impl RetryPolicy

pub fn new(max_retries: usize) -> Self

A policy that retries at most max_retries times (after the first attempt).

pub fn base_delay(self, delay: Duration) -> Self

The first backoff delay, doubled on each retry (default 200 ms).

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

The longest backoff delay (default 8 s). It does not limit how long a server can ask to wait with Retry-After: that is RetryPolicy::max_retry_after.

pub fn max_retry_after(self, delay: Duration) -> Self

The longest wait a server can ask for with Retry-After or retry-after-ms (default 60 s). A response that asks for longer is not retried but returned.

pub fn jitter(self, jitter: bool) -> Self

Whether each backoff delay is picked at random between half and all of it (default true). The waits a server asks for are never jittered.

pub fn server_directed_429(self, server_directed: bool) -> Self

Whether a 429 is retried only when the server says when, with Retry-After or retry-after-ms (default false: every 429 is retried, with backoff when the server does not say when).

Some APIs answer a 429 without advice when waiting will not help (a quota, a request too large for a rate limit), and with it when it will. 408, 5xx and connect failures are retried either way.

pub fn retry_timeouts(self, retry: bool) -> Self

Whether a request that timed out is retried (default false), like a failure to connect: with a TimeoutLayer inside the retries, an attempt that takes too long is given up and tried again. A request that timed out may have reached the server, so turn this on for requests that are safe to repeat (or that the API deduplicates, with an idempotency key).

pub fn max_retries(&self) -> usize

The number of retries allowed.

Trait Implementations

impl Clone for RetryPolicy

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RetryPolicy

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for RetryPolicy

Three retries.

fn default() -> Self

Returns the “default value” for a type.

impl<B> Policy<Request<Body>, Response<B>, Box<dyn Error + Sync + Send>> for RetryPolicy

type Future = Pin<Box<dyn Future<Output = ()> + Send>>

The Future type returned by Policy::retry.

fn retry( &mut self, _request: &mut Request<Body>, result: &mut Result<Response<B>, BoxError>, ) -> Option<Self::Future>

Check the policy if a certain request should be retried.

fn clone_request(&mut self, request: &Request<Body>) -> Option<Request<Body>>

Tries to clone a request before being passed to the inner service.