tower_http/decompression/
mod.rs

1//! Middleware that decompresses request and response bodies.
2//!
3//! # Examples
4//!
5//! #### Request
6//!
7//! ```rust
8//! use bytes::Bytes;
9//! use flate2::{write::GzEncoder, Compression};
10//! use http::{header, HeaderValue, Request, Response};
11//! use http_body_util::{Full, BodyExt};
12//! use std::{error::Error, io::Write};
13//! use tower::{Service, ServiceBuilder, service_fn, ServiceExt};
14//! use tower_http::{BoxError, decompression::{DecompressionBody, RequestDecompressionLayer}};
15//!
16//! # #[tokio::main]
17//! # async fn main() -> Result<(), BoxError> {
18//! // A request encoded with gzip coming from some HTTP client.
19//! let mut encoder = GzEncoder::new(Vec::new(), Compression::default());
20//! encoder.write_all(b"Hello?")?;
21//! let request = Request::builder()
22//!     .header(header::CONTENT_ENCODING, "gzip")
23//!     .body(Full::from(encoder.finish()?))?;
24//!
25//! // Our HTTP server
26//! let mut server = ServiceBuilder::new()
27//!     // Automatically decompress request bodies.
28//!     .layer(RequestDecompressionLayer::new())
29//!     .service(service_fn(handler));
30//!
31//! // Send the request, with the gzip encoded body, to our server.
32//! let _response = server.ready().await?.call(request).await?;
33//!
34//! // Handler receives request whose body is decoded when read
35//! async fn handler(
36//!     mut req: Request<DecompressionBody<Full<Bytes>>>,
37//! ) -> Result<Response<Full<Bytes>>, BoxError>{
38//!     let data = req.into_body().collect().await?.to_bytes();
39//!     assert_eq!(&data[..], b"Hello?");
40//!     Ok(Response::new(Full::from("Hello, World!")))
41//! }
42//! # Ok(())
43//! # }
44//! ```
45//!
46//! #### Response
47//!
48//! ```rust
49//! use bytes::Bytes;
50//! use http::{Request, Response};
51//! use http_body_util::{Full, BodyExt};
52//! use std::convert::Infallible;
53//! use tower::{Service, ServiceExt, ServiceBuilder, service_fn};
54//! use tower_http::{compression::Compression, decompression::DecompressionLayer, BoxError};
55//! #
56//! # #[tokio::main]
57//! # async fn main() -> Result<(), tower_http::BoxError> {
58//! # async fn handle(req: Request<Full<Bytes>>) -> Result<Response<Full<Bytes>>, Infallible> {
59//! #     let body = Full::from("Hello, World!");
60//! #     Ok(Response::new(body))
61//! # }
62//!
63//! // Some opaque service that applies compression.
64//! let service = Compression::new(service_fn(handle));
65//!
66//! // Our HTTP client.
67//! let mut client = ServiceBuilder::new()
68//!     // Automatically decompress response bodies.
69//!     .layer(DecompressionLayer::new())
70//!     .service(service);
71//!
72//! // Call the service.
73//! //
74//! // `DecompressionLayer` takes care of setting `Accept-Encoding`.
75//! let request = Request::new(Full::<Bytes>::default());
76//!
77//! let response = client
78//!     .ready()
79//!     .await?
80//!     .call(request)
81//!     .await?;
82//!
83//! // Read the body
84//! let body = response.into_body();
85//! let bytes = body.collect().await?.to_bytes().to_vec();
86//! let body = String::from_utf8(bytes).map_err(Into::<BoxError>::into)?;
87//!
88//! assert_eq!(body, "Hello, World!");
89//! #
90//! # Ok(())
91//! # }
92//! ```
93
94mod request;
95
96mod body;
97mod future;
98mod layer;
99mod service;
100
101pub use self::{
102    body::DecompressionBody, future::ResponseFuture, layer::DecompressionLayer,
103    service::Decompression,
104};
105
106pub use self::request::future::RequestDecompressionFuture;
107pub use self::request::layer::RequestDecompressionLayer;
108pub use self::request::service::RequestDecompression;
109
110#[cfg(test)]
111mod tests {
112    use std::convert::Infallible;
113    use std::io::Write;
114
115    use super::*;
116    use crate::test_helpers::Body;
117    use crate::{compression::Compression, test_helpers::WithTrailers};
118    use flate2::write::GzEncoder;
119    use http::Response;
120    use http::{HeaderMap, HeaderName, Request};
121    use http_body_util::BodyExt;
122    use tower::{service_fn, Service, ServiceExt};
123
124    #[tokio::test]
125    async fn works() {
126        let mut client = Decompression::new(Compression::new(service_fn(handle)));
127
128        let req = Request::builder()
129            .header("accept-encoding", "gzip")
130            .body(Body::empty())
131            .unwrap();
132        let res = client.ready().await.unwrap().call(req).await.unwrap();
133
134        // read the body, it will be decompressed automatically
135        let body = res.into_body();
136        let collected = body.collect().await.unwrap();
137        let trailers = collected.trailers().cloned().unwrap();
138        let decompressed_data = String::from_utf8(collected.to_bytes().to_vec()).unwrap();
139
140        assert_eq!(decompressed_data, "Hello, World!");
141
142        // maintains trailers
143        assert_eq!(trailers["foo"], "bar");
144    }
145
146    async fn handle(_req: Request<Body>) -> Result<Response<WithTrailers<Body>>, Infallible> {
147        let mut trailers = HeaderMap::new();
148        trailers.insert(HeaderName::from_static("foo"), "bar".parse().unwrap());
149        let body = Body::from("Hello, World!").with_trailers(trailers);
150        Ok(Response::builder().body(body).unwrap())
151    }
152
153    #[tokio::test]
154    async fn decompress_multi_gz() {
155        let mut client = Decompression::new(service_fn(handle_multi_gz));
156
157        let req = Request::builder()
158            .header("accept-encoding", "gzip")
159            .body(Body::empty())
160            .unwrap();
161        let res = client.ready().await.unwrap().call(req).await.unwrap();
162
163        // read the body, it will be decompressed automatically
164        let body = res.into_body();
165        let decompressed_data =
166            String::from_utf8(body.collect().await.unwrap().to_bytes().to_vec()).unwrap();
167
168        assert_eq!(decompressed_data, "Hello, World!");
169    }
170
171    #[tokio::test]
172    async fn decompress_multi_zstd() {
173        let mut client = Decompression::new(service_fn(handle_multi_zstd));
174
175        let req = Request::builder()
176            .header("accept-encoding", "zstd")
177            .body(Body::empty())
178            .unwrap();
179        let res = client.ready().await.unwrap().call(req).await.unwrap();
180
181        // read the body, it will be decompressed automatically
182        let body = res.into_body();
183        let decompressed_data =
184            String::from_utf8(body.collect().await.unwrap().to_bytes().to_vec()).unwrap();
185
186        assert_eq!(decompressed_data, "Hello, World!");
187    }
188
189    async fn handle_multi_gz(_req: Request<Body>) -> Result<Response<Body>, Infallible> {
190        let mut buf = Vec::new();
191        let mut enc1 = GzEncoder::new(&mut buf, Default::default());
192        enc1.write_all(b"Hello, ").unwrap();
193        enc1.finish().unwrap();
194
195        let mut enc2 = GzEncoder::new(&mut buf, Default::default());
196        enc2.write_all(b"World!").unwrap();
197        enc2.finish().unwrap();
198
199        let mut res = Response::new(Body::from(buf));
200        res.headers_mut()
201            .insert("content-encoding", "gzip".parse().unwrap());
202        Ok(res)
203    }
204
205    async fn handle_multi_zstd(_req: Request<Body>) -> Result<Response<Body>, Infallible> {
206        let mut buf = Vec::new();
207        let mut enc1 = zstd::Encoder::new(&mut buf, Default::default()).unwrap();
208        enc1.write_all(b"Hello, ").unwrap();
209        enc1.finish().unwrap();
210
211        let mut enc2 = zstd::Encoder::new(&mut buf, Default::default()).unwrap();
212        enc2.write_all(b"World!").unwrap();
213        enc2.finish().unwrap();
214
215        let mut res = Response::new(Body::from(buf));
216        res.headers_mut()
217            .insert("content-encoding", "zstd".parse().unwrap());
218        Ok(res)
219    }
220
221    #[allow(dead_code)]
222    async fn is_compatible_with_hyper() {
223        let client =
224            hyper_util::client::legacy::Client::builder(hyper_util::rt::TokioExecutor::new())
225                .build_http();
226        let mut client = Decompression::new(client);
227
228        let req = Request::new(Body::empty());
229
230        let _: Response<DecompressionBody<_>> =
231            client.ready().await.unwrap().call(req).await.unwrap();
232    }
233}
tower_http/decompression/mod.rs

tower_http/decompression/
mod.rs
