请求解压

pub struct RequestDecompression<S> {
    pub(super) inner: S,
    pub(super) accept: AcceptEncoding,
    pub(super) pass_through_unaccepted: bool,
}

                match entry.get().as_bytes() {
                    #[cfg(feature = "decompression-gzip")]
                    b"gzip" if self.accept.gzip() => {
                        entry.remove();
                        parts.headers.remove(header::CONTENT_LENGTH);
                        BodyInner::gzip(crate::compression_utils::WrapBody::new(
                            body,
                            CompressionLevel::default(),
                        ))
                    }
                    // deflate、br、zstd 同样
                    b"identity" => BodyInner::identity(body),
                    _ if self.pass_through_unaccepted => BodyInner::identity(body),
                    _ => return ResponseFuture::unsupported_encoding(self.accept),
                }

            StateProj::Unsupported { accept } => {
                let res = Response::builder()
                    .header(
                        header::ACCEPT_ENCODING,
                        accept
                            .to_header_value()
                            .unwrap_or(HeaderValue::from_static("identity")),
                    )
                    .status(StatusCode::UNSUPPORTED_MEDIA_TYPE)
                    .body(UnsyncBoxBody::from_inner(
                        Empty::new().map_err(Into::into).boxed_unsync(),
                    ))
                    .unwrap();
                Poll::Ready(Ok(res))
            }

    type Response = Response<UnsyncBoxBody<D, BoxError>>;

tower-http = { version = "=0.7.1", features = ["decompression-full", "limit"] }
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"
flate2 = "1"

use bytes::Bytes;
use http::{header, Request, Response};
use http_body_util::{BodyExt, Full};
use std::{convert::Infallible, io::Write};
use tower::{ServiceBuilder, ServiceExt};
use tower_http::{decompression::RequestDecompressionLayer, limit::RequestBodyLimitLayer};

// handler 读完请求 body，报告读到多少字节，以及它看到的两个头
async fn handler<B>(req: Request<B>) -> Result<Response<Full<Bytes>>, Infallible>
where
  B: http_body::Body,
  B::Error: std::fmt::Display,
{
  let heads = format!("ce={:?} cl={:?}", req.headers().get(header::CONTENT_ENCODING), req.headers().get(header::CONTENT_LENGTH));
  let msg = match req.into_body().collect().await {
    Ok(c) => format!("{heads} read {} bytes", c.to_bytes().len()),
    Err(e) => format!("{heads} error: {e}"),
  };
  Ok(Response::new(Full::from(msg)))
}

fn gzip(data: &[u8]) -> Bytes {
  let mut e = flate2::write::GzEncoder::new(Vec::new(), flate2::Compression::best());
  e.write_all(data).unwrap();
  Bytes::from(e.finish().unwrap())
}

fn post(ce: &str, body: Bytes) -> Request<Full<Bytes>> {
  Request::post("/").header(header::CONTENT_ENCODING, ce).header(header::CONTENT_LENGTH, body.len()).body(Full::new(body)).unwrap()
}

// show(label, svc, req)：发请求，打印状态码、响应的 Accept-Encoding 和响应正文

#[tokio::main(flavor = "current_thread")]
async fn main() {
  let hello = gzip(b"hello world");
  let dec = || ServiceBuilder::new().layer(RequestDecompressionLayer::new()).service_fn(handler);
  show("gzip", dec(), post("gzip", hello.clone())).await;
  show("identity", dec(), post("identity", Bytes::from("plain"))).await;
  show("GZIP", dec(), post("GZIP", hello.clone())).await;
  let no_br = ServiceBuilder::new().layer(RequestDecompressionLayer::new().no_br()).service_fn(handler);
  show("br, no_br()", no_br, post("br", Bytes::from("whatever"))).await;
  let pass = ServiceBuilder::new().layer(RequestDecompressionLayer::new().pass_through_unaccepted(true)).service_fn(handler);
  show("GZIP, pass_through", pass, post("GZIP", hello.clone())).await;

  let bomb = gzip(&vec![0u8; 10 * 1024 * 1024]);
  println!("bomb: {} bytes compressed", bomb.len());
  let outside = ServiceBuilder::new()
    .layer(RequestBodyLimitLayer::new(1 << 20))
    .layer(RequestDecompressionLayer::new())
    .service_fn(handler);
  show("limit outside decompression", outside, post("gzip", bomb.clone())).await;
  let inside = ServiceBuilder::new()
    .layer(RequestDecompressionLayer::new())
    .layer(RequestBodyLimitLayer::new(1 << 20))
    .service_fn(handler);
  show("limit inside decompression", inside, post("gzip", bomb.clone())).await;
}

gzip                         200 OK accept-encoding=None "ce=None cl=None read 11 bytes"
identity                     200 OK accept-encoding=None "ce=Some(\"identity\") cl=Some(\"5\") read 5 bytes"
GZIP                         415 Unsupported Media Type accept-encoding=Some("zstd,gzip,deflate,br") ""
br, no_br()                  415 Unsupported Media Type accept-encoding=Some("zstd,gzip,deflate") ""
GZIP, pass_through           200 OK accept-encoding=None "ce=Some(\"GZIP\") cl=Some(\"31\") read 31 bytes"
bomb: 10208 bytes compressed
limit outside decompression  200 OK accept-encoding=None "ce=None cl=None read 10485760 bytes"
limit inside decompression   200 OK accept-encoding=None "ce=None cl=None error: length limit exceeded"