itsi 0.1.7 → 0.1.9

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

@@ -1,6 +1,7 @@
 use super::bind::{Bind, BindAddress};
 use super::bind_protocol::BindProtocol;
 use super::io_stream::IoStream;
+use super::serve_strategy::single_mode::RunningPhase;
 use super::tls::ItsiTlsAcceptor;
 use itsi_error::{ItsiError, Result};
 use itsi_tracing::info;
@@ -11,6 +12,7 @@ use std::{os::unix::net::UnixListener, path::PathBuf};
 use tokio::net::TcpListener as TokioTcpListener;
 use tokio::net::UnixListener as TokioUnixListener;
 use tokio::net::{unix, TcpStream, UnixStream};
+use tokio::sync::watch::Receiver;
 use tokio_rustls::TlsAcceptor;
 use tokio_stream::StreamExt;
 use tracing::error;
@@ -23,45 +25,79 @@ pub(crate) enum Listener {
 }
 
 pub(crate) enum TokioListener {
-    Tcp {
-        listener: TokioTcpListener,
-        host: String,
-        port: u16,
-    },
-    TcpTls {
-        listener: TokioTcpListener,
-        acceptor: ItsiTlsAcceptor,
-        host: String,
-        port: u16,
-    },
-    Unix {
-        listener: TokioUnixListener,
-    },
-    UnixTls {
-        listener: TokioUnixListener,
-        acceptor: ItsiTlsAcceptor,
-    },
+    Tcp(TokioTcpListener),
+    TcpTls(TokioTcpListener, ItsiTlsAcceptor),
+    Unix(TokioUnixListener),
+    UnixTls(TokioUnixListener, ItsiTlsAcceptor),
+}
+
+#[derive(Debug, Clone)]
+pub struct ListenerInfo {
+    pub host: String,
+    pub port: u16,
+    pub scheme: String,
 }
 
 impl TokioListener {
-    pub fn unbind(self) {
+    pub fn listener_info(&self) -> ListenerInfo {
         match self {
-            TokioListener::Tcp { listener, .. } => drop(listener.into_std().unwrap()),
-            TokioListener::TcpTls { listener, .. } => drop(listener.into_std().unwrap()),
-            TokioListener::Unix { listener } => drop(listener.into_std().unwrap()),
-            TokioListener::UnixTls { listener, .. } => drop(listener.into_std().unwrap()),
-        };
+            TokioListener::Tcp(listener) => ListenerInfo {
+                host: listener
+                    .local_addr()
+                    .unwrap()
+                    .ip()
+                    .to_canonical()
+                    .to_string(),
+                port: listener.local_addr().unwrap().port(),
+                scheme: "http".to_string(),
+            },
+            TokioListener::TcpTls(listener, _) => ListenerInfo {
+                host: listener
+                    .local_addr()
+                    .unwrap()
+                    .ip()
+                    .to_canonical()
+                    .to_string(),
+                port: listener.local_addr().unwrap().port(),
+                scheme: "https".to_string(),
+            },
+            TokioListener::Unix(listener) => ListenerInfo {
+                host: listener
+                    .local_addr()
+                    .unwrap()
+                    .as_pathname()
+                    .unwrap()
+                    .to_str()
+                    .unwrap()
+                    .to_owned(),
+                port: 0,
+                scheme: "unix".to_string(),
+            },
+            TokioListener::UnixTls(listener, _) => ListenerInfo {
+                host: listener
+                    .local_addr()
+                    .unwrap()
+                    .as_pathname()
+                    .unwrap()
+                    .to_str()
+                    .unwrap()
+                    .to_owned(),
+                port: 0,
+                scheme: "ssl".to_string(),
+            },
+        }
     }
+
     pub(crate) async fn accept(&self) -> Result<IoStream> {
         match self {
-            TokioListener::Tcp { listener, .. } => TokioListener::accept_tcp(listener).await,
-            TokioListener::TcpTls {
-                listener, acceptor, ..
-            } => TokioListener::accept_tls(listener, acceptor).await,
-            TokioListener::Unix { listener, .. } => TokioListener::accept_unix(listener).await,
-            TokioListener::UnixTls {
-                listener, acceptor, ..
-            } => TokioListener::accept_unix_tls(listener, acceptor).await,
+            TokioListener::Tcp(listener) => TokioListener::accept_tcp(listener).await,
+            TokioListener::TcpTls(listener, acceptor) => {
+                TokioListener::accept_tls(listener, acceptor).await
+            }
+            TokioListener::Unix(listener) => TokioListener::accept_unix(listener).await,
+            TokioListener::UnixTls(listener, acceptor) => {
+                TokioListener::accept_unix_tls(listener, acceptor).await
+            }
         }
     }
 
@@ -70,17 +106,24 @@ impl TokioListener {
         Self::to_tokio_io(Stream::TcpStream(tcp_stream), None).await
     }
 
-    pub async fn spawn_state_task(&self) {
-        if let TokioListener::TcpTls {
-            acceptor: ItsiTlsAcceptor::Automatic(_acme_acceptor, state, _server_config),
-            ..
-        } = self
+    pub async fn spawn_state_task(&self, mut shutdown_receiver: Receiver<RunningPhase>) {
+        if let TokioListener::TcpTls(
+            _,
+            ItsiTlsAcceptor::Automatic(_acme_acceptor, state, _server_config),
+        ) = self
         {
             let mut state = state.lock().await;
             loop {
-                match StreamExt::next(&mut *state).await {
-                    Some(event) => info!("Received acme event: {:?}", event),
-                    None => error!("Received no acme event"),
+                tokio::select! {
+                  stream_event = StreamExt::next(&mut *state) => {
+                      match stream_event {
+                        Some(event) => info!("ACME Event: {:?}", event),
+                        None => error!("Received no acme event"),
+                      }
+                  },
+                  _ = shutdown_receiver.changed() => {
+                      break;
+                  }
                 }
             }
         }
@@ -175,33 +218,6 @@ impl TokioListener {
             },
         }
     }
-
-    pub(crate) fn scheme(&self) -> String {
-        match self {
-            TokioListener::Tcp { .. } => "http".to_string(),
-            TokioListener::TcpTls { .. } => "https".to_string(),
-            TokioListener::Unix { .. } => "http".to_string(),
-            TokioListener::UnixTls { .. } => "https".to_string(),
-        }
-    }
-
-    pub(crate) fn port(&self) -> u16 {
-        match self {
-            TokioListener::Tcp { port, .. } => *port,
-            TokioListener::TcpTls { port, .. } => *port,
-            TokioListener::Unix { .. } => 0,
-            TokioListener::UnixTls { .. } => 0,
-        }
-    }
-
-    pub(crate) fn host(&self) -> String {
-        match self {
-            TokioListener::Tcp { host, .. } => host.to_string(),
-            TokioListener::TcpTls { host, .. } => host.to_string(),
-            TokioListener::Unix { .. } => "unix".to_string(),
-            TokioListener::UnixTls { .. } => "unix".to_string(),
-        }
-    }
 }
 
 enum Stream {
@@ -227,48 +243,22 @@ impl std::fmt::Display for SockAddr {
 }
 
 impl Listener {
-    pub fn unbind(self) {
-        match self {
-            Listener::Tcp(listener) => drop(listener),
-            Listener::TcpTls((listener, _)) => drop(listener),
-            Listener::Unix(listener) => drop(listener),
-            Listener::UnixTls((listener, _)) => drop(listener),
-        };
-    }
     pub fn to_tokio_listener(&self) -> TokioListener {
         match self {
-            Listener::Tcp(listener) => TokioListener::Tcp {
-                listener: TokioTcpListener::from_std(TcpListener::try_clone(listener).unwrap())
-                    .unwrap(),
-                host: listener
-                    .local_addr()
-                    .unwrap()
-                    .ip()
-                    .to_canonical()
-                    .to_string(),
-                port: listener.local_addr().unwrap().port(),
-            },
-            Listener::TcpTls((listener, acceptor)) => TokioListener::TcpTls {
-                listener: TokioTcpListener::from_std(TcpListener::try_clone(listener).unwrap())
-                    .unwrap(),
-                acceptor: acceptor.clone(),
-                host: listener
-                    .local_addr()
-                    .unwrap()
-                    .ip()
-                    .to_canonical()
-                    .to_string(),
-                port: listener.local_addr().unwrap().port(),
-            },
-            Listener::Unix(listener) => TokioListener::Unix {
-                listener: TokioUnixListener::from_std(UnixListener::try_clone(listener).unwrap())
-                    .unwrap(),
-            },
-            Listener::UnixTls((listener, acceptor)) => TokioListener::UnixTls {
-                listener: TokioUnixListener::from_std(UnixListener::try_clone(listener).unwrap())
-                    .unwrap(),
-                acceptor: acceptor.clone(),
-            },
+            Listener::Tcp(listener) => TokioListener::Tcp(
+                TokioTcpListener::from_std(TcpListener::try_clone(listener).unwrap()).unwrap(),
+            ),
+            Listener::TcpTls((listener, acceptor)) => TokioListener::TcpTls(
+                TokioTcpListener::from_std(TcpListener::try_clone(listener).unwrap()).unwrap(),
+                acceptor.clone(),
+            ),
+            Listener::Unix(listener) => TokioListener::Unix(
+                TokioUnixListener::from_std(UnixListener::try_clone(listener).unwrap()).unwrap(),
+            ),
+            Listener::UnixTls((listener, acceptor)) => TokioListener::UnixTls(
+                TokioUnixListener::from_std(UnixListener::try_clone(listener).unwrap()).unwrap(),
+                acceptor.clone(),
+            ),
         }
     }
 }
@@ -307,6 +297,7 @@ fn connect_tcp_socket(addr: IpAddr, port: u16) -> Result<TcpListener> {
     socket.set_nonblocking(true).ok();
     socket.set_nodelay(true).ok();
     socket.set_recv_buffer_size(262_144).ok();
+    info!("Binding to {:?}", socket_address);
     socket.bind(&socket_address.into())?;
     socket.listen(1024)?;
     Ok(socket.into())

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

@@ -4,7 +4,7 @@ use crate::{
         io_stream::IoStream,
         itsi_server::{RequestJob, Server},
         lifecycle_event::LifecycleEvent,
-        listener::{Listener, TokioListener},
+        listener::{Listener, ListenerInfo},
         thread_worker::{build_thread_workers, ThreadWorker},
     },
 };
@@ -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(())
     }
 
@@ -87,18 +93,28 @@ impl SingleMode {
     pub fn run(self: Arc<Self>) -> Result<()> {
         let mut listener_task_set = JoinSet::new();
         let self_ref = Arc::new(self);
-        self_ref.build_runtime().block_on(async {
+        let runtime = self_ref.build_runtime();
 
-          for listener in self_ref.listeners.clone().iter() {
-              let listener = Arc::new(listener.to_tokio_listener());
+        runtime.block_on(async {
+          let tokio_listeners = self_ref
+              .listeners
+              .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();
 
-              tokio::spawn(async move {
-                listener_clone.spawn_state_task().await;
+
+              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;
               });
 
               listener_task_set.spawn(async move {
@@ -107,8 +123,11 @@ impl SingleMode {
                     tokio::select! {
                         accept_result = listener.accept() => match accept_result {
                           Ok(accept_result) => {
-                            if let Err(e) = strategy.serve_connection(accept_result, listener.clone(), shutdown_receiver.clone()).await {
-                              error!("Error in serve_connection {:?}", e)
+                            match strategy.serve_connection(accept_result, listener_info.clone(), shutdown_receiver.clone()).await {
+                              Ok(_) => {
+                                debug!("Connection accepted and served");
+                              },
+                              Err(e) => error!("Error in serve_connection {:?}", e)
                             }
                           },
                           Err(e) => debug!("Listener.accept failed {:?}", e),
@@ -130,24 +149,24 @@ impl SingleMode {
                       }
                     }
                 }
-                if let Ok(listener) = Arc::try_unwrap(listener){
-                  listener.unbind();
-                }
             });
 
           }
 
           while let Some(_res) = listener_task_set.join_next().await {}
+
         });
+        runtime.shutdown_timeout(Duration::from_millis(100));
 
+        info!("Runtime has shut down");
         Ok(())
     }
 
     pub(crate) async fn serve_connection(
         &self,
         stream: IoStream,
-        listener: Arc<TokioListener>,
-        shutdown_channel: tokio::sync::watch::Receiver<RunningPhase>,
+        listener: Arc<ListenerInfo>,
+        shutdown_channel: watch::Receiver<RunningPhase>,
     ) -> Result<()> {
         let sender_clone = self.sender.clone();
         let addr = stream.addr();
@@ -209,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;
@@ -233,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);
             });

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

@@ -10,6 +10,13 @@ pub static SIGNAL_HANDLER_CHANNEL: LazyLock<(
     broadcast::Receiver<LifecycleEvent>,
 )> = LazyLock::new(|| sync::broadcast::channel(5));
 
+pub fn send_shutdown_event() {
+    SIGNAL_HANDLER_CHANNEL
+        .0
+        .send(LifecycleEvent::Shutdown)
+        .expect("Failed to send shutdown event");
+}
+
 pub static SIGINT_COUNT: AtomicI8 = AtomicI8::new(0);
 fn receive_signal(signum: i32, _: sighandler_t) {
     SIGINT_COUNT.fetch_add(-1, std::sync::atomic::Ordering::SeqCst);

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

@@ -1,7 +1,7 @@
 use super::itsi_server::RequestJob;
 use crate::{request::itsi_request::ItsiRequest, ITSI_SERVER};
 use itsi_rb_helpers::{
-    call_with_gvl, call_without_gvl, create_ruby_thread, kill_threads, HeapValue,
+    call_with_gvl, call_without_gvl, create_ruby_thread, kill_threads, HeapVal, HeapValue,
 };
 use itsi_tracing::{debug, error, info, warn};
 use magnus::{
@@ -52,7 +52,7 @@ pub struct TerminateWakerSignal(bool);
 pub fn build_thread_workers(
     pid: Pid,
     threads: NonZeroU8,
-    app: Opaque<Value>,
+    app: HeapVal,
     scheduler_class: Option<String>,
 ) -> Result<(Arc<Vec<ThreadWorker>>, async_channel::Sender<RequestJob>)> {
     let (sender, receiver) = async_channel::bounded(20);
@@ -79,11 +79,10 @@ pub fn build_thread_workers(
 }
 
 pub fn load_app(
-    app: Opaque<Value>,
+    app: HeapVal,
     scheduler_class: Option<String>,
 ) -> Result<(Opaque<Value>, Option<Opaque<Value>>)> {
     call_with_gvl(|ruby| {
-        let app = app.get_inner_with(&ruby);
         let app = Opaque::from(
             app.funcall::<_, _, Value>(*ID_CALL, ())
                 .expect("Couldn't load app"),

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);
 
@@ -186,7 +189,15 @@ pub fn load_private_key(path: &str) -> PrivateKeyDer<'static> {
 pub fn generate_ca_signed_cert(
     domains: Vec<String>,
 ) -> Result<(Vec<CertificateDer<'static>>, PrivateKeyDer<'static>)> {
-    info!("Generating New Itsi CA - Self signed Certificate. Use `itsi ca export` to export the CA certificate for import into your local trust store.");
+    info!(
+        domains = format!("{}", domains.join(", ")),
+        "Self signed cert",
+    );
+    info!(
+        "Add {} to your system's trusted cert store to resolve certificate errors.",
+        format!("{}/itsi_dev_ca.crt", ITSI_LOCAL_CA_DIR.to_str().unwrap())
+    );
+    info!("Dev CA path can be overridden by setting env var: `ITSI_LOCAL_CA_DIR`.");
     let (ca_key_pem, ca_cert_pem) = get_or_create_local_dev_ca()?;
 
     let ca_kp = KeyPair::from_pem(&ca_key_pem).expect("Failed to load CA key");
@@ -198,10 +209,6 @@ pub fn generate_ca_signed_cert(
     let ee_key = KeyPair::generate_for(&rcgen::PKCS_ECDSA_P256_SHA256).unwrap();
     let mut ee_params = CertificateParams::default();
 
-    info!(
-        "Generated certificate will be valid for domains {:?}",
-        domains
-    );
     use std::net::IpAddr;
 
     ee_params.subject_alt_names = domains

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.7"
+    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