itsi-server 0.1.1 → 0.1.13

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),
+}

data/ext/itsi_server/src/server/middleware_stack/mod.rs

@@ -0,0 +1,315 @@
+mod middleware;
+mod middlewares;
+use super::types::HttpRequest;
+use http::header::{ACCEPT, CONTENT_TYPE, HOST};
+use itsi_rb_helpers::HeapVal;
+use magnus::{error::Result, value::ReprValue, RArray, RHash, Ruby, TryConvert, Value};
+pub use middleware::Middleware;
+pub use middlewares::*;
+use regex::{Regex, RegexSet};
+use std::{collections::HashMap, sync::Arc};
+use tracing::info;
+
+#[derive(Debug)]
+pub struct MiddlewareSet {
+    pub route_set: RegexSet,
+    pub patterns: Vec<Arc<Regex>>,
+    pub stacks: HashMap<usize, MiddlewareStack>,
+    pub default_stack: Vec<Middleware>,
+}
+
+#[derive(Debug)]
+pub struct MiddlewareStack {
+    layers: Vec<Middleware>,
+    methods: Option<Vec<StringMatch>>,
+    protocols: Option<Vec<StringMatch>>,
+    hosts: Option<Vec<StringMatch>>,
+    extensions: Option<Vec<StringMatch>>,
+    ports: Option<Vec<StringMatch>>,
+    content_types: Option<Vec<StringMatch>>,
+    accepts: Option<Vec<StringMatch>>,
+}
+
+#[derive(Debug)]
+enum StringMatch {
+    Exact(String),
+    Wildcard(Regex),
+}
+
+impl StringMatch {
+    fn from_value(value: Value) -> Result<Self> {
+        let ruby = Ruby::get().unwrap();
+        if value.is_kind_of(ruby.class_regexp()) {
+            let src_str = value.funcall::<_, _, String>("source", ())?;
+            let regex = Regex::new(&src_str).map_err(|e| {
+                magnus::Error::new(
+                    magnus::exception::exception(),
+                    format!("Invalid regexp: {}", e),
+                )
+            })?;
+            Ok(StringMatch::Wildcard(regex))
+        } else {
+            Ok(StringMatch::Exact(value.to_string()))
+        }
+    }
+
+    fn matches(&self, value: &str) -> bool {
+        match self {
+            StringMatch::Exact(s) => s.eq_ignore_ascii_case(value),
+            StringMatch::Wildcard(re) => re.is_match(value),
+        }
+    }
+}
+
+impl MiddlewareStack {
+    pub fn matches(&self, request: &HttpRequest) -> bool {
+        if let Some(methods) = &self.methods {
+            let method = request.method().as_str();
+            if !methods.iter().any(|m| m.matches(method)) {
+                return false;
+            }
+        }
+
+        if let (Some(protocols), Some(protocol)) = (&self.protocols, request.uri().scheme()) {
+            if !protocols.iter().any(|p| p.matches(protocol.as_str())) {
+                return false;
+            }
+        }
+
+        if let (Some(hosts), Some(host)) = (&self.hosts, request.headers().get(HOST)) {
+            if let Ok(host) = host.to_str() {
+                if !hosts.iter().any(|d| d.matches(host)) {
+                    return false;
+                }
+            }
+        }
+
+        if let (Some(ports), Some(port)) = (&self.ports, request.uri().port()) {
+            if !ports.iter().any(|d| d.matches(port.as_str())) {
+                info!("No match between port {} and {:?}", port, ports);
+                return false;
+            }
+        }
+
+        if let Some(extensions) = &self.extensions {
+            let extension = request.uri().path().split('.').next_back().unwrap_or("");
+            if !extensions.iter().any(|e| e.matches(extension)) {
+                return false;
+            }
+        }
+
+        if let Some(content_types) = &self.content_types {
+            if let Some(content_type) = request.headers().get(CONTENT_TYPE) {
+                if !content_types
+                    .iter()
+                    .any(|ct| ct.matches(content_type.to_str().unwrap_or("")))
+                {
+                    return false;
+                }
+            }
+        }
+
+        if let Some(accepts) = &self.accepts {
+            if let Some(accept) = request.headers().get(ACCEPT) {
+                if !accepts
+                    .iter()
+                    .any(|a| a.matches(accept.to_str().unwrap_or("")))
+                {
+                    return false;
+                }
+            }
+        }
+
+        true
+    }
+}
+
+impl MiddlewareSet {
+    pub fn new(routes_raw: Option<HeapVal>, default_app: HeapVal) -> Result<Self> {
+        if let Some(routes_raw) = routes_raw {
+            let mut stacks = HashMap::new();
+            let mut routes = vec![];
+            for (index, route) in RArray::from_value(*routes_raw)
+                .ok_or(magnus::Error::new(
+                    magnus::exception::exception(),
+                    format!("Routes must be an array. Got {:?}", routes_raw),
+                ))?
+                .into_iter()
+                .enumerate()
+            {
+                let route_hash: RHash = RHash::try_convert(route)?;
+                let route_raw = route_hash
+                    .get("route")
+                    .ok_or(magnus::Error::new(
+                        magnus::exception::exception(),
+                        "Route is missing :route key",
+                    ))?
+                    .funcall::<_, _, String>("source", ())?;
+                let middleware =
+                    RArray::from_value(route_hash.get("middleware").ok_or(magnus::Error::new(
+                        magnus::exception::exception(),
+                        "Route is missing middleware key",
+                    ))?)
+                    .ok_or(magnus::Error::new(
+                        magnus::exception::exception(),
+                        format!("middleware must be an array. Got {:?}", routes_raw),
+                    ))?;
+
+                let mut layers = middleware
+                    .into_iter()
+                    .map(MiddlewareSet::parse_middleware)
+                    .collect::<Result<Vec<_>>>()?;
+                layers.push(Middleware::RubyApp(RubyApp::from_value(
+                    default_app.clone(),
+                )?));
+                routes.push(route_raw);
+                layers.sort();
+                stacks.insert(
+                    index,
+                    MiddlewareStack {
+                        layers,
+                        methods: extract_optional_match_array(route_hash, "methods")?,
+                        protocols: extract_optional_match_array(route_hash, "protocols")?,
+                        hosts: extract_optional_match_array(route_hash, "hosts")?,
+                        extensions: extract_optional_match_array(route_hash, "extensions")?,
+                        ports: extract_optional_match_array(route_hash, "ports")?,
+                        content_types: extract_optional_match_array(route_hash, "content_types")?,
+                        accepts: extract_optional_match_array(route_hash, "accepts")?,
+                    },
+                );
+            }
+            info!("Routes are {:?}", routes);
+            Ok(Self {
+                route_set: RegexSet::new(&routes).map_err(|e| {
+                    magnus::Error::new(
+                        magnus::exception::exception(),
+                        format!("Failed to create route set: {}", e),
+                    )
+                })?,
+                patterns: routes
+                    .into_iter()
+                    .map(|r| Regex::new(&r))
+                    .collect::<std::result::Result<Vec<Regex>, regex::Error>>()
+                    .map_err(|e| {
+                        magnus::Error::new(
+                            magnus::exception::exception(),
+                            format!("Failed to create route set: {}", e),
+                        )
+                    })?
+                    .into_iter()
+                    .map(Arc::new)
+                    .collect(),
+                stacks,
+                default_stack: vec![Middleware::RubyApp(RubyApp::from_value(default_app)?)],
+            })
+        } else {
+            Ok(Self {
+                route_set: RegexSet::empty(),
+                patterns: Vec::new(),
+                stacks: HashMap::new(),
+                default_stack: vec![Middleware::RubyApp(RubyApp::from_value(default_app)?)],
+            })
+        }
+    }
+
+    pub fn stack_for(&self, request: &HttpRequest) -> (&Vec<Middleware>, Option<Arc<Regex>>) {
+        let binding = self.route_set.matches(request.uri().path());
+        let matches = binding.iter();
+        for index in matches {
+            let matching_pattern = self.patterns.get(index).cloned();
+            if let Some(stack) = self.stacks.get(&index) {
+                if stack.matches(request) {
+                    return (&stack.layers, matching_pattern);
+                }
+            }
+        }
+        (self.default_stack(), None)
+    }
+
+    pub fn parse_middleware(middleware: Value) -> Result<Middleware> {
+        let middleware_hash = RHash::from_value(middleware).ok_or(magnus::Error::new(
+            magnus::exception::exception(),
+            format!("Filter must be a hash. Got {:?}", middleware),
+        ))?;
+        let middleware_type: String = middleware_hash
+            .get("type")
+            .ok_or(magnus::Error::new(
+                magnus::exception::exception(),
+                format!("Filter must have a :type key. Got {:?}", middleware_hash),
+            ))?
+            .to_string();
+
+        let parameters: Value = middleware_hash.get("parameters").ok_or(magnus::Error::new(
+            magnus::exception::exception(),
+            format!(
+                "Filter must have a :parameters key. Got {:?}",
+                middleware_hash
+            ),
+        ))?;
+
+        let result = match middleware_type.as_str() {
+            "allow_list" => Middleware::AllowList(AllowList::from_value(parameters)?),
+            "auth_basic" => Middleware::AuthBasic(AuthBasic::from_value(parameters)?),
+            "auth_jwt" => Middleware::AuthJwt(Box::new(AuthJwt::from_value(parameters)?)),
+            "auth_api_key" => Middleware::AuthAPIKey(AuthAPIKey::from_value(parameters)?),
+            "cache_control" => Middleware::CacheControl(CacheControl::from_value(parameters)?),
+            "deny_list" => Middleware::DenyList(DenyList::from_value(parameters)?),
+            "etag" => Middleware::ETag(ETag::from_value(parameters)?),
+            "intrusion_protection" => {
+                Middleware::IntrusionProtection(IntrusionProtection::from_value(parameters)?)
+            }
+            "rate_limit" => Middleware::RateLimit(RateLimit::from_value(parameters)?),
+            "cors" => Middleware::Cors(Box::new(Cors::from_value(parameters)?)),
+            "request_headers" => {
+                Middleware::RequestHeaders(RequestHeaders::from_value(parameters)?)
+            }
+            "response_headers" => {
+                Middleware::ResponseHeaders(ResponseHeaders::from_value(parameters)?)
+            }
+            "static_assets" => Middleware::StaticAssets(StaticAssets::from_value(parameters)?),
+            "compression" => Middleware::Compression(Compression::from_value(parameters)?),
+            "log_requests" => Middleware::LogRequests(LogRequests::from_value(parameters)?),
+            "redirect" => Middleware::Redirect(Redirect::from_value(parameters)?),
+            "app" => Middleware::RubyApp(RubyApp::from_value(parameters.into())?),
+            "proxy" => Middleware::Proxy(Proxy::from_value(parameters)?),
+            _ => {
+                return Err(magnus::Error::new(
+                    magnus::exception::exception(),
+                    format!("Unknown filter type: {}", middleware_type),
+                ))
+            }
+        };
+
+        Ok(result)
+    }
+
+    fn default_stack(&self) -> &Vec<Middleware> {
+        &self.default_stack
+    }
+
+    pub async fn initialize_layers(&self) -> Result<()> {
+        for middleware in &self.default_stack {
+            middleware.initialize().await?;
+        }
+        for stack in self.stacks.values() {
+            for middleware in &stack.layers {
+                middleware.initialize().await?;
+            }
+        }
+        Ok(())
+    }
+}
+
+fn extract_optional_match_array(route_hash: RHash, arg: &str) -> Result<Option<Vec<StringMatch>>> {
+    let rarray = route_hash.aref::<_, Option<RArray>>(arg)?;
+    if let Some(array) = rarray {
+        Ok(Some(
+            array
+                .into_iter()
+                .map(StringMatch::from_value)
+                .collect::<Result<Vec<StringMatch>>>()?,
+        ))
+    } else {
+        Ok(None)
+    }
+}

data/ext/itsi_server/src/server/mod.rs

@@ -1,5 +1,18 @@
 pub mod bind;
-pub mod itsi_server;
+pub mod bind_protocol;
+pub mod byte_frame;
+pub mod cache_store;
+pub mod io_stream;
+pub mod itsi_service;
+pub mod lifecycle_event;
 pub mod listener;
+pub mod middleware_stack;
+pub mod process_worker;
+pub mod rate_limiter;
+pub mod request_job;
+pub mod serve_strategy;
+pub mod signal;
+pub mod static_file_server;
+pub mod thread_worker;
 pub mod tls;
-pub mod transfer_protocol;
+pub mod types;