itsi 0.1.8 → 0.1.9

data/gems/scheduler/ext/itsi_server/src/server/tls.rs

@@ -48,23 +48,26 @@ pub fn configure_tls(
 ) -> Result<ItsiTlsAcceptor> {
     let domains = query_params
         .get("domains")
-        .map(|v| v.split(',').map(String::from).collect::<Vec<_>>());
+        .map(|v| v.split(',').map(String::from).collect::<Vec<_>>())
+        .or_else(|| query_params.get("domain").map(|v| vec![v.to_string()]));
 
-    if query_params.get("cert").is_some_and(|c| c == "auto") {
+    if query_params.get("cert").is_some_and(|c| c == "acme") {
         if let Some(domains) = domains {
             let directory_url = &*ITSI_ACME_DIRECTORY_URL;
             info!(
                 domains = format!("{:?}", domains),
                 directory_url, "Requesting acme cert"
             );
+            let acme_contact_email = query_params
+                .get("acme_email")
+                .map(|s| s.to_string())
+                .or_else(|| (*ITSI_ACME_CONTACT_EMAIL).as_ref().ok().map(|s| s.to_string()))
+                .ok_or_else(|| itsi_error::ItsiError::ArgumentError(
+                    "acme_cert query param or ITSI_ACME_CONTACT_EMAIL must be set before you can auto-generate let's encrypt certificates".to_string(),
+                ))?;
 
             let acme_config = AcmeConfig::new(domains)
-                .contact([format!("mailto:{}", (*ITSI_ACME_CONTACT_EMAIL).as_ref().map_err(|_| {
-                    itsi_error::ItsiError::ArgumentError(
-                      "ITSI_ACME_CONTACT_EMAIL must be set before you can auto-generate production certificates"
-                          .to_string(),
-                  )
-                })?)])
+                .contact([format!("mailto:{}", acme_contact_email)])
                 .cache(LockedDirCache::new(&*ITSI_ACME_CACHE_DIR))
                 .directory(directory_url);
 

data/gems/scheduler/ext/itsi_tracing/src/lib.rs

@@ -1,11 +1,13 @@
 use std::env;
 
 use atty::{Stream, is};
+use tracing::level_filters::LevelFilter;
 pub use tracing::{debug, error, info, trace, warn};
 pub use tracing_attributes::instrument; // Explicitly export from tracing-attributes
 use tracing_subscriber::{
-    EnvFilter,
+    EnvFilter, Layer,
     fmt::{self, format},
+    layer::SubscriberExt,
 };
 
 #[instrument]
@@ -39,3 +41,18 @@ pub fn init() {
             .init();
     }
 }
+
+pub fn run_silently<F, R>(f: F) -> R
+where
+    F: FnOnce() -> R,
+{
+    // Build a minimal subscriber that filters *everything* out
+    let no_op_subscriber =
+        tracing_subscriber::registry().with(fmt::layer().with_filter(LevelFilter::OFF));
+
+    // Turn that subscriber into a `Dispatch`
+    let no_op_dispatch = tracing::dispatcher::Dispatch::new(no_op_subscriber);
+
+    // Temporarily set `no_op_dispatch` as the *default* within this closure
+    tracing::dispatcher::with_default(&no_op_dispatch, f)
+}

data/gems/scheduler/lib/itsi/scheduler/version.rb

@@ -2,6 +2,6 @@
 
 module Itsi
   class Scheduler
-    VERSION = "0.1.8"
+    VERSION = "0.1.9"
   end
 end

data/gems/scheduler/test/test_address_resolve.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 require 'debug'
 
-
 class TestAddressResolve < Minitest::Test
   include Itsi::Scheduler::TestHelper
 

data/gems/scheduler/test/test_file_io.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-
 class TestFileIO < Minitest::Test
   include Itsi::Scheduler::TestHelper
 

data/gems/scheduler/test/test_kernel_sleep.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-
 class TestKernelSleep < Minitest::Test
   include Itsi::Scheduler::TestHelper
 
@@ -14,7 +13,7 @@ class TestKernelSleep < Minitest::Test
     # Run the scheduler in a dedicated thread to avoid interference with the
     # main thread’s scheduler state.
     with_scheduler do |_scheduler|
-      5.times do
+      10.times do
         Fiber.schedule do
           sleep 0.05
           results << "first"
@@ -26,9 +25,9 @@ class TestKernelSleep < Minitest::Test
 
     ends_at = Time.now
     # We expect 10 sleep completions overall (2 per fiber).
-    assert_equal 10, results.size
+    assert_equal 20, results.size
     # Because all sleeps run concurrently, the total elapsed time should be about 1 second.
-    assert_in_delta 0.1, ends_at - start_at, 0.02, "Total elapsed time should be close to 0.1 second"
+    assert_in_delta 0.1, ends_at - start_at, 0.1, "Total elapsed time should be close to 0.1 second"
   end
 
   def test_sleep_zero_duration

data/gems/server/Rakefile

@@ -3,7 +3,14 @@
 require "bundler/gem_tasks"
 require "minitest/test_task"
 
-Minitest::TestTask.create
+
+Minitest::TestTask.create(:test) do |t|
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.warning = false
+  t.test_globs = ['test/**/*.rb']
+  t.test_prelude = 'require "helpers/test_helper.rb"'
+end
 
 require "rubocop/rake_task"
 

data/gems/server/ext/itsi_server/src/lib.rs

@@ -71,6 +71,7 @@ fn init(ruby: &Ruby) -> Result<()> {
     server.define_singleton_method("new", function!(Server::new, -1))?;
     server.define_singleton_method("reset_signal_handlers", function!(reset_signal_handlers, 0))?;
     server.define_method("start", method!(Server::start, 0))?;
+    server.define_method("stop", method!(Server::stop, 0))?;
 
     let request = ruby.get_inner(&ITSI_REQUEST);
     request.define_method("path", method!(ItsiRequest::path, 0))?;
@@ -86,6 +87,8 @@ fn init(ruby: &Ruby) -> Result<()> {
     request.define_method("port", method!(ItsiRequest::port, 0))?;
     request.define_method("body", method!(ItsiRequest::body, 0))?;
     request.define_method("response", method!(ItsiRequest::response, 0))?;
+    request.define_method("json?", method!(ItsiRequest::is_json, 0))?;
+    request.define_method("html?", method!(ItsiRequest::is_html, 0))?;
 
     let body_proxy = ruby.get_inner(&ITSI_BODY_PROXY);
     body_proxy.define_method("gets", method!(ItsiBodyProxy::gets, 0))?;
@@ -102,6 +105,8 @@ fn init(ruby: &Ruby) -> Result<()> {
     response.define_method("close_read", method!(ItsiResponse::close_read, 0))?;
     response.define_method("close", method!(ItsiResponse::close, 0))?;
     response.define_method("hijack", method!(ItsiResponse::hijack, 1))?;
+    response.define_method("json?", method!(ItsiResponse::is_json, 0))?;
+    response.define_method("html?", method!(ItsiResponse::is_html, 0))?;
 
     Ok(())
 }

data/gems/server/ext/itsi_server/src/request/itsi_request.rs

@@ -13,7 +13,7 @@ use crate::{
 use bytes::Bytes;
 use derive_more::Debug;
 use futures::StreamExt;
-use http::{request::Parts, Response, StatusCode};
+use http::{request::Parts, HeaderValue, Response, StatusCode};
 use http_body_util::{combinators::BoxBody, BodyExt, Empty};
 use hyper::{body::Incoming, Request};
 use itsi_error::from::CLIENT_CONNECTION_CLOSED;
@@ -49,6 +49,7 @@ pub struct ItsiRequest {
     pub server: Arc<Server>,
     pub response: ItsiResponse,
     pub start: Instant,
+    pub content_type: String,
 }
 
 impl fmt::Display for ItsiRequest {
@@ -82,6 +83,14 @@ impl ItsiRequest {
         }
     }
 
+    pub fn is_json(&self) -> bool {
+        self.content_type.eq("application/json")
+    }
+
+    pub fn is_html(&self) -> bool {
+        self.content_type.eq("text/html")
+    }
+
     pub fn process(
         self,
         ruby: &Ruby,
@@ -175,8 +184,27 @@ impl ItsiRequest {
                 server,
                 listener,
                 version: format!("{:?}", &parts.version),
-                response: ItsiResponse::new(parts.clone(), response_channel.0),
+                response: ItsiResponse::new(
+                    parts.clone(),
+                    response_channel.0,
+                    parts
+                        .headers
+                        .get("Accept")
+                        .unwrap_or(&HeaderValue::from_static("text/html"))
+                        .to_str()
+                        .unwrap()
+                        .to_string(),
+                ),
                 start: Instant::now(),
+                content_type: parts
+                    .headers
+                    .get("Content-Type")
+                    .unwrap_or(&HeaderValue::from_static(
+                        "application/x-www-form-urlencoded",
+                    ))
+                    .to_str()
+                    .unwrap()
+                    .to_string(),
                 parts,
             },
             response_channel.1,

data/gems/server/ext/itsi_server/src/response/itsi_response.rs

@@ -37,6 +37,7 @@ use crate::server::serve_strategy::single_mode::RunningPhase;
 #[derive(Debug, Clone)]
 pub struct ItsiResponse {
     pub data: Arc<ResponseData>,
+    pub accept: String,
 }
 
 #[derive(Debug)]
@@ -293,11 +294,19 @@ impl ItsiResponse {
         Ok(true)
     }
 
+    pub fn is_html(&self) -> bool {
+        self.accept.starts_with("text/html")
+    }
+
+    pub fn is_json(&self) -> bool {
+        self.accept.starts_with("application/json")
+    }
+
     pub fn close_read(&self) -> MagnusResult<bool> {
-        todo!();
+        Ok(true)
     }
 
-    pub fn new(parts: Parts, response_writer: mpsc::Sender<Option<Bytes>>) -> Self {
+    pub fn new(parts: Parts, response_writer: mpsc::Sender<Option<Bytes>>, accept: String) -> Self {
         Self {
             data: Arc::new(ResponseData {
                 response: RwLock::new(Some(Response::new(BoxBody::new(Empty::new())))),
@@ -306,6 +315,7 @@ impl ItsiResponse {
                 hijacked_socket: RwLock::new(None),
                 parts,
             }),
+            accept,
         }
     }
 

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

@@ -2,20 +2,22 @@ use super::{
     bind::Bind,
     listener::Listener,
     serve_strategy::{cluster_mode::ClusterMode, single_mode::SingleMode},
-    signal::{clear_signal_handlers, reset_signal_handlers, SIGNAL_HANDLER_CHANNEL},
+    signal::{
+        clear_signal_handlers, reset_signal_handlers, send_shutdown_event, SIGNAL_HANDLER_CHANNEL,
+    },
 };
 use crate::{request::itsi_request::ItsiRequest, server::serve_strategy::ServeStrategy};
 use derive_more::Debug;
-use itsi_rb_helpers::call_without_gvl;
-use itsi_tracing::error;
+use itsi_rb_helpers::{call_without_gvl, HeapVal};
+use itsi_tracing::{error, run_silently};
 use magnus::{
     block::Proc,
     error::Result,
-    scan_args::{get_kwargs, scan_args, Args, KwArgs},
+    scan_args::{get_kwargs, scan_args, Args, KwArgs, ScanArgsKw, ScanArgsOpt, ScanArgsRequired},
     value::{InnerValue, Opaque, ReprValue},
-    RHash, Ruby, Symbol, Value,
+    ArgList, RHash, Ruby, Symbol, Value,
 };
-use parking_lot::Mutex;
+use parking_lot::{Mutex, RwLock};
 use std::{cmp::max, ops::Deref, sync::Arc};
 use tracing::{info, instrument};
 
@@ -39,7 +41,7 @@ type AfterFork = Mutex<Arc<Option<Box<dyn Fn() + Send + Sync>>>>;
 #[derive(Debug)]
 pub struct ServerConfig {
     #[debug(skip)]
-    pub app: Opaque<Value>,
+    pub app: HeapVal,
     #[allow(unused)]
     pub workers: u8,
     #[allow(unused)]
@@ -55,6 +57,9 @@ pub struct ServerConfig {
     pub scheduler_class: Option<String>,
     pub stream_body: Option<bool>,
     pub worker_memory_limit: Option<u64>,
+    #[debug(skip)]
+    pub(crate) strategy: RwLock<Option<ServeStrategy>>,
+    pub silence: bool,
 }
 
 #[derive(Debug)]
@@ -63,6 +68,35 @@ pub enum RequestJob {
     Shutdown,
 }
 
+// Define your helper function.
+// Here P, A, C correspond to the types for the first tuple, second tuple, and extra parameters respectively.
+fn extract_args<Req, Opt, Splat>(
+    scan_args: &Args<(), (), (), (), RHash, ()>,
+    primaries: &[&str],
+    rest: &[&str],
+) -> Result<KwArgs<Req, Opt, Splat>>
+where
+    Req: ScanArgsRequired,
+    Opt: ScanArgsOpt,
+    Splat: ScanArgsKw,
+{
+    // Combine the primary and rest names into one Vec of Symbols.
+    let symbols: Vec<Symbol> = primaries
+        .iter()
+        .chain(rest.iter())
+        .map(|&name| Symbol::new(name))
+        .collect();
+
+    // Call the "slice" function with the combined symbols.
+    let hash = scan_args
+        .keywords
+        .funcall::<_, _, RHash>("slice", symbols.into_arg_list_with(&Ruby::get().unwrap()))
+        .unwrap();
+
+    // Finally, call get_kwargs with the original name slices.
+    get_kwargs(hash, primaries, rest)
+}
+
 impl Server {
     #[instrument(
         name = "Itsi",
@@ -73,39 +107,44 @@ impl Server {
     pub fn new(args: &[Value]) -> Result<Self> {
         let scan_args: Args<(), (), (), (), RHash, ()> = scan_args(args)?;
 
-        type ArgSet1 = (
-            Option<u8>,
-            Option<u8>,
-            Option<f64>,
-            Option<String>,
-            Option<Vec<String>>,
-            Option<Proc>,
-            Option<Proc>,
-            Option<String>,
-            Option<bool>,
-        );
-
-        type ArgSet2 = (Option<u64>,);
-
-        let args1: KwArgs<(Value,), ArgSet1, ()> = get_kwargs(
-            scan_args
-                .keywords
-                .funcall::<_, _, RHash>(
-                    "slice",
-                    (
-                        Symbol::new("app"),
-                        Symbol::new("workers"),
-                        Symbol::new("threads"),
-                        Symbol::new("shutdown_timeout"),
-                        Symbol::new("script_name"),
-                        Symbol::new("binds"),
-                        Symbol::new("before_fork"),
-                        Symbol::new("after_fork"),
-                        Symbol::new("scheduler_class"),
-                        Symbol::new("stream_body"),
-                    ),
-                )
-                .unwrap(),
+        type Args1 = KwArgs<
+            (Value,),
+            (
+                // Workers
+                Option<u8>,
+                // Threads
+                Option<u8>,
+                // Shutdown Timeout
+                Option<f64>,
+                // Script Name
+                Option<String>,
+                // Binds
+                Option<Vec<String>>,
+                // Stream Body
+                Option<bool>,
+            ),
+            (),
+        >;
+
+        type Args2 = KwArgs<
+            (),
+            (
+                // Before Fork
+                Option<Proc>,
+                // After Fork
+                Option<Proc>,
+                // Scheduler Class
+                Option<String>,
+                // Worker Memory Limit
+                Option<u64>,
+                // Silence
+                Option<bool>,
+            ),
+            (),
+        >;
+
+        let args1: Args1 = extract_args(
+            &scan_args,
             &["app"],
             &[
                 "workers",
@@ -113,24 +152,24 @@ impl Server {
                 "shutdown_timeout",
                 "script_name",
                 "binds",
-                "before_fork",
-                "after_fork",
-                "scheduler_class",
                 "stream_body",
             ],
         )?;
 
-        let args2: KwArgs<(), ArgSet2, ()> = get_kwargs(
-            scan_args
-                .keywords
-                .funcall::<_, _, RHash>("slice", (Symbol::new("worker_memory_limit"),))
-                .unwrap(),
+        let args2: Args2 = extract_args(
+            &scan_args,
             &[],
-            &["worker_memory_limit"],
+            &[
+                "before_fork",
+                "after_fork",
+                "scheduler_class",
+                "worker_memory_limit",
+                "silence",
+            ],
         )?;
 
         let config = ServerConfig {
-            app: Opaque::from(args1.required.0),
+            app: HeapVal::from(args1.required.0),
             workers: max(args1.optional.0.unwrap_or(1), 1),
             threads: max(args1.optional.1.unwrap_or(1), 1),
             shutdown_timeout: args1.optional.2.unwrap_or(5.0),
@@ -144,7 +183,8 @@ impl Server {
                     .map(|s| s.parse())
                     .collect::<itsi_error::Result<Vec<Bind>>>()?,
             ),
-            before_fork: Mutex::new(args1.optional.5.map(|p| {
+            stream_body: args1.optional.5,
+            before_fork: Mutex::new(args2.optional.0.map(|p| {
                 let opaque_proc = Opaque::from(p);
                 Box::new(move || {
                     opaque_proc
@@ -153,7 +193,7 @@ impl Server {
                         .unwrap();
                 }) as Box<dyn FnOnce() + Send + Sync>
             })),
-            after_fork: Mutex::new(Arc::new(args1.optional.6.map(|p| {
+            after_fork: Mutex::new(Arc::new(args2.optional.1.map(|p| {
                 let opaque_proc = Opaque::from(p);
                 Box::new(move || {
                     opaque_proc
@@ -162,15 +202,18 @@ impl Server {
                         .unwrap();
                 }) as Box<dyn Fn() + Send + Sync>
             }))),
-            scheduler_class: args1.optional.7.clone(),
-            stream_body: args1.optional.8,
-            worker_memory_limit: args2.optional.0,
+            scheduler_class: args2.optional.2.clone(),
+            worker_memory_limit: args2.optional.3,
+            silence: args2.optional.4.is_some_and(|s| s),
+            strategy: RwLock::new(None),
         };
 
-        if let Some(scheduler_class) = args1.optional.7 {
-            info!(scheduler_class, fiber_scheduler = true);
-        } else {
-            info!(fiber_scheduler = false);
+        if !config.silence {
+            if let Some(scheduler_class) = args2.optional.2 {
+                info!(scheduler_class, fiber_scheduler = true);
+            } else {
+                info!(fiber_scheduler = false);
+            }
         }
 
         Ok(Server {
@@ -179,7 +222,7 @@ impl Server {
     }
 
     #[instrument(name = "Bind", skip_all, fields(binds=format!("{:?}", self.config.binds.lock())))]
-    pub(crate) fn listeners(&self) -> Result<Arc<Vec<Arc<Listener>>>> {
+    pub(crate) fn build_listeners(&self) -> Result<Arc<Vec<Arc<Listener>>>> {
         let listeners = self
             .config
             .binds
@@ -195,11 +238,9 @@ impl Server {
         Ok(Arc::new(listeners))
     }
 
-    pub(crate) fn build_strategy(
-        self,
-        listeners: Arc<Vec<Arc<Listener>>>,
-    ) -> Result<ServeStrategy> {
+    pub(crate) fn build_strategy(self, listeners: Arc<Vec<Arc<Listener>>>) -> Result<()> {
         let server = Arc::new(self);
+        let server_clone = server.clone();
 
         let strategy = if server.config.workers == 1 {
             ServeStrategy::Single(Arc::new(SingleMode::new(
@@ -214,24 +255,40 @@ impl Server {
                 SIGNAL_HANDLER_CHANNEL.0.clone(),
             )))
         };
-        Ok(strategy)
+
+        *server_clone.strategy.write() = Some(strategy);
+        Ok(())
+    }
+
+    pub fn stop(&self) -> Result<()> {
+        send_shutdown_event();
+        Ok(())
     }
 
     pub fn start(&self) -> Result<()> {
+        if self.silence {
+            run_silently(|| self.build_and_run_strategy())
+        } else {
+            self.build_and_run_strategy()
+        }
+    }
+
+    fn build_and_run_strategy(&self) -> Result<()> {
         reset_signal_handlers();
         let rself = self.clone();
-        let listeners = self.listeners()?;
+        let listeners = self.build_listeners()?;
         let listeners_clone = listeners.clone();
         call_without_gvl(move || -> Result<()> {
-            let strategy = rself.build_strategy(listeners_clone)?;
-            if let Err(e) = strategy.run() {
+            rself.clone().build_strategy(listeners_clone)?;
+            if let Err(e) = rself.clone().strategy.read().as_ref().unwrap().run() {
                 error!("Error running server: {}", e);
-                strategy.stop()?;
+                rself.strategy.read().as_ref().unwrap().stop()?;
             }
-            drop(strategy);
             Ok(())
         })?;
         clear_signal_handlers();
+        self.strategy.write().take();
+        info!("Server stopped");
         Ok(())
     }
 }

data/gems/server/ext/itsi_server/src/server/listener.rs

@@ -117,7 +117,7 @@ impl TokioListener {
                 tokio::select! {
                   stream_event = StreamExt::next(&mut *state) => {
                       match stream_event {
-                        Some(event) => info!("Received acme event: {:?}", event),
+                        Some(event) => info!("ACME Event: {:?}", event),
                         None => error!("Received no acme event"),
                       }
                   },

data/gems/server/ext/itsi_server/src/server/serve_strategy/single_mode.rs

@@ -25,7 +25,10 @@ use std::{
 };
 use tokio::{
     runtime::{Builder as RuntimeBuilder, Runtime},
-    sync::broadcast,
+    sync::{
+        broadcast,
+        watch::{self, Sender},
+    },
     task::JoinSet,
 };
 use tracing::instrument;
@@ -55,7 +58,7 @@ impl SingleMode {
         let (thread_workers, sender) = build_thread_workers(
             Pid::this(),
             NonZeroU8::try_from(server.threads).unwrap(),
-            server.app,
+            server.app.clone(),
             server.scheduler_class.clone(),
         )?;
         Ok(Self {
@@ -80,6 +83,9 @@ impl SingleMode {
     }
 
     pub fn stop(&self) -> Result<()> {
+        self.lifecycle_channel
+            .send(LifecycleEvent::Shutdown)
+            .expect("Failed to send shutdown event");
         Ok(())
     }
 
@@ -95,14 +101,17 @@ impl SingleMode {
               .iter()
               .map(|list| Arc::new(list.to_tokio_listener()))
               .collect::<Vec<_>>();
+          let (shutdown_sender, _) = watch::channel::<RunningPhase>(RunningPhase::Running);
           for listener in tokio_listeners.iter() {
               let mut lifecycle_rx = self_ref.lifecycle_channel.subscribe();
               let listener_info = Arc::new(listener.listener_info());
               let self_ref = self_ref.clone();
               let listener = listener.clone();
-              let (shutdown_sender, mut shutdown_receiver) = tokio::sync::watch::channel::<RunningPhase>(RunningPhase::Running);
-              let listener_clone = listener.clone();
+              let shutdown_sender = shutdown_sender.clone();
 
+
+              let listener_clone = listener.clone();
+              let mut shutdown_receiver = shutdown_sender.clone().subscribe();
               let shutdown_receiver_clone = shutdown_receiver.clone();
               listener_task_set.spawn(async move {
                 listener_clone.spawn_state_task(shutdown_receiver_clone).await;
@@ -157,7 +166,7 @@ impl SingleMode {
         &self,
         stream: IoStream,
         listener: Arc<ListenerInfo>,
-        shutdown_channel: tokio::sync::watch::Receiver<RunningPhase>,
+        shutdown_channel: watch::Receiver<RunningPhase>,
     ) -> Result<()> {
         let sender_clone = self.sender.clone();
         let addr = stream.addr();
@@ -219,12 +228,11 @@ impl SingleMode {
     pub async fn handle_lifecycle_event(
         &self,
         lifecycle_event: LifecycleEvent,
-        shutdown_sender: tokio::sync::watch::Sender<RunningPhase>,
+        shutdown_sender: Sender<RunningPhase>,
     ) -> Result<()> {
+        info!("Handling lifecycle event: {:?}", lifecycle_event);
         if let LifecycleEvent::Shutdown = lifecycle_event {
-            shutdown_sender
-                .send(RunningPhase::ShutdownPending)
-                .expect("Failed to send shutdown pending signal");
+            shutdown_sender.send(RunningPhase::ShutdownPending).ok();
             let deadline = Instant::now() + Duration::from_secs_f64(self.server.shutdown_timeout);
             for worker in &*self.thread_workers {
                 worker.request_shutdown().await;
@@ -243,9 +251,7 @@ impl SingleMode {
             }
 
             info!("Sending shutdown signal");
-            shutdown_sender
-                .send(RunningPhase::Shutdown)
-                .expect("Failed to send shutdown signal");
+            shutdown_sender.send(RunningPhase::Shutdown).ok();
             self.thread_workers.iter().for_each(|worker| {
                 worker.poll_shutdown(deadline);
             });