yaiko_core/
compression.rs1use crate::{Handler, Middleware, Request, Response};
2use async_compression::tokio::write::{BrotliEncoder, GzipEncoder};
3use async_trait::async_trait;
4use std::sync::Arc;
5use tokio::io::AsyncWriteExt;
6
7pub struct CompressionMiddleware {
8 min_size: usize,
9}
10
11impl Default for CompressionMiddleware {
12 fn default() -> Self {
13 Self::new()
14 }
15}
16
17impl CompressionMiddleware {
18 pub fn new() -> Self {
19 CompressionMiddleware {
20 min_size: 1024, }
22 }
23
24 pub fn min_size(mut self, size: usize) -> Self {
25 self.min_size = size;
26 self
27 }
28
29 async fn compress_response(
30 &self,
31 response: Response,
32 encoding: &str,
33 ) -> Result<Response, Box<dyn std::error::Error + Send + Sync>> {
34 let body_bytes = hyper::body::to_bytes(response.body).await?;
35
36 if body_bytes.len() < self.min_size {
37 return Ok(Response {
38 status: response.status,
39 headers: response.headers,
40 body: hyper::Body::from(body_bytes),
41 });
42 }
43
44 let compressed = match encoding {
45 "gzip" => {
46 let mut encoder = GzipEncoder::new(Vec::new());
47 encoder.write_all(&body_bytes).await?;
48 encoder.shutdown().await?;
49 encoder.into_inner()
50 }
51 "br" => {
52 let mut encoder = BrotliEncoder::new(Vec::new());
53 encoder.write_all(&body_bytes).await?;
54 encoder.shutdown().await?;
55 encoder.into_inner()
56 }
57 _ => {
58 return Ok(Response {
59 status: response.status,
60 headers: response.headers,
61 body: hyper::Body::from(body_bytes),
62 })
63 }
64 };
65
66 let mut headers = response.headers;
67 headers.insert("Content-Encoding".to_string(), encoding.to_string());
68 headers.insert("Content-Length".to_string(), compressed.len().to_string());
69
70 Ok(Response {
71 status: response.status,
72 headers,
73 body: hyper::Body::from(compressed),
74 })
75 }
76}
77
78#[async_trait]
79impl Middleware for CompressionMiddleware {
80 async fn handle(
81 &self,
82 req: Request,
83 next: Arc<dyn Handler>,
84 ) -> Result<Response, Box<dyn std::error::Error + Send + Sync>> {
85 let accept_encoding = req
86 .headers
87 .get("accept-encoding")
88 .and_then(|v| v.to_str().ok())
89 .unwrap_or("")
90 .to_string();
91
92 let response = next.handle(req).await?;
93
94 if accept_encoding.contains("br") {
96 self.compress_response(response, "br").await
97 } else if accept_encoding.contains("gzip") {
98 self.compress_response(response, "gzip").await
99 } else {
100 Ok(response)
101 }
102 }
103}