itsi 0.1.14 → 0.1.18

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

@@ -1,19 +1,17 @@
 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 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)]
@@ -21,6 +19,8 @@ pub struct RubyApp {
     app: Arc<HeapValue<Proc>>,
     request_type: RequestType,
     sendfile: bool,
+    nonblocking: bool,
+    base_path: Regex,
 }
 
 #[derive(Debug)]
@@ -47,6 +47,14 @@ impl RubyApp {
         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())
@@ -56,7 +64,9 @@ impl RubyApp {
         Ok(RubyApp {
             app: Arc::new(app.into()),
             sendfile,
+            nonblocking,
             request_type,
+            base_path,
         })
     }
 }
@@ -66,25 +76,48 @@ impl MiddlewareLayer for RubyApp {
     async fn before(
         &self,
         req: HttpRequest,
-        context: &mut RequestContext,
+        context: &mut HttpRequestContext,
     ) -> Result<Either<HttpRequest, HttpResponse>> {
+        context.is_ruby_request.store(true, Ordering::SeqCst);
         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)
+            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),
+                .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 RequestContext) -> HttpResponse {
+    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(sendfile_header.to_str().unwrap())
+                    .serve_single_abs(
+                        sendfile_header.to_str().unwrap(),
+                        context.accept.clone(),
+                        &[],
+                    )
                     .await;
             }
         }

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

@@ -1,8 +1,12 @@
 use super::{FromValue, MiddlewareLayer};
-use crate::server::{
-    itsi_service::RequestContext,
-    static_file_server::{NotFoundBehavior, ServeRange, StaticFileServer, StaticFileServerConfig},
-    types::{HttpRequest, HttpResponse},
+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;
@@ -12,6 +16,7 @@ use http::{
 };
 use itsi_error::ItsiError;
 use magnus::error::Result;
+use regex::Regex;
 use serde::Deserialize;
 use std::{collections::HashMap, path::PathBuf, sync::OnceLock, time::Duration};
 
@@ -25,7 +30,12 @@ pub struct StaticAssets {
     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>,
 }
@@ -46,6 +56,9 @@ impl MiddlewareLayer for StaticAssets {
                 "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)?;
         self.file_server
             .set(StaticFileServer::new(StaticFileServerConfig {
                 root_dir: self.root_dir.clone(),
@@ -55,15 +68,17 @@ impl MiddlewareLayer for StaticAssets {
                 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),
+                serve_hidden_files: self.serve_hidden_files,
+                allowed_extensions: self.allowed_extensions.clone(),
             }))
-            .map_err(ItsiError::default)?;
+            .map_err(ItsiError::new)?;
         Ok(())
     }
 
     async fn before(
         &self,
         req: HttpRequest,
-        context: &mut RequestContext,
+        context: &mut HttpRequestContext,
     ) -> Result<Either<HttpRequest, HttpResponse>> {
         // Only handle GET and HEAD requests
         if req.method() != Method::GET && req.method() != Method::HEAD {
@@ -73,13 +88,16 @@ impl MiddlewareLayer for StaticAssets {
         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"))
+            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)),
             }
@@ -106,9 +124,9 @@ impl MiddlewareLayer for StaticAssets {
                 serve_range,
                 if_modified_since,
                 is_head_request,
+                &context.supported_encoding_set,
             )
             .await;
-
         if response.is_none() {
             Ok(Either::Left(req))
         } else {

data/crates/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/crates/itsi_server/src/server/middleware_stack/middlewares/string_rewrite.rs

@@ -1,10 +1,11 @@
-use crate::server::{
-    itsi_service::RequestContext,
-    types::{HttpRequest, HttpResponse},
-};
 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 {
@@ -49,7 +50,7 @@ pub fn parse_template(template: &str) -> Vec<Segment> {
 }
 
 impl StringRewrite {
-    pub fn rewrite_request(&self, req: &HttpRequest, context: &RequestContext) -> String {
+    pub fn rewrite_request(&self, req: &HttpRequest, context: &HttpRequestContext) -> String {
         let segments = self
             .segments
             .get_or_init(|| parse_template(&self.template_string));
@@ -65,9 +66,11 @@ impl StringRewrite {
                 Segment::Literal(text) => result.push_str(text),
                 Segment::Placeholder(placeholder) => {
                     let replacement = match placeholder.as_str() {
-                        "request_id" => context.request_id(),
+                        "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()
@@ -116,7 +119,7 @@ impl StringRewrite {
         result
     }
 
-    pub fn rewrite_response(&self, resp: &HttpResponse, context: &RequestContext) -> String {
+    pub fn rewrite_response(&self, resp: &HttpResponse, context: &HttpRequestContext) -> String {
         let segments = self
             .segments
             .get_or_init(|| parse_template(&self.template_string));
@@ -127,8 +130,10 @@ impl StringRewrite {
                 Segment::Literal(text) => result.push_str(text),
                 Segment::Placeholder(placeholder) => {
                     let replacement = match placeholder.as_str() {
-                        "request_id" => context.request_id(),
+                        "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() {

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

@@ -1,6 +1,5 @@
 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};
@@ -8,14 +7,15 @@ pub use middleware::Middleware;
 pub use middlewares::*;
 use regex::{Regex, RegexSet};
 use std::{collections::HashMap, sync::Arc};
-use tracing::info;
+use tracing::debug;
+
+use super::http_message_types::HttpRequest;
 
 #[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)]
@@ -43,7 +43,7 @@ impl StringMatch {
             let src_str = value.funcall::<_, _, String>("source", ())?;
             let regex = Regex::new(&src_str).map_err(|e| {
                 magnus::Error::new(
-                    magnus::exception::exception(),
+                    magnus::exception::standard_error(),
                     format!("Invalid regexp: {}", e),
                 )
             })?;
@@ -86,13 +86,15 @@ impl MiddlewareStack {
 
         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("");
+            let path = request.uri().path();
+            let segment = path.split('/').next_back().unwrap_or("");
+            let extension = segment.split('.').next_back().unwrap_or("");
+            let extension = if segment != extension { extension } else { "" };
             if !extensions.iter().any(|e| e.matches(extension)) {
                 return false;
             }
@@ -125,13 +127,13 @@ impl MiddlewareStack {
 }
 
 impl MiddlewareSet {
-    pub fn new(routes_raw: Option<HeapVal>, default_app: HeapVal) -> Result<Self> {
+    pub fn new(routes_raw: Option<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(),
+                    magnus::exception::standard_error(),
                     format!("Routes must be an array. Got {:?}", routes_raw),
                 ))?
                 .into_iter()
@@ -141,17 +143,17 @@ impl MiddlewareSet {
                 let route_raw = route_hash
                     .get("route")
                     .ok_or(magnus::Error::new(
-                        magnus::exception::exception(),
+                        magnus::exception::standard_error(),
                         "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(),
+                        magnus::exception::standard_error(),
                         "Route is missing middleware key",
                     ))?)
                     .ok_or(magnus::Error::new(
-                        magnus::exception::exception(),
+                        magnus::exception::standard_error(),
                         format!("middleware must be an array. Got {:?}", routes_raw),
                     ))?;
 
@@ -159,9 +161,6 @@ impl MiddlewareSet {
                     .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(
@@ -178,11 +177,10 @@ impl MiddlewareSet {
                     },
                 );
             }
-            info!("Routes are {:?}", routes);
             Ok(Self {
                 route_set: RegexSet::new(&routes).map_err(|e| {
                     magnus::Error::new(
-                        magnus::exception::exception(),
+                        magnus::exception::standard_error(),
                         format!("Failed to create route set: {}", e),
                     )
                 })?,
@@ -192,7 +190,7 @@ impl MiddlewareSet {
                     .collect::<std::result::Result<Vec<Regex>, regex::Error>>()
                     .map_err(|e| {
                         magnus::Error::new(
-                            magnus::exception::exception(),
+                            magnus::exception::standard_error(),
                             format!("Failed to create route set: {}", e),
                         )
                     })?
@@ -200,97 +198,131 @@ impl MiddlewareSet {
                     .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)?)],
-            })
+            Err(magnus::Error::new(
+                magnus::exception::standard_error(),
+                "Failed to create middleware stack",
+            ))
         }
     }
 
-    pub fn stack_for(&self, request: &HttpRequest) -> (&Vec<Middleware>, Option<Arc<Regex>>) {
+    pub fn stack_for(
+        &self,
+        request: &HttpRequest,
+    ) -> Result<(&Vec<Middleware>, Option<Arc<Regex>>)> {
         let binding = self.route_set.matches(request.uri().path());
         let matches = binding.iter();
+
+        debug!(
+            "Matching request URI {:?} against self.route_set: {:?}",
+            request.uri().path(),
+            self.route_set
+        );
         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);
+                    return Ok((&stack.layers, matching_pattern));
                 }
             }
         }
-        (self.default_stack(), None)
+        debug!(
+            "Failed to match request URI {:?} to self.route_set: {:?}",
+            request.uri().path(),
+            self.route_set
+        );
+        Err(magnus::Error::new(
+            magnus::exception::standard_error(),
+            format!(
+                "No matching middleware stack found for request: {:?}",
+                request
+            ),
+        ))
     }
 
     pub fn parse_middleware(middleware: Value) -> Result<Middleware> {
         let middleware_hash = RHash::from_value(middleware).ok_or(magnus::Error::new(
-            magnus::exception::exception(),
+            magnus::exception::standard_error(),
             format!("Filter must be a hash. Got {:?}", middleware),
         ))?;
         let middleware_type: String = middleware_hash
             .get("type")
             .ok_or(magnus::Error::new(
-                magnus::exception::exception(),
+                magnus::exception::standard_error(),
                 format!("Filter must have a :type key. Got {:?}", middleware_hash),
             ))?
             .to_string();
+        let mw_type = middleware_type.clone();
 
         let parameters: Value = middleware_hash.get("parameters").ok_or(magnus::Error::new(
-            magnus::exception::exception(),
+            magnus::exception::standard_error(),
             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)?)
+        let result = (move || -> Result<Middleware> {
+            match mw_type.as_str() {
+                "allow_list" => Ok(Middleware::AllowList(AllowList::from_value(parameters)?)),
+                "auth_basic" => Ok(Middleware::AuthBasic(AuthBasic::from_value(parameters)?)),
+                "auth_jwt" => Ok(Middleware::AuthJwt(Box::new(AuthJwt::from_value(
+                    parameters,
+                )?))),
+                "auth_api_key" => Ok(Middleware::AuthAPIKey(AuthAPIKey::from_value(parameters)?)),
+                "cache_control" => Ok(Middleware::CacheControl(CacheControl::from_value(
+                    parameters,
+                )?)),
+                "deny_list" => Ok(Middleware::DenyList(DenyList::from_value(parameters)?)),
+                "etag" => Ok(Middleware::ETag(ETag::from_value(parameters)?)),
+                "intrusion_protection" => Ok({
+                    Middleware::IntrusionProtection(IntrusionProtection::from_value(parameters)?)
+                }),
+                "max_body" => Ok(Middleware::MaxBody(MaxBody::from_value(parameters)?)),
+                "rate_limit" => Ok(Middleware::RateLimit(RateLimit::from_value(parameters)?)),
+                "cors" => Ok(Middleware::Cors(Box::new(Cors::from_value(parameters)?))),
+                "request_headers" => Ok(Middleware::RequestHeaders(RequestHeaders::from_value(
+                    parameters,
+                )?)),
+                "response_headers" => Ok(Middleware::ResponseHeaders(ResponseHeaders::from_value(
+                    parameters,
+                )?)),
+                "static_assets" => Ok(Middleware::StaticAssets(StaticAssets::from_value(
+                    parameters,
+                )?)),
+                "static_response" => Ok(Middleware::StaticResponse(StaticResponse::from_value(
+                    parameters,
+                )?)),
+                "compression" => Ok(Middleware::Compression(Compression::from_value(
+                    parameters,
+                )?)),
+                "log_requests" => Ok(Middleware::LogRequests(LogRequests::from_value(
+                    parameters,
+                )?)),
+                "redirect" => Ok(Middleware::Redirect(Redirect::from_value(parameters)?)),
+                "app" => Ok(Middleware::RubyApp(RubyApp::from_value(parameters.into())?)),
+                "proxy" => Ok(Middleware::Proxy(Proxy::from_value(parameters)?)),
+                _ => Err(magnus::Error::new(
+                    magnus::exception::standard_error(),
+                    format!("Unknown filter type: {}", mw_type),
+                )),
             }
-            "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
+        match result {
+            Ok(result) => Ok(result),
+            Err(err) => Err(magnus::Error::new(
+                magnus::exception::standard_error(),
+                format!(
+                    "Failed to instantiate middleware of type {}, due to {}",
+                    middleware_type, err
+                ),
+            )),
+        }
     }
 
     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?;

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

@@ -1,18 +1,12 @@
-pub mod bind;
-pub mod bind_protocol;
+pub mod binds;
 pub mod byte_frame;
-pub mod cache_store;
+pub mod http_message_types;
 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 size_limited_incoming;
 pub mod thread_worker;
-pub mod tls;
-pub mod types;