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_zstd() {
155        let mut client = Decompression::new(service_fn(handle_multi_zstd));
156
157        let req = Request::builder()
158            .header("accept-encoding", "zstd")
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    async fn handle_multi_zstd(_req: Request<Body>) -> Result<Response<Body>, Infallible> {
172        let mut buf = Vec::new();
173        let mut enc1 = zstd::Encoder::new(&mut buf, Default::default()).unwrap();
174        enc1.write_all(b"Hello, ").unwrap();
175        enc1.finish().unwrap();
176
177        let mut enc2 = zstd::Encoder::new(&mut buf, Default::default()).unwrap();
178        enc2.write_all(b"World!").unwrap();
179        enc2.finish().unwrap();
180
181        let mut res = Response::new(Body::from(buf));
182        res.headers_mut()
183            .insert("content-encoding", "zstd".parse().unwrap());
184        Ok(res)
185    }
186
187    #[allow(dead_code)]
188    async fn is_compatible_with_hyper() {
189        let client =
190            hyper_util::client::legacy::Client::builder(hyper_util::rt::TokioExecutor::new())
191                .build_http();
192        let mut client = Decompression::new(client);
193
194        let req = Request::new(Body::empty());
195
196        let _: Response<DecompressionBody<_>> =
197            client.ready().await.unwrap().call(req).await.unwrap();
198    }
199
200    #[tokio::test]
201    async fn decompress_empty() {
202        let mut client = Decompression::new(Compression::new(service_fn(handle_empty)));
203
204        let req = Request::builder()
205            .header("accept-encoding", "gzip")
206            .body(Body::empty())
207            .unwrap();
208        let res = client.ready().await.unwrap().call(req).await.unwrap();
209
210        let body = res.into_body();
211        let decompressed_data =
212            String::from_utf8(body.collect().await.unwrap().to_bytes().to_vec()).unwrap();
213
214        assert_eq!(decompressed_data, "");
215    }
216
217    async fn handle_empty(_req: Request<Body>) -> Result<Response<Body>, Infallible> {
218        let mut res = Response::new(Body::empty());
219        res.headers_mut()
220            .insert("content-encoding", "gzip".parse().unwrap());
221        Ok(res)
222    }
223
224    #[tokio::test]
225    async fn decompress_empty_with_trailers() {
226        let mut client =
227            Decompression::new(Compression::new(service_fn(handle_empty_with_trailers)));
228
229        let req = Request::builder()
230            .header("accept-encoding", "gzip")
231            .body(Body::empty())
232            .unwrap();
233        let res = client.ready().await.unwrap().call(req).await.unwrap();
234
235        let body = res.into_body();
236        let collected = body.collect().await.unwrap();
237        let trailers = collected.trailers().cloned().unwrap();
238        let decompressed_data = String::from_utf8(collected.to_bytes().to_vec()).unwrap();
239
240        assert_eq!(decompressed_data, "");
241        assert_eq!(trailers["foo"], "bar");
242    }
243
244    async fn handle_empty_with_trailers(
245        _req: Request<Body>,
246    ) -> Result<Response<WithTrailers<Body>>, Infallible> {
247        let mut trailers = HeaderMap::new();
248        trailers.insert(HeaderName::from_static("foo"), "bar".parse().unwrap());
249        let body = Body::empty().with_trailers(trailers);
250        Ok(Response::builder()
251            .header("content-encoding", "gzip")
252            .body(body)
253            .unwrap())
254    }
255}
tower_http/decompression/mod.rs

tower_http/decompression/
mod.rs
