rama_http/layer/decompression/
mod.rs

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

rama_http/layer/decompression/
mod.rs
