itsi 0.1.19 → 0.2.2

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

@@ -8,8 +8,10 @@ use async_trait::async_trait;
 use either::Either;
 use magnus::error::Result;
 use serde::Deserialize;
+use std::collections::HashMap;
 use std::sync::{Arc, OnceLock};
 use std::time::Duration;
+use tracing::{debug, error, warn};
 
 #[derive(Debug, Clone, Deserialize)]
 pub struct RateLimit {
@@ -19,6 +21,7 @@ pub struct RateLimit {
     #[serde(skip_deserializing)]
     pub rate_limiter: OnceLock<Arc<dyn RateLimiter>>,
     pub store_config: RateLimiterConfig,
+    pub trusted_proxies: HashMap<String, TokenSource>,
     #[serde(default = "too_many_requests_error_response")]
     pub error_response: ErrorResponse,
 }
@@ -55,7 +58,12 @@ impl MiddlewareLayer for RateLimit {
         let key_value = match &self.key {
             RateLimitKey::SocketAddress => {
                 // Use the socket address from the context
-                &context.addr
+                if self.trusted_proxies.contains_key(&context.addr) {
+                    let source = self.trusted_proxies.get(&context.addr).unwrap();
+                    source.extract_token(&req).unwrap_or(&context.addr)
+                } else {
+                    &context.addr
+                }
             }
             RateLimitKey::Parameter(token_source) => {
                 match token_source {
@@ -68,7 +76,7 @@ impl MiddlewareLayer for RateLimit {
                             }
                         } else {
                             // If no token is found, skip rate limiting
-                            tracing::warn!("No token found in header for rate limiting");
+                            warn!("No token found in header for rate limiting");
                             return Ok(Either::Left(req));
                         }
                     }
@@ -77,7 +85,7 @@ impl MiddlewareLayer for RateLimit {
                             value
                         } else {
                             // If no token is found, skip rate limiting
-                            tracing::warn!("No token found in query for rate limiting");
+                            warn!("No token found in query for rate limiting");
                             return Ok(Either::Left(req));
                         }
                     }
@@ -88,6 +96,7 @@ impl MiddlewareLayer for RateLimit {
         // Create a rate limit key
         let rate_limit_key = create_rate_limit_key(key_value, req.uri().path());
 
+        debug!(target: "middleware::rate_limit", "Rate limit key: {}", rate_limit_key);
         // Get the rate limiter
         if let Some(limiter) = self.rate_limiter.get() {
             // Check if rate limit is exceeded
@@ -95,8 +104,12 @@ impl MiddlewareLayer for RateLimit {
             let limit = self.requests;
 
             match limiter.check_limit(&rate_limit_key, limit, timeout).await {
-                Ok(_) => Ok(Either::Left(req)),
+                Ok(_) => {
+                    debug!(target: "middleware::rate_limit", "Rate limit not exceeded");
+                    Ok(Either::Left(req))
+                }
                 Err(RateLimitError::RateLimitExceeded { limit, ttl, .. }) => {
+                    debug!(target: "middleware::rate_limit", "Rate limit exceeded. Limit: {}, ttl: {}", limit, ttl);
                     let mut response = self
                         .error_response
                         .to_http_response(req.accept().into())
@@ -116,14 +129,12 @@ impl MiddlewareLayer for RateLimit {
                     Ok(Either::Right(response))
                 }
                 Err(e) => {
-                    // Other error, log and allow request (fail open)
-                    tracing::error!("Rate limiter error: {:?}", e);
+                    error!("Rate limiter error: {:?}", e);
                     Ok(Either::Left(req))
                 }
             }
         } else {
-            // If rate limiter is not initialized, allow request
-            tracing::warn!("Rate limiter not initialized");
+            warn!("Rate limiter not initialized");
             Ok(Either::Left(req))
         }
     }

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

@@ -1,21 +1,19 @@
+use super::{string_rewrite::StringRewrite, FromValue, MiddlewareLayer};
 use crate::{
-    server::http_message_types::{HttpRequest, HttpResponse},
+    server::{
+        http_message_types::{HttpRequest, HttpResponse},
+        redirect_type::RedirectType,
+    },
     services::itsi_http_service::HttpRequestContext,
 };
-
-use super::{string_rewrite::StringRewrite, FromValue, MiddlewareLayer};
-
 use async_trait::async_trait;
 use either::Either;
-use http::{Response, StatusCode};
+use http::Response;
 use http_body_util::{combinators::BoxBody, Empty};
 use magnus::error::Result;
 use serde::Deserialize;
+use tracing::debug;
 
-/// A simple API key filter.
-/// The API key can be given inside the header or a query string
-/// Keys are validated against a list of allowed key values (Changing these requires a restart)
-///
 #[derive(Debug, Clone, Deserialize)]
 pub struct Redirect {
     pub to: StringRewrite,
@@ -24,19 +22,6 @@ pub struct Redirect {
     pub redirect_type: RedirectType,
 }
 
-#[derive(Debug, Clone, Deserialize, Default)]
-pub enum RedirectType {
-    #[serde(rename(deserialize = "permanent"))]
-    #[default]
-    Permanent,
-    #[serde(rename(deserialize = "temporary"))]
-    Temporary,
-    #[serde(rename(deserialize = "found"))]
-    Found,
-    #[serde(rename(deserialize = "moved_permanently"))]
-    MovedPermanently,
-}
-
 #[async_trait]
 impl MiddlewareLayer for Redirect {
     async fn before(
@@ -55,21 +40,15 @@ impl Redirect {
         context: &mut HttpRequestContext,
     ) -> Result<HttpResponse> {
         let mut response = Response::new(BoxBody::new(Empty::new()));
-        *response.status_mut() = match self.redirect_type {
-            RedirectType::Permanent => StatusCode::PERMANENT_REDIRECT,
-            RedirectType::Temporary => StatusCode::TEMPORARY_REDIRECT,
-            RedirectType::MovedPermanently => StatusCode::MOVED_PERMANENTLY,
-            RedirectType::Found => StatusCode::FOUND,
-        };
-        response.headers_mut().append(
-            "Location",
-            self.to.rewrite_request(req, context).parse().map_err(|e| {
-                magnus::Error::new(
-                    magnus::exception::standard_error(),
-                    format!("Invalid Rewrite String: {:?}: {}", self.to, e),
-                )
-            })?,
-        );
+        *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)
     }
 }

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

@@ -5,7 +5,7 @@ use crate::{
     services::itsi_http_service::HttpRequestContext,
 };
 
-use super::{FromValue, MiddlewareLayer};
+use super::{FromValue, MiddlewareLayer, StringRewrite};
 use async_trait::async_trait;
 use either::Either;
 use http::HeaderName;
@@ -14,30 +14,40 @@ use serde::Deserialize;
 
 #[derive(Debug, Clone, Deserialize)]
 pub struct RequestHeaders {
-    pub additions: HashMap<String, Vec<String>>,
+    pub additions: HashMap<String, Vec<StringRewrite>>,
     pub removals: Vec<String>,
 }
-
 #[async_trait]
 impl MiddlewareLayer for RequestHeaders {
     async fn before(
         &self,
         mut req: HttpRequest,
-        _: &mut HttpRequestContext,
+        context: &mut HttpRequestContext,
     ) -> Result<Either<HttpRequest, HttpResponse>> {
-        let headers = req.headers_mut();
-        for removal in &self.removals {
-            headers.remove(removal);
-        }
+        let mut headers_to_add = Vec::new();
+
         for (header_name, header_values) in &self.additions {
-            for header_value in header_values {
-                if let Ok(parsed_header_name) = header_name.parse::<HeaderName>() {
-                    if let Ok(parsed_header_value) = header_value.parse() {
-                        headers.append(parsed_header_name, parsed_header_value);
+            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))
     }
 }

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

@@ -1,6 +1,6 @@
 use std::collections::HashMap;
 
-use super::{FromValue, MiddlewareLayer};
+use super::{FromValue, MiddlewareLayer, StringRewrite};
 use crate::{
     server::http_message_types::HttpResponse, services::itsi_http_service::HttpRequestContext,
 };
@@ -10,26 +10,41 @@ use serde::Deserialize;
 
 #[derive(Debug, Clone, Deserialize)]
 pub struct ResponseHeaders {
-    pub additions: HashMap<String, Vec<String>>,
+    pub additions: HashMap<String, Vec<StringRewrite>>,
     pub removals: Vec<String>,
 }
 
 #[async_trait]
 impl MiddlewareLayer for ResponseHeaders {
-    async fn after(&self, mut resp: HttpResponse, _: &mut HttpRequestContext) -> HttpResponse {
-        let headers = resp.headers_mut();
-        for removal in &self.removals {
-            headers.remove(removal);
-        }
+    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 {
-            for header_value in header_values {
-                if let Ok(parsed_header_name) = header_name.parse::<HeaderName>() {
-                    if let Ok(parsed_header_value) = header_value.parse() {
-                        headers.append(parsed_header_name, parsed_header_value);
+            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
     }
 }

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

@@ -42,7 +42,7 @@ impl FromStr for RequestType {
 }
 
 impl RubyApp {
-    pub fn from_value(params: HeapVal) -> magnus::error::Result<Self> {
+    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",))
@@ -61,13 +61,13 @@ impl RubyApp {
             .parse()
             .unwrap_or(RequestType::Http);
 
-        Ok(RubyApp {
+        Ok(Arc::new(RubyApp {
             app: Arc::new(app.into()),
             sendfile,
             nonblocking,
             request_type,
             base_path,
-        })
+        }))
     }
 }
 

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

@@ -19,6 +19,7 @@ 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 {
@@ -59,6 +60,9 @@ impl MiddlewareLayer for StaticAssets {
         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(),
@@ -67,10 +71,11 @@ impl MiddlewareLayer for StaticAssets {
                 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(())
     }
@@ -82,11 +87,12 @@ impl MiddlewareLayer for StaticAssets {
     ) -> 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
+            abs_path.trim_start_matches("/")
         } else {
             let base_path = self
                 .base_path_regex
@@ -103,6 +109,7 @@ impl MiddlewareLayer for StaticAssets {
             }
         };
 
+        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;
 

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

@@ -98,8 +98,13 @@ impl StringRewrite {
                             }
                         }
                         other => {
-                            // Try using the context's matching regex if available.
-                            if let Some(caps) = &captures {
+                            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 {
@@ -146,8 +151,13 @@ impl StringRewrite {
                             }
                         }
                         other => {
-                            if let Some(header_value) = resp.headers().get(other) {
-                                format!("{:?}", header_value)
+                            // 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)
                             }

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

@@ -1,5 +1,7 @@
 use serde::{Deserialize, Serialize};
 
+use crate::server::http_message_types::{HttpRequest, RequestExt};
+
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub enum TokenSource {
     #[serde(rename(deserialize = "header"))]
@@ -10,3 +12,20 @@ pub enum TokenSource {
     #[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),
+        }
+    }
+}

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

@@ -2,11 +2,16 @@ mod middleware;
 mod middlewares;
 use http::header::{ACCEPT, CONTENT_TYPE, HOST};
 use itsi_rb_helpers::HeapVal;
-use magnus::{error::Result, value::ReprValue, RArray, RHash, Ruby, TryConvert, Value};
+use magnus::{
+    error::Result, rb_sys::AsRawValue, 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 std::{
+    collections::{hash_map::Entry::Vacant, HashMap},
+    sync::Arc,
+};
 use tracing::debug;
 
 use super::http_message_types::HttpRequest;
@@ -16,6 +21,7 @@ pub struct MiddlewareSet {
     pub route_set: RegexSet,
     pub patterns: Vec<Arc<Regex>>,
     pub stacks: HashMap<usize, MiddlewareStack>,
+    unique_middlewares: HashMap<u64, Middleware>,
 }
 
 #[derive(Debug)]
@@ -128,6 +134,9 @@ impl MiddlewareStack {
 
 impl MiddlewareSet {
     pub fn new(routes_raw: Option<HeapVal>) -> Result<Self> {
+        let mut unique_middlewares = HashMap::new();
+        clear_value_cache();
+
         if let Some(routes_raw) = routes_raw {
             let mut stacks = HashMap::new();
             let mut routes = vec![];
@@ -147,22 +156,65 @@ impl MiddlewareSet {
                         "Route is missing :route key",
                     ))?
                     .funcall::<_, _, String>("source", ())?;
+
                 let middleware =
-                    RArray::from_value(route_hash.get("middleware").ok_or(magnus::Error::new(
+                    RHash::from_value(route_hash.get("middleware").ok_or(magnus::Error::new(
                         magnus::exception::standard_error(),
                         "Route is missing middleware key",
                     ))?)
                     .ok_or(magnus::Error::new(
                         magnus::exception::standard_error(),
-                        format!("middleware must be an array. Got {:?}", routes_raw),
+                        format!("middleware must be a hash. Got {:?}", routes_raw),
                     ))?;
 
+                let ruby = Ruby::get().unwrap();
                 let mut layers = middleware
-                    .into_iter()
-                    .map(MiddlewareSet::parse_middleware)
+                    .enumeratorize("each", ())
+                    .flat_map(|pair| {
+                        let pair = RArray::from_value(pair.unwrap()).unwrap();
+                        let middleware_type: String = pair.entry(0).unwrap();
+                        let value: Value = pair.entry(1).unwrap();
+                        let middleware_values: Vec<Value> = if value.is_kind_of(ruby.class_array())
+                        {
+                            RArray::from_value(value)
+                                .ok_or_else(|| {
+                                    magnus::Error::new(
+                                        magnus::exception::type_error(),
+                                        "Expected array",
+                                    )
+                                })
+                                .unwrap()
+                                .into_iter()
+                                .collect()
+                        } else {
+                            vec![value]
+                        };
+                        middleware_values
+                            .into_iter()
+                            .map(|value| {
+                                let middleware =
+                                    if let Vacant(e) = unique_middlewares.entry(value.as_raw()) {
+                                        let middleware = MiddlewareSet::parse_middleware(
+                                            middleware_type.clone(),
+                                            value,
+                                        );
+                                        if let Ok(middleware) = middleware.as_ref() {
+                                            e.insert(middleware.clone());
+                                        };
+                                        middleware
+                                    } else {
+                                        Ok(unique_middlewares.get(&value.as_raw()).unwrap().clone())
+                                    };
+                                middleware
+                            })
+                            .collect::<Vec<Result<Middleware>>>()
+                    })
                     .collect::<Result<Vec<_>>>()?;
                 routes.push(route_raw);
                 layers.sort();
+
+                debug!("Middleware at index: {} has layers: {:?}", index, layers);
+
                 stacks.insert(
                     index,
                     MiddlewareStack {
@@ -184,6 +236,7 @@ impl MiddlewareSet {
                         format!("Failed to create route set: {}", e),
                     )
                 })?,
+                unique_middlewares,
                 patterns: routes
                     .into_iter()
                     .map(|r| Regex::new(&r))
@@ -241,47 +294,28 @@ impl MiddlewareSet {
         ))
     }
 
-    pub fn parse_middleware(middleware: Value) -> Result<Middleware> {
-        let middleware_hash = RHash::from_value(middleware).ok_or(magnus::Error::new(
-            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::standard_error(),
-                format!("Filter must have a :type key. Got {:?}", middleware_hash),
-            ))?
-            .to_string();
+    pub fn parse_middleware(middleware_type: String, parameters: Value) -> Result<Middleware> {
         let mw_type = middleware_type.clone();
 
-        let parameters: Value = middleware_hash.get("parameters").ok_or(magnus::Error::new(
-            magnus::exception::standard_error(),
-            format!(
-                "Filter must have a :parameters key. Got {:?}",
-                middleware_hash
-            ),
-        ))?;
-
+        debug!(target: "itsi_server::middleware_stack", "Parsing middleware: {} from {}", mw_type, 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_jwt" => Ok(Middleware::AuthJwt(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)?)),
+                "csp" => Ok(Middleware::Csp(Csp::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)?))),
+                "cors" => Ok(Middleware::Cors(Cors::from_value(parameters)?)),
                 "request_headers" => Ok(Middleware::RequestHeaders(RequestHeaders::from_value(
                     parameters,
                 )?)),
@@ -294,7 +328,7 @@ impl MiddlewareSet {
                 "static_response" => Ok(Middleware::StaticResponse(StaticResponse::from_value(
                     parameters,
                 )?)),
-                "compression" => Ok(Middleware::Compression(Compression::from_value(
+                "compress" => Ok(Middleware::Compression(Compression::from_value(
                     parameters,
                 )?)),
                 "log_requests" => Ok(Middleware::LogRequests(LogRequests::from_value(
@@ -310,6 +344,8 @@ impl MiddlewareSet {
             }
         })();
 
+        debug!(target: "itsi_server::middleware_stack", "Stack layer init result {:?}", result);
+
         match result {
             Ok(result) => Ok(result),
             Err(err) => Err(magnus::Error::new(
@@ -323,10 +359,8 @@ impl MiddlewareSet {
     }
 
     pub async fn initialize_layers(&self) -> Result<()> {
-        for stack in self.stacks.values() {
-            for middleware in &stack.layers {
-                middleware.initialize().await?;
-            }
+        for middleware in self.unique_middlewares.values() {
+            middleware.initialize().await?;
         }
         Ok(())
     }

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

@@ -5,6 +5,7 @@ pub mod io_stream;
 pub mod lifecycle_event;
 pub mod middleware_stack;
 pub mod process_worker;
+pub mod redirect_type;
 pub mod request_job;
 pub mod serve_strategy;
 pub mod signal;

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

@@ -0,0 +1,26 @@
+use http::StatusCode;
+use serde::Deserialize;
+
+#[derive(Debug, Clone, Deserialize, Default)]
+pub enum RedirectType {
+    #[serde(rename(deserialize = "permanent"))]
+    #[default]
+    Permanent,
+    #[serde(rename(deserialize = "temporary"))]
+    Temporary,
+    #[serde(rename(deserialize = "found"))]
+    Found,
+    #[serde(rename(deserialize = "moved_permanently"))]
+    MovedPermanently,
+}
+
+impl RedirectType {
+    pub fn status_code(&self) -> StatusCode {
+        match self {
+            RedirectType::Permanent => StatusCode::PERMANENT_REDIRECT,
+            RedirectType::Temporary => StatusCode::TEMPORARY_REDIRECT,
+            RedirectType::Found => StatusCode::FOUND,
+            RedirectType::MovedPermanently => StatusCode::MOVED_PERMANENTLY,
+        }
+    }
+}