itsi-scheduler 0.2.16 → 0.2.18

data/ext/itsi_server/src/server/middleware_stack/middlewares/compression.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,
 };
 
@@ -20,8 +20,8 @@ use http::{
     header::{GetAll, CONTENT_ENCODING, CONTENT_LENGTH, CONTENT_TYPE},
     HeaderValue, Response,
 };
-use http_body_util::{combinators::BoxBody, BodyExt, Full, StreamBody};
-use hyper::body::{Body, Frame};
+use http_body_util::{BodyExt, StreamBody};
+use hyper::body::Body;
 use magnus::error::Result;
 use serde::{Deserialize, Serialize};
 use std::convert::Infallible;
@@ -126,15 +126,13 @@ impl MimeType {
     }
 }
 
-fn stream_encode<R>(encoder: R) -> BoxBody<Bytes, Infallible>
+fn stream_encode<R>(encoder: R) -> HttpBody
 where
     R: AsyncRead + Unpin + Sync + Send + 'static,
 {
-    let encoded_stream = ReaderStream::new(encoder).map(|res| {
-        res.map(Frame::data)
-            .map_err(|_| -> Infallible { unreachable!("We handle IO errors above") })
-    });
-    BoxBody::new(StreamBody::new(encoded_stream))
+    let encoded_stream = ReaderStream::new(encoder)
+        .map(|res| res.map_err(|_| -> Infallible { unreachable!("We handle IO errors above") }));
+    HttpBody::stream(StreamBody::new(encoded_stream))
 }
 
 fn update_content_encoding(parts: &mut http::response::Parts, new_encoding: HeaderValue) {
@@ -293,7 +291,7 @@ impl MiddlewareLayer for Compression {
                 }
                 CompressionAlgorithm::Identity => unreachable!(),
             };
-            BoxBody::new(Full::new(Bytes::from(compressed_bytes)))
+            HttpBody::full(Bytes::from(compressed_bytes))
         } else {
             let stream = body
                 .into_data_stream()

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

@@ -1,12 +1,11 @@
 use super::{FromValue, MiddlewareLayer};
 use crate::{
-    server::http_message_types::{HttpRequest, HttpResponse, RequestExt},
+    server::http_message_types::{HttpBody, HttpRequest, HttpResponse, RequestExt},
     services::itsi_http_service::HttpRequestContext,
 };
 
 use async_trait::async_trait;
 use http::{HeaderMap, Method, Response};
-use http_body_util::{combinators::BoxBody, Empty};
 use itsi_error::ItsiError;
 use magnus::error::Result;
 use serde::Deserialize;
@@ -273,7 +272,7 @@ impl MiddlewareLayer for Cors {
             let mut response_builder = Response::builder().status(204);
             *response_builder.headers_mut().unwrap() = headers;
             let response = response_builder
-                .body(BoxBody::new(Empty::new()))
+                .body(HttpBody::empty())
                 .map_err(ItsiError::new)?;
             return Ok(either::Either::Right(response));
         }

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

@@ -1,6 +1,6 @@
 use super::FromValue;
 use crate::{
-    server::http_message_types::{HttpRequest, HttpResponse},
+    server::http_message_types::{HttpBody, HttpRequest, HttpResponse},
     services::itsi_http_service::HttpRequestContext,
 };
 use async_trait::async_trait;
@@ -8,7 +8,7 @@ use bytes::{Bytes, BytesMut};
 use either::Either;
 use futures::TryStreamExt;
 use http::{HeaderValue, StatusCode};
-use http_body_util::{combinators::BoxBody, BodyExt, Empty};
+use http_body_util::BodyExt;
 use itsi_error::ItsiError;
 use serde::{Deserialize, Serialize};
 use std::sync::Arc;
@@ -164,7 +164,7 @@ impl super::MiddlewareLayer for Csp {
                 }
             }
 
-            let mut resp = HttpResponse::new(BoxBody::new(Empty::new()));
+            let mut resp = HttpResponse::new(HttpBody::empty());
             *resp.status_mut() = StatusCode::NO_CONTENT;
             return Ok(Either::Right(resp));
         }

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;
 
 impl DefaultFormat {
     pub fn response_for_code(&self, code: u16) -> ContentSource {
         match self {
             DefaultFormat::Plaintext => match code {
-                500 => ContentSource::Static(Full::new("500 Internal Error".into())),
-                404 => ContentSource::Static(Full::new("404 Not Found".into())),
-                401 => ContentSource::Static(Full::new("401 Unauthorized".into())),
-                403 => ContentSource::Static(Full::new("403 Forbidden".into())),
-                413 => ContentSource::Static(Full::new("413 Payload Too Large".into())),
-                429 => ContentSource::Static(Full::new("429 Too Many Requests".into())),
-                502 => ContentSource::Static(Full::new("502 Bad Gateway".into())),
-                503 => ContentSource::Static(Full::new("503 Service Unavailable".into())),
-                504 => ContentSource::Static(Full::new("504 Gateway Timeout".into())),
-                _ => ContentSource::Static(Full::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(Full::new(
+                500 => ContentSource::Static(
                     include_str!("../../../../default_responses/html/500.html").into(),
-                )),
-                404 => ContentSource::Static(Full::new(
+                ),
+                404 => ContentSource::Static(
                     include_str!("../../../../default_responses/html/404.html").into(),
-                )),
-                401 => ContentSource::Static(Full::new(
+                ),
+                401 => ContentSource::Static(
                     include_str!("../../../../default_responses/html/401.html").into(),
-                )),
-                403 => ContentSource::Static(Full::new(
+                ),
+                403 => ContentSource::Static(
                     include_str!("../../../../default_responses/html/403.html").into(),
-                )),
-                413 => ContentSource::Static(Full::new(
+                ),
+                413 => ContentSource::Static(
                     include_str!("../../../../default_responses/html/413.html").into(),
-                )),
-                429 => ContentSource::Static(Full::new(
+                ),
+                429 => ContentSource::Static(
                     include_str!("../../../../default_responses/html/429.html").into(),
-                )),
-                502 => ContentSource::Static(Full::new(
+                ),
+                502 => ContentSource::Static(
                     include_str!("../../../../default_responses/html/502.html").into(),
-                )),
-                503 => ContentSource::Static(Full::new(
+                ),
+                503 => ContentSource::Static(
                     include_str!("../../../../default_responses/html/503.html").into(),
-                )),
-                504 => ContentSource::Static(Full::new(
+                ),
+                504 => ContentSource::Static(
                     include_str!("../../../../default_responses/html/504.html").into(),
-                )),
-                _ => ContentSource::Static(Full::new(
+                ),
+                _ => ContentSource::Static(
                     include_str!("../../../../default_responses/html/500.html").into(),
-                )),
+                ),
             },
             DefaultFormat::Json => match code {
-                500 => ContentSource::Static(Full::new(
+                500 => ContentSource::Static(
                     include_str!("../../../../default_responses/json/500.json").into(),
-                )),
-                404 => ContentSource::Static(Full::new(
+                ),
+                404 => ContentSource::Static(
                     include_str!("../../../../default_responses/json/404.json").into(),
-                )),
-                401 => ContentSource::Static(Full::new(
+                ),
+                401 => ContentSource::Static(
                     include_str!("../../../../default_responses/json/401.json").into(),
-                )),
-                403 => ContentSource::Static(Full::new(
+                ),
+                403 => ContentSource::Static(
                     include_str!("../../../../default_responses/json/403.json").into(),
-                )),
-                413 => ContentSource::Static(Full::new(
+                ),
+                413 => ContentSource::Static(
                     include_str!("../../../../default_responses/json/413.json").into(),
-                )),
-                429 => ContentSource::Static(Full::new(
+                ),
+                429 => ContentSource::Static(
                     include_str!("../../../../default_responses/json/429.json").into(),
-                )),
-                502 => ContentSource::Static(Full::new(
+                ),
+                502 => ContentSource::Static(
                     include_str!("../../../../default_responses/json/502.json").into(),
-                )),
-                503 => ContentSource::Static(Full::new(
+                ),
+                503 => ContentSource::Static(
                     include_str!("../../../../default_responses/json/503.json").into(),
-                )),
-                504 => ContentSource::Static(Full::new(
+                ),
+                504 => ContentSource::Static(
                     include_str!("../../../../default_responses/json/504.json").into(),
-                )),
-                _ => ContentSource::Static(Full::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,9 +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(bytes) => BoxBody::new(bytes),
-            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,13 +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 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;
 
@@ -19,7 +17,7 @@ pub enum ContentSource {
     File(PathBuf),
     #[serde(rename(deserialize = "static"))]
     #[serde(skip_deserializing)]
-    Static(Full<Bytes>),
+    Static(Bytes),
 }
 
 #[derive(Debug, Clone, Deserialize, Default)]
@@ -144,13 +142,13 @@ 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(text.clone());
+                return HttpBody::full(text.clone());
             }
             Some(ContentSource::File(path)) => {
                 // Convert the PathBuf to a &str (assumes valid UTF-8).

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;
@@ -113,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 {
@@ -139,14 +139,14 @@ impl MiddlewareLayer for ETag {
                 parts.headers.insert(header::ETAG, value);
             }
 
-            body = Full::new(full_bytes).boxed();
+            body = HttpBody::full(full_bytes);
             formatted_etag
         };
 
         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()));
+                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() {

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::{
@@ -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/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/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,

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

@@ -1,15 +1,13 @@
 use std::sync::OnceLock;
 
 use super::{FromValue, MiddlewareLayer};
-use crate::server::http_message_types::{HttpRequest, HttpResponse};
+use crate::server::http_message_types::{HttpBody, HttpRequest, HttpResponse};
 use crate::services::itsi_http_service::HttpRequestContext;
 use async_trait::async_trait;
 use bytes::Bytes;
 use derive_more::Debug;
 use either::Either;
 use http::{HeaderMap, HeaderName, HeaderValue, Response, StatusCode};
-use http_body_util::combinators::BoxBody;
-use http_body_util::Full;
 use itsi_error::ItsiError;
 use magnus::error::Result;
 use serde::Deserialize;
@@ -22,7 +20,7 @@ pub struct StaticResponse {
     #[serde(skip)]
     header_map: OnceLock<HeaderMap>,
     #[serde(skip)]
-    body_bytes: OnceLock<Full<Bytes>>,
+    body_bytes: OnceLock<Bytes>,
     #[serde(skip)]
     status_code: OnceLock<StatusCode>,
 }
@@ -40,7 +38,7 @@ impl MiddlewareLayer for StaticResponse {
             .set(header_map)
             .map_err(|_| ItsiError::new("Failed to set headers"))?;
         self.body_bytes
-            .set(Full::new(Bytes::from(self.body.clone())))
+            .set(Bytes::from(self.body.clone()))
             .map_err(|_| ItsiError::new("Failed to set body bytes"))?;
         self.status_code
             .set(StatusCode::from_u16(self.code).unwrap_or(StatusCode::OK))
@@ -53,7 +51,7 @@ impl MiddlewareLayer for StaticResponse {
         _req: HttpRequest,
         _context: &mut HttpRequestContext,
     ) -> Result<Either<HttpRequest, HttpResponse>> {
-        let mut resp = Response::new(BoxBody::new(self.body_bytes.get().unwrap().clone()));
+        let mut resp = Response::new(HttpBody::full(self.body_bytes.get().unwrap().clone()));
         *resp.status_mut() = *self.status_code.get().unwrap();
         *resp.headers_mut() = self.header_map.get().unwrap().clone();
 

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

@@ -1,5 +1,6 @@
 pub mod binds;
 pub mod byte_frame;
+pub mod frame_stream;
 pub mod http_message_types;
 pub mod io_stream;
 pub mod lifecycle_event;

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

@@ -79,7 +79,7 @@ impl ProcessWorker {
                 ) {
                     error!("Failed to set process group ID: {}", e);
                 }
-                match SingleMode::new(cluster_template.server_config.clone()) {
+                match SingleMode::new(cluster_template.server_config.clone(), self.worker_id) {
                     Ok(single_mode) => {
                         if cluster_template
                             .server_config
@@ -88,7 +88,7 @@ impl ProcessWorker {
                             .pin_worker_cores
                         {
                             core_affinity::set_for_current(
-                                CORE_IDS[self.worker_id % CORE_IDS.len()],
+                                CORE_IDS[(2 * self.worker_id) % CORE_IDS.len()],
                             );
                         }
                         Arc::new(single_mode).run().ok();
@@ -166,7 +166,7 @@ impl ProcessWorker {
     }
 
     pub(crate) fn boot_if_dead(&self, cluster_template: Arc<ClusterMode>) -> bool {
-        if !self.is_alive() {
+        if !self.is_alive() && self.child_pid.lock().is_some() {
             if self.just_started() {
                 error!(
                     "Worker in crash loop {:?}. Refusing to restart",
@@ -202,7 +202,6 @@ impl ProcessWorker {
         let child_pid = *self.child_pid.lock();
         if let Some(pid) = child_pid {
             if self.is_alive() {
-                info!("Worker still alive, sending SIGKILL {}", pid);
                 if let Err(e) = kill(pid, SIGKILL) {
                     error!("Failed to force kill process {}: {}", pid, e);
                 }

data/ext/itsi_server/src/server/serve_strategy/acceptor.rs

@@ -1,6 +1,5 @@
-use std::{ops::Deref, pin::Pin, sync::Arc, time::Duration};
-
 use hyper_util::rt::TokioIo;
+use std::{ops::Deref, pin::Pin, sync::Arc, time::Duration};
 use tokio::task::JoinSet;
 use tracing::debug;
 
@@ -40,17 +39,21 @@ impl Acceptor {
         let io: TokioIo<Pin<Box<IoStream>>> = TokioIo::new(Box::pin(stream));
         let mut shutdown_channel = self.shutdown_receiver.clone();
         let acceptor_args = self.acceptor_args.clone();
+        let service = ItsiHttpService {
+            inner: Arc::new(ItsiHttpServiceInner {
+                acceptor_args: acceptor_args.clone(),
+                addr,
+            }),
+        };
+
         self.join_set.spawn(async move {
             let executor = &acceptor_args.strategy.executor;
-            let mut serve = Box::pin(executor.serve_connection_with_upgrades(
-                io,
-                ItsiHttpService {
-                    inner: Arc::new(ItsiHttpServiceInner {
-                        acceptor_args: acceptor_args.clone(),
-                        addr: addr.to_string(),
-                    }),
-                },
-            ));
+            let svc = hyper::service::service_fn(move |req| {
+                let service = service.clone();
+                async move { service.handle_request(req).await }
+            });
+
+            let mut serve = Box::pin(executor.serve_connection_with_upgrades(io, svc));
 
             tokio::select! {
                 // Await the connection finishing naturally.
@@ -63,7 +66,6 @@ impl Acceptor {
                             debug!("Connection closed abruptly: {:?}", res);
                         }
                     }
-                    serve.as_mut().graceful_shutdown();
                 },
                 // A lifecycle event triggers shutdown.
                 _ = shutdown_channel.changed() => {
@@ -81,6 +83,7 @@ impl Acceptor {
 
     pub async fn join(&mut self) {
         // Join all acceptor tasks with timeout
+
         let deadline = tokio::time::Instant::now()
             + Duration::from_secs_f64(self.server_params.shutdown_timeout);
         let sleep_until = tokio::time::sleep_until(deadline);
@@ -89,6 +92,7 @@ impl Acceptor {
                 while (self.join_set.join_next().await).is_some() {}
             } => {},
             _ = sleep_until => {
+                self.join_set.abort_all();
                 debug!("Shutdown timeout reached; abandoning remaining acceptor tasks.");
             }
         }