itsi 0.1.20 → 0.2.2

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

@@ -33,13 +33,14 @@ use reqwest::{
     Body, Client, Url,
 };
 use serde::Deserialize;
+use tracing::{debug, info};
 
 #[derive(Debug, Clone, Deserialize)]
 pub struct Proxy {
     pub to: StringRewrite,
     pub backends: Vec<String>,
     pub backend_priority: BackendPriority,
-    pub headers: HashMap<String, Option<ProxiedHeader>>,
+    pub headers: HashMap<String, Option<StringRewrite>>,
     pub verify_ssl: bool,
     pub timeout: u64,
     pub tls_sni: bool,
@@ -63,23 +64,6 @@ pub enum BackendPriority {
     Random,
 }
 
-#[derive(Debug, Clone, Deserialize)]
-pub enum ProxiedHeader {
-    #[serde(rename(deserialize = "value"))]
-    String(String),
-    #[serde(rename(deserialize = "rewrite"))]
-    StringRewrite(StringRewrite),
-}
-
-impl ProxiedHeader {
-    pub fn to_string(&self, req: &HttpRequest, context: &HttpRequestContext) -> String {
-        match self {
-            ProxiedHeader::String(value) => value.clone(),
-            ProxiedHeader::StringRewrite(rewrite) => rewrite.rewrite_request(req, context),
-        }
-    }
-}
-
 #[derive(Debug, Clone)]
 pub struct Resolver {
     backends: Arc<Vec<SocketAddr>>,
@@ -164,7 +148,7 @@ impl Proxy {
         for (name, header_opt) in self.headers.iter() {
             if let Some(header_value) = header_opt {
                 // Compute the header value using the full HttpRequest.
-                let value_str = header_value.to_string(req, context);
+                let value_str = header_value.rewrite_request(req, context);
                 if let Ok(header_val) = http::HeaderValue::from_str(&value_str) {
                     if let Ok(header_name) = name.parse::<http::header::HeaderName>() {
                         headers.insert(header_name, header_val);
@@ -201,6 +185,7 @@ impl Proxy {
 
         // Add a Host header if not overridden.
         if !overriding_headers.contains_key("host") && !host_str.is_empty() {
+            debug!("Adding Host header: {}", host_str);
             builder = builder.header("Host", host_str);
         }
 
@@ -231,6 +216,7 @@ impl Proxy {
                 Err(e) => {
                     // Retry for connectivity-related errors.
                     if e.is_connect() {
+                        debug!(target: "middleware::proxy", "Connection error, retrying");
                         last_err = Some(e);
                         if attempt + 1 < max_attempts {
                             continue;
@@ -278,6 +264,7 @@ impl MiddlewareLayer for Proxy {
                 }
             })
             .collect::<Vec<_>>();
+        debug!(target: "middleware::proxy", "backends: {:?}", backends);
 
         self.client
             .set(
@@ -314,14 +301,20 @@ impl MiddlewareLayer for Proxy {
         context: &mut HttpRequestContext,
     ) -> Result<Either<HttpRequest, HttpResponse>> {
         let url = self.to.rewrite_request(&req, context);
+
         let accept: ResponseFormat = req.accept().into();
         let error_response = self.error_response.to_http_response(accept.clone()).await;
 
         let destination = match Url::parse(&url) {
             Ok(dest) => dest,
-            Err(_) => return Ok(Either::Right(error_response)),
+            Err(_) => {
+                debug!(target: "middleware::proxy", "Failed to parse URL: {}", url);
+                return Ok(Either::Right(error_response));
+            }
         };
 
+        debug!(target: "middleware::proxy", "Proxying to: {:?}", destination);
+
         // Clone the headers before consuming the request.
         let req_headers = req.headers().clone();
         let host_str = destination.host_str().unwrap_or_else(|| {
@@ -331,6 +324,7 @@ impl MiddlewareLayer for Proxy {
                 .unwrap_or("")
         });
 
+        info!("Extracted host str is {}", host_str);
         let req_info = RequestInfo {
             method: req.method().clone(),
             headers: req_headers.clone(),
@@ -373,6 +367,8 @@ impl MiddlewareLayer for Proxy {
 
         let response = match reqwest_response_result {
             Ok(response) => {
+                debug!(target: "middleware::proxy", "Response {} received", response.status());
+
                 let status = response.status();
                 let mut builder = Response::builder().status(status);
                 for (hn, hv) in response.headers() {
@@ -387,6 +383,7 @@ impl MiddlewareLayer for Proxy {
                 response.unwrap_or(error_response)
             }
             Err(e) => {
+                debug!(target: "middleware::proxy", "Error {:?} received", e);
                 if let Some(inner) = e.source() {
                     if inner.downcast_ref::<MaxBodySizeReached>().is_some() {
                         let mut max_body_response = Response::new(BoxBody::new(Empty::new()));

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/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 {
@@ -60,6 +61,8 @@ impl MiddlewareLayer for StaticAssets {
             .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(),
@@ -68,6 +71,7 @@ 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(),
@@ -83,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
@@ -104,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

@@ -8,8 +8,11 @@ use magnus::{
 pub use middleware::Middleware;
 pub use middlewares::*;
 use regex::{Regex, RegexSet};
-use std::{collections::HashMap, sync::Arc};
-use tracing::{debug, info};
+use std::{
+    collections::{hash_map::Entry::Vacant, HashMap},
+    sync::Arc,
+};
+use tracing::debug;
 
 use super::http_message_types::HttpRequest;
 
@@ -132,6 +135,8 @@ 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![];
@@ -162,22 +167,54 @@ impl MiddlewareSet {
                         format!("middleware must be a hash. Got {:?}", routes_raw),
                     ))?;
 
+                let ruby = Ruby::get().unwrap();
                 let mut layers = middleware
                     .enumeratorize("each", ())
-                    .map(|pair| {
+                    .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();
-                        info!("Parsing middleware from value {}", value);
-                        let middleware = MiddlewareSet::parse_middleware(middleware_type, value);
-                        if let Ok(middleware) = middleware.as_ref() {
-                            unique_middlewares.insert(value.as_raw(), middleware.clone());
+                        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
+                        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 {
@@ -260,6 +297,7 @@ impl MiddlewareSet {
     pub fn parse_middleware(middleware_type: String, parameters: Value) -> Result<Middleware> {
         let mw_type = middleware_type.clone();
 
+        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)?)),
@@ -290,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(
@@ -306,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(
@@ -319,10 +359,6 @@ impl MiddlewareSet {
     }
 
     pub async fn initialize_layers(&self) -> Result<()> {
-        info!(
-            "Unique middleware keys: {:?}",
-            self.unique_middlewares.keys()
-        );
         for middleware in self.unique_middlewares.values() {
             middleware.initialize().await?;
         }

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