Module follow_redirect 

Available on crate feature follow-redirect only.

Middleware for following redirections.

Overview

The FollowRedirect middleware retries requests with the inner Service to follow HTTP redirections.

The middleware tries to clone the original Request when making a redirected request. Request headers and Extensions are carried over to redirected requests; the policy decides which survive each hop (the Standard policy drops credential headers and all extensions cross-origin), and filtering is cumulative, so a dropped value never reappears later in the chain. Extension forwarding can be disabled with FollowRedirectLayer::preserve_extensions.

The request body cannot always be cloned. When the original body is known to be empty by Body::size_hint, the middleware uses the Default implementation of the body type. If the body can be cloned in some way, you can tell the middleware to clone it by configuring a policy.

Examples

Basic usage

use http::{Request, Response};
use bytes::Bytes;
use http_body_util::Full;
use tower::{Service, ServiceBuilder, ServiceExt};
use tower_http::follow_redirect::{FollowRedirectLayer, RequestUri};

let mut client = ServiceBuilder::new()
    .layer(FollowRedirectLayer::new())
    .service(http_client);

let request = Request::builder()
    .uri("https://rust-lang.org/")
    .body(Full::<Bytes>::default())
    .unwrap();

let response = client.ready().await?.call(request).await?;
// Get the final request URI.
assert_eq!(response.extensions().get::<RequestUri>().unwrap().0, "https://www.rust-lang.org/");

Customizing the Policy

You can use a Policy value to customize how the middleware handles redirections.

use http::{Request, Response};
use http_body_util::Full;
use bytes::Bytes;
use tower::{Service, ServiceBuilder, ServiceExt};
use tower_http::follow_redirect::{
    policy::{self, PolicyExt},
    FollowRedirectLayer,
};

#[derive(Debug)]
enum MyError {
    TooManyRedirects,
    Other(tower::BoxError),
}

let policy = policy::Limited::new(10) // Set the maximum number of redirections to 10.
    // Return an error when the limit was reached.
    .or::<_, (), _>(policy::redirect_fn(|_| Err(MyError::TooManyRedirects)))
    // Do not follow cross-origin redirections, and return the redirection responses as-is.
    .and::<_, (), _>(policy::SameOrigin::new());

let mut client = ServiceBuilder::new()
    .layer(FollowRedirectLayer::with_policy(policy))
    .map_err(MyError::Other)
    .service(http_client);

// ...

Modules

policy

Tools for customizing the behavior of a FollowRedirect middleware.

Structs

FollowRedirect

Middleware that retries requests with a Service to follow redirection responses.

FollowRedirectLayer

Layer for retrying requests with a Service to follow redirection responses.

RequestUri

Response Extensions value that represents the effective request URI of a response returned by a FollowRedirect middleware.

ResponseFuture

Response future for FollowRedirect.