itsi-server 0.1.1 → 0.2.2

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

@@ -0,0 +1,55 @@
+use super::{string_rewrite::StringRewrite, FromValue, MiddlewareLayer};
+use crate::{
+    server::{
+        http_message_types::{HttpRequest, HttpResponse},
+        redirect_type::RedirectType,
+    },
+    services::itsi_http_service::HttpRequestContext,
+};
+use async_trait::async_trait;
+use either::Either;
+use http::Response;
+use http_body_util::{combinators::BoxBody, Empty};
+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(BoxBody::new(Empty::new()));
+        *response.status_mut() = self.redirect_type.status_code();
+        let destination = self.to.rewrite_request(req, context).parse().map_err(|e| {
+            magnus::Error::new(
+                magnus::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,126 @@
+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, Symbol};
+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,
+    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>(Symbol::new("[]"), ("app_proc",))?;
+        let sendfile = params
+            .funcall::<_, _, bool>(Symbol::new("[]"), ("sendfile",))
+            .unwrap_or(true);
+        let nonblocking = params
+            .funcall::<_, _, bool>(Symbol::new("[]"), ("nonblocking",))
+            .unwrap_or(false);
+        let base_path_src = params
+            .funcall::<_, _, String>(Symbol::new("[]"), ("base_path",))
+            .unwrap_or("".to_owned());
+        let base_path = Regex::new(&base_path_src).unwrap();
+
+        let request_type: RequestType = params
+            .funcall::<_, _, String>(Symbol::new("[]"), ("request_type",))
+            .unwrap_or("http".to_string())
+            .parse()
+            .unwrap_or(RequestType::Http);
+
+        Ok(Arc::new(RubyApp {
+            app: Arc::new(app.into()),
+            sendfile,
+            nonblocking,
+            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
+                    .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.clone(),
+                        &[],
+                    )
+                    .await;
+            }
+        }
+        resp
+    }
+}

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

@@ -0,0 +1,187 @@
+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, Method,
+};
+use itsi_error::ItsiError;
+use magnus::error::Result;
+use regex::Regex;
+use serde::Deserialize;
+use std::{collections::HashMap, path::PathBuf, sync::OnceLock, time::Duration};
+use tracing::debug;
+
+#[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(),
+            })?)
+            .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));
+        }
+        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);
+        // Determine if this is a HEAD request
+        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 response = file_server
+            .serve(
+                &req,
+                rel_path,
+                abs_path,
+                serve_range,
+                if_modified_since,
+                is_head_request,
+                &context.supported_encoding_set,
+            )
+            .await;
+        if response.is_none() {
+            Ok(Either::Left(req))
+        } else {
+            Ok(Either::Right(response.unwrap()))
+        }
+    }
+}
+
+fn parse_range_header(headers: &HeaderMap) -> ServeRange {
+    let range_header = headers.get(RANGE);
+    if range_header.is_none() {
+        return ServeRange::Full;
+    }
+    let range_header = range_header.unwrap().to_str().unwrap_or("");
+    let bytes_prefix = "bytes=";
+    if !range_header.starts_with(bytes_prefix) {
+        return ServeRange::Full;
+    }
+
+    let range_str = &range_header[bytes_prefix.len()..];
+
+    let range_parts: Vec<&str> = range_str
+        .split(',')
+        .next()
+        .unwrap_or("")
+        .split('-')
+        .collect();
+    if range_parts.len() != 2 {
+        return ServeRange::Full;
+    }
+
+    let start = if range_parts[0].is_empty() {
+        range_parts[1].parse::<u64>().unwrap_or(0)
+    } else if let Ok(start) = range_parts[0].parse::<u64>() {
+        start
+    } else {
+        return ServeRange::Full;
+    };
+
+    let end = if range_parts[1].is_empty() {
+        u64::MAX // Use u64::MAX as sentinel for open-ended ranges
+    } else if let Ok(end) = range_parts[1].parse::<u64>() {
+        end // No conversion needed, already u64
+    } 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,55 @@
+use std::sync::OnceLock;
+
+use super::{FromValue, MiddlewareLayer};
+use crate::server::http_message_types::{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 http_body_util::combinators::BoxBody;
+use http_body_util::Full;
+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>,
+}
+
+#[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"))?;
+        Ok(())
+    }
+
+    async fn before(
+        &self,
+        _req: HttpRequest,
+        _context: &mut HttpRequestContext,
+    ) -> Result<Either<HttpRequest, HttpResponse>> {
+        let mut resp = Response::new(BoxBody::new(Full::new(Bytes::from(self.body.clone()))));
+        let status = StatusCode::from_u16(self.code).unwrap_or(StatusCode::OK);
+        *resp.status_mut() = status;
+        *resp.headers_mut() = self.header_map.get().unwrap().clone();
+
+        Ok(Either::Right(resp))
+    }
+}
+
+impl FromValue for StaticResponse {}