itsi 0.1.14 → 0.1.18

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

@@ -1,127 +1,157 @@
-use crate::server::static_file_server::ROOT_STATIC_FILE_SERVER;
-use crate::server::types::RequestExt;
-use crate::server::{
-    itsi_service::RequestContext,
-    types::{HttpRequest, HttpResponse},
-};
-
 use bytes::Bytes;
-use either::Either;
+use http::header::CONTENT_TYPE;
 use http::Response;
 use http_body_util::{combinators::BoxBody, Full};
-use itsi_error::ItsiError;
-use serde::Deserialize;
-use std::path::{Path, PathBuf};
+use serde::{Deserialize, Deserializer};
+use std::convert::Infallible;
+use std::path::PathBuf;
+
+use crate::server::http_message_types::{HttpResponse, ResponseFormat};
+use crate::services::static_file_server::ROOT_STATIC_FILE_SERVER;
+mod default_responses;
 
 #[derive(Debug, Clone, Deserialize)]
-/// Filters can each have a customizable error response.
-/// They can:
-/// * Return Plain-text
-/// * Return HTML
-/// * Return JSON
-pub struct ErrorResponse {
-    code: u16,
-    plaintext: Option<String>,
-    html: Option<PathBuf>,
-    json: Option<serde_json::Value>,
-    default: ErrorFormat,
+pub enum ContentSource {
+    #[serde(rename(deserialize = "inline"))]
+    Inline(String),
+    #[serde(rename(deserialize = "file"))]
+    File(PathBuf),
 }
 
 #[derive(Debug, Clone, Deserialize, Default)]
-enum ErrorFormat {
-    #[default]
+pub enum DefaultFormat {
     #[serde(rename(deserialize = "plaintext"))]
     Plaintext,
+    #[default]
     #[serde(rename(deserialize = "html"))]
     Html,
     #[serde(rename(deserialize = "json"))]
     Json,
 }
 
-impl Default for ErrorResponse {
-    fn default() -> Self {
-        ErrorResponse {
-            code: 500,
-            plaintext: Some("Error".to_owned()),
-            html: None,
-            json: None,
-            default: ErrorFormat::Plaintext,
+#[derive(Debug, Clone)]
+pub struct ErrorResponse {
+    pub code: u16,
+    pub plaintext: Option<ContentSource>,
+    pub html: Option<ContentSource>,
+    pub json: Option<ContentSource>,
+    pub default: DefaultFormat, // must match one of the provided fields
+}
+
+impl<'de> Deserialize<'de> for ErrorResponse {
+    fn deserialize<D>(deserializer: D) -> Result<ErrorResponse, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let def = ErrorResponseDef::deserialize(deserializer)?;
+        Ok(def.into())
+    }
+}
+
+/// An untagged enum to support two input formats:
+/// - A detailed struct with all fields.
+/// - A string with the name of a default error response.
+#[derive(Debug, Clone, Deserialize)]
+#[serde(untagged)]
+pub enum ErrorResponseDef {
+    Detailed {
+        code: u16,
+        plaintext: Option<ContentSource>,
+        html: Option<ContentSource>,
+        json: Option<ContentSource>,
+        default: DefaultFormat,
+    },
+    Named(String),
+}
+
+impl From<ErrorResponseDef> for ErrorResponse {
+    fn from(def: ErrorResponseDef) -> Self {
+        match def {
+            ErrorResponseDef::Detailed {
+                code,
+                plaintext,
+                html,
+                json,
+                default,
+            } => ErrorResponse {
+                code,
+                plaintext,
+                html,
+                json,
+                default,
+            },
+            ErrorResponseDef::Named(name) => match name.as_str() {
+                "internal_server_error" => ErrorResponse::internal_server_error(),
+                "not_found" => ErrorResponse::not_found(),
+                "unauthorized" => ErrorResponse::unauthorized(),
+                "forbidden" => ErrorResponse::forbidden(),
+                "payload_too_large" => ErrorResponse::payload_too_large(),
+                "too_many_requests" => ErrorResponse::too_many_requests(),
+                "bad_gateway" => ErrorResponse::bad_gateway(),
+                "service_unavailable" => ErrorResponse::service_unavailable(),
+                "gateway_timeout" => ErrorResponse::gateway_timeout(),
+                _ => panic!("Unknown error response name: {}", name),
+            },
         }
     }
 }
 
 impl ErrorResponse {
-    pub(crate) async fn to_http_response(&self, request: &HttpRequest) -> HttpResponse {
-        let accept = request.accept();
-        let body = match accept {
-            Some(accept) if accept.contains("text/plain") => BoxBody::new(Full::new(Bytes::from(
-                self.plaintext.clone().unwrap_or_else(|| "Error".to_owned()),
-            ))),
-            Some(accept) if accept.contains("text/html") => {
-                if let Some(path) = &self.html {
-                    let path = path.to_str().unwrap();
-                    let response = ROOT_STATIC_FILE_SERVER.serve_single(path).await;
-
-                    if response.status().is_success() {
-                        response.into_body()
-                    } else {
-                        BoxBody::new(Full::new(Bytes::from("Error")))
-                    }
-                } else {
-                    BoxBody::new(Full::new(Bytes::from("Error")))
-                }
+    pub(crate) async fn to_http_response(&self, accept: ResponseFormat) -> HttpResponse {
+        let mut resp = Response::builder().status(self.code);
+        let response = match accept {
+            ResponseFormat::TEXT => {
+                resp = resp.header(CONTENT_TYPE, "text/plain");
+                resp.body(Self::get_response_body(self.code, &self.plaintext, accept).await)
             }
-            Some(accept) if accept.contains("application/json") => {
-                BoxBody::new(Full::new(Bytes::from(
-                    self.json
-                        .as_ref()
-                        .map(|json| json.to_string())
-                        .unwrap_or_else(|| "Error".to_owned()),
-                )))
+            ResponseFormat::HTML => {
+                resp = resp.header(CONTENT_TYPE, "text/html");
+                resp.body(Self::get_response_body(self.code, &self.html, accept).await)
             }
-            _ => match self.default {
-                ErrorFormat::Plaintext => BoxBody::new(Full::new(Bytes::from(
-                    self.plaintext.clone().unwrap_or_else(|| "Error".to_owned()),
-                ))),
-                ErrorFormat::Html => {
-                    if let Some(path) = &self.html {
-                        let path = path.to_str().unwrap();
-                        let response = ROOT_STATIC_FILE_SERVER.serve_single(path).await;
-
-                        if response.status().is_success() {
-                            response.into_body()
-                        } else {
-                            BoxBody::new(Full::new(Bytes::from("Error")))
-                        }
-                    } else {
-                        BoxBody::new(Full::new(Bytes::from("Error")))
-                    }
+            ResponseFormat::JSON => {
+                resp = resp.header(CONTENT_TYPE, "application/json");
+                resp.body(Self::get_response_body(self.code, &self.json, accept).await)
+            }
+            ResponseFormat::UNKNOWN => match self.default {
+                DefaultFormat::Plaintext => {
+                    resp = resp.header(CONTENT_TYPE, "text/plain");
+                    resp.body(Self::get_response_body(self.code, &self.plaintext, accept).await)
+                }
+                DefaultFormat::Html => {
+                    resp = resp.header(CONTENT_TYPE, "text/html");
+                    resp.body(Self::get_response_body(self.code, &self.html, accept).await)
+                }
+                DefaultFormat::Json => {
+                    resp = resp.header(CONTENT_TYPE, "application/json");
+                    resp.body(Self::get_response_body(self.code, &self.json, accept).await)
                 }
-                ErrorFormat::Json => BoxBody::new(Full::new(Bytes::from(
-                    self.json
-                        .as_ref()
-                        .map(|json| json.to_string())
-                        .unwrap_or_else(|| "Error".to_owned()),
-                ))),
             },
         };
-
-        Response::builder().status(self.code).body(body).unwrap()
+        response.unwrap()
     }
 
-    pub async fn before(
-        &self,
-        req: HttpRequest,
-        _context: &mut RequestContext,
-    ) -> Result<Either<HttpRequest, HttpResponse>, ItsiError> {
-        if let Some(path) = req.uri().path().strip_prefix("/error/") {
-            let path = Path::new(path);
-            if path.exists() {
-                let path = path.to_str().unwrap();
-                let response = ROOT_STATIC_FILE_SERVER.serve_single(path).await;
-                return Ok(Either::Right(response));
+    async fn get_response_body(
+        code: u16,
+        source: &Option<ContentSource>,
+        accept: ResponseFormat,
+    ) -> BoxBody<Bytes, Infallible> {
+        match source {
+            Some(ContentSource::Inline(text)) => {
+                return BoxBody::new(Full::new(Bytes::from(text.clone())));
+            }
+            Some(ContentSource::File(path)) => {
+                // Convert the PathBuf to a &str (assumes valid UTF-8).
+                if let Some(path_str) = path.to_str() {
+                    let response = ROOT_STATIC_FILE_SERVER
+                        .serve_single(path_str, accept.clone(), &[])
+                        .await;
+                    if response.status().is_success() {
+                        return response.into_body();
+                    }
+                }
             }
+            None => {}
         }
-        Ok(Either::Left(req))
+        ErrorResponse::fallback_body_for(code, accept)
     }
 }

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

@@ -1,5 +1,9 @@
+use crate::{
+    server::http_message_types::{HttpRequest, HttpResponse},
+    services::itsi_http_service::HttpRequestContext,
+};
+
 use super::{FromValue, MiddlewareLayer};
-use crate::server::{itsi_service::RequestContext, types::HttpResponse};
 use async_trait::async_trait;
 use base64::{engine::general_purpose, Engine as _};
 use bytes::{Bytes, BytesMut};
@@ -50,9 +54,9 @@ fn default_true() -> bool {
 impl MiddlewareLayer for ETag {
     async fn before(
         &self,
-        req: crate::server::types::HttpRequest,
-        context: &mut RequestContext,
-    ) -> Result<Either<crate::server::types::HttpRequest, HttpResponse>> {
+        req: HttpRequest,
+        context: &mut HttpRequestContext,
+    ) -> Result<Either<HttpRequest, HttpResponse>> {
         // Store if-none-match header in context if present for later use in after hook
         if self.handle_if_none_match {
             if let Some(if_none_match) = req.headers().get(header::IF_NONE_MATCH) {
@@ -64,7 +68,7 @@ impl MiddlewareLayer for ETag {
         Ok(Either::Left(req))
     }
 
-    async fn after(&self, resp: HttpResponse, context: &mut RequestContext) -> HttpResponse {
+    async fn after(&self, resp: HttpResponse, context: &mut HttpRequestContext) -> HttpResponse {
         // Skip for error responses or responses that shouldn't have ETags
         match resp.status() {
             StatusCode::OK

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

@@ -3,10 +3,7 @@ use http::{header::GetAll, HeaderValue};
 /// Given a list of header values (which may be comma-separated and may have quality parameters)
 /// and a list of supported items (each supported item is a full value or a prefix ending with '*'),
 /// return Some(supported_item) for the first supported item that matches any header value, or None.
-pub fn find_first_supported<'a, I>(
-    header_values: &http::header::GetAll<http::HeaderValue>,
-    supported: I,
-) -> Option<&'a str>
+pub fn find_first_supported<'a, I>(header_values: &[HeaderValue], supported: I) -> Option<&'a str>
 where
     I: IntoIterator<Item = &'a str> + Clone,
 {

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

@@ -1,9 +1,11 @@
-use super::{ErrorResponse, FromValue, MiddlewareLayer};
-use crate::server::{
-    itsi_service::RequestContext,
-    rate_limiter::{get_ban_manager, get_rate_limiter, BanManager, RateLimiter, RateLimiterConfig},
-    types::{HttpRequest, HttpResponse, RequestExt},
+use crate::server::http_message_types::{HttpRequest, HttpResponse, RequestExt};
+use crate::services::itsi_http_service::HttpRequestContext;
+use crate::services::rate_limiter::{
+    get_ban_manager, get_rate_limiter, BanManager, RateLimiter, RateLimiterConfig,
 };
+
+use super::{ErrorResponse, FromValue, MiddlewareLayer};
+
 use async_trait::async_trait;
 use either::Either;
 use itsi_tracing::*;
@@ -32,9 +34,14 @@ pub struct IntrusionProtection {
     #[serde(skip_deserializing)]
     pub ban_manager: OnceLock<BanManager>,
     pub store_config: RateLimiterConfig,
+    #[serde(default = "forbidden_error_response")]
     pub error_response: ErrorResponse,
 }
 
+fn forbidden_error_response() -> ErrorResponse {
+    ErrorResponse::forbidden()
+}
+
 #[async_trait]
 impl MiddlewareLayer for IntrusionProtection {
     async fn initialize(&self) -> Result<()> {
@@ -89,7 +96,7 @@ impl MiddlewareLayer for IntrusionProtection {
     async fn before(
         &self,
         req: HttpRequest,
-        context: &mut RequestContext,
+        context: &mut HttpRequestContext,
     ) -> Result<Either<HttpRequest, HttpResponse>> {
         // Get client IP address from context's service
         let client_ip = &context.addr;
@@ -97,10 +104,11 @@ impl MiddlewareLayer for IntrusionProtection {
         // Check if the IP is already banned
         if let Some(ban_manager) = self.ban_manager.get() {
             match ban_manager.is_banned(client_ip).await {
-                Ok(Some(reason)) => {
-                    info!("Request from banned IP {}: {}", client_ip, reason);
+                Ok(Some(_)) => {
                     return Ok(Either::Right(
-                        self.error_response.to_http_response(&req).await,
+                        self.error_response
+                            .to_http_response(req.accept().into())
+                            .await,
                     ));
                 }
                 Err(e) => {
@@ -118,11 +126,8 @@ impl MiddlewareLayer for IntrusionProtection {
         // Check for banned URL patterns
         if let Some(url_matcher) = self.banned_url_pattern_matcher.get() {
             let path = req.uri().path_and_query().map(|p| p.as_str()).unwrap_or("");
-            info!("Checking URL pattern match for {}", path);
-            if url_matcher.is_match(path) {
-                info!("Intrusion detected: URL pattern match for {}", path);
 
-                // Ban the IP address if possible
+            if url_matcher.is_match(path) {
                 if let Some(ban_manager) = self.ban_manager.get() {
                     match ban_manager
                         .ban_ip(
@@ -132,17 +137,16 @@ impl MiddlewareLayer for IntrusionProtection {
                         )
                         .await
                     {
-                        Ok(_) => info!(
-                            "Successfully banned IP {} for {} seconds",
-                            client_ip, self.banned_time_seconds
-                        ),
+                        Ok(_) => {}
                         Err(e) => error!("Failed to ban IP {}: {:?}", client_ip, e),
                     }
                 }
 
                 // Always return the error response even if banning failed
                 return Ok(Either::Right(
-                    self.error_response.to_http_response(&req).await,
+                    self.error_response
+                        .to_http_response(req.accept().into())
+                        .await,
                 ));
             }
         }
@@ -180,7 +184,9 @@ impl MiddlewareLayer for IntrusionProtection {
 
                         // Always return the error response even if banning failed
                         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/log_requests.rs

@@ -4,8 +4,8 @@ use itsi_tracing::*;
 use magnus::error::Result;
 use serde::Deserialize;
 
-use crate::server::itsi_service::RequestContext;
-use crate::server::types::{HttpRequest, HttpResponse};
+use crate::server::http_message_types::{HttpRequest, HttpResponse};
+use crate::services::itsi_http_service::HttpRequestContext;
 
 use super::string_rewrite::StringRewrite;
 use super::{FromValue, MiddlewareLayer};
@@ -60,7 +60,7 @@ impl MiddlewareLayer for LogRequests {
     async fn before(
         &self,
         req: HttpRequest,
-        context: &mut RequestContext,
+        context: &mut HttpRequestContext,
     ) -> Result<Either<HttpRequest, HttpResponse>> {
         context.track_start_time();
         if let Some(LogConfig { level, format }) = self.before.as_ref() {
@@ -70,7 +70,7 @@ impl MiddlewareLayer for LogRequests {
         Ok(Either::Left(req))
     }
 
-    async fn after(&self, resp: HttpResponse, context: &mut RequestContext) -> HttpResponse {
+    async fn after(&self, resp: HttpResponse, context: &mut HttpRequestContext) -> HttpResponse {
         if let Some(LogConfig { level, format }) = self.after.as_ref() {
             level.log(format.rewrite_response(&resp, context));
         }

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

@@ -0,0 +1,47 @@
+use crate::{
+    server::http_message_types::{HttpRequest, HttpResponse, RequestExt},
+    services::itsi_http_service::HttpRequestContext,
+};
+
+use super::{ErrorResponse, FromValue, MiddlewareLayer};
+use async_trait::async_trait;
+use either::Either;
+use http::StatusCode;
+use magnus::error::Result;
+use serde::Deserialize;
+use std::sync::atomic::Ordering;
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct MaxBody {
+    pub max_size: usize,
+    #[serde(default = "payload_too_large_error_response")]
+    pub error_response: ErrorResponse,
+}
+
+fn payload_too_large_error_response() -> ErrorResponse {
+    ErrorResponse::payload_too_large()
+}
+
+#[async_trait]
+impl MiddlewareLayer for MaxBody {
+    async fn before(
+        &self,
+        req: HttpRequest,
+        context: &mut HttpRequestContext,
+    ) -> Result<Either<HttpRequest, HttpResponse>> {
+        req.body().limit.store(self.max_size, Ordering::Relaxed);
+        context.set_response_format(req.accept().into());
+        Ok(Either::Left(req))
+    }
+
+    async fn after(&self, resp: HttpResponse, context: &mut HttpRequestContext) -> HttpResponse {
+        if resp.status() == StatusCode::PAYLOAD_TOO_LARGE {
+            self.error_response
+                .to_http_response(context.response_format().clone())
+                .await
+        } else {
+            resp
+        }
+    }
+}
+impl FromValue for MaxBody {}

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

@@ -11,6 +11,7 @@ mod etag;
 mod header_interpretation;
 mod intrusion_protection;
 mod log_requests;
+mod max_body;
 mod proxy;
 mod rate_limit;
 mod redirect;
@@ -18,6 +19,7 @@ mod request_headers;
 mod response_headers;
 mod ruby_app;
 mod static_assets;
+mod static_response;
 mod string_rewrite;
 mod token_source;
 
@@ -38,6 +40,7 @@ pub use intrusion_protection::IntrusionProtection;
 pub use log_requests::LogRequests;
 use magnus::error::Result;
 use magnus::Value;
+pub use max_body::MaxBody;
 pub use proxy::Proxy;
 pub use rate_limit::RateLimit;
 pub use redirect::Redirect;
@@ -47,9 +50,11 @@ pub use ruby_app::RubyApp;
 use serde::Deserialize;
 use serde_magnus::deserialize;
 pub use static_assets::StaticAssets;
+pub use static_response::StaticResponse;
 
-use crate::server::itsi_service::RequestContext;
-use crate::server::types::{HttpRequest, HttpResponse};
+use crate::server::http_message_types::HttpRequest;
+use crate::server::http_message_types::HttpResponse;
+use crate::services::itsi_http_service::HttpRequestContext;
 
 pub trait FromValue: Sized + Send + Sync + 'static {
     fn from_value(value: Value) -> Result<Self>
@@ -70,13 +75,13 @@ pub trait MiddlewareLayer: Sized + Send + Sync + 'static {
     async fn before(
         &self,
         req: HttpRequest,
-        _context: &mut RequestContext,
+        _context: &mut HttpRequestContext,
     ) -> Result<Either<HttpRequest, HttpResponse>> {
         Ok(Either::Left(req))
     }
 
     /// The "after" hook. By default, it passes through the response.
-    async fn after(&self, resp: HttpResponse, _context: &mut RequestContext) -> HttpResponse {
+    async fn after(&self, resp: HttpResponse, _context: &mut HttpRequestContext) -> HttpResponse {
         resp
     }
 }