ServiceBuilderExt 与 ServiceExt

pub trait ServiceBuilderExt<L>: sealed::Sealed<L> + Sized {
    #[cfg(feature = "propagate-header")]
    fn propagate_header(
        self,
        header: HeaderName,
    ) -> ServiceBuilder<Stack<crate::propagate_header::PropagateHeaderLayer, L>>;
    // ...
}

impl<L> sealed::Sealed<L> for ServiceBuilder<L> {}

tower-http = { version = "=0.7.1", features = ["util", "timeout", "trace", "compression-gzip"] }
tower = { version = "=0.5.3", features = ["util", "timeout"] }
tokio = { version = "=1.54.1", features = ["macros", "rt", "time", "test-util"] }
http = "1"
http-body-util = "0.1"
bytes = "1"

use bytes::Bytes;
use http::{Request, Response, StatusCode};
use http_body_util::Full;
use std::{convert::Infallible, time::Duration};
use tower::{service_fn, ServiceBuilder, ServiceExt};
use tower_http::{timeout::TimeoutLayer, ServiceBuilderExt as _};

async fn slow(_: Request<Full<Bytes>>) -> Result<Response<Full<Bytes>>, Infallible> {
  tokio::time::sleep(Duration::from_secs(5)).await;
  Ok(Response::new(Full::from("done")))
}

fn short(name: &str) -> String {
  let mut out = String::new();
  for part in name.split_inclusive(['<', '>', ',']) {
    out.push_str(part.trim_start().rsplit("::").next().unwrap());
  }
  out
}

#[tokio::main(flavor = "current_thread", start_paused = true)]
async fn main() {
  let req = || Request::new(Full::default());

  // ServiceBuilder::timeout 来自 tower 自己（tower 的 timeout feature）
  let a = ServiceBuilder::new().timeout(Duration::from_secs(1)).service_fn(slow);
  println!("builder.timeout(..):  {}", std::any::type_name_of_val(&a));
  match a.oneshot(req()).await {
    Ok(res) => println!("  Ok({})", res.status()),
    Err(e) => println!("  Err({e})"),
  }

  // tower-http 的 TimeoutLayer 没有 builder 快捷方法，只能 .layer(..)
  let b = ServiceBuilder::new()
    .layer(TimeoutLayer::with_status_code(StatusCode::REQUEST_TIMEOUT, Duration::from_secs(1)))
    .service_fn(slow);
  println!("layer(TimeoutLayer):  {}", std::any::type_name_of_val(&b));
  match b.oneshot(req()).await {
    Ok(res) => println!("  Ok({})", res.status()),
    Err(e) => println!("  Err({e:?})"),
  }

  // ServiceBuilderExt：tower-http 加在 ServiceBuilder 上的方法
  let c = ServiceBuilder::new().trace_for_http().compression().service_fn(slow);
  println!("builder ext:          {}", short(std::any::type_name_of_val(&c)));
  // ServiceExt（0.6.4 起）：直接在服务上链；只在这个块里导入，原因见下文
  let d = {
    use tower_http::ServiceExt as _;
    service_fn(slow).compression().trace_for_http()
  };
  println!("service ext:          {}", short(std::any::type_name_of_val(&d)));
}

builder.timeout(..):  tower::timeout::Timeout<tower::util::service_fn::ServiceFn<ext::slow>>
  Err(request timed out)
layer(TimeoutLayer):  tower_http::timeout::service::Timeout<tower::util::service_fn::ServiceFn<ext::slow>>
  Ok(408 Request Timeout)
builder ext:          Trace<Compression<ServiceFn<slow>>,SharedClassifier<ServerErrorsAsFailures>>
service ext:          Trace<Compression<ServiceFn<slow>>,SharedClassifier<ServerErrorsAsFailures>>

impl<T> ServiceExt for T {}

use tower_http::{timeout::TimeoutLayer, ServiceBuilderExt as _, ServiceExt as _};

error[E0034]: multiple applicable items in scope
  --> src/main.rs:44:33
   |
44 |   let c = ServiceBuilder::new().trace_for_http().compression().service_fn(slow);
   |                                 ^^^^^^^^^^^^^^ multiple `trace_for_http` found
   |
   = note: candidate #1 is defined in an impl of the trait `ServiceBuilderExt` for the type `ServiceBuilder<L>`
   = note: candidate #2 is defined in an impl of the trait `tower_http::ServiceExt` for the type `T`
help: disambiguate the method for candidate #1
   |
44 -   let c = ServiceBuilder::new().trace_for_http().compression().service_fn(slow);
44 +   let c = ServiceBuilderExt::trace_for_http(ServiceBuilder::new()).compression().service_fn(slow);
   |
help: disambiguate the method for candidate #2
   |
44 -   let c = ServiceBuilder::new().trace_for_http().compression().service_fn(slow);
44 +   let c = tower_http::ServiceExt::trace_for_http(ServiceBuilder::new()).compression().service_fn(slow);
   |