itsi-scheduler 0.1.5 → 0.2.2

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 {}

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

@@ -0,0 +1,173 @@
+use serde::Deserialize;
+use std::sync::OnceLock;
+
+use crate::{
+    server::http_message_types::{HttpRequest, HttpResponse},
+    services::itsi_http_service::HttpRequestContext,
+};
+
+#[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: &HttpRequestContext) -> 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.short_request_id(),
+                        "request_id_full" => context.request_id(),
+                        "method" => req.method().as_str().to_string(),
+                        "path" => req.uri().path().to_string(),
+                        "addr" => context.addr.to_owned(),
+                        "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 => {
+                            if let Some(header_val) = req.headers().get(other) {
+                                if let Ok(s) = header_val.to_str() {
+                                    s.to_string()
+                                } else {
+                                    "".to_string()
+                                }
+                            } else 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: &HttpRequestContext) -> 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.short_request_id(),
+                        "request_id_full" => context.request_id(),
+                        "status" => resp.status().as_str().to_string(),
+                        "addr" => context.addr.to_owned(),
+                        "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 => {
+                            // Try pulling from response headers first
+                            if let Some(val) = resp.headers().get(other) {
+                                if let Ok(s) = val.to_str() {
+                                    s.to_string()
+                                } else {
+                                    "".to_string()
+                                }
+                            } else {
+                                format!("{{{}}}", other)
+                            }
+                        }
+                    };
+                    result.push_str(&replacement);
+                }
+            }
+        }
+
+        result
+    }
+}

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

@@ -0,0 +1,31 @@
+use serde::{Deserialize, Serialize};
+
+use crate::server::http_message_types::{HttpRequest, RequestExt};
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub enum TokenSource {
+    #[serde(rename(deserialize = "header"))]
+    Header {
+        name: String,
+        prefix: Option<String>,
+    },
+    #[serde(rename(deserialize = "query"))]
+    Query(String),
+}
+
+impl TokenSource {
+    pub fn extract_token<'req>(&self, req: &'req HttpRequest) -> Option<&'req str> {
+        match self {
+            TokenSource::Header { name, prefix } => req.headers().get(name).and_then(|value| {
+                value.to_str().ok().and_then(|value| {
+                    if let Some(prefix) = prefix {
+                        value.strip_prefix(prefix).map(|v| v.trim())
+                    } else {
+                        Some(value)
+                    }
+                })
+            }),
+            TokenSource::Query(query_name) => req.query_param(query_name),
+        }
+    }
+}