itsi-server 0.2.22-aarch64-linux

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

@@ -0,0 +1,54 @@
+use super::{string_rewrite::StringRewrite, FromValue, MiddlewareLayer};
+use crate::{
+    server::{
+        http_message_types::{HttpBody, HttpRequest, HttpResponse},
+        redirect_type::RedirectType,
+    },
+    services::itsi_http_service::HttpRequestContext,
+};
+use async_trait::async_trait;
+use either::Either;
+use http::Response;
+use magnus::error::Result;
+use serde::Deserialize;
+use tracing::debug;
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct Redirect {
+    pub to: StringRewrite,
+    #[serde(default)]
+    #[serde(rename(deserialize = "type"))]
+    pub redirect_type: RedirectType,
+}
+
+#[async_trait]
+impl MiddlewareLayer for Redirect {
+    async fn before(
+        &self,
+        req: HttpRequest,
+        context: &mut HttpRequestContext,
+    ) -> Result<Either<HttpRequest, HttpResponse>> {
+        Ok(Either::Right(self.redirect_response(&req, context)?))
+    }
+}
+
+impl Redirect {
+    pub fn redirect_response(
+        &self,
+        req: &HttpRequest,
+        context: &mut HttpRequestContext,
+    ) -> Result<HttpResponse> {
+        let mut response = Response::new(HttpBody::empty());
+        *response.status_mut() = self.redirect_type.status_code();
+        let destination = self.to.rewrite_request(req, context).parse().map_err(|e| {
+            magnus::Error::new(
+                magnus::Ruby::get().unwrap().exception_standard_error(),
+                format!("Invalid Rewrite String: {:?}: {}", self.to, e),
+            )
+        })?;
+        debug!(target: "middleware::redirect", "Redirecting to {:?}", destination);
+        response.headers_mut().append("Location", destination);
+        Ok(response)
+    }
+}
+impl FromValue for Redirect {}

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

@@ -0,0 +1,54 @@
+use std::collections::HashMap;
+
+use crate::{
+    server::http_message_types::{HttpRequest, HttpResponse},
+    services::itsi_http_service::HttpRequestContext,
+};
+
+use super::{FromValue, MiddlewareLayer, StringRewrite};
+use async_trait::async_trait;
+use either::Either;
+use http::HeaderName;
+use magnus::error::Result;
+use serde::Deserialize;
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct RequestHeaders {
+    pub additions: HashMap<String, Vec<StringRewrite>>,
+    pub removals: Vec<String>,
+}
+#[async_trait]
+impl MiddlewareLayer for RequestHeaders {
+    async fn before(
+        &self,
+        mut req: HttpRequest,
+        context: &mut HttpRequestContext,
+    ) -> Result<Either<HttpRequest, HttpResponse>> {
+        let mut headers_to_add = Vec::new();
+
+        for (header_name, header_values) in &self.additions {
+            if let Ok(parsed_header_name) = header_name.parse::<HeaderName>() {
+                for header_value in header_values {
+                    if let Ok(parsed_header_value) =
+                        header_value.rewrite_request(&req, context).parse()
+                    {
+                        headers_to_add.push((parsed_header_name.clone(), parsed_header_value));
+                    }
+                }
+            }
+        }
+
+        let headers = req.headers_mut();
+
+        for removal in &self.removals {
+            headers.remove(removal);
+        }
+
+        for (name, value) in headers_to_add {
+            headers.append(name, value);
+        }
+
+        Ok(Either::Left(req))
+    }
+}
+impl FromValue for RequestHeaders {}

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

@@ -0,0 +1,51 @@
+use std::collections::HashMap;
+
+use super::{FromValue, MiddlewareLayer, StringRewrite};
+use crate::{
+    server::http_message_types::HttpResponse, services::itsi_http_service::HttpRequestContext,
+};
+use async_trait::async_trait;
+use http::HeaderName;
+use serde::Deserialize;
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct ResponseHeaders {
+    pub additions: HashMap<String, Vec<StringRewrite>>,
+    pub removals: Vec<String>,
+}
+
+#[async_trait]
+impl MiddlewareLayer for ResponseHeaders {
+    async fn after(
+        &self,
+        mut resp: HttpResponse,
+        context: &mut HttpRequestContext,
+    ) -> HttpResponse {
+        let mut headers_to_add = Vec::new();
+
+        for (header_name, header_values) in &self.additions {
+            if let Ok(parsed_header_name) = header_name.parse::<HeaderName>() {
+                for header_value in header_values {
+                    if let Ok(parsed_header_value) =
+                        header_value.rewrite_response(&resp, context).parse()
+                    {
+                        headers_to_add.push((parsed_header_name.clone(), parsed_header_value));
+                    }
+                }
+            }
+        }
+
+        let headers = resp.headers_mut();
+
+        for removal in &self.removals {
+            headers.remove(removal);
+        }
+
+        for (name, value) in headers_to_add {
+            headers.append(name, value);
+        }
+
+        resp
+    }
+}
+impl FromValue for ResponseHeaders {}

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

@@ -0,0 +1,138 @@
+use super::MiddlewareLayer;
+use crate::ruby_types::itsi_grpc_call::ItsiGrpcCall;
+use crate::ruby_types::itsi_http_request::ItsiHttpRequest;
+use crate::server::http_message_types::{HttpRequest, HttpResponse};
+use crate::services::itsi_http_service::HttpRequestContext;
+use crate::services::static_file_server::ROOT_STATIC_FILE_SERVER;
+use async_trait::async_trait;
+use derive_more::Debug;
+use either::Either;
+use itsi_rb_helpers::{HeapVal, HeapValue};
+use magnus::{block::Proc, error::Result, value::ReprValue};
+use regex::Regex;
+use std::str::FromStr;
+use std::sync::atomic::Ordering;
+use std::sync::Arc;
+
+#[derive(Debug)]
+pub struct RubyApp {
+    app: Arc<HeapValue<Proc>>,
+    request_type: RequestType,
+    script_name: Option<String>,
+    sendfile: bool,
+    nonblocking: bool,
+    base_path: Regex,
+}
+
+#[derive(Debug)]
+pub enum RequestType {
+    Http,
+    Grpc,
+}
+
+impl FromStr for RequestType {
+    type Err = &'static str;
+
+    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+        match s {
+            "http" => Ok(RequestType::Http),
+            "grpc" => Ok(RequestType::Grpc),
+            _ => Err("Invalid request type"),
+        }
+    }
+}
+
+impl RubyApp {
+    pub fn from_value(params: HeapVal) -> magnus::error::Result<Arc<Self>> {
+        let app = params
+            .funcall::<_, _, Proc>(magnus::Ruby::get().unwrap().to_symbol("[]"), ("app_proc",))?;
+        let sendfile = params
+            .funcall::<_, _, bool>(magnus::Ruby::get().unwrap().to_symbol("[]"), ("sendfile",))
+            .unwrap_or(true);
+        let nonblocking = params
+            .funcall::<_, _, bool>(
+                magnus::Ruby::get().unwrap().to_symbol("[]"),
+                ("nonblocking",),
+            )
+            .unwrap_or(false);
+        let base_path_src = params
+            .funcall::<_, _, String>(magnus::Ruby::get().unwrap().to_symbol("[]"), ("base_path",))
+            .unwrap_or("".to_owned());
+        let script_name = params
+            .funcall::<_, _, Option<String>>(
+                magnus::Ruby::get().unwrap().to_symbol("[]"),
+                ("script_name",),
+            )
+            .unwrap_or(None);
+        let base_path = Regex::new(&base_path_src).unwrap();
+
+        let request_type: RequestType = params
+            .funcall::<_, _, String>(
+                magnus::Ruby::get().unwrap().to_symbol("[]"),
+                ("request_type",),
+            )
+            .unwrap_or("http".to_string())
+            .parse()
+            .unwrap_or(RequestType::Http);
+
+        Ok(Arc::new(RubyApp {
+            app: Arc::new(app.into()),
+            sendfile,
+            nonblocking,
+            script_name,
+            request_type,
+            base_path,
+        }))
+    }
+}
+
+#[async_trait]
+impl MiddlewareLayer for RubyApp {
+    async fn before(
+        &self,
+        req: HttpRequest,
+        context: &mut HttpRequestContext,
+    ) -> Result<Either<HttpRequest, HttpResponse>> {
+        context.is_ruby_request.store(true, Ordering::SeqCst);
+        match self.request_type {
+            RequestType::Http => {
+                let uri = req.uri().path();
+                let script_name = self.script_name.clone().unwrap_or_else(|| {
+                    self.base_path
+                        .captures(uri)
+                        .and_then(|caps| caps.name("base_path"))
+                        .map(|m| m.as_str())
+                        .unwrap_or("/")
+                        .to_owned()
+                });
+                ItsiHttpRequest::process_request(
+                    self.app.clone(),
+                    req,
+                    context,
+                    script_name,
+                    self.nonblocking,
+                )
+                .await
+                .map_err(|e| e.into())
+                .map(Either::Right)
+            }
+            RequestType::Grpc => {
+                ItsiGrpcCall::process_request(self.app.clone(), req, context, self.nonblocking)
+                    .await
+                    .map_err(|e| e.into())
+                    .map(Either::Right)
+            }
+        }
+    }
+
+    async fn after(&self, resp: HttpResponse, context: &mut HttpRequestContext) -> HttpResponse {
+        if self.sendfile {
+            if let Some(sendfile_header) = resp.headers().get("X-Sendfile") {
+                return ROOT_STATIC_FILE_SERVER
+                    .serve_single_abs(sendfile_header.to_str().unwrap(), context.accept, &[])
+                    .await;
+            }
+        }
+        resp
+    }
+}

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

@@ -0,0 +1,269 @@
+use super::{FromValue, MiddlewareLayer};
+use crate::{
+    server::http_message_types::{HttpRequest, HttpResponse},
+    services::{
+        itsi_http_service::HttpRequestContext,
+        static_file_server::{
+            NotFoundBehavior, ServeRange, StaticFileServer, StaticFileServerConfig,
+        },
+    },
+};
+use async_trait::async_trait;
+use either::Either;
+use http::{
+    header::{IF_MODIFIED_SINCE, RANGE},
+    HeaderMap, HeaderValue, Method,
+};
+use itsi_error::ItsiError;
+use magnus::error::Result;
+use quick_cache::sync::Cache;
+use regex::Regex;
+use serde::Deserialize;
+use std::{
+    collections::HashMap,
+    path::PathBuf,
+    sync::{Arc, OnceLock},
+    time::Duration,
+};
+use tracing::debug;
+
+/// Compact representation of the client's Accept-Encoding preferences.
+/// Priority order is determined by the bit checks in `pick_encoding`.
+#[derive(Clone, Copy, Debug, Default)]
+struct AcceptEncodingMask(u8);
+
+impl AcceptEncodingMask {
+    const BR: u8 = 1 << 0;
+    const GZIP: u8 = 1 << 1;
+    const ZSTD: u8 = 1 << 2;
+    const DEFLATE: u8 = 1 << 3;
+
+    fn from_headers(headers: &[HeaderValue]) -> Self {
+        let mut mask = 0u8;
+
+        for hv in headers {
+            let Ok(s) = hv.to_str() else { continue };
+
+            // We intentionally ignore q-values and treat any mention as "acceptable".
+            // This is a fast-path optimization for common benchmark/client headers.
+            for part in s.split(',') {
+                let token = part.split(';').next().unwrap_or("").trim();
+                match token {
+                    "br" => mask |= Self::BR,
+                    "gzip" => mask |= Self::GZIP,
+                    "zstd" => mask |= Self::ZSTD,
+                    "deflate" => mask |= Self::DEFLATE,
+                    _ => {}
+                }
+            }
+        }
+
+        Self(mask)
+    }
+
+    fn pick_encoding(self) -> Option<&'static str> {
+        // Prefer stronger/faster compression if available.
+        // (Actual availability is checked by the file server.)
+        if (self.0 & Self::ZSTD) != 0 {
+            return Some("zstd");
+        }
+        if (self.0 & Self::BR) != 0 {
+            return Some("br");
+        }
+        if (self.0 & Self::GZIP) != 0 {
+            return Some("gzip");
+        }
+        if (self.0 & Self::DEFLATE) != 0 {
+            return Some("deflate");
+        }
+        None
+    }
+}
+
+#[derive(Debug, Deserialize)]
+pub struct StaticAssets {
+    pub root_dir: PathBuf,
+    pub not_found_behavior: NotFoundBehavior,
+    pub auto_index: bool,
+    pub try_html_extension: bool,
+    pub max_file_size_in_memory: u64,
+    pub max_files_in_memory: u64,
+    pub file_check_interval: u64,
+    pub headers: Option<HashMap<String, String>>,
+    pub allowed_extensions: Vec<String>,
+    pub relative_path: bool,
+    pub serve_hidden_files: bool,
+    pub base_path: String,
+    #[serde(skip)]
+    pub base_path_regex: OnceLock<Regex>,
+    #[serde(skip)]
+    file_server: OnceLock<StaticFileServer>,
+}
+
+#[async_trait]
+impl MiddlewareLayer for StaticAssets {
+    async fn initialize(&self) -> Result<()> {
+        if let Ok(metadata) = tokio::fs::metadata(&self.root_dir).await {
+            if metadata.is_dir() {
+                Ok(())
+            } else {
+                Err(ItsiError::InvalidInput(
+                    "Root directory exists but is not a directory".to_string(),
+                ))
+            }
+        } else {
+            Err(ItsiError::InvalidInput(
+                "Root directory exists but is not a directory".to_string(),
+            ))
+        }?;
+        self.base_path_regex
+            .set(Regex::new(&self.base_path).map_err(ItsiError::new)?)
+            .map_err(ItsiError::new)?;
+
+        debug!(target: "middleware::static_assets", "Base path regexp: {}", self.base_path);
+
+        self.file_server
+            .set(StaticFileServer::new(StaticFileServerConfig {
+                root_dir: self.root_dir.clone(),
+                not_found_behavior: self.not_found_behavior.clone(),
+                auto_index: self.auto_index,
+                max_entries: self.max_files_in_memory,
+                try_html_extension: self.try_html_extension,
+                max_file_size: self.max_file_size_in_memory,
+                headers: self.headers.clone(),
+                recheck_interval: Duration::from_secs(self.file_check_interval),
+                serve_hidden_files: self.serve_hidden_files,
+                allowed_extensions: self.allowed_extensions.clone(),
+                miss_cache: Arc::new(Cache::new(self.max_files_in_memory as usize)),
+            })?)
+            .map_err(ItsiError::new)?;
+        Ok(())
+    }
+
+    async fn before(
+        &self,
+        req: HttpRequest,
+        context: &mut HttpRequestContext,
+    ) -> Result<Either<HttpRequest, HttpResponse>> {
+        // Only handle GET and HEAD requests
+        if req.method() != Method::GET && req.method() != Method::HEAD {
+            debug!(target: "middleware::static_assets", "Refusing to handle non-GET/HEAD request");
+            return Ok(Either::Left(req));
+        }
+
+        // We still populate the context cache for any other middleware that might want it,
+        // but we avoid re-parsing Accept-Encoding later by computing a compact mask here.
+        context.set_supported_encoding_set(&req);
+
+        let abs_path = req.uri().path();
+        let rel_path = if !self.relative_path {
+            abs_path.trim_start_matches("/")
+        } else {
+            let base_path = self
+                .base_path_regex
+                .get()
+                .unwrap()
+                .captures(abs_path)
+                .and_then(|caps| caps.name("base_path"))
+                .map(|m| m.as_str())
+                .unwrap_or("/");
+
+            match abs_path.strip_prefix(base_path) {
+                Some(suffix) => suffix,
+                None => return Ok(Either::Left(req)),
+            }
+        };
+
+        debug!(target: "middleware::static_assets", "Asset path is {}", rel_path);
+        let is_head_request = req.method() == Method::HEAD;
+
+        // Extract range and if-modified-since headers
+        let serve_range = parse_range_header(req.headers());
+        let if_modified_since = req
+            .headers()
+            .get(IF_MODIFIED_SINCE)
+            .and_then(|ims| ims.to_str().ok())
+            .and_then(|ims_str| httpdate::parse_http_date(ims_str).ok());
+
+        // Let the file server handle everything
+        let file_server = self.file_server.get().unwrap();
+        let encodings: &[HeaderValue] = context
+            .supported_encoding_set()
+            .map_or(&[], |set| set.as_slice());
+
+        // Compute a fast encoding preference and narrow the encoding list we hand to the server.
+        // This avoids repeated per-request string splitting/trim in the static file server.
+        let mask = AcceptEncodingMask::from_headers(encodings);
+        let preferred = mask.pick_encoding();
+
+        let narrowed: [HeaderValue; 1];
+        let encodings_for_server: &[HeaderValue] = if let Some(token) = preferred {
+            // Safe: these are valid header values and the file server only needs to see
+            // a minimal representation to pick a cached variant.
+            narrowed = [HeaderValue::from_static(token)];
+            &narrowed
+        } else {
+            &[]
+        };
+
+        let response = file_server
+            .serve(
+                &req,
+                rel_path,
+                abs_path,
+                serve_range,
+                if_modified_since,
+                is_head_request,
+                encodings_for_server,
+            )
+            .await;
+
+        if response.is_none() {
+            Ok(Either::Left(req))
+        } else {
+            Ok(Either::Right(response.unwrap()))
+        }
+    }
+}
+
+fn parse_range_header(headers: &HeaderMap) -> ServeRange {
+    let Some(range_header) = headers.get(RANGE) else {
+        return ServeRange::Full;
+    };
+
+    let range_header = range_header.to_str().unwrap_or("");
+    let bytes_prefix = "bytes=";
+    if !range_header.starts_with(bytes_prefix) {
+        return ServeRange::Full;
+    }
+
+    // Only consider the first range specifier, ignore multi-range requests.
+    let range_str = range_header[bytes_prefix.len()..]
+        .split(',')
+        .next()
+        .unwrap_or("");
+
+    let Some((start_str, end_str)) = range_str.split_once('-') else {
+        return ServeRange::Full;
+    };
+
+    let start = if start_str.is_empty() {
+        end_str.parse::<u64>().unwrap_or(0)
+    } else if let Ok(start) = start_str.parse::<u64>() {
+        start
+    } else {
+        return ServeRange::Full;
+    };
+
+    let end = if end_str.is_empty() {
+        u64::MAX // sentinel for open-ended ranges
+    } else if let Ok(end) = end_str.parse::<u64>() {
+        end
+    } else {
+        return ServeRange::Full;
+    };
+
+    ServeRange::Range(start, end)
+}
+
+impl FromValue for StaticAssets {}

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

@@ -0,0 +1,62 @@
+use std::sync::OnceLock;
+
+use super::{FromValue, MiddlewareLayer};
+use crate::server::http_message_types::{HttpBody, HttpRequest, HttpResponse};
+use crate::services::itsi_http_service::HttpRequestContext;
+use async_trait::async_trait;
+use bytes::Bytes;
+use derive_more::Debug;
+use either::Either;
+use http::{HeaderMap, HeaderName, HeaderValue, Response, StatusCode};
+use itsi_error::ItsiError;
+use magnus::error::Result;
+use serde::Deserialize;
+
+#[derive(Debug, Deserialize)]
+pub struct StaticResponse {
+    code: u16,
+    headers: Vec<(String, String)>,
+    body: Vec<u8>,
+    #[serde(skip)]
+    header_map: OnceLock<HeaderMap>,
+    #[serde(skip)]
+    body_bytes: OnceLock<Bytes>,
+    #[serde(skip)]
+    status_code: OnceLock<StatusCode>,
+}
+
+#[async_trait]
+impl MiddlewareLayer for StaticResponse {
+    async fn initialize(&self) -> Result<()> {
+        let mut header_map = HeaderMap::new();
+        for (key, value) in self.headers.iter() {
+            if let (Ok(hn), Ok(hv)) = (key.parse::<HeaderName>(), value.parse::<HeaderValue>()) {
+                header_map.insert(hn, hv);
+            }
+        }
+        self.header_map
+            .set(header_map)
+            .map_err(|_| ItsiError::new("Failed to set headers"))?;
+        self.body_bytes
+            .set(Bytes::from(self.body.clone()))
+            .map_err(|_| ItsiError::new("Failed to set body bytes"))?;
+        self.status_code
+            .set(StatusCode::from_u16(self.code).unwrap_or(StatusCode::OK))
+            .map_err(|_| ItsiError::new("Failed to set status code"))?;
+        Ok(())
+    }
+
+    async fn before(
+        &self,
+        _req: HttpRequest,
+        _context: &mut HttpRequestContext,
+    ) -> Result<Either<HttpRequest, HttpResponse>> {
+        let mut resp = Response::new(HttpBody::full(self.body_bytes.get().unwrap().clone()));
+        *resp.status_mut() = *self.status_code.get().unwrap();
+        *resp.headers_mut() = self.header_map.get().unwrap().clone();
+
+        Ok(Either::Right(resp))
+    }
+}
+
+impl FromValue for StaticResponse {}