itsi 0.1.14 → 0.1.19

data/crates/itsi_server/src/server/middleware_stack/middlewares/cache_control.rs

@@ -1,5 +1,8 @@
+use crate::{
+    server::http_message_types::HttpResponse, services::itsi_http_service::HttpRequestContext,
+};
+
 use super::{FromValue, MiddlewareLayer};
-use crate::server::{itsi_service::RequestContext, types::HttpResponse};
 use async_trait::async_trait;
 use http::{HeaderName, HeaderValue};
 use magnus::error::Result;
@@ -90,7 +93,7 @@ impl MiddlewareLayer for CacheControl {
         Ok(())
     }
 
-    async fn after(&self, mut resp: HttpResponse, _: &mut RequestContext) -> HttpResponse {
+    async fn after(&self, mut resp: HttpResponse, _: &mut HttpRequestContext) -> HttpResponse {
         // Skip for statuses where caching doesn't make sense
         let status = resp.status().as_u16();
         if matches!(status, 401 | 403 | 500..=599) {

data/crates/itsi_server/src/server/middleware_stack/middlewares/compression.rs

@@ -1,26 +1,25 @@
+use crate::{
+    server::http_message_types::HttpResponse, services::itsi_http_service::HttpRequestContext,
+};
+
 use super::{
     header_interpretation::{find_first_supported, header_contains},
     FromValue, MiddlewareLayer,
 };
-use crate::server::{
-    itsi_service::RequestContext,
-    types::{HttpRequest, HttpResponse},
-};
+
 use async_compression::{
     tokio::bufread::{BrotliEncoder, DeflateEncoder, GzipEncoder, ZstdEncoder},
     Level,
 };
 use async_trait::async_trait;
 use bytes::{Bytes, BytesMut};
-use either::Either;
 use futures::TryStreamExt;
 use http::{
-    header::{GetAll, ACCEPT_ENCODING, CONTENT_ENCODING, CONTENT_LENGTH, CONTENT_TYPE},
+    header::{GetAll, CONTENT_ENCODING, CONTENT_LENGTH, CONTENT_TYPE},
     HeaderValue, Response,
 };
 use http_body_util::{combinators::BoxBody, BodyExt, Full, StreamBody};
 use hyper::body::{Body, Frame};
-use magnus::error::Result;
 use serde::{Deserialize, Serialize};
 use std::convert::Infallible;
 use tokio::io::{AsyncRead, AsyncReadExt, BufReader};
@@ -148,55 +147,16 @@ fn update_content_encoding(parts: &mut http::response::Parts, new_encoding: Head
 
 #[async_trait]
 impl MiddlewareLayer for Compression {
-    /// A the request comes in, take note of the accepted content encodings,
-    /// so that we can apply compression on the response, where appropriate.
-    ///
-    /// We store the temporary state inside the RequestContext.
-    async fn before(
-        &self,
-        req: HttpRequest,
-        context: &mut RequestContext,
-    ) -> Result<Either<HttpRequest, HttpResponse>> {
-        let algo = match find_first_supported(
-            &req.headers().get_all(ACCEPT_ENCODING),
-            self.algorithms.iter().map(|algo| algo.as_str()),
-        ) {
-            Some("gzip") => CompressionAlgorithm::Gzip,
-            Some("br") => CompressionAlgorithm::Brotli,
-            Some("deflate") => CompressionAlgorithm::Deflate,
-            Some("zstd") => CompressionAlgorithm::Zstd,
-            _ => CompressionAlgorithm::None,
-        };
-
-        if matches!(algo, CompressionAlgorithm::None) {
-            return Ok(Either::Left(req));
-        }
-
-        context.set_compression_method(algo);
-
-        Ok(Either::Left(req))
-    }
-
     /// We'll apply compression on the response, where appropriate.
     /// This is if:
     /// * The response body is larger than the minimum size.
     /// * The response content type is supported.
     /// * The client supports the compression algorithm.
-    async fn after(&self, resp: HttpResponse, context: &mut RequestContext) -> HttpResponse {
-        let compression_method;
-        if let Some(method) = context.compression_method.get() {
-            compression_method = method.clone();
-        } else {
-            return resp;
-        }
-
-        if matches!(compression_method, CompressionAlgorithm::None) {
-            return resp;
-        }
-
+    async fn after(&self, resp: HttpResponse, context: &mut HttpRequestContext) -> HttpResponse {
         let body_size = resp.size_hint().exact();
         let resp = resp;
 
+        // Don't compress if it's not an explicitly listed compressable type
         if !self
             .mime_types
             .iter()
@@ -205,14 +165,43 @@ impl MiddlewareLayer for Compression {
             return resp;
         }
 
+        // Don't compress streams unless compress streams is enabled.
         if body_size.is_none() && !self.compress_streams {
             return resp;
         }
 
+        // Don't compress too small bodies
         if body_size.is_some_and(|s| s < self.min_size as u64) {
             return resp;
         }
 
+        // Don't recompress if we're already compressed in a supported format
+        for existing_encoding in resp.headers().get_all(CONTENT_ENCODING) {
+            if let Ok(encodings) = existing_encoding.to_str() {
+                for encoding in encodings.split(',').map(str::trim) {
+                    let encoding = encoding.split(';').next().unwrap_or(encoding).trim();
+                    if self.algorithms.iter().any(|algo| algo.as_str() == encoding) {
+                        return resp;
+                    }
+                }
+            }
+        }
+
+        let compression_method = match find_first_supported(
+            &context.supported_encoding_set,
+            self.algorithms.iter().map(|algo| algo.as_str()),
+        ) {
+            Some("gzip") => CompressionAlgorithm::Gzip,
+            Some("br") => CompressionAlgorithm::Brotli,
+            Some("deflate") => CompressionAlgorithm::Deflate,
+            Some("zstd") => CompressionAlgorithm::Zstd,
+            _ => CompressionAlgorithm::None,
+        };
+
+        if matches!(compression_method, CompressionAlgorithm::None) {
+            return resp;
+        }
+
         let (mut parts, body) = resp.into_parts();
 
         let new_body = if let Some(_size) = body_size {

data/crates/itsi_server/src/server/middleware_stack/middlewares/cors.rs

@@ -1,8 +1,9 @@
 use super::{FromValue, MiddlewareLayer};
-use crate::server::{
-    itsi_service::RequestContext,
-    types::{HttpRequest, HttpResponse, RequestExt},
+use crate::{
+    server::http_message_types::{HttpRequest, HttpResponse, RequestExt},
+    services::itsi_http_service::HttpRequestContext,
 };
+
 use async_trait::async_trait;
 use http::{HeaderMap, Method, Response};
 use http_body_util::{combinators::BoxBody, Empty};
@@ -69,14 +70,14 @@ impl Cors {
     fn cors_headers(&self, origin: &str) -> Result<HeaderMap> {
         let mut headers = HeaderMap::new();
 
-        headers.insert("Vary", "Origin".parse().map_err(ItsiError::default)?);
+        headers.insert("Vary", "Origin".parse().map_err(ItsiError::new)?);
 
         if origin.is_empty() {
             // When credentials are allowed, you cannot return "*".
             if !self.allow_credentials {
                 headers.insert(
                     "Access-Control-Allow-Origin",
-                    "*".parse().map_err(ItsiError::default)?,
+                    "*".parse().map_err(ItsiError::new)?,
                 );
             }
             return Ok(headers);
@@ -97,7 +98,7 @@ impl Cors {
             };
             headers.insert(
                 "Access-Control-Allow-Origin",
-                value.parse().map_err(ItsiError::default)?,
+                value.parse().map_err(ItsiError::new)?,
             );
         }
 
@@ -110,7 +111,7 @@ impl Cors {
                     .collect::<Vec<&str>>()
                     .join(", ")
                     .parse()
-                    .map_err(ItsiError::default)?,
+                    .map_err(ItsiError::new)?,
             );
         }
         if !self.allowed_headers.is_empty() {
@@ -119,19 +120,19 @@ impl Cors {
                 self.allowed_headers
                     .join(", ")
                     .parse()
-                    .map_err(ItsiError::default)?,
+                    .map_err(ItsiError::new)?,
             );
         }
         if self.allow_credentials {
             headers.insert(
                 "Access-Control-Allow-Credentials",
-                "true".parse().map_err(ItsiError::default)?,
+                "true".parse().map_err(ItsiError::new)?,
             );
         }
         if let Some(max_age) = self.max_age {
             headers.insert(
                 "Access-Control-Max-Age",
-                max_age.to_string().parse().map_err(ItsiError::default)?,
+                max_age.to_string().parse().map_err(ItsiError::new)?,
             );
         }
         if !self.exposed_headers.is_empty() {
@@ -140,7 +141,7 @@ impl Cors {
                 self.exposed_headers
                     .join(", ")
                     .parse()
-                    .map_err(ItsiError::default)?,
+                    .map_err(ItsiError::new)?,
             );
         }
         Ok(headers)
@@ -154,7 +155,7 @@ impl Cors {
     ) -> Result<HeaderMap> {
         let mut headers = HeaderMap::new();
 
-        headers.insert("Vary", "Origin".parse().map_err(ItsiError::default)?);
+        headers.insert("Vary", "Origin".parse().map_err(ItsiError::new)?);
 
         let origin = match origin {
             Some(o) if !o.is_empty() => o,
@@ -208,25 +209,25 @@ impl Cors {
                 .collect::<Vec<&str>>()
                 .join(", ")
                 .parse()
-                .map_err(ItsiError::default)?,
+                .map_err(ItsiError::new)?,
         );
         headers.insert(
             "Access-Control-Allow-Headers",
             self.allowed_headers
                 .join(", ")
                 .parse()
-                .map_err(ItsiError::default)?,
+                .map_err(ItsiError::new)?,
         );
         if self.allow_credentials {
             headers.insert(
                 "Access-Control-Allow-Credentials",
-                "true".parse().map_err(ItsiError::default)?,
+                "true".parse().map_err(ItsiError::new)?,
             );
         }
         if let Some(max_age) = self.max_age {
             headers.insert(
                 "Access-Control-Max-Age",
-                max_age.to_string().parse().map_err(ItsiError::default)?,
+                max_age.to_string().parse().map_err(ItsiError::new)?,
             );
         }
         if !self.exposed_headers.is_empty() {
@@ -235,7 +236,7 @@ impl Cors {
                 self.exposed_headers
                     .join(", ")
                     .parse()
-                    .map_err(ItsiError::default)?,
+                    .map_err(ItsiError::new)?,
             );
         }
 
@@ -253,7 +254,7 @@ impl MiddlewareLayer for Cors {
     async fn before(
         &self,
         req: HttpRequest,
-        context: &mut RequestContext,
+        context: &mut HttpRequestContext,
     ) -> Result<either::Either<HttpRequest, HttpResponse>> {
         let origin = req.header("Origin");
         if req.method() == Method::OPTIONS {
@@ -265,7 +266,7 @@ impl MiddlewareLayer for Cors {
             *response_builder.headers_mut().unwrap() = headers;
             let response = response_builder
                 .body(BoxBody::new(Empty::new()))
-                .map_err(ItsiError::default)?;
+                .map_err(ItsiError::new)?;
             return Ok(either::Either::Right(response));
         }
         context.set_origin(origin.map(|s| s.to_string()));
@@ -273,7 +274,11 @@ impl MiddlewareLayer for Cors {
     }
 
     // The after hook can be used to inject CORS headers into non-preflight responses.
-    async fn after(&self, mut resp: HttpResponse, context: &mut RequestContext) -> HttpResponse {
+    async fn after(
+        &self,
+        mut resp: HttpResponse,
+        context: &mut HttpRequestContext,
+    ) -> HttpResponse {
         if let Some(Some(origin)) = context.origin.get() {
             if let Ok(cors_headers) = self.cors_headers(origin) {
                 for (key, value) in cors_headers.iter() {

data/crates/itsi_server/src/server/middleware_stack/middlewares/deny_list.rs

@@ -1,6 +1,6 @@
-use crate::server::{
-    itsi_service::RequestContext,
-    types::{HttpRequest, HttpResponse},
+use crate::{
+    server::http_message_types::{HttpRequest, HttpResponse, RequestExt},
+    services::itsi_http_service::HttpRequestContext,
 };
 
 use super::{ErrorResponse, FromValue, MiddlewareLayer};
@@ -17,28 +17,35 @@ pub struct DenyList {
     #[serde(skip_deserializing)]
     pub denied_ips: OnceLock<RegexSet>,
     pub denied_patterns: Vec<String>,
+    #[serde(default = "forbidden_error_response")]
     pub error_response: ErrorResponse,
 }
 
+fn forbidden_error_response() -> ErrorResponse {
+    ErrorResponse::forbidden()
+}
+
 #[async_trait]
 impl MiddlewareLayer for DenyList {
     async fn initialize(&self) -> Result<()> {
-        let denied_ips = RegexSet::new(&self.denied_patterns).map_err(ItsiError::default)?;
+        let denied_ips = RegexSet::new(&self.denied_patterns).map_err(ItsiError::new)?;
         self.denied_ips
             .set(denied_ips)
-            .map_err(|e| ItsiError::default(format!("Failed to set allowed IPs: {:?}", e)))?;
+            .map_err(|e| ItsiError::new(format!("Failed to set allowed IPs: {:?}", e)))?;
         Ok(())
     }
 
     async fn before(
         &self,
         req: HttpRequest,
-        context: &mut RequestContext,
+        context: &mut HttpRequestContext,
     ) -> Result<Either<HttpRequest, HttpResponse>> {
         if let Some(denied_ips) = self.denied_ips.get() {
             if denied_ips.is_match(&context.addr) {
                 return Ok(Either::Right(
-                    self.error_response.to_http_response(&req).await,
+                    self.error_response
+                        .to_http_response(req.accept().into())
+                        .await,
                 ));
             }
         }

data/crates/itsi_server/src/server/middleware_stack/middlewares/error_response/default_responses.rs

@@ -0,0 +1,190 @@
+use std::convert::Infallible;
+
+use bytes::Bytes;
+use http_body_util::{combinators::BoxBody, Full};
+
+use crate::server::http_message_types::ResponseFormat;
+
+use super::{ContentSource, DefaultFormat, ErrorResponse};
+
+impl DefaultFormat {
+    pub fn response_for_code(&self, code: u16) -> ContentSource {
+        match self {
+            DefaultFormat::Plaintext => match code {
+                500 => ContentSource::Inline("500 Internal Error".to_owned()),
+                404 => ContentSource::Inline("404 Not Found".to_owned()),
+                401 => ContentSource::Inline("401 Unauthorized".to_owned()),
+                403 => ContentSource::Inline("403 Forbidden".to_owned()),
+                413 => ContentSource::Inline("413 Payload Too Large".to_owned()),
+                429 => ContentSource::Inline("429 Too Many Requests".to_owned()),
+                502 => ContentSource::Inline("502 Bad Gateway".to_owned()),
+                503 => ContentSource::Inline("503 Service Unavailable".to_owned()),
+                504 => ContentSource::Inline("504 Gateway Timeout".to_owned()),
+                _ => ContentSource::Inline("Unexpected Error".to_owned()),
+            },
+            DefaultFormat::Html => match code {
+                500 => ContentSource::Inline(
+                    include_str!("../../../../default_responses/html/500.html").to_owned(),
+                ),
+                404 => ContentSource::Inline(
+                    include_str!("../../../../default_responses/html/404.html").to_owned(),
+                ),
+                401 => ContentSource::Inline(
+                    include_str!("../../../../default_responses/html/401.html").to_owned(),
+                ),
+                403 => ContentSource::Inline(
+                    include_str!("../../../../default_responses/html/403.html").to_owned(),
+                ),
+                413 => ContentSource::Inline(
+                    include_str!("../../../../default_responses/html/413.html").to_owned(),
+                ),
+                429 => ContentSource::Inline(
+                    include_str!("../../../../default_responses/html/429.html").to_owned(),
+                ),
+                502 => ContentSource::Inline(
+                    include_str!("../../../../default_responses/html/502.html").to_owned(),
+                ),
+                503 => ContentSource::Inline(
+                    include_str!("../../../../default_responses/html/503.html").to_owned(),
+                ),
+                504 => ContentSource::Inline(
+                    include_str!("../../../../default_responses/html/504.html").to_owned(),
+                ),
+                _ => ContentSource::Inline("Unexpected Error".to_owned()),
+            },
+            DefaultFormat::Json => match code {
+                500 => ContentSource::Inline(
+                    include_str!("../../../../default_responses/json/500.json").to_owned(),
+                ),
+                404 => ContentSource::Inline(
+                    include_str!("../../../../default_responses/json/404.json").to_owned(),
+                ),
+                401 => ContentSource::Inline(
+                    include_str!("../../../../default_responses/json/401.json").to_owned(),
+                ),
+                403 => ContentSource::Inline(
+                    include_str!("../../../../default_responses/json/403.json").to_owned(),
+                ),
+                413 => ContentSource::Inline(
+                    include_str!("../../../../default_responses/json/413.json").to_owned(),
+                ),
+                429 => ContentSource::Inline(
+                    include_str!("../../../../default_responses/json/429.json").to_owned(),
+                ),
+                502 => ContentSource::Inline(
+                    include_str!("../../../../default_responses/json/502.json").to_owned(),
+                ),
+                503 => ContentSource::Inline(
+                    include_str!("../../../../default_responses/json/503.json").to_owned(),
+                ),
+                504 => ContentSource::Inline(
+                    include_str!("../../../../default_responses/json/504.json").to_owned(),
+                ),
+                _ => ContentSource::Inline("Unexpected Error".to_owned()),
+            },
+        }
+    }
+}
+impl ErrorResponse {
+    pub fn fallback_body_for(code: u16, accept: ResponseFormat) -> BoxBody<Bytes, Infallible> {
+        let source = match accept {
+            ResponseFormat::TEXT => DefaultFormat::Plaintext.response_for_code(code),
+            ResponseFormat::HTML => DefaultFormat::Html.response_for_code(code),
+            ResponseFormat::JSON => DefaultFormat::Json.response_for_code(code),
+            ResponseFormat::UNKNOWN => ContentSource::Inline("Unexpected Error".to_owned()),
+        };
+        match source {
+            ContentSource::Inline(bytes) => BoxBody::new(Full::new(Bytes::from(bytes))),
+            ContentSource::File(_) => BoxBody::new(Full::new(Bytes::from("Unexpected error"))),
+        }
+    }
+    pub fn internal_server_error() -> Self {
+        ErrorResponse {
+            code: 500,
+            plaintext: Some(DefaultFormat::Plaintext.response_for_code(500)),
+            html: Some(DefaultFormat::Html.response_for_code(500)),
+            json: Some(DefaultFormat::Json.response_for_code(500)),
+            default: DefaultFormat::Html,
+        }
+    }
+
+    pub fn not_found() -> Self {
+        ErrorResponse {
+            code: 404,
+            plaintext: Some(DefaultFormat::Plaintext.response_for_code(404)),
+            html: Some(DefaultFormat::Html.response_for_code(404)),
+            json: Some(DefaultFormat::Json.response_for_code(404)),
+            default: DefaultFormat::Html,
+        }
+    }
+
+    pub fn unauthorized() -> Self {
+        ErrorResponse {
+            code: 401,
+            plaintext: Some(DefaultFormat::Plaintext.response_for_code(401)),
+            html: Some(DefaultFormat::Html.response_for_code(401)),
+            json: Some(DefaultFormat::Json.response_for_code(401)),
+            default: DefaultFormat::Html,
+        }
+    }
+
+    pub fn forbidden() -> Self {
+        ErrorResponse {
+            code: 403,
+            plaintext: Some(DefaultFormat::Plaintext.response_for_code(403)),
+            html: Some(DefaultFormat::Html.response_for_code(403)),
+            json: Some(DefaultFormat::Json.response_for_code(403)),
+            default: DefaultFormat::Html,
+        }
+    }
+
+    pub fn payload_too_large() -> Self {
+        ErrorResponse {
+            code: 413,
+            plaintext: Some(DefaultFormat::Plaintext.response_for_code(413)),
+            html: Some(DefaultFormat::Html.response_for_code(413)),
+            json: Some(DefaultFormat::Json.response_for_code(413)),
+            default: DefaultFormat::Html,
+        }
+    }
+
+    pub fn too_many_requests() -> Self {
+        ErrorResponse {
+            code: 429,
+            plaintext: Some(DefaultFormat::Plaintext.response_for_code(429)),
+            html: Some(DefaultFormat::Html.response_for_code(429)),
+            json: Some(DefaultFormat::Json.response_for_code(429)),
+            default: DefaultFormat::Html,
+        }
+    }
+
+    pub fn bad_gateway() -> Self {
+        ErrorResponse {
+            code: 502,
+            plaintext: Some(DefaultFormat::Plaintext.response_for_code(502)),
+            html: Some(DefaultFormat::Html.response_for_code(502)),
+            json: Some(DefaultFormat::Json.response_for_code(502)),
+            default: DefaultFormat::Html,
+        }
+    }
+
+    pub fn service_unavailable() -> Self {
+        ErrorResponse {
+            code: 503,
+            plaintext: Some(DefaultFormat::Plaintext.response_for_code(503)),
+            html: Some(DefaultFormat::Html.response_for_code(503)),
+            json: Some(DefaultFormat::Json.response_for_code(503)),
+            default: DefaultFormat::Html,
+        }
+    }
+
+    pub fn gateway_timeout() -> Self {
+        ErrorResponse {
+            code: 504,
+            plaintext: Some(DefaultFormat::Plaintext.response_for_code(504)),
+            html: Some(DefaultFormat::Html.response_for_code(504)),
+            json: Some(DefaultFormat::Json.response_for_code(504)),
+            default: DefaultFormat::Html,
+        }
+    }
+}