itsi-server 0.2.16 → 0.2.17

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

@@ -3,13 +3,12 @@ use itsi_error::ItsiError;
 use itsi_rb_helpers::{
     call_with_gvl, call_without_gvl, create_ruby_thread, kill_threads, HeapValue,
 };
-use itsi_tracing::{debug, error, warn};
+use itsi_tracing::{debug, error};
 use magnus::{
     error::Result,
     value::{InnerValue, Lazy, LazyId, Opaque, ReprValue},
     Module, RClass, Ruby, Thread, Value,
 };
-use nix::unistd::Pid;
 use parking_lot::{Mutex, RwLock};
 use std::{
     ops::Deref,
@@ -17,8 +16,7 @@ use std::{
         atomic::{AtomicBool, AtomicU64, Ordering},
         Arc,
     },
-    thread,
-    time::{Duration, Instant, SystemTime, UNIX_EPOCH},
+    time::{Instant, SystemTime, UNIX_EPOCH},
 };
 use tokio::{runtime::Builder as RuntimeBuilder, sync::watch};
 use tracing::instrument;
@@ -35,7 +33,7 @@ use super::request_job::RequestJob;
 pub struct ThreadWorker {
     pub params: Arc<ServerParams>,
     pub id: u8,
-    pub name: String,
+    pub worker_id: usize,
     pub request_id: AtomicU64,
     pub current_request_start: AtomicU64,
     pub receiver: Arc<async_channel::Receiver<RequestJob>>,
@@ -64,8 +62,11 @@ type ThreadWorkerBuildResult = Result<(
     Sender<RequestJob>,
 )>;
 
-#[instrument(name = "boot", parent=None, skip(params, pid))]
-pub fn build_thread_workers(params: Arc<ServerParams>, pid: Pid) -> ThreadWorkerBuildResult {
+#[instrument(name = "boot", parent=None, skip(params, worker_id))]
+pub fn build_thread_workers(
+    params: Arc<ServerParams>,
+    worker_id: usize,
+) -> ThreadWorkerBuildResult {
     let blocking_thread_count = params.threads;
     let nonblocking_thread_count = params.scheduler_threads;
     let ruby_thread_request_backlog_size: usize = params
@@ -83,7 +84,7 @@ pub fn build_thread_workers(params: Arc<ServerParams>, pid: Pid) -> ThreadWorker
             ThreadWorker::new(
                 params.clone(),
                 id,
-                format!("{:?}#{:?}", pid, id),
+                worker_id,
                 blocking_receiver_ref.clone(),
                 blocking_sender_ref.clone(),
                 if nonblocking_thread_count.is_some() {
@@ -106,7 +107,7 @@ pub fn build_thread_workers(params: Arc<ServerParams>, pid: Pid) -> ThreadWorker
             workers.push(ThreadWorker::new(
                 params.clone(),
                 id,
-                format!("{:?}#{:?}", pid, id),
+                worker_id,
                 nonblocking_receiver_ref.clone(),
                 nonblocking_sender_ref.clone(),
                 Some(scheduler_class),
@@ -141,7 +142,7 @@ impl ThreadWorker {
     pub fn new(
         params: Arc<ServerParams>,
         id: u8,
-        name: String,
+        worker_id: usize,
         receiver: Arc<async_channel::Receiver<RequestJob>>,
         sender: Sender<RequestJob>,
         scheduler_class: Option<Opaque<Value>>,
@@ -149,9 +150,9 @@ impl ThreadWorker {
         let worker = Arc::new(Self {
             params,
             id,
+            worker_id,
             request_id: AtomicU64::new(0),
             current_request_start: AtomicU64::new(0),
-            name,
             receiver,
             sender,
             thread: RwLock::new(None),
@@ -181,24 +182,24 @@ impl ThreadWorker {
     }
 
     pub fn run(self: Arc<Self>) -> Result<()> {
-        let name = self.name.clone();
         let receiver = self.receiver.clone();
         let terminated = self.terminated.clone();
         let scheduler_class = self.scheduler_class;
         let params = self.params.clone();
         let self_ref = self.clone();
-        let id = self.id;
+        let worker_id = self.worker_id;
         call_with_gvl(|_| {
             *self.thread.write() = Some(
                 create_ruby_thread(move || {
                     if params.pin_worker_cores {
-                        core_affinity::set_for_current(CORE_IDS[(id as usize) % CORE_IDS.len()]);
+                        core_affinity::set_for_current(
+                            CORE_IDS[((2 * worker_id) + 1) % CORE_IDS.len()],
+                        );
                     }
                     debug!("Ruby thread worker started");
                     if let Some(scheduler_class) = scheduler_class {
                         if let Err(err) = self_ref.fiber_accept_loop(
                             params,
-                            name,
                             receiver,
                             scheduler_class,
                             terminated,
@@ -206,7 +207,7 @@ impl ThreadWorker {
                             error!("Error in fiber_accept_loop: {:?}", err);
                         }
                     } else {
-                        self_ref.accept_loop(params, name, receiver, terminated);
+                        self_ref.accept_loop(params, receiver, terminated);
                     }
                 })
                 .ok_or_else(|| {
@@ -262,9 +263,14 @@ impl ThreadWorker {
                         }
                     }
                 }
+
                 for _ in 0..MAX_BATCH_SIZE {
                     if let Ok(req) = receiver.try_recv() {
+                        let should_break = matches!(req, RequestJob::Shutdown);
                         batch.push(req);
+                        if should_break {
+                            break;
+                        }
                     } else {
                         break;
                     }
@@ -307,7 +313,9 @@ impl ThreadWorker {
                                     ItsiGrpcCall::internal_error(ruby, response, err)
                                 }
                             }
-                            RequestJob::Shutdown => return true,
+                            RequestJob::Shutdown => {
+                                return true;
+                            }
                         }
                     }
                     false
@@ -339,15 +347,14 @@ impl ThreadWorker {
                 if yield_result.is_err() {
                     break;
                 }
-            })
+            });
         })
     }
 
-    #[instrument(skip_all, fields(thread_worker=name))]
+    #[instrument(skip_all, fields(thread_worker=format!("{}:{}", self.id, self.worker_id)))]
     pub fn fiber_accept_loop(
         self: Arc<Self>,
         params: Arc<ServerParams>,
-        name: String,
         receiver: Arc<async_channel::Receiver<RequestJob>>,
         scheduler_class: Opaque<Value>,
         terminated: Arc<AtomicBool>,
@@ -422,68 +429,76 @@ impl ThreadWorker {
         });
     }
 
-    #[instrument(skip_all, fields(thread_worker=id))]
+    #[instrument(skip_all, fields(thread_worker=format!("{}:{}", self.id, self.worker_id)))]
     pub fn accept_loop(
         self: Arc<Self>,
         params: Arc<ServerParams>,
-        id: String,
         receiver: Arc<async_channel::Receiver<RequestJob>>,
         terminated: Arc<AtomicBool>,
     ) {
-        let ruby = Ruby::get().unwrap();
         let mut idle_counter = 0;
-        let self_ref = self.clone();
         call_without_gvl(|| loop {
-            if receiver.is_empty() {
-                if let Some(oob_gc_threshold) = params.oob_gc_responses_threshold {
-                    idle_counter = (idle_counter + 1) % oob_gc_threshold;
-                    if idle_counter == 0 {
-                        call_with_gvl(|_ruby| {
-                            ruby.gc_start();
-                        });
-                    }
-                };
-            }
             match receiver.recv_blocking() {
-                Ok(RequestJob::ProcessHttpRequest(request, app_proc)) => {
-                    self_ref.request_id.fetch_add(1, Ordering::Relaxed);
-                    self_ref.current_request_start.store(
-                        SystemTime::now()
-                            .duration_since(UNIX_EPOCH)
-                            .unwrap()
-                            .as_secs(),
-                        Ordering::Relaxed,
-                    );
-                    call_with_gvl(|_ruby| {
-                        request.process(&ruby, app_proc).ok();
-                    });
-                    if terminated.load(Ordering::Relaxed) {
-                        break;
+                Err(_) => break,
+                Ok(RequestJob::Shutdown) => break,
+                Ok(request_job) => call_with_gvl(|ruby| {
+                    self.process_one(&ruby, request_job, &terminated);
+                    while let Ok(request_job) = receiver.try_recv() {
+                        if matches!(request_job, RequestJob::Shutdown) {
+                            terminated.store(true, Ordering::Relaxed);
+                            break;
+                        }
+                        self.process_one(&ruby, request_job, &terminated);
                     }
-                }
-                Ok(RequestJob::ProcessGrpcRequest(request, app_proc)) => {
-                    self_ref.request_id.fetch_add(1, Ordering::Relaxed);
-                    self_ref.current_request_start.store(
-                        SystemTime::now()
-                            .duration_since(UNIX_EPOCH)
-                            .unwrap()
-                            .as_secs(),
-                        Ordering::Relaxed,
-                    );
-                    call_with_gvl(|_ruby| {
-                        request.process(&ruby, app_proc).ok();
-                    });
-                    if terminated.load(Ordering::Relaxed) {
-                        break;
+                    if let Some(thresh) = params.oob_gc_responses_threshold {
+                        idle_counter = (idle_counter + 1) % thresh;
+                        if idle_counter == 0 {
+                            ruby.gc_start();
+                        }
                     }
+                }),
+            };
+            if terminated.load(Ordering::Relaxed) {
+                break;
+            }
+        });
+    }
+
+    fn process_one(self: &Arc<Self>, ruby: &Ruby, job: RequestJob, terminated: &Arc<AtomicBool>) {
+        match job {
+            RequestJob::ProcessHttpRequest(request, app_proc) => {
+                if terminated.load(Ordering::Relaxed) {
+                    request.response().unwrap().service_unavailable();
+                    return;
                 }
-                Ok(RequestJob::Shutdown) => {
-                    break;
-                }
-                Err(_) => {
-                    thread::sleep(Duration::from_micros(1));
+                self.request_id.fetch_add(1, Ordering::Relaxed);
+                self.current_request_start.store(
+                    SystemTime::now()
+                        .duration_since(UNIX_EPOCH)
+                        .unwrap()
+                        .as_secs(),
+                    Ordering::Relaxed,
+                );
+                request.process(ruby, app_proc).ok();
+            }
+
+            RequestJob::ProcessGrpcRequest(request, app_proc) => {
+                if terminated.load(Ordering::Relaxed) {
+                    request.stream().unwrap().close().ok();
+                    return;
                 }
+                self.request_id.fetch_add(1, Ordering::Relaxed);
+                self.current_request_start.store(
+                    SystemTime::now()
+                        .duration_since(UNIX_EPOCH)
+                        .unwrap()
+                        .as_secs(),
+                    Ordering::Relaxed,
+                );
+                request.process(ruby, app_proc).ok();
             }
-        });
+
+            RequestJob::Shutdown => unreachable!(),
+        }
     }
 }

data/ext/itsi_server/src/services/itsi_http_service.rs

@@ -6,22 +6,20 @@ use crate::server::http_message_types::{
 use crate::server::lifecycle_event::LifecycleEvent;
 use crate::server::middleware_stack::MiddlewareLayer;
 use crate::server::serve_strategy::acceptor::AcceptorArgs;
-use crate::server::signal::send_lifecycle_event;
+use crate::server::signal::{send_lifecycle_event, SHUTDOWN_REQUESTED};
 use chrono::{self, DateTime, Local};
 use either::Either;
 use http::header::ACCEPT_ENCODING;
 use http::{HeaderValue, Request};
 use hyper::body::Incoming;
-use hyper::service::Service;
-use itsi_error::ItsiError;
 use regex::Regex;
+use smallvec::SmallVec;
+use std::ops::Deref;
 use std::sync::atomic::{AtomicBool, Ordering};
-use std::sync::OnceLock;
+use std::sync::{Arc, OnceLock};
 use std::time::{Duration, Instant};
-use tracing::error;
-
-use std::{future::Future, ops::Deref, pin::Pin, sync::Arc};
 use tokio::time::timeout;
+use tracing::error;
 
 #[derive(Clone)]
 pub struct ItsiHttpService {
@@ -80,12 +78,14 @@ pub struct RequestContextInner {
     pub request_start_time: OnceLock<DateTime<Local>>,
     pub start_instant: Instant,
     pub if_none_match: OnceLock<Option<String>>,
-    pub supported_encoding_set: OnceLock<Vec<HeaderValue>>,
+    pub supported_encoding_set: OnceLock<AcceptEncodingSet>,
     pub is_ruby_request: Arc<AtomicBool>,
 }
 
+type AcceptEncodingSet = SmallVec<[HeaderValue; 2]>;
+
 impl HttpRequestContext {
-    fn new(
+    pub fn new(
         service: ItsiHttpService,
         matching_pattern: Option<Arc<Regex>>,
         accept: ResponseFormat,
@@ -109,12 +109,14 @@ impl HttpRequestContext {
     }
 
     pub fn set_supported_encoding_set(&self, req: &HttpRequest) {
-        self.inner.supported_encoding_set.get_or_init(move || {
-            req.headers()
-                .get_all(ACCEPT_ENCODING)
-                .into_iter()
-                .cloned()
-                .collect::<Vec<_>>()
+        self.inner.supported_encoding_set.get_or_init(|| {
+            let mut set: AcceptEncodingSet = SmallVec::new();
+
+            for hv in req.headers().get_all(ACCEPT_ENCODING) {
+                set.push(hv.clone()); // clone ≈ 16 B struct copy
+            }
+
+            set
         });
     }
 
@@ -164,7 +166,7 @@ impl HttpRequestContext {
         self.inner.response_format.get().unwrap()
     }
 
-    pub fn supported_encoding_set(&self) -> Option<&Vec<HeaderValue>> {
+    pub fn supported_encoding_set(&self) -> Option<&AcceptEncodingSet> {
         self.inner.supported_encoding_set.get()
     }
 }
@@ -173,13 +175,8 @@ const SERVER_TOKEN_VERSION: HeaderValue =
     HeaderValue::from_static(concat!("Itsi/", env!("CARGO_PKG_VERSION")));
 const SERVER_TOKEN_NAME: HeaderValue = HeaderValue::from_static("Itsi");
 
-impl Service<Request<Incoming>> for ItsiHttpService {
-    type Response = HttpResponse;
-    type Error = ItsiError;
-    type Future = Pin<Box<dyn Future<Output = itsi_error::Result<HttpResponse>> + Send>>;
-
-    fn call(&self, req: Request<Incoming>) -> Self::Future {
-        let self_clone = self.clone();
+impl ItsiHttpService {
+    pub async fn handle_request(&self, req: Request<Incoming>) -> itsi_error::Result<HttpResponse> {
         let mut req = req.limit();
         let accept: ResponseFormat = req.accept().into();
         let is_single_mode = self.server_params.workers == 1;
@@ -191,7 +188,7 @@ impl Service<Request<Incoming>> for ItsiHttpService {
         let token_preference = self.server_params.itsi_server_token_preference;
 
         let service_future = async move {
-            let middleware_stack = self_clone
+            let middleware_stack = self
                 .server_params
                 .middleware
                 .get()
@@ -202,7 +199,7 @@ impl Service<Request<Incoming>> for ItsiHttpService {
             let mut resp: Option<HttpResponse> = None;
 
             let mut context =
-                HttpRequestContext::new(self_clone.clone(), matching_pattern, accept, irr_clone);
+                HttpRequestContext::new(self.clone(), matching_pattern, accept, irr_clone);
             let mut depth = 0;
 
             for (index, elm) in stack.iter().enumerate() {
@@ -243,28 +240,31 @@ impl Service<Request<Incoming>> for ItsiHttpService {
         };
 
         if let Some(timeout_duration) = request_timeout {
-            Box::pin(async move {
-                match timeout(timeout_duration, service_future).await {
-                    Ok(result) => result,
-                    Err(_) => {
-                        // If we're still running Ruby at this point, we can't just kill the
-                        // thread as it might be in a critical section.
-                        // Instead we must ask the worker to hot restart.
-                        if is_ruby_request.load(Ordering::Relaxed) {
-                            if is_single_mode {
-                                // If we're in single mode, re-exec the whole process
-                                send_lifecycle_event(LifecycleEvent::Restart);
-                            } else {
-                                // Otherwise we can shutdown the worker and rely on the master to restart it
-                                send_lifecycle_event(LifecycleEvent::Shutdown);
-                            }
+            match timeout(timeout_duration, service_future).await {
+                Ok(result) => result,
+                Err(_) => {
+                    // If we're still running Ruby at this point, we can't just kill the
+                    // thread as it might be in a critical section.
+                    // Instead we must ask the worker to hot restart.
+                    // But only if we're not already shutting down
+                    if is_ruby_request.load(Ordering::Relaxed)
+                        && !SHUTDOWN_REQUESTED.load(Ordering::SeqCst)
+                    {
+                        // When we've detected a timeout, use the safer send_lifecycle_event
+                        // which will properly handle signal-safe state transitions
+                        if is_single_mode {
+                            // If we're in single mode, re-exec the whole process
+                            send_lifecycle_event(LifecycleEvent::Restart);
+                        } else {
+                            // Otherwise we can shutdown the worker and rely on the master to restart it
+                            send_lifecycle_event(LifecycleEvent::Shutdown);
                         }
-                        Ok(TIMEOUT_RESPONSE.to_http_response(accept).await)
                     }
+                    Ok(TIMEOUT_RESPONSE.to_http_response(accept).await)
                 }
-            })
+            }
         } else {
-            Box::pin(service_future)
+            service_future.await
         }
     }
 }

data/ext/itsi_server/src/services/static_file_server.rs

@@ -2,7 +2,7 @@ use crate::{
     default_responses::NOT_FOUND_RESPONSE,
     prelude::*,
     server::{
-        http_message_types::{HttpRequest, HttpResponse, RequestExt, ResponseFormat},
+        http_message_types::{HttpBody, HttpRequest, HttpResponse, RequestExt, ResponseFormat},
         middleware_stack::ErrorResponse,
         redirect_type::RedirectType,
     },
@@ -16,7 +16,6 @@ use http::{
     },
     HeaderName, HeaderValue, Response, StatusCode,
 };
-use http_body_util::{combinators::BoxBody, Full};
 use itsi_error::Result;
 use parking_lot::{Mutex, RwLock};
 use percent_encoding::percent_decode_str;
@@ -28,7 +27,6 @@ use std::{
     borrow::Cow,
     cmp::Ordering,
     collections::HashMap,
-    convert::Infallible,
     fs::Metadata,
     ops::Deref,
     path::{Path, PathBuf},
@@ -324,7 +322,7 @@ impl StaticFileServer {
             }) => Response::builder()
                 .status(StatusCode::MOVED_PERMANENTLY)
                 .header(header::LOCATION, redirect_to)
-                .body(BoxBody::new(Full::new(Bytes::new())))
+                .body(HttpBody::empty())
                 .unwrap(),
             Err(not_found_behavior) => match not_found_behavior {
                 NotFoundBehavior::Error(error_response) => {
@@ -340,7 +338,7 @@ impl StaticFileServer {
                 NotFoundBehavior::Redirect(redirect) => Response::builder()
                     .status(redirect.r#type.status_code())
                     .header(header::LOCATION, redirect.to)
-                    .body(BoxBody::new(Full::new(Bytes::new())))
+                    .body(HttpBody::empty())
                     .unwrap(),
             },
         })
@@ -407,7 +405,7 @@ impl StaticFileServer {
 
         Response::builder()
             .status(StatusCode::NOT_FOUND)
-            .body(BoxBody::new(Full::new(Bytes::new())))
+            .body(HttpBody::empty())
             .unwrap()
     }
 
@@ -648,15 +646,8 @@ impl StaticFileServer {
         Err(nf)
     }
 
-    async fn stream_file_range(
-        &self,
-        path: PathBuf,
-        start: u64,
-        end: u64,
-    ) -> Option<BoxBody<Bytes, Infallible>> {
+    async fn stream_file_range(&self, path: PathBuf, start: u64, end: u64) -> Option<HttpBody> {
         use futures::TryStreamExt;
-        use http_body_util::StreamBody;
-        use hyper::body::Frame;
         use tokio::io::AsyncSeekExt;
         use tokio_util::io::ReaderStream;
 
@@ -687,32 +678,25 @@ impl StaticFileServer {
         let range_length = end - start + 1;
         let limited_reader = tokio::io::AsyncReadExt::take(file, range_length);
         let path_clone = path.clone();
-        let stream = ReaderStream::with_capacity(limited_reader, 64 * 1024)
-            .map_ok(Frame::data)
-            .map_err(move |e| {
-                warn!("Error streaming file {}: {}", path_clone.display(), e);
-                unreachable!("We handle IO errors above")
-            });
-
-        Some(BoxBody::new(StreamBody::new(stream)))
+        let stream = ReaderStream::with_capacity(limited_reader, 64 * 1024).map_err(move |e| {
+            warn!("Error streaming file {}: {}", path_clone.display(), e);
+            unreachable!("We handle IO errors above")
+        });
+        Some(HttpBody::stream(stream))
     }
 
-    async fn stream_file(&self, path: PathBuf) -> Option<BoxBody<Bytes, Infallible>> {
+    async fn stream_file(&self, path: PathBuf) -> Option<HttpBody> {
         use futures::TryStreamExt;
-        use http_body_util::StreamBody;
-        use hyper::body::Frame;
         use tokio_util::io::ReaderStream;
 
         match File::open(&path).await {
             Ok(file) => {
                 let path_clone = path.clone();
-                let stream = ReaderStream::with_capacity(file, 64 * 1024)
-                    .map_ok(Frame::data)
-                    .map_err(move |e| {
-                        warn!("Error streaming file {}: {}", path_clone.display(), e);
-                        unreachable!("We handle IO errors above")
-                    });
-                Some(BoxBody::new(StreamBody::new(stream)))
+                let stream = ReaderStream::with_capacity(file, 64 * 1024).map_err(move |e| {
+                    warn!("Error streaming file {}: {}", path_clone.display(), e);
+                    unreachable!("We handle IO errors above")
+                });
+                Some(HttpBody::stream(stream))
             }
             Err(e) => {
                 warn!(
@@ -749,7 +733,7 @@ impl StaticFileServer {
             return Response::builder()
                 .status(StatusCode::RANGE_NOT_SATISFIABLE)
                 .header("Content-Range", format!("bytes */{}", content_length))
-                .body(BoxBody::new(Full::new(Bytes::new())))
+                .body(HttpBody::empty())
                 .unwrap();
         }
 
@@ -795,7 +779,7 @@ impl StaticFileServer {
                 builder = builder.header("Content-Range", range);
             }
 
-            return builder.body(BoxBody::new(Full::new(Bytes::new()))).unwrap();
+            return builder.body(HttpBody::empty()).unwrap();
         }
 
         // For GET requests, prepare the actual content
@@ -829,10 +813,7 @@ impl StaticFileServer {
         }
     }
 
-    fn serve_cached_content(
-        &self,
-        serve_cache_args: ServeCacheArgs,
-    ) -> http::Response<BoxBody<Bytes, Infallible>> {
+    fn serve_cached_content(&self, serve_cache_args: ServeCacheArgs) -> HttpResponse {
         let ServeCacheArgs(
             cache_entry,
             start,
@@ -855,7 +836,7 @@ impl StaticFileServer {
             return Response::builder()
                 .status(StatusCode::RANGE_NOT_SATISFIABLE)
                 .header("Content-Range", format!("bytes */{}", content_length))
-                .body(BoxBody::new(Full::new(Bytes::new())))
+                .body(HttpBody::empty())
                 .unwrap();
         }
 
@@ -904,7 +885,7 @@ impl StaticFileServer {
                 builder = builder.header("Content-Range", range);
             }
 
-            return builder.body(BoxBody::new(Full::new(Bytes::new()))).unwrap();
+            return builder.body(HttpBody::empty()).unwrap();
         }
 
         if is_range_request {
@@ -920,7 +901,7 @@ impl StaticFileServer {
                 cache_entry.last_modified_http_date.clone(),
                 content_range,
                 &self.headers,
-                BoxBody::new(Full::new(range_bytes)),
+                HttpBody::full(range_bytes),
             )
         } else {
             // Return the full content
@@ -987,15 +968,15 @@ fn format_http_date_header(time: SystemTime) -> HeaderValue {
         .unwrap()
 }
 
-fn build_ok_body(bytes: Arc<Bytes>) -> BoxBody<Bytes, Infallible> {
-    BoxBody::new(Full::new(bytes.as_ref().clone()))
+fn build_ok_body(bytes: Arc<Bytes>) -> HttpBody {
+    HttpBody::full(bytes.as_ref().clone())
 }
 
 // Helper function to handle not modified responses
-fn build_not_modified_response() -> http::Response<BoxBody<Bytes, Infallible>> {
+fn build_not_modified_response() -> HttpResponse {
     Response::builder()
         .status(StatusCode::NOT_MODIFIED)
-        .body(BoxBody::new(Full::new(Bytes::new())))
+        .body(HttpBody::empty())
         .unwrap()
 }
 
@@ -1009,8 +990,8 @@ fn build_file_response(
     last_modified_http_date: HeaderValue,
     range_header: Option<String>,
     headers: &Option<HashMap<String, String>>,
-    body: BoxBody<Bytes, Infallible>,
-) -> http::Response<BoxBody<Bytes, Infallible>> {
+    body: HttpBody,
+) -> HttpResponse {
     let mut response = Response::new(body);
 
     *response.status_mut() = status;