FollowRedirect 的策略

pub trait Policy<B, E> {
    fn redirect(&mut self, attempt: &Attempt<'_>) -> Result<Action, E>;

    fn on_request(&mut self, _request: &mut Request<B>) {}

    fn clone_body(&self, _body: &B) -> Option<B> {
        None
    }
}

pub type Standard = And<Limited, FilterCredentials>;

    fn redirect(&mut self, attempt: &Attempt<'_>) -> Result<Action, E> {
        self.blocked = self.block_any
            || (self.block_cross_origin && !eq_origin(attempt.previous(), attempt.location()));
        Ok(Action::Follow)
    }

    fn on_request(&mut self, request: &mut Request<B>) {
        if self.blocked {
            // 删头：remove_all 清空，否则删黑名单
            // 删扩展：remove_all_extensions 时，只把 allow_extension::<T>() 登记过的类型搬过去
        }
    }

                this.policy.on_request(&mut req);
                // Carry the filtered headers and extensions forward so anything dropped on this
                // hop stays dropped on the next one (e.g. credentials after a cross-origin hop).
                *this.headers = req.headers().clone();
                *this.extensions = req.extensions().clone();

tower-http = { version = "=0.7.1", features = ["follow-redirect"] }
old = { package = "tower-http", version = "=0.6.11", features = ["follow-redirect"] }
tower = { version = "=0.5.3", features = ["util"] }
tokio = { version = "=1.54.1", features = ["macros", "rt"] }
http = "1"
http-body = "1"
http-body-util = "0.1"
bytes = "1"

use bytes::Bytes;
use http::{header, Request, Response, StatusCode};
use http_body::Body as _;
use http_body_util::Full;
use std::{
  convert::Infallible,
  sync::atomic::{AtomicBool, AtomicUsize, Ordering},
};
use tower::{ServiceBuilder, ServiceExt};
use tower_http::follow_redirect::{
  policy::{self, PolicyExt},
  FollowRedirectLayer, RequestUri,
};

static SENT: AtomicUsize = AtomicUsize::new(0);
static QUIET: AtomicBool = AtomicBool::new(false);

#[derive(Clone)]
struct Tag(&'static str);

// 假的「网络」：按路径回 3xx，并打印每一跳收到了什么
async fn net(req: Request<Full<Bytes>>) -> Result<Response<Full<Bytes>>, Infallible> {
  SENT.fetch_add(1, Ordering::SeqCst);
  if !QUIET.load(Ordering::SeqCst) {
    let auth = req.headers().contains_key(header::AUTHORIZATION);
    let tag = req.extensions().get::<Tag>().map(|t| t.0).unwrap_or("-");
    let len = req.body().size_hint().exact().unwrap_or(0);
    println!("    -> {:<4} {:<24} auth={auth:<5} ext={tag:<8} body={len}", req.method(), req.uri().to_string());
  }
  let path = req.uri().path().to_owned();
  let (status, location) = match path.as_str() {
    "/start" => (301, "http://b.test/hop".to_owned()),
    "/hop" => (302, "/hop2".to_owned()),
    "/hop2" => (302, "http://a.test/back".to_owned()),
    "/same" => (302, "/same2".to_owned()),
    "/form" => (307, "/done".to_owned()),
    "/form302" => (302, "/done".to_owned()),
    p if p.starts_with("/loop") => (302, format!("/loop{}", p[5..].parse::<u32>().unwrap() + 1)),
    _ => (200, String::new()),
  };
  let mut res = Response::builder().status(StatusCode::from_u16(status).unwrap());
  if !location.is_empty() {
    res = res.header(header::LOCATION, location);
  }
  Ok(res.body(Full::default()).unwrap())
}

fn req(method: &str, uri: &str, body: &'static str) -> Request<Full<Bytes>> {
  let mut r = Request::builder()
    .method(method)
    .uri(uri)
    .header(header::AUTHORIZATION, "Bearer t")
    .body(Full::from(body))
    .unwrap();
  r.extensions_mut().insert(Tag("trace-id"));
  r
}

fn show(res: Response<Full<Bytes>>) {
  let last = res.extensions().get::<RequestUri>().map(|u| u.0.to_string()).unwrap_or_default();
  println!("  = {} (RequestUri {last})", res.status());
}

#[tokio::main(flavor = "current_thread")]
async fn main() {
  let standard = ServiceBuilder::new().layer(FollowRedirectLayer::new()).service_fn(net);

  println!("[1] Standard, a -> b -> b -> a");
  show(standard.clone().oneshot(req("GET", "http://a.test/start", "")).await.unwrap());

  println!("[2] 0.6.11 Standard, a -> b -> b -> a");
  let old = ServiceBuilder::new().layer(old::follow_redirect::FollowRedirectLayer::new()).service_fn(net);
  // 0.6.11 的 RequestUri 是另一个 crate 里的类型，这里只打印状态码
  println!("  = {}", old.oneshot(req("GET", "http://a.test/start", "")).await.unwrap().status());

  println!("[3] Standard, same origin");
  show(standard.clone().oneshot(req("GET", "http://a.test/same", "")).await.unwrap());

  println!("[4] preserve_extensions(false), same origin");
  let no_ext = ServiceBuilder::new().layer(FollowRedirectLayer::new().preserve_extensions(false)).service_fn(net);
  show(no_ext.oneshot(req("GET", "http://a.test/same", "")).await.unwrap());

  println!("[5] Standard, POST 302");
  show(standard.clone().oneshot(req("POST", "http://a.test/form302", "hello")).await.unwrap());

  println!("[6] Standard, POST 307");
  show(standard.clone().oneshot(req("POST", "http://a.test/form", "hello")).await.unwrap());

  println!("[7] Standard.and(clone_body_fn), POST 307");
  let p = policy::Standard::default()
    .and::<_, Full<Bytes>, Infallible>(policy::clone_body_fn(|b: &Full<Bytes>| Some(b.clone())));
  let cloning = ServiceBuilder::new().layer(FollowRedirectLayer::with_policy(p)).service_fn(net);
  show(cloning.oneshot(req("POST", "http://a.test/form", "hello")).await.unwrap());

  println!("[8] Limited::new(2), endless chain");
  let limited = ServiceBuilder::new().layer(FollowRedirectLayer::with_policy(policy::Limited::new(2))).service_fn(net);
  show(limited.oneshot(req("GET", "http://a.test/loop0", "")).await.unwrap());

  println!("[9] Standard, endless chain (hops not printed)");
  QUIET.store(true, Ordering::SeqCst);
  SENT.store(0, Ordering::SeqCst);
  show(standard.oneshot(req("GET", "http://a.test/loop0", "")).await.unwrap());
  println!("  requests sent: {}", SENT.load(Ordering::SeqCst));
}

[1] Standard, a -> b -> b -> a
    -> GET http://a.test/start      auth=true  ext=trace-id body=0
    -> GET http://b.test/hop        auth=false ext=-        body=0
    -> GET http://b.test/hop2       auth=false ext=-        body=0
    -> GET http://a.test/back       auth=false ext=-        body=0
  = 200 OK (RequestUri http://a.test/back)
[2] 0.6.11 Standard, a -> b -> b -> a
    -> GET http://a.test/start      auth=true  ext=trace-id body=0
    -> GET http://b.test/hop        auth=false ext=-        body=0
    -> GET http://b.test/hop2       auth=true  ext=-        body=0
    -> GET http://a.test/back       auth=false ext=-        body=0
  = 200 OK
[3] Standard, same origin
    -> GET http://a.test/same       auth=true  ext=trace-id body=0
    -> GET http://a.test/same2      auth=true  ext=trace-id body=0
  = 200 OK (RequestUri http://a.test/same2)
[4] preserve_extensions(false), same origin
    -> GET http://a.test/same       auth=true  ext=trace-id body=0
    -> GET http://a.test/same2      auth=true  ext=-        body=0
  = 200 OK (RequestUri http://a.test/same2)
[5] Standard, POST 302
    -> POST http://a.test/form302    auth=true  ext=trace-id body=5
    -> GET http://a.test/done       auth=true  ext=trace-id body=0
  = 200 OK (RequestUri http://a.test/done)
[6] Standard, POST 307
    -> POST http://a.test/form       auth=true  ext=trace-id body=5
  = 307 Temporary Redirect (RequestUri http://a.test/form)
[7] Standard.and(clone_body_fn), POST 307
    -> POST http://a.test/form       auth=true  ext=trace-id body=5
    -> POST http://a.test/done       auth=true  ext=trace-id body=5
  = 200 OK (RequestUri http://a.test/done)
[8] Limited::new(2), endless chain
    -> GET http://a.test/loop0      auth=true  ext=trace-id body=0
    -> GET http://a.test/loop1      auth=true  ext=trace-id body=0
    -> GET http://a.test/loop2      auth=true  ext=trace-id body=0
  = 302 Found (RequestUri http://a.test/loop2)
[9] Standard, endless chain (hops not printed)
  = 302 Found (RequestUri http://a.test/loop20)
  requests sent: 21