itsi-scheduler 0.2.15 → 0.2.17

data/ext/itsi_server/src/server/middleware_stack/middlewares/error_response/default_responses.rs

@@ -1,91 +1,89 @@
 use super::{ContentSource, DefaultFormat, ErrorResponse};
-use crate::server::http_message_types::ResponseFormat;
+use crate::server::http_message_types::{HttpBody, ResponseFormat};
 use bytes::Bytes;
-use http_body_util::{combinators::BoxBody, Full};
-use std::{convert::Infallible, sync::Arc};
 
 impl DefaultFormat {
     pub fn response_for_code(&self, code: u16) -> ContentSource {
         match self {
             DefaultFormat::Plaintext => match code {
-                500 => ContentSource::Static(Arc::new("500 Internal Error".into())),
-                404 => ContentSource::Static(Arc::new("404 Not Found".into())),
-                401 => ContentSource::Static(Arc::new("401 Unauthorized".into())),
-                403 => ContentSource::Static(Arc::new("403 Forbidden".into())),
-                413 => ContentSource::Static(Arc::new("413 Payload Too Large".into())),
-                429 => ContentSource::Static(Arc::new("429 Too Many Requests".into())),
-                502 => ContentSource::Static(Arc::new("502 Bad Gateway".into())),
-                503 => ContentSource::Static(Arc::new("503 Service Unavailable".into())),
-                504 => ContentSource::Static(Arc::new("504 Gateway Timeout".into())),
-                _ => ContentSource::Static(Arc::new("Unexpected Error".into())),
+                500 => ContentSource::Static("500 Internal Error".into()),
+                404 => ContentSource::Static("404 Not Found".into()),
+                401 => ContentSource::Static("401 Unauthorized".into()),
+                403 => ContentSource::Static("403 Forbidden".into()),
+                413 => ContentSource::Static("413 Payload Too Large".into()),
+                429 => ContentSource::Static("429 Too Many Requests".into()),
+                502 => ContentSource::Static("502 Bad Gateway".into()),
+                503 => ContentSource::Static("503 Service Unavailable".into()),
+                504 => ContentSource::Static("504 Gateway Timeout".into()),
+                _ => ContentSource::Static("Unexpected Error".into()),
             },
             DefaultFormat::Html => match code {
-                500 => ContentSource::Static(Arc::new(
+                500 => ContentSource::Static(
                     include_str!("../../../../default_responses/html/500.html").into(),
-                )),
-                404 => ContentSource::Static(Arc::new(
+                ),
+                404 => ContentSource::Static(
                     include_str!("../../../../default_responses/html/404.html").into(),
-                )),
-                401 => ContentSource::Static(Arc::new(
+                ),
+                401 => ContentSource::Static(
                     include_str!("../../../../default_responses/html/401.html").into(),
-                )),
-                403 => ContentSource::Static(Arc::new(
+                ),
+                403 => ContentSource::Static(
                     include_str!("../../../../default_responses/html/403.html").into(),
-                )),
-                413 => ContentSource::Static(Arc::new(
+                ),
+                413 => ContentSource::Static(
                     include_str!("../../../../default_responses/html/413.html").into(),
-                )),
-                429 => ContentSource::Static(Arc::new(
+                ),
+                429 => ContentSource::Static(
                     include_str!("../../../../default_responses/html/429.html").into(),
-                )),
-                502 => ContentSource::Static(Arc::new(
+                ),
+                502 => ContentSource::Static(
                     include_str!("../../../../default_responses/html/502.html").into(),
-                )),
-                503 => ContentSource::Static(Arc::new(
+                ),
+                503 => ContentSource::Static(
                     include_str!("../../../../default_responses/html/503.html").into(),
-                )),
-                504 => ContentSource::Static(Arc::new(
+                ),
+                504 => ContentSource::Static(
                     include_str!("../../../../default_responses/html/504.html").into(),
-                )),
-                _ => ContentSource::Static(Arc::new(
+                ),
+                _ => ContentSource::Static(
                     include_str!("../../../../default_responses/html/500.html").into(),
-                )),
+                ),
             },
             DefaultFormat::Json => match code {
-                500 => ContentSource::Static(Arc::new(
+                500 => ContentSource::Static(
                     include_str!("../../../../default_responses/json/500.json").into(),
-                )),
-                404 => ContentSource::Static(Arc::new(
+                ),
+                404 => ContentSource::Static(
                     include_str!("../../../../default_responses/json/404.json").into(),
-                )),
-                401 => ContentSource::Static(Arc::new(
+                ),
+                401 => ContentSource::Static(
                     include_str!("../../../../default_responses/json/401.json").into(),
-                )),
-                403 => ContentSource::Static(Arc::new(
+                ),
+                403 => ContentSource::Static(
                     include_str!("../../../../default_responses/json/403.json").into(),
-                )),
-                413 => ContentSource::Static(Arc::new(
+                ),
+                413 => ContentSource::Static(
                     include_str!("../../../../default_responses/json/413.json").into(),
-                )),
-                429 => ContentSource::Static(Arc::new(
+                ),
+                429 => ContentSource::Static(
                     include_str!("../../../../default_responses/json/429.json").into(),
-                )),
-                502 => ContentSource::Static(Arc::new(
+                ),
+                502 => ContentSource::Static(
                     include_str!("../../../../default_responses/json/502.json").into(),
-                )),
-                503 => ContentSource::Static(Arc::new(
+                ),
+                503 => ContentSource::Static(
                     include_str!("../../../../default_responses/json/503.json").into(),
-                )),
-                504 => ContentSource::Static(Arc::new(
+                ),
+                504 => ContentSource::Static(
                     include_str!("../../../../default_responses/json/504.json").into(),
-                )),
-                _ => ContentSource::Static(Arc::new("Unexpected Error".into())),
+                ),
+                _ => ContentSource::Static("Unexpected Error".into()),
             },
         }
     }
 }
 impl ErrorResponse {
-    pub fn fallback_body_for(code: u16, accept: ResponseFormat) -> BoxBody<Bytes, Infallible> {
+    pub fn fallback_body_for(code: u16, accept: ResponseFormat) -> HttpBody {
         let source = match accept {
             ResponseFormat::TEXT => DefaultFormat::Plaintext.response_for_code(code),
             ResponseFormat::HTML => DefaultFormat::Html.response_for_code(code),
@@ -93,11 +91,9 @@ impl ErrorResponse {
             ResponseFormat::UNKNOWN => ContentSource::Inline("Unexpected Error".to_owned()),
         };
         match source {
-            ContentSource::Inline(bytes) => BoxBody::new(Full::new(Bytes::from(bytes))),
-            ContentSource::Static(text) => {
-                BoxBody::new(Full::new(Bytes::from(String::from(text.as_str()))))
-            }
-            ContentSource::File(_) => BoxBody::new(Full::new(Bytes::from("Unexpected error"))),
+            ContentSource::Inline(bytes) => HttpBody::full(Bytes::from(bytes)),
+            ContentSource::Static(bytes) => HttpBody::full(bytes),
+            ContentSource::File(_) => HttpBody::full(Bytes::from("Unexpected error")),
         }
     }
     pub fn internal_server_error() -> Self {

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

@@ -1,14 +1,11 @@
 use bytes::Bytes;
 use http::header::CONTENT_TYPE;
 use http::Response;
-use http_body_util::{combinators::BoxBody, Full};
 use serde::{Deserialize, Deserializer};
-use std::convert::Infallible;
 use std::path::PathBuf;
-use std::sync::Arc;
 use tracing::warn;
 
-use crate::server::http_message_types::{HttpResponse, ResponseFormat};
+use crate::server::http_message_types::{HttpBody, HttpResponse, ResponseFormat};
 use crate::services::static_file_server::ROOT_STATIC_FILE_SERVER;
 mod default_responses;
 
@@ -20,7 +17,7 @@ pub enum ContentSource {
     File(PathBuf),
     #[serde(rename(deserialize = "static"))]
     #[serde(skip_deserializing)]
-    Static(Arc<String>),
+    Static(Bytes),
 }
 
 #[derive(Debug, Clone, Deserialize, Default)]
@@ -145,19 +142,19 @@ impl ErrorResponse {
         code: u16,
         source: &Option<ContentSource>,
         accept: ResponseFormat,
-    ) -> BoxBody<Bytes, Infallible> {
+    ) -> HttpBody {
         match source {
             Some(ContentSource::Inline(text)) => {
-                return BoxBody::new(Full::new(Bytes::from(text.clone())));
+                return HttpBody::full(Bytes::from(text.clone()));
             }
             Some(ContentSource::Static(text)) => {
-                return BoxBody::new(Full::new(Bytes::from(String::from(text.as_str()))));
+                return HttpBody::full(text.clone());
             }
             Some(ContentSource::File(path)) => {
                 // Convert the PathBuf to a &str (assumes valid UTF-8).
                 if let Some(path_str) = path.to_str() {
                     let response = ROOT_STATIC_FILE_SERVER
-                        .serve_single(path_str, accept.clone(), &[])
+                        .serve_single(path_str, accept, &[])
                         .await;
                     if response.status().is_success() {
                         return response.into_body();

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

@@ -1,5 +1,5 @@
 use crate::{
-    server::http_message_types::{HttpRequest, HttpResponse},
+    server::http_message_types::{HttpBody, HttpRequest, HttpResponse},
     services::itsi_http_service::HttpRequestContext,
 };
 
@@ -10,7 +10,7 @@ use bytes::{Bytes, BytesMut};
 use either::Either;
 use futures::TryStreamExt;
 use http::{header, HeaderValue, Response, StatusCode};
-use http_body_util::{combinators::BoxBody, BodyExt, Empty, Full};
+use http_body_util::BodyExt;
 use hyper::body::Body;
 use magnus::error::Result;
 use serde::Deserialize;
@@ -43,12 +43,6 @@ pub struct ETag {
     pub algorithm: HashAlgorithm,
     #[serde(default)]
     pub min_body_size: usize,
-    #[serde(default = "default_true")]
-    pub handle_if_none_match: bool,
-}
-
-fn default_true() -> bool {
-    true
 }
 
 #[async_trait]
@@ -59,14 +53,13 @@ impl MiddlewareLayer for ETag {
         context: &mut HttpRequestContext,
     ) -> Result<Either<HttpRequest, HttpResponse>> {
         // Store if-none-match header in context if present for later use in after hook
-        if self.handle_if_none_match {
-            if let Some(if_none_match) = req.headers().get(header::IF_NONE_MATCH) {
-                debug!(target: "middleware::etag", "Received If-None-Match header: {:?}", if_none_match);
-                if let Ok(etag_value) = if_none_match.to_str() {
-                    context.set_if_none_match(Some(etag_value.to_string()));
-                }
+        if let Some(if_none_match) = req.headers().get(header::IF_NONE_MATCH) {
+            debug!(target: "middleware::etag", "Received If-None-Match header: {:?}", if_none_match);
+            if let Ok(etag_value) = if_none_match.to_str() {
+                context.set_if_none_match(Some(etag_value.to_string()));
             }
         }
+
         Ok(Either::Left(req))
     }
 
@@ -85,11 +78,6 @@ impl MiddlewareLayer for ETag {
             }
         }
 
-        if resp.headers().contains_key(header::ETAG) {
-            debug!(target: "middleware::etag", "Forwarding response with existing ETag");
-            return resp;
-        }
-
         if let Some(cache_control) = resp.headers().get(header::CACHE_CONTROL) {
             if let Ok(cache_control_str) = cache_control.to_str() {
                 if cache_control_str.contains("no-store") {
@@ -125,7 +113,7 @@ impl MiddlewareLayer for ETag {
                 .await
             {
                 Ok(bytes_mut) => bytes_mut.freeze(),
-                Err(_) => return Response::from_parts(parts, BoxBody::new(Empty::new())),
+                Err(_) => return Response::from_parts(parts, HttpBody::empty()),
             };
 
             let computed_etag = match self.algorithm {
@@ -151,32 +139,30 @@ impl MiddlewareLayer for ETag {
                 parts.headers.insert(header::ETAG, value);
             }
 
-            body = Full::new(full_bytes).boxed();
+            body = HttpBody::full(full_bytes);
             formatted_etag
         };
 
-        if self.handle_if_none_match {
-            if let Some(if_none_match) = context.get_if_none_match() {
-                if if_none_match == etag_value || if_none_match == "*" {
-                    // Return 304 Not Modified without the body
-                    let mut not_modified = Response::new(BoxBody::new(Empty::new()));
-                    *not_modified.status_mut() = StatusCode::NOT_MODIFIED;
-                    // Copy headers we want to preserve
-                    for (name, value) in parts.headers.iter() {
-                        if matches!(
-                            name,
-                            &header::CACHE_CONTROL
-                                | &header::CONTENT_LOCATION
-                                | &header::DATE
-                                | &header::ETAG
-                                | &header::EXPIRES
-                                | &header::VARY
-                        ) {
-                            not_modified.headers_mut().insert(name, value.clone());
-                        }
+        if let Some(if_none_match) = context.get_if_none_match() {
+            if if_none_match == etag_value || if_none_match == "*" {
+                // Return 304 Not Modified without the body
+                let mut not_modified = Response::new(HttpBody::empty());
+                *not_modified.status_mut() = StatusCode::NOT_MODIFIED;
+                // Copy headers we want to preserve
+                for (name, value) in parts.headers.iter() {
+                    if matches!(
+                        name,
+                        &header::CACHE_CONTROL
+                            | &header::CONTENT_LOCATION
+                            | &header::DATE
+                            | &header::ETAG
+                            | &header::EXPIRES
+                            | &header::VARY
+                    ) {
+                        not_modified.headers_mut().insert(name, value.clone());
                     }
-                    return not_modified;
                 }
+                return not_modified;
             }
         }
 
@@ -190,7 +176,6 @@ impl Default for ETag {
             r#type: ETagType::Strong,
             algorithm: HashAlgorithm::Sha256,
             min_body_size: 0,
-            handle_if_none_match: true,
         }
     }
 }

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

@@ -3,6 +3,7 @@ use either::Either;
 use itsi_tracing::*;
 use magnus::error::Result;
 use serde::Deserialize;
+use tracing::enabled;
 
 use crate::server::http_message_types::{HttpRequest, HttpResponse};
 use crate::services::itsi_http_service::HttpRequestContext;
@@ -39,18 +40,6 @@ pub enum LogMiddlewareLevel {
     Error,
 }
 
-impl LogMiddlewareLevel {
-    pub fn log(&self, message: String) {
-        match self {
-            LogMiddlewareLevel::Trace => trace!(target: "middleware::log_requests", message),
-            LogMiddlewareLevel::Debug => debug!(target: "middleware::log_requests", message),
-            LogMiddlewareLevel::Info => info!(target: "middleware::log_requests", message),
-            LogMiddlewareLevel::Warn => warn!(target: "middleware::log_requests", message),
-            LogMiddlewareLevel::Error => error!(target: "middleware::log_requests", message),
-        }
-    }
-}
-
 #[async_trait]
 impl MiddlewareLayer for LogRequests {
     async fn initialize(&self) -> Result<()> {
@@ -64,7 +53,38 @@ impl MiddlewareLayer for LogRequests {
     ) -> Result<Either<HttpRequest, HttpResponse>> {
         context.init_logging_params();
         if let Some(LogConfig { level, format }) = self.before.as_ref() {
-            level.log(format.rewrite_request(&req, context));
+            match level {
+                LogMiddlewareLevel::Trace => {
+                    if enabled!(target: "middleware::log_requests", tracing::Level::TRACE) {
+                        let message = format.rewrite_request(&req, context);
+                        trace!(target: "middleware::log_requests", message);
+                    }
+                }
+                LogMiddlewareLevel::Debug => {
+                    if enabled!(target: "middleware::log_requests", tracing::Level::DEBUG) {
+                        let message = format.rewrite_request(&req, context);
+                        debug!(target: "middleware::log_requests", message);
+                    }
+                }
+                LogMiddlewareLevel::Info => {
+                    if enabled!(target: "middleware::log_requests", tracing::Level::INFO) {
+                        let message = format.rewrite_request(&req, context);
+                        info!(target: "middleware::log_requests", message);
+                    }
+                }
+                LogMiddlewareLevel::Warn => {
+                    if enabled!(target: "middleware::log_requests", tracing::Level::WARN) {
+                        let message = format.rewrite_request(&req, context);
+                        warn!(target: "middleware::log_requests", message);
+                    }
+                }
+                LogMiddlewareLevel::Error => {
+                    if enabled!(target: "middleware::log_requests", tracing::Level::ERROR) {
+                        let message = format.rewrite_request(&req, context);
+                        error!(target: "middleware::log_requests", message);
+                    }
+                }
+            }
         }
 
         Ok(Either::Left(req))
@@ -72,7 +92,38 @@ impl MiddlewareLayer for LogRequests {
 
     async fn after(&self, resp: HttpResponse, context: &mut HttpRequestContext) -> HttpResponse {
         if let Some(LogConfig { level, format }) = self.after.as_ref() {
-            level.log(format.rewrite_response(&resp, context));
+            match level {
+                LogMiddlewareLevel::Trace => {
+                    if enabled!(target: "middleware::log_requests", tracing::Level::TRACE) {
+                        let message = format.rewrite_response(&resp, context);
+                        trace!(target: "middleware::log_requests", message);
+                    }
+                }
+                LogMiddlewareLevel::Debug => {
+                    if enabled!(target: "middleware::log_requests", tracing::Level::DEBUG) {
+                        let message = format.rewrite_response(&resp, context);
+                        debug!(target: "middleware::log_requests", message);
+                    }
+                }
+                LogMiddlewareLevel::Info => {
+                    if enabled!(target: "middleware::log_requests", tracing::Level::INFO) {
+                        let message = format.rewrite_response(&resp, context);
+                        info!(target: "middleware::log_requests", message);
+                    }
+                }
+                LogMiddlewareLevel::Warn => {
+                    if enabled!(target: "middleware::log_requests", tracing::Level::WARN) {
+                        let message = format.rewrite_response(&resp, context);
+                        warn!(target: "middleware::log_requests", message);
+                    }
+                }
+                LogMiddlewareLevel::Error => {
+                    if enabled!(target: "middleware::log_requests", tracing::Level::ERROR) {
+                        let message = format.rewrite_response(&resp, context);
+                        error!(target: "middleware::log_requests", message);
+                    }
+                }
+            }
         }
 
         resp

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

@@ -37,7 +37,7 @@ impl MiddlewareLayer for MaxBody {
     async fn after(&self, resp: HttpResponse, context: &mut HttpRequestContext) -> HttpResponse {
         if resp.status() == StatusCode::PAYLOAD_TOO_LARGE {
             self.error_response
-                .to_http_response(context.response_format().clone())
+                .to_http_response(*context.response_format())
                 .await
         } else {
             resp

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

@@ -14,7 +14,7 @@ use super::{string_rewrite::StringRewrite, ErrorResponse, FromValue, MiddlewareL
 use crate::{
     server::{
         binds::bind::{Bind, BindAddress},
-        http_message_types::{HttpRequest, HttpResponse, RequestExt, ResponseFormat},
+        http_message_types::{HttpBody, HttpRequest, HttpResponse, RequestExt, ResponseFormat},
         size_limited_incoming::MaxBodySizeReached,
     },
     services::itsi_http_service::HttpRequestContext,
@@ -24,8 +24,7 @@ use bytes::{Bytes, BytesMut};
 use either::Either;
 use futures::TryStreamExt;
 use http::{HeaderMap, Method, Response, StatusCode};
-use http_body_util::{combinators::BoxBody, BodyExt, Empty, StreamBody};
-use hyper::body::Frame;
+use http_body_util::BodyExt;
 use magnus::error::Result;
 use rand::Rng;
 use reqwest::{
@@ -303,7 +302,7 @@ impl MiddlewareLayer for Proxy {
         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 error_response = self.error_response.to_http_response(accept).await;
 
         let destination = match Url::parse(&url) {
             Ok(dest) => dest,
@@ -373,19 +372,17 @@ impl MiddlewareLayer for Proxy {
                 for (hn, hv) in response.headers() {
                     builder = builder.header(hn, hv);
                 }
-                let response = builder.body(BoxBody::new(StreamBody::new(
-                    response
-                        .bytes_stream()
-                        .map_ok(Frame::data)
-                        .map_err(|_| -> Infallible { unreachable!("We handle IO errors above") }),
-                )));
+                let response =
+                    builder.body(HttpBody::stream(response.bytes_stream().map_err(
+                        |_| -> Infallible { unreachable!("We handle IO errors above") },
+                    )));
                 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()));
+                        let mut max_body_response = Response::new(HttpBody::empty());
                         *max_body_response.status_mut() = StatusCode::PAYLOAD_TOO_LARGE;
                         return Ok(Either::Right(max_body_response));
                     }

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

@@ -6,6 +6,7 @@ use crate::services::rate_limiter::{
 };
 use async_trait::async_trait;
 use either::Either;
+use http::{HeaderName, HeaderValue};
 use magnus::error::Result;
 use serde::Deserialize;
 use std::collections::HashMap;
@@ -24,6 +25,8 @@ pub struct RateLimit {
     pub trusted_proxies: HashMap<String, TokenSource>,
     #[serde(default = "too_many_requests_error_response")]
     pub error_response: ErrorResponse,
+    #[serde(skip)]
+    pub limit_header_value: OnceLock<HeaderValue>,
 }
 
 fn too_many_requests_error_response() -> ErrorResponse {
@@ -38,6 +41,12 @@ pub enum RateLimitKey {
     Parameter(TokenSource),
 }
 
+static X_RATELIMIT_LIMIT: HeaderName = HeaderName::from_static("x-ratelimit-limit");
+static X_RATELIMIT_REMAINING: HeaderName = HeaderName::from_static("x-ratelimit-remaining");
+static X_RATELIMIT_RESET: HeaderName = HeaderName::from_static("x-ratelimit-reset");
+static RETRY_AFTER: HeaderName = HeaderName::from_static("retry-after");
+static ZERO_VALUE: HeaderValue = HeaderValue::from_static("0");
+
 #[async_trait]
 impl MiddlewareLayer for RateLimit {
     async fn initialize(&self) -> Result<()> {
@@ -46,6 +55,9 @@ impl MiddlewareLayer for RateLimit {
         if let Ok(limiter) = get_rate_limiter(&self.store_config).await {
             let _ = self.rate_limiter.set(limiter);
         }
+        self.limit_header_value
+            .set(self.requests.to_string().parse().unwrap())
+            .ok();
         Ok(())
     }
 
@@ -58,8 +70,7 @@ impl MiddlewareLayer for RateLimit {
         let key_value = match &self.key {
             RateLimitKey::SocketAddress => {
                 // Use the socket address from the context
-                if self.trusted_proxies.contains_key(&context.addr) {
-                    let source = self.trusted_proxies.get(&context.addr).unwrap();
+                if let Some(source) = self.trusted_proxies.get(&context.addr) {
                     source.extract_token(&req).unwrap_or(&context.addr)
                 } else {
                     &context.addr
@@ -114,18 +125,20 @@ impl MiddlewareLayer for RateLimit {
                         .error_response
                         .to_http_response(req.accept().into())
                         .await;
+                    let ttl_header_value: HeaderValue = ttl.to_string().parse().unwrap();
+                    response.headers_mut().insert(
+                        X_RATELIMIT_LIMIT.clone(),
+                        self.limit_header_value.get().unwrap().clone(),
+                    );
                     response
                         .headers_mut()
-                        .insert("X-RateLimit-Limit", limit.to_string().parse().unwrap());
-                    response
-                        .headers_mut()
-                        .insert("X-RateLimit-Remaining", "0".parse().unwrap());
+                        .insert(X_RATELIMIT_REMAINING.clone(), ZERO_VALUE.clone());
                     response
                         .headers_mut()
-                        .insert("X-RateLimit-Reset", ttl.to_string().parse().unwrap());
+                        .insert(X_RATELIMIT_RESET.clone(), ttl_header_value.clone());
                     response
                         .headers_mut()
-                        .insert("Retry-After", ttl.to_string().parse().unwrap());
+                        .insert(RETRY_AFTER.clone(), ttl_header_value);
                     Ok(Either::Right(response))
                 }
                 Err(e) => {

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

@@ -1,7 +1,7 @@
 use super::{string_rewrite::StringRewrite, FromValue, MiddlewareLayer};
 use crate::{
     server::{
-        http_message_types::{HttpRequest, HttpResponse},
+        http_message_types::{HttpBody, HttpRequest, HttpResponse},
         redirect_type::RedirectType,
     },
     services::itsi_http_service::HttpRequestContext,
@@ -9,7 +9,6 @@ use crate::{
 use async_trait::async_trait;
 use either::Either;
 use http::Response;
-use http_body_util::{combinators::BoxBody, Empty};
 use magnus::error::Result;
 use serde::Deserialize;
 use tracing::debug;
@@ -39,7 +38,7 @@ impl Redirect {
         req: &HttpRequest,
         context: &mut HttpRequestContext,
     ) -> Result<HttpResponse> {
-        let mut response = Response::new(BoxBody::new(Empty::new()));
+        let mut response = Response::new(HttpBody::empty());
         *response.status_mut() = self.redirect_type.status_code();
         let destination = self.to.rewrite_request(req, context).parse().map_err(|e| {
             magnus::Error::new(

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

@@ -119,11 +119,7 @@ impl MiddlewareLayer for RubyApp {
         if self.sendfile {
             if let Some(sendfile_header) = resp.headers().get("X-Sendfile") {
                 return ROOT_STATIC_FILE_SERVER
-                    .serve_single_abs(
-                        sendfile_header.to_str().unwrap(),
-                        context.accept.clone(),
-                        &[],
-                    )
+                    .serve_single_abs(sendfile_header.to_str().unwrap(), context.accept, &[])
                     .await;
             }
         }

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

@@ -134,8 +134,7 @@ impl MiddlewareLayer for StaticAssets {
         let file_server = self.file_server.get().unwrap();
         let encodings: &[HeaderValue] = context
             .supported_encoding_set()
-            .map(Vec::as_slice)
-            .unwrap_or(&[] as &[HeaderValue]);
+            .map_or(&[], |set| set.as_slice());
         let response = file_server
             .serve(
                 &req,