itsi-server 0.2.15 → 0.2.17

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

@@ -1,17 +1,18 @@
 use crate::{
     ruby_types::itsi_server::itsi_server_config::ItsiServerConfig,
     server::{
-        binds::listener::ListenerInfo,
-        io_stream::IoStream,
         lifecycle_event::LifecycleEvent,
         request_job::RequestJob,
-        signal::{SHUTDOWN_REQUESTED, SIGNAL_HANDLER_CHANNEL},
+        serve_strategy::acceptor::{Acceptor, AcceptorArgs},
+        signal::{
+            send_lifecycle_event, subscribe_runtime_to_signals, unsubscribe_runtime,
+            SHUTDOWN_REQUESTED,
+        },
         thread_worker::{build_thread_workers, ThreadWorker},
     },
-    services::itsi_http_service::{ItsiHttpService, ItsiHttpServiceInner},
 };
 use hyper_util::{
-    rt::{TokioExecutor, TokioIo, TokioTimer},
+    rt::{TokioExecutor, TokioTimer},
     server::conn::auto::Builder,
 };
 use itsi_error::{ItsiError, Result};
@@ -22,34 +23,29 @@ use itsi_tracing::{debug, error, info};
 use magnus::{value::ReprValue, Value};
 use nix::unistd::Pid;
 use parking_lot::RwLock;
+use std::sync::Arc;
 use std::{
     collections::HashMap,
-    pin::Pin,
-    sync::{
-        atomic::{AtomicBool, Ordering},
-        Arc,
-    },
+    sync::atomic::{AtomicBool, Ordering},
     thread::sleep,
     time::{Duration, Instant, SystemTime, UNIX_EPOCH},
 };
 use tokio::{
     runtime::{Builder as RuntimeBuilder, Runtime},
-    sync::{
-        broadcast,
-        watch::{self},
-    },
+    sync::watch::{self},
     task::JoinSet,
 };
 use tracing::instrument;
 
 pub struct SingleMode {
+    pub worker_id: usize,
     pub executor: Builder<TokioExecutor>,
     pub server_config: Arc<ItsiServerConfig>,
-    pub(crate) lifecycle_channel: broadcast::Sender<LifecycleEvent>,
     pub restart_requested: AtomicBool,
     pub status: RwLock<HashMap<u8, (u64, u64)>>,
 }
 
+#[derive(PartialEq, Debug)]
 pub enum RunningPhase {
     Running,
     ShutdownPending,
@@ -58,17 +54,45 @@ pub enum RunningPhase {
 
 impl SingleMode {
     #[instrument(parent=None, skip_all)]
-    pub fn new(server_config: Arc<ItsiServerConfig>) -> Result<Self> {
+    pub fn new(server_config: Arc<ItsiServerConfig>, worker_id: usize) -> Result<Self> {
         server_config.server_params.read().preload_ruby()?;
+        let executor = {
+            let mut executor = Builder::new(TokioExecutor::new());
+            let server_params = server_config.server_params.read();
+            let mut http1_executor = executor.http1();
+
+            http1_executor
+                .header_read_timeout(server_params.header_read_timeout)
+                .pipeline_flush(server_params.pipeline_flush)
+                .timer(TokioTimer::new());
+
+            if let Some(writev) = server_params.writev {
+                http1_executor.writev(writev);
+            }
+
+            executor
+                .http2()
+                .max_concurrent_streams(server_params.max_concurrent_streams)
+                .max_local_error_reset_streams(server_params.max_local_error_reset_streams)
+                .max_header_list_size(server_params.max_header_list_size)
+                .max_send_buf_size(server_params.max_send_buf_size)
+                .enable_connect_protocol();
+            executor
+        };
+
         Ok(Self {
-            executor: Builder::new(TokioExecutor::new()),
+            worker_id,
+            executor,
             server_config,
-            lifecycle_channel: SIGNAL_HANDLER_CHANNEL.0.clone(),
             restart_requested: AtomicBool::new(false),
             status: RwLock::new(HashMap::new()),
         })
     }
 
+    pub fn is_zero_worker(&self) -> bool {
+        self.worker_id == 0
+    }
+
     pub fn build_runtime(&self) -> Runtime {
         let mut builder: RuntimeBuilder = if self
             .server_config
@@ -82,7 +106,11 @@ impl SingleMode {
         };
         builder
             .thread_name("itsi-server-accept-loop")
-            .thread_stack_size(3 * 1024 * 1024)
+            .thread_stack_size(512 * 1024)
+            .max_blocking_threads(4)
+            .event_interval(16)
+            .global_queue_interval(64)
+            .max_io_events_per_tick(256)
             .enable_all()
             .build()
             .expect("Failed to build Tokio runtime")
@@ -90,7 +118,7 @@ impl SingleMode {
 
     pub fn stop(&self) -> Result<()> {
         SHUTDOWN_REQUESTED.store(true, std::sync::atomic::Ordering::SeqCst);
-        self.lifecycle_channel.send(LifecycleEvent::Shutdown).ok();
+        send_lifecycle_event(LifecycleEvent::Shutdown);
         Ok(())
     }
 
@@ -169,7 +197,7 @@ impl SingleMode {
                         .unwrap();
                     let receiver = self.clone();
                     monitor_runtime.block_on({
-                        let mut lifecycle_rx = receiver.lifecycle_channel.subscribe();
+                        let mut lifecycle_rx = subscribe_runtime_to_signals();
                         let receiver = receiver.clone();
                         let thread_workers = thread_workers.clone();
                         async move {
@@ -188,18 +216,19 @@ impl SingleMode {
                                   }
                                   lifecycle_event = lifecycle_rx.recv() => {
                                       match lifecycle_event {
-                                          Ok(LifecycleEvent::Restart) => {
+                                          Ok(LifecycleEvent::Restart) | Ok(LifecycleEvent::Reload) => {
                                               receiver.restart().await.ok();
                                           }
-                                          Ok(LifecycleEvent::Reload) => {
-                                              receiver.reload().await.ok();
-                                          }
                                           Ok(LifecycleEvent::Shutdown) => {
                                             break;
                                           }
                                           Ok(LifecycleEvent::PrintInfo) => {
                                             receiver.print_info(thread_workers.clone()).await.ok();
                                           }
+                                          Err(e) => {
+                                            debug!("Lifecycle channel closed: {:?}, exiting single mode monitor loop", e);
+                                            break;
+                                          }
                                           _ => {}
                                       }
                                   }
@@ -214,24 +243,26 @@ impl SingleMode {
 
     #[instrument(name="worker", parent=None, skip(self), fields(pid=format!("{}", Pid::this())))]
     pub fn run(self: Arc<Self>) -> Result<()> {
-        let mut listener_task_set = JoinSet::new();
-        let runtime = self.build_runtime();
-
-        let (thread_workers, job_sender, nonblocking_sender) =
-            build_thread_workers(self.server_config.server_params.read().clone(), Pid::this())
-                .inspect_err(|e| {
-                    if let Some(err_val) = e.value() {
-                        print_rb_backtrace(err_val);
-                    }
-                })?;
+        let (thread_workers, job_sender, nonblocking_sender) = build_thread_workers(
+            self.server_config.server_params.read().clone(),
+            self.worker_id,
+        )
+        .inspect_err(|e| {
+            if let Some(err_val) = e.value() {
+                print_rb_backtrace(err_val);
+            }
+        })?;
 
+        let worker_count = thread_workers.len();
         info!(
-            threads = thread_workers.len(),
+            threads = worker_count,
             binds = format!("{:?}", self.server_config.server_params.read().binds)
         );
 
+        let shutdown_timeout = self.server_config.server_params.read().shutdown_timeout;
         let (shutdown_sender, _) = watch::channel(RunningPhase::Running);
         let monitor_thread = self.clone().start_monitors(thread_workers.clone());
+        let is_zero_worker = self.is_zero_worker();
         if monitor_thread.is_none() {
             error!("Failed to start monitor thread");
             return Err(ItsiError::new("Failed to start monitor thread"));
@@ -240,118 +271,127 @@ impl SingleMode {
         if SHUTDOWN_REQUESTED.load(Ordering::SeqCst) {
             return Ok(());
         }
-        let result = runtime.block_on(
-          async  {
-              let server_params = self.server_config.server_params.read().clone();
-              if let Err(err) = server_params.initialize_middleware().await {
-                  error!("Failed to initialize middleware: {}", err);
-                  return Err(ItsiError::new("Failed to initialize middleware"))
-              }
-              let tokio_listeners = server_params.listeners.lock()
-                  .drain(..)
-                  .map(|list| {
-                    Arc::new(list.into_tokio_listener())
-                  })
-                  .collect::<Vec<_>>();
-
-              for listener in tokio_listeners.iter() {
-                  let mut lifecycle_rx = self.lifecycle_channel.subscribe();
-
-                  let listener_info = Arc::new(listener.listener_info());
-                  let self_ref = self.clone();
-                  let listener = listener.clone();
-                  let shutdown_sender = shutdown_sender.clone();
-                  let job_sender = job_sender.clone();
-                  let nonblocking_sender = nonblocking_sender.clone();
-                  let workers_clone = thread_workers.clone();
-                  let listener_clone = listener.clone();
-                  let mut shutdown_receiver = shutdown_sender.subscribe();
-                  let shutdown_receiver_clone = shutdown_receiver.clone();
-                  listener_task_set.spawn(async move {
-                    listener_clone.spawn_state_task(shutdown_receiver_clone).await;
-                  });
-
-                  listener_task_set.spawn(async move {
-                    let strategy_clone = self_ref.clone();
-                    let mut acceptor_task_set = JoinSet::new();
+        let runtime = self.build_runtime();
+        let result = runtime.block_on(async {
+            let mut listener_task_set = JoinSet::new();
+            let server_params = self.server_config.server_params.read().clone();
+            if let Err(err) = server_params.initialize_middleware().await {
+                error!("Failed to initialize middleware: {}", err);
+                return Err(ItsiError::new("Failed to initialize middleware"));
+            }
+            let tokio_listeners = server_params
+                .listeners
+                .lock()
+                .drain(..)
+                .map(|list| Arc::new(list.into_tokio_listener(is_zero_worker)))
+                .collect::<Vec<_>>();
+
+            tokio_listeners.iter().cloned().for_each(|listener| {
+                let shutdown_sender = shutdown_sender.clone();
+                let job_sender = job_sender.clone();
+                let nonblocking_sender = nonblocking_sender.clone();
+
+                let mut lifecycle_rx = subscribe_runtime_to_signals();
+                let mut shutdown_receiver = shutdown_sender.subscribe();
+                let mut acceptor = Acceptor {
+                    acceptor_args: Arc::new(AcceptorArgs {
+                        strategy: self.clone(),
+                        listener_info: listener.listener_info(),
+                        shutdown_receiver: shutdown_sender.subscribe(),
+                        job_sender: job_sender.clone(),
+                        nonblocking_sender: nonblocking_sender.clone(),
+                        server_params: server_params.clone(),
+                    }),
+                    join_set: JoinSet::new(),
+                };
+
+                let shutdown_rx_for_acme_task = shutdown_receiver.clone();
+                let acme_task_listener_clone = listener.clone();
+
+                let mut after_accept_wait: Option<Duration> = None::<Duration>;
+
+                if cfg!(target_os = "macos") {
+                    after_accept_wait = if server_params.workers > 1 {
+                        Some(Duration::from_nanos(10 * server_params.workers as u64))
+                    } else {
+                        None
+                    };
+                };
+
+                listener_task_set.spawn(async move {
+                    acme_task_listener_clone
+                        .spawn_acme_event_task(shutdown_rx_for_acme_task)
+                        .await;
+                });
+
+                listener_task_set.spawn(async move {
                     loop {
+                        // Process any pending signals before select
                         tokio::select! {
-                            accept_result = listener.accept() => match accept_result {
-                              Ok(accept_result) => {
-                                let strategy = strategy_clone.clone();
-                                let listener_info = listener_info.clone();
-                                let shutdown_receiver = shutdown_receiver.clone();
-                                let job_sender = job_sender.clone();
-                                let nonblocking_sender = nonblocking_sender.clone();
-                                acceptor_task_set.spawn(async move {
-                                  strategy.serve_connection(accept_result, job_sender, nonblocking_sender, listener_info, shutdown_receiver).await;
-                                });
-                              },
-                              Err(e) => debug!("Listener.accept failed {:?}", e),
+                            accept_result = listener.accept() => {
+                                match accept_result {
+                                    Ok(accepted) => acceptor.serve_connection(accepted).await,
+                                    Err(e) => debug!("Listener.accept failed: {:?}", e)
+                                }
+                                if cfg!(target_os = "macos") {
+                                  if let Some(after_accept_wait) = after_accept_wait{
+                                    tokio::time::sleep(after_accept_wait).await;
+                                  }
+                                }
                             },
                             _ = shutdown_receiver.changed() => {
-                              break;
-                            }
-                            lifecycle_event = lifecycle_rx.recv() => match lifecycle_event{
-                              Ok(LifecycleEvent::Shutdown) => {
-                                debug!("Received lifecycle event: {:?}", lifecycle_event);
-                                shutdown_sender.send(RunningPhase::ShutdownPending).unwrap();
-                                tokio::time::sleep(Duration::from_millis(25)).await;
-                                for _i in 0..workers_clone.len() {
-                                  job_sender.send(RequestJob::Shutdown).await.unwrap();
-                                  nonblocking_sender.send(RequestJob::Shutdown).await.unwrap();
-                                }
+                                debug!("Shutdown requested via receiver");
                                 break;
-                              },
-                              Err(e) => error!("Error receiving lifecycle_event: {:?}", e),
-                              _ => {}
-                          }
+                            },
+                            lifecycle_event = lifecycle_rx.recv() => {
+                                match lifecycle_event {
+                                    Ok(LifecycleEvent::Shutdown) => {
+                                        debug!("Received LifecycleEvent::Shutdown");
+                                        let _ = shutdown_sender.send(RunningPhase::ShutdownPending);
+                                        break;
+                                    },
+                                    Err(e) => {
+                                      debug!("Lifecycle channel closed: {:?}, exiting accept loop", e);
+                                      break
+                                    },
+                                    _ => ()
+                                }
+                            }
                         }
                     }
-
-                    let deadline = Instant::now()
-                        + Duration::from_secs_f64(self_ref.server_config.server_params.read().shutdown_timeout);
-                    tokio::select! {
-                        _ = async {
-                            while let Some(_res) = acceptor_task_set.join_next().await {}
-                        } => {},
-                        _ = tokio::time::sleep_until(tokio::time::Instant::from_std(deadline)) => {},
-                    }
+                    acceptor.join().await;
                 });
+            });
 
-              }
-
-              if self.is_single_mode() {
+            if self.is_single_mode() {
                 self.invoke_hook("after_start");
-              }
-
-              while let Some(_res) = listener_task_set.join_next().await {}
+            }
 
-              // Explicitly drop all listeners to ensure file descriptors are released
-              drop(tokio_listeners);
+            while let Some(_res) = listener_task_set.join_next().await {}
+            drop(tokio_listeners);
 
-              Ok::<(), ItsiError>(())
-          });
+            Ok::<(), ItsiError>(())
+        });
 
         debug!("Single mode runtime exited.");
 
+        for _i in 0..thread_workers.len() {
+            job_sender.send_blocking(RequestJob::Shutdown).unwrap();
+            nonblocking_sender
+                .send_blocking(RequestJob::Shutdown)
+                .unwrap();
+        }
         if result.is_err() {
-            for _i in 0..thread_workers.len() {
-                job_sender.send_blocking(RequestJob::Shutdown).unwrap();
-                nonblocking_sender
-                    .send_blocking(RequestJob::Shutdown)
-                    .unwrap();
-            }
-            self.lifecycle_channel.send(LifecycleEvent::Shutdown).ok();
+            send_lifecycle_event(LifecycleEvent::Shutdown);
         }
 
         shutdown_sender.send(RunningPhase::Shutdown).ok();
-        let deadline = Instant::now()
-            + Duration::from_secs_f64(self.server_config.server_params.read().shutdown_timeout);
-
         runtime.shutdown_timeout(Duration::from_millis(100));
+        unsubscribe_runtime();
 
         debug!("Shutdown timeout finished.");
+
+        let deadline = Instant::now() + Duration::from_secs_f64(shutdown_timeout);
         loop {
             if thread_workers
                 .iter()
@@ -381,86 +421,6 @@ impl SingleMode {
         self.server_config.server_params.read().workers == 1
     }
 
-    pub(crate) async fn serve_connection(
-        &self,
-        stream: IoStream,
-        job_sender: async_channel::Sender<RequestJob>,
-        nonblocking_sender: async_channel::Sender<RequestJob>,
-        listener: Arc<ListenerInfo>,
-        shutdown_channel: watch::Receiver<RunningPhase>,
-    ) {
-        let addr = stream.addr();
-        let io: TokioIo<Pin<Box<IoStream>>> = TokioIo::new(Box::pin(stream));
-        let executor = self.executor.clone();
-        let mut shutdown_channel_clone = shutdown_channel.clone();
-        let mut executor = executor.clone();
-        let mut binding = executor.http1();
-        let shutdown_channel = shutdown_channel_clone.clone();
-
-        let service = ItsiHttpService {
-            inner: Arc::new(ItsiHttpServiceInner {
-                sender: job_sender.clone(),
-                nonblocking_sender: nonblocking_sender.clone(),
-                server_params: self.server_config.server_params.read().clone(),
-                listener,
-                addr: addr.to_string(),
-                shutdown_channel: shutdown_channel.clone(),
-            }),
-        };
-        let mut serve = Box::pin(
-            binding
-                .timer(TokioTimer::new())
-                .header_read_timeout(self.server_config.server_params.read().header_read_timeout)
-                .serve_connection_with_upgrades(io, service),
-        );
-
-        tokio::select! {
-            // Await the connection finishing naturally.
-            res = &mut serve => {
-                match res{
-                    Ok(()) => {
-                      debug!("Connection closed normally")
-                    },
-                    Err(res) => {
-                      debug!("Connection closed abruptly: {:?}", res)
-                    }
-                }
-                serve.as_mut().graceful_shutdown();
-            },
-            // A lifecycle event triggers shutdown.
-            _ = shutdown_channel_clone.changed() => {
-                // Initiate graceful shutdown.
-                serve.as_mut().graceful_shutdown();
-
-                // Now await the connection to finish shutting down.
-                if let Err(e) = serve.await {
-                    debug!("Connection shutdown error: {:?}", e);
-                }
-            }
-        }
-    }
-
-    /// Attempts to reload the config "live"
-    /// Not that when running in single mode this will not unload
-    /// old code. If you need a clean restart, use the `restart` (SIGHUP) method instead
-    pub async fn reload(&self) -> Result<()> {
-        if !self.server_config.check_config().await {
-            return Ok(());
-        }
-        let should_reexec = self.server_config.clone().reload(false)?;
-        if should_reexec {
-            if self.is_single_mode() {
-                self.invoke_hook("before_restart");
-            }
-            self.server_config.dup_fds()?;
-            self.server_config.reload_exec()?;
-        }
-        self.restart_requested.store(true, Ordering::SeqCst);
-        self.stop()?;
-        self.server_config.server_params.read().preload_ruby()?;
-        Ok(())
-    }
-
     pub fn invoke_hook(&self, hook_name: &str) {
         if let Some(hook) = self.server_config.server_params.read().hooks.get(hook_name) {
             call_with_gvl(|_| hook.call::<_, Value>(()).ok());

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

@@ -1,22 +1,50 @@
-use std::sync::{
-    atomic::{AtomicBool, AtomicI8},
-    LazyLock,
+use std::{
+    collections::VecDeque,
+    sync::atomic::{AtomicBool, AtomicI8},
 };
 
 use nix::libc::{self, sighandler_t};
-use tokio::sync::{self, broadcast};
+use parking_lot::Mutex;
+use tokio::sync::broadcast;
 
 use super::lifecycle_event::LifecycleEvent;
 
 pub static SIGINT_COUNT: AtomicI8 = AtomicI8::new(0);
 pub static SHUTDOWN_REQUESTED: AtomicBool = AtomicBool::new(false);
-pub static SIGNAL_HANDLER_CHANNEL: LazyLock<(
-    broadcast::Sender<LifecycleEvent>,
-    broadcast::Receiver<LifecycleEvent>,
-)> = LazyLock::new(|| sync::broadcast::channel(5));
+pub static SIGNAL_HANDLER_CHANNEL: Mutex<Option<broadcast::Sender<LifecycleEvent>>> =
+    Mutex::new(None);
+
+pub static PENDING_QUEUE: Mutex<VecDeque<LifecycleEvent>> = Mutex::new(VecDeque::new());
+
+pub fn subscribe_runtime_to_signals() -> broadcast::Receiver<LifecycleEvent> {
+    let mut guard = SIGNAL_HANDLER_CHANNEL.lock();
+    if let Some(sender) = guard.as_ref() {
+        return sender.subscribe();
+    }
+    let (sender, receiver) = broadcast::channel(5);
+    let sender_clone = sender.clone();
+    std::thread::spawn(move || {
+        std::thread::sleep(std::time::Duration::from_millis(50));
+        for event in PENDING_QUEUE.lock().drain(..) {
+            sender_clone.send(event).ok();
+        }
+    });
+
+    guard.replace(sender);
+
+    receiver
+}
+
+pub fn unsubscribe_runtime() {
+    SIGNAL_HANDLER_CHANNEL.lock().take();
+}
 
 pub fn send_lifecycle_event(event: LifecycleEvent) {
-    SIGNAL_HANDLER_CHANNEL.0.send(event).ok();
+    if let Some(sender) = SIGNAL_HANDLER_CHANNEL.lock().as_ref() {
+        sender.send(event).ok();
+    } else {
+        PENDING_QUEUE.lock().push_back(event);
+    }
 }
 
 fn receive_signal(signum: i32, _: sighandler_t) {