itsi-scheduler 0.1.11 → 0.1.12

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

@@ -0,0 +1,93 @@
+use super::MiddlewareLayer;
+use crate::ruby_types::itsi_grpc_request::ItsiGrpcRequest;
+use crate::server::static_file_server::ROOT_STATIC_FILE_SERVER;
+use crate::{
+    ruby_types::itsi_http_request::ItsiHttpRequest,
+    server::{
+        itsi_service::RequestContext,
+        types::{HttpRequest, HttpResponse},
+    },
+};
+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 std::str::FromStr;
+use std::sync::Arc;
+
+#[derive(Debug)]
+pub struct RubyApp {
+    app: Arc<HeapValue<Proc>>,
+    request_type: RequestType,
+    sendfile: bool,
+}
+
+#[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<Self> {
+        let app = params.funcall::<_, _, Proc>(Symbol::new("[]"), ("app_proc",))?;
+        let sendfile = params
+            .funcall::<_, _, bool>(Symbol::new("[]"), ("sendfile",))
+            .unwrap_or(true);
+        let request_type: RequestType = params
+            .funcall::<_, _, String>(Symbol::new("[]"), ("request_type",))
+            .unwrap_or("http".to_string())
+            .parse()
+            .unwrap_or(RequestType::Http);
+
+        Ok(RubyApp {
+            app: Arc::new(app.into()),
+            sendfile,
+            request_type,
+        })
+    }
+}
+
+#[async_trait]
+impl MiddlewareLayer for RubyApp {
+    async fn before(
+        &self,
+        req: HttpRequest,
+        context: &mut RequestContext,
+    ) -> Result<Either<HttpRequest, HttpResponse>> {
+        match self.request_type {
+            RequestType::Http => ItsiHttpRequest::process_request(self.app.clone(), req, context)
+                .await
+                .map_err(|e| e.into())
+                .map(Either::Right),
+            RequestType::Grpc => ItsiGrpcRequest::process_request(self.app.clone(), req, context)
+                .await
+                .map_err(|e| e.into())
+                .map(Either::Right),
+        }
+    }
+
+    async fn after(&self, resp: HttpResponse, _context: &mut RequestContext) -> HttpResponse {
+        if self.sendfile {
+            if let Some(sendfile_header) = resp.headers().get("X-Sendfile") {
+                return ROOT_STATIC_FILE_SERVER
+                    .serve_single(sendfile_header.to_str().unwrap())
+                    .await;
+            }
+        }
+        resp
+    }
+}

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

@@ -0,0 +1,162 @@
+use super::{FromValue, MiddlewareLayer};
+use crate::server::{
+    itsi_service::RequestContext,
+    static_file_server::{NotFoundBehavior, ServeRange, StaticFileServer, StaticFileServerConfig},
+    types::{HttpRequest, HttpResponse},
+};
+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 serde::Deserialize;
+use std::{collections::HashMap, path::PathBuf, sync::OnceLock, time::Duration};
+
+#[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 relative_path: bool,
+    #[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.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,
+                recheck_interval: Duration::from_secs(self.file_check_interval),
+            }))
+            .map_err(ItsiError::default)?;
+        Ok(())
+    }
+
+    async fn before(
+        &self,
+        req: HttpRequest,
+        context: &mut RequestContext,
+    ) -> Result<Either<HttpRequest, HttpResponse>> {
+        // Only handle GET and HEAD requests
+        if req.method() != Method::GET && req.method() != Method::HEAD {
+            return Ok(Either::Left(req));
+        }
+        let abs_path = req.uri().path();
+        let rel_path = if !self.relative_path {
+            abs_path
+        } else {
+            match context
+                .matching_pattern
+                .as_ref()
+                .and_then(|pattern| pattern.captures(req.uri().path()))
+                .and_then(|captures| captures.name("path_suffix"))
+                .map(|m| m.as_str())
+            {
+                Some(suffix) => suffix,
+                None => return Ok(Either::Left(req)),
+            }
+        };
+
+        // 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,
+            )
+            .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/string_rewrite.rs

@@ -0,0 +1,158 @@
+use crate::server::{
+    itsi_service::RequestContext,
+    types::{HttpRequest, HttpResponse},
+};
+use serde::Deserialize;
+use std::sync::OnceLock;
+
+#[derive(Debug, Clone, Deserialize)]
+#[serde(transparent)]
+pub struct StringRewrite {
+    pub template_string: String,
+    #[serde(default)]
+    pub segments: OnceLock<Vec<Segment>>,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+pub enum Segment {
+    Literal(String),
+    Placeholder(String),
+}
+
+pub fn parse_template(template: &str) -> Vec<Segment> {
+    let mut segments = Vec::new();
+    let mut last_index = 0;
+    while let Some(start_index) = template[last_index..].find('{') {
+        let start_index = last_index + start_index;
+        // Add the literal text before the placeholder.
+        if start_index > last_index {
+            segments.push(Segment::Literal(
+                template[last_index..start_index].to_string(),
+            ));
+        }
+        // Find the corresponding closing brace.
+        if let Some(end_index) = template[start_index..].find('}') {
+            let end_index = start_index + end_index;
+            let placeholder = &template[start_index + 1..end_index];
+            segments.push(Segment::Placeholder(placeholder.to_string()));
+            last_index = end_index + 1;
+        } else {
+            // No closing brace found; treat the rest as literal.
+            segments.push(Segment::Literal(template[start_index..].to_string()));
+            break;
+        }
+    }
+    if last_index < template.len() {
+        segments.push(Segment::Literal(template[last_index..].to_string()));
+    }
+    segments
+}
+
+impl StringRewrite {
+    pub fn rewrite_request(&self, req: &HttpRequest, context: &RequestContext) -> String {
+        let segments = self
+            .segments
+            .get_or_init(|| parse_template(&self.template_string));
+        let captures = context
+            .matching_pattern
+            .as_ref()
+            .and_then(|re| re.captures(req.uri().path()));
+
+        let mut result = String::with_capacity(self.template_string.len());
+
+        for segment in segments {
+            match segment {
+                Segment::Literal(text) => result.push_str(text),
+                Segment::Placeholder(placeholder) => {
+                    let replacement = match placeholder.as_str() {
+                        "request_id" => context.request_id(),
+                        "method" => req.method().as_str().to_string(),
+                        "path" => req.uri().path().to_string(),
+                        "host" => req.uri().host().unwrap_or("localhost").to_string(),
+                        "path_and_query" => req
+                            .uri()
+                            .path_and_query()
+                            .map(|pq| pq.to_string())
+                            .unwrap_or("".to_string()),
+                        "query" => {
+                            let query = req.uri().query().unwrap_or("").to_string();
+                            if query.is_empty() {
+                                query
+                            } else {
+                                format!("?{}", query)
+                            }
+                        }
+                        "port" => req
+                            .uri()
+                            .port()
+                            .map(|p| p.to_string())
+                            .unwrap_or_else(|| "80".to_string()),
+                        "start_time" => {
+                            if let Some(start_time) = context.start_time() {
+                                start_time.format("%Y-%m-%d:%H:%M:%S:%3f").to_string()
+                            } else {
+                                "N/A".to_string()
+                            }
+                        }
+                        other => {
+                            // Try using the context's matching regex if available.
+                            if let Some(caps) = &captures {
+                                if let Some(m) = caps.name(other) {
+                                    m.as_str().to_string()
+                                } else {
+                                    // Fallback: leave the placeholder as is.
+                                    format!("{{{}}}", other)
+                                }
+                            } else {
+                                format!("{{{}}}", other)
+                            }
+                        }
+                    };
+                    result.push_str(&replacement);
+                }
+            }
+        }
+
+        result
+    }
+
+    pub fn rewrite_response(&self, resp: &HttpResponse, context: &RequestContext) -> String {
+        let segments = self
+            .segments
+            .get_or_init(|| parse_template(&self.template_string));
+
+        let mut result = String::with_capacity(self.template_string.len());
+        for segment in segments {
+            match segment {
+                Segment::Literal(text) => result.push_str(text),
+                Segment::Placeholder(placeholder) => {
+                    let replacement = match placeholder.as_str() {
+                        "request_id" => context.request_id(),
+                        "status" => resp.status().as_str().to_string(),
+                        "response_time" => {
+                            if let Some(response_time) = context.get_response_time() {
+                                if let Some(microseconds) = response_time.num_microseconds() {
+                                    format!("{:.3}ms", microseconds as f64 / 1000.0)
+                                } else {
+                                    format!("{}ms", response_time.num_milliseconds())
+                                }
+                            } else {
+                                "-".to_string()
+                            }
+                        }
+                        other => {
+                            if let Some(header_value) = resp.headers().get(other) {
+                                format!("{:?}", header_value)
+                            } else {
+                                format!("{{{}}}", other)
+                            }
+                        }
+                    };
+                    result.push_str(&replacement);
+                }
+            }
+        }
+
+        result
+    }
+}

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

@@ -0,0 +1,12 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub enum TokenSource {
+    #[serde(rename(deserialize = "header"))]
+    Header {
+        name: String,
+        prefix: Option<String>,
+    },
+    #[serde(rename(deserialize = "query"))]
+    Query(String),
+}