itsi-scheduler 0.1.5 → 0.1.19

data/ext/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,
+        }
+    }
+}

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

@@ -0,0 +1,157 @@
+use bytes::Bytes;
+use http::header::CONTENT_TYPE;
+use http::Response;
+use http_body_util::{combinators::BoxBody, Full};
+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)]
+pub enum ContentSource {
+    #[serde(rename(deserialize = "inline"))]
+    Inline(String),
+    #[serde(rename(deserialize = "file"))]
+    File(PathBuf),
+}
+
+#[derive(Debug, Clone, Deserialize, Default)]
+pub enum DefaultFormat {
+    #[serde(rename(deserialize = "plaintext"))]
+    Plaintext,
+    #[default]
+    #[serde(rename(deserialize = "html"))]
+    Html,
+    #[serde(rename(deserialize = "json"))]
+    Json,
+}
+
+#[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, 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)
+            }
+            ResponseFormat::HTML => {
+                resp = resp.header(CONTENT_TYPE, "text/html");
+                resp.body(Self::get_response_body(self.code, &self.html, accept).await)
+            }
+            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)
+                }
+            },
+        };
+        response.unwrap()
+    }
+
+    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 => {}
+        }
+        ErrorResponse::fallback_body_for(code, accept)
+    }
+}

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

@@ -0,0 +1,195 @@
+use crate::{
+    server::http_message_types::{HttpRequest, HttpResponse},
+    services::itsi_http_service::HttpRequestContext,
+};
+
+use super::{FromValue, MiddlewareLayer};
+use async_trait::async_trait;
+use base64::{engine::general_purpose, Engine as _};
+use bytes::{Bytes, BytesMut};
+use either::Either;
+use futures::TryStreamExt;
+use http::{header, HeaderValue, Response, StatusCode};
+use http_body_util::{combinators::BoxBody, BodyExt, Empty, Full};
+use hyper::body::Body;
+use magnus::error::Result;
+use serde::Deserialize;
+use sha2::{Digest, Sha256};
+
+#[derive(Debug, Clone, Copy, Deserialize, Default)]
+pub enum ETagType {
+    #[serde(rename = "strong")]
+    #[default]
+    Strong,
+    #[serde(rename = "weak")]
+    Weak,
+}
+
+#[derive(Debug, Clone, Copy, Deserialize, Default)]
+pub enum HashAlgorithm {
+    #[serde(rename = "sha256")]
+    #[default]
+    Sha256,
+    #[serde(rename = "md5")]
+    Md5,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct ETag {
+    #[serde(default)]
+    pub r#type: ETagType,
+    #[serde(default)]
+    pub algorithm: HashAlgorithm,
+    #[serde(default)]
+    pub min_body_size: usize,
+    #[serde(default = "default_true")]
+    pub handle_if_none_match: bool,
+}
+
+fn default_true() -> bool {
+    true
+}
+
+#[async_trait]
+impl MiddlewareLayer for ETag {
+    async fn before(
+        &self,
+        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) {
+                if let Ok(etag_value) = if_none_match.to_str() {
+                    context.set_if_none_match(Some(etag_value.to_string()));
+                }
+            }
+        }
+        Ok(Either::Left(req))
+    }
+
+    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
+            | StatusCode::CREATED
+            | StatusCode::ACCEPTED
+            | StatusCode::NON_AUTHORITATIVE_INFORMATION
+            | StatusCode::NO_CONTENT
+            | StatusCode::PARTIAL_CONTENT => {}
+            _ => return resp,
+        }
+
+        // Skip if already has an ETag
+        if resp.headers().contains_key(header::ETAG) {
+            return resp;
+        }
+
+        // Skip if Cache-Control: no-store is present
+        if let Some(cache_control) = resp.headers().get(header::CACHE_CONTROL) {
+            if let Ok(cache_control_str) = cache_control.to_str() {
+                if cache_control_str.contains("no-store") {
+                    return resp;
+                }
+            }
+        }
+
+        // Check if body is a stream or fixed size using size_hint (similar to compression.rs)
+        let body_size = resp.size_hint().exact();
+
+        // Skip streaming bodies
+        if body_size.is_none() {
+            return resp;
+        }
+
+        // Skip if body is too small
+        if body_size.unwrap_or(0) < self.min_body_size as u64 {
+            return resp;
+        }
+
+        let (mut parts, mut body) = resp.into_parts();
+        let etag_value = if let Some(existing_etag) = parts.headers.get(header::ETAG) {
+            existing_etag.to_str().unwrap_or("").to_string()
+        } else {
+            // Get the full bytes from the body
+            let full_bytes: Bytes = match body
+                .into_data_stream()
+                .try_fold(BytesMut::new(), |mut acc, chunk| async move {
+                    acc.extend_from_slice(&chunk);
+                    Ok(acc)
+                })
+                .await
+            {
+                Ok(bytes_mut) => bytes_mut.freeze(),
+                Err(_) => return Response::from_parts(parts, BoxBody::new(Empty::new())),
+            };
+
+            let computed_etag = match self.algorithm {
+                HashAlgorithm::Sha256 => {
+                    let mut hasher = Sha256::new();
+                    hasher.update(&full_bytes);
+                    let result = hasher.finalize();
+                    general_purpose::STANDARD.encode(result)
+                }
+                HashAlgorithm::Md5 => {
+                    let digest = md5::compute(&full_bytes);
+                    format!("{:x}", digest)
+                }
+            };
+
+            let formatted_etag = match self.r#type {
+                ETagType::Strong => format!("\"{}\"", computed_etag),
+                ETagType::Weak => format!("W/\"{}\"", computed_etag),
+            };
+
+            if let Ok(value) = HeaderValue::from_str(&formatted_etag) {
+                parts.headers.insert(header::ETAG, value);
+            }
+
+            body = Full::new(full_bytes).boxed();
+            formatted_etag
+        };
+
+        // Handle 304 Not Modified if we have an If-None-Match header and it matches
+        if self.handle_if_none_match {
+            if let Some(if_none_match) = context.get_if_none_match() {
+                if if_none_match == etag_value || if_none_match == "*" {
+                    // Return 304 Not Modified without the body
+                    let mut not_modified = Response::new(BoxBody::new(Empty::new()));
+                    *not_modified.status_mut() = StatusCode::NOT_MODIFIED;
+                    // Copy headers we want to preserve
+                    for (name, value) in parts.headers.iter() {
+                        if matches!(
+                            name,
+                            &header::CACHE_CONTROL
+                                | &header::CONTENT_LOCATION
+                                | &header::DATE
+                                | &header::ETAG
+                                | &header::EXPIRES
+                                | &header::VARY
+                        ) {
+                            not_modified.headers_mut().insert(name, value.clone());
+                        }
+                    }
+                    return not_modified;
+                }
+            }
+        }
+
+        // Recreate response with the original body and the ETag header
+        Response::from_parts(parts, body)
+    }
+}
+
+impl Default for ETag {
+    fn default() -> Self {
+        Self {
+            r#type: ETagType::Strong,
+            algorithm: HashAlgorithm::Sha256,
+            min_body_size: 0,
+            handle_if_none_match: true,
+        }
+    }
+}
+
+impl FromValue for ETag {}

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

@@ -0,0 +1,82 @@
+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: &[HeaderValue], supported: I) -> Option<&'a str>
+where
+    I: IntoIterator<Item = &'a str> + Clone,
+{
+    // best candidate: (quality, supported_index, candidate)
+    let mut best: Option<(f32, usize, &'a str)> = None;
+
+    for value in header_values.iter() {
+        if let Ok(s) = value.to_str() {
+            for token in s.split(',') {
+                let token = token.trim();
+                if token.is_empty() {
+                    continue;
+                }
+                let mut parts = token.split(';');
+                let enc = parts.next()?.trim();
+                if enc.is_empty() {
+                    continue;
+                }
+                let quality = parts
+                    .find_map(|p| {
+                        let p = p.trim();
+                        if let Some(q_str) = p.strip_prefix("q=") {
+                            q_str.parse::<f32>().ok()
+                        } else {
+                            None
+                        }
+                    })
+                    .unwrap_or(1.0);
+
+                // For each supported encoding, iterate over a clone of the iterable.
+                for (i, supp) in supported.clone().into_iter().enumerate() {
+                    let is_match = if supp == "*" {
+                        true
+                    } else if let Some(prefix) = supp.strip_suffix('*') {
+                        enc.starts_with(prefix)
+                    } else {
+                        enc.eq_ignore_ascii_case(supp)
+                    };
+
+                    if is_match {
+                        best = match best {
+                            Some((best_q, best_idx, _))
+                                if quality > best_q || (quality == best_q && i < best_idx) =>
+                            {
+                                Some((quality, i, supp))
+                            }
+                            None => Some((quality, i, supp)),
+                            _ => best,
+                        };
+                    }
+                }
+            }
+        }
+    }
+
+    best.map(|(_, _, candidate)| candidate)
+}
+
+pub fn header_contains(header_values: &GetAll<HeaderValue>, needle: &str) -> bool {
+    if needle == "*" {
+        return true;
+    }
+    let mut headers = header_values
+        .iter()
+        .flat_map(|value| value.to_str().unwrap_or("").split(','))
+        .map(|s| s.trim().split(';').next().unwrap_or(""))
+        .filter(|s| !s.is_empty());
+
+    let needle_lower = needle;
+    if needle.ends_with('*') {
+        let prefix = &needle_lower[..needle_lower.len() - 1];
+        headers.any(|h| h.starts_with(prefix))
+    } else {
+        headers.any(|h| h == needle_lower)
+    }
+}