Trait tower::retry::Policy[][src]

pub trait Policy<Req, Res, E>: Sized {
    type Future: Future<Output = Self>;
    fn retry(&self, req: &Req, result: Result<&Res, &E>) -> Option<Self::Future>;
fn clone_request(&self, req: &Req) -> Option<Req>; }
This is supported on crate feature retry only.

A “retry policy” to classify if a request should be retried.


use tower::retry::Policy;
use futures_util::future;

type Req = String;
type Res = String;

struct Attempts(usize);

impl<E> Policy<Req, Res, E> for Attempts {
    type Future = future::Ready<Self>;

    fn retry(&self, req: &Req, result: Result<&Res, &E>) -> Option<Self::Future> {
        match result {
            Ok(_) => {
                // Treat all `Response`s as success,
                // so don't retry...
            Err(_) => {
                // Treat all errors as failures...
                // But we limit the number of attempts...
                if self.0 > 0 {
                    // Try again!
                    Some(future::ready(Attempts(self.0 - 1)))
                } else {
                    // Used all our attempts, no retry...

    fn clone_request(&self, req: &Req) -> Option<Req> {

Associated Types

type Future: Future<Output = Self>[src]

The Future type returned by Policy::retry.

Loading content...

Required methods

fn retry(&self, req: &Req, result: Result<&Res, &E>) -> Option<Self::Future>[src]

Check the policy if a certain request should be retried.

This method is passed a reference to the original request, and either the Service::Response or Service::Error from the inner service.

If the request should not be retried, return None.

If the request should be retried, return Some future of a new policy that would apply for the next request attempt.

fn clone_request(&self, req: &Req) -> Option<Req>[src]

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

If the request cannot be cloned, return None.

Loading content...


Loading content...