body 模块

All these are wrappers around other body types. You shouldn't have to use them in your code.
Use `http-body-util` instead.

They exist because we don't want to expose types from `http-body-util` in `tower-http`s public
API.

#[cfg(any(
    feature = "catch-panic",
    feature = "decompression-br",
    feature = "decompression-deflate",
    feature = "decompression-gzip",
    feature = "decompression-zstd",
    feature = "fs",
    feature = "limit",
))]
pub mod body;

tower-http = { version = "=0.7.1", features = ["limit", "map-response-body"] }
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"

// 请求 body 类型也会被层改掉（RequestBodyLimit 把它换成 Limited<B>），所以 handler 写成泛型
async fn echo<B>(req: Request<B>) -> Result<Response<Full<Bytes>>, Infallible>
where
  B: http_body::Body,
  B::Error: Into<BoxError>,
{
  let msg = match req.into_body().collect().await {
    Ok(c) => format!("read {} bytes", c.to_bytes().len()),
    Err(e) => format!("error: {}", e.into()),
  };
  Ok(Response::new(Full::from(msg)))
}

    let svc = if limit {
      ServiceBuilder::new().layer(RequestBodyLimitLayer::new(4)).service_fn(echo)
    } else {
      service_fn(echo)
    };

error[E0308]: `if` and `else` have incompatible types
  --> src/main.rs:27:7
   |
24 |       let svc = if limit {
   |  _______________-
25 | |       ServiceBuilder::new().layer(RequestBodyLimitLayer::new(4)).service_fn(echo)
   | |       --------------------------------------------------------------------------- expected because of this
26 | |     } else {
27 | |       service_fn(echo)
   | |       ^^^^^^^^^^^^^^^^ expected `RequestBodyLimit<ServiceFn<_>>`, found `ServiceFn<fn(_) -> _ {echo::<_>}>`
28 | |     };
   | |_____- `if` and `else` have incompatible types

error[E0308]: `if` and `else` have incompatible types
  --> src/main.rs:27:7
   |
24 |       let svc = if limit {
   |  _______________-
25 | |       ServiceBuilder::new().layer(RequestBodyLimitLayer::new(4)).service_fn(echo).boxed_clone()
   | |       ----------------------------------------------------------------------------------------- expected because of this
26 | |     } else {
27 | |       service_fn(echo).boxed_clone()
   | |       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `ResponseBody<Full<Bytes>>`, found `http_body_util::Full<bytes::Bytes>`
28 | |     };
   | |_____- `if` and `else` have incompatible types
   |
   = note: expected struct `BoxCloneService<Request<_>, Response<ResponseBody<Full<_>>>, _>`
              found struct `BoxCloneService<Request<_>, Response<Full<_>>, _>`

use tower_http::{body::UnsyncBoxBody, limit::RequestBodyLimitLayer, map_response_body::MapResponseBodyLayer};

#[tokio::main(flavor = "current_thread")]
async fn main() {
  for limit in [true, false] {
    let svc = if limit {
      ServiceBuilder::new()
        .layer(MapResponseBodyLayer::new(UnsyncBoxBody::new))
        .layer(RequestBodyLimitLayer::new(4))
        .service_fn(echo)
        .boxed_clone()
    } else {
      ServiceBuilder::new()
        .layer(MapResponseBodyLayer::new(UnsyncBoxBody::new))
        .service_fn(echo::<Full<Bytes>>)
        .boxed_clone()
    };
    let res = svc.oneshot(Request::new(Full::from("hello"))).await.unwrap();
    let status = res.status();
    let body = res.into_body().collect().await.unwrap().to_bytes();
    println!("limit={limit}: {status} {body:?}");
  }
}

limit=true: 200 OK b"error: length limit exceeded"
limit=false: 200 OK b"read 5 bytes"

impl From<ResponseBody> for UnsyncBoxBody<Bytes, io::Error> {
    fn from(body: ResponseBody) -> Self {
        body.inner
    }
}