itsi-server 0.1.8 → 0.1.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9c791653e9cd4ad12e4cca1c5673cfcb8f1838d1365d5c55acfd7caf7e1b508b
-  data.tar.gz: f8457b766bab580b2fb7128bc1437ee95f8e9509f7edc4b547fdca3d4e6c98df
+  metadata.gz: 479b2a6c1ed83ad8996367e19ca025b9b53172a66a143128eb2399c98a1b2f7d
+  data.tar.gz: '0687d23ed59b8a9fe81055d85c74cb374b679eae6025a9c89307591cf881a7bf'
 SHA512:
-  metadata.gz: afe673bfe7f60f8f70216aed28a044caeb6855e91d820618c343c4a18a4e2c18e436a7bee80205a51b14f26ce1a8fb165f585c5179a61947e59cb833736f81cc
-  data.tar.gz: dff7d5e6f0b65314004a1cc257c998a7ea0040f618a378b8624ddc4b0635a0d12f382e84c8c0770b2153ba95f0e166a773ceddd1c6517f4620aadf24bebc508b
+  metadata.gz: 0b6ee383356c06fb6dfe62f3f1a2c9e631d584246f300ad3b6eb2b507f508099560c97d661cedf762553b6d062d6daece0ec9c7244971d1576be929b1e2cbad2
+  data.tar.gz: 78045f8853d52c243b8a458dc46d85199daf8a6c15984492644826c3fa0c5edfdd61f8842892b03a887c85441f5ce96ae67d05fe8f85f0db5370a31732f3272c

data/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/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/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/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/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/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/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);
             });

data/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/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/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/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/lib/itsi/request.rb

@@ -1,17 +1,16 @@
 # frozen_string_literal: true
 
+require "stringio"
+require "socket"
+
 module Itsi
   class Request
-    require "stringio"
-    require "socket"
-
     attr_accessor :hijacked
 
-    def to_env
+    def to_rack_env
       path = self.path
       host = self.host
       version = self.version
-      body = self.body
       {
         "SERVER_SOFTWARE" => "Itsi",
         "SCRIPT_NAME" => script_name,
@@ -25,31 +24,40 @@ module Itsi
         "HTTP_HOST" => host,
         "SERVER_PROTOCOL" => version,
         "HTTP_VERSION" => version,
+        "itsi.request" => self,
+        "itsi.response" => response,
         "rack.version" => [version],
         "rack.url_scheme" => scheme,
-        "rack.input" => \
-          case body
-          when Array then File.open(body.first, "rb")
-          when String then StringIO.new(body)
-          else body
-          end,
+        "rack.input" => build_input_io,
         "rack.errors" => $stderr,
         "rack.multithread" => true,
         "rack.multiprocess" => true,
         "rack.run_once" => false,
         "rack.hijack?" => true,
         "rack.multipart.buffer_size" => 16_384,
-        "rack.hijack" => lambda do
-          self.hijacked = true
-          UNIXSocket.pair.yield_self do |(server_sock, app_sock)|
-            response.hijack(server_sock.fileno)
-            server_sock.sync = true
-            app_sock.sync = true
-            app_sock.instance_variable_set("@server_sock", server_sock)
-            app_sock
-          end
-        end
+        "rack.hijack" => build_hijack_proc
       }.tap { |r| headers.each { |(k, v)| r[k] = v } }
     end
+
+    def build_hijack_proc
+      lambda do
+        self.hijacked = true
+        UNIXSocket.pair.yield_self do |(server_sock, app_sock)|
+          response.hijack(server_sock.fileno)
+          server_sock.sync = true
+          app_sock.sync = true
+          app_sock.instance_variable_set("@server_sock", server_sock)
+          app_sock
+        end
+      end
+    end
+
+    def build_input_io
+      case body
+      when Array then File.open(body.first, "rb")
+      when String then StringIO.new(body)
+      else body
+      end
+    end
   end
 end

data/lib/itsi/server/rack/handler/itsi.rb

@@ -3,13 +3,12 @@ return unless defined?(::Rackup::Handler) || defined?(Rack::Handler)
 module Rack
   module Handler
     module Itsi
-
       def self.run(app, options = {})
         ::Itsi::Server.new(
-          app: ->{ app },
-          binds: ["#{options.fetch(:host, "127.0.0.1")}:#{options.fetch(:Port, 3001)}"],
+          app: -> { app },
+          binds: ["http://#{options.fetch(:host, "127.0.0.1")}:#{options.fetch(:Port, 3001)}"],
           workers: options.fetch(:workers, 1),
-          threads: options.fetch(:threads, 1),
+          threads: options.fetch(:threads, 1)
         ).start
       end
     end

data/lib/itsi/server/rack_interface.rb

@@ -0,0 +1,79 @@
+module Itsi
+  class Server
+    module RackInterface
+      # Interface to Rack applications.
+      # Here we build the env, and invoke the Rack app's call method.
+      # We then turn the Rack response into something Itsi server understands.
+      def call(app, request)
+        respond request, app.call(request.to_rack_env)
+      end
+
+      # Itsi responses are asynchronous and can be streamed.
+      # Response chunks are sent using response.send_frame
+      # and the response is finished using response.close_write.
+      # If only a single chunk is written, you can use the #send_and_close method.
+      def respond(request, (status, headers, body))
+        response = request.response
+
+        # Don't try and respond if we've been hijacked.
+        # The hijacker is now responsible for this.
+        return if request.hijacked
+
+        # 1. Set Status
+        response.status = status
+
+        # 2. Set Headers
+        body_streamer = streaming_body?(body) ? body : headers.delete("rack.hijack")
+        headers.each do |key, value|
+          next response.add_header(key, value) unless value.is_a?(Array)
+
+          value.each do |v|
+            response.add_header(key, v)
+          end
+        end
+
+        # 3. Set Body
+        # As soon as we start setting the response
+        # the server will begin to stream it to the client.
+
+        # If we're partially hijacked or returned a streaming body,
+        # stream this response.
+
+        if body_streamer
+          body_streamer.call(StreamIO.new(response))
+
+        # If we're enumerable with more than one chunk
+        # also stream, otherwise write in a single chunk
+        elsif body.respond_to?(:each) || body.respond_to?(:to_ary)
+          unless body.respond_to?(:each)
+            body = body.to_ary
+            raise "Body #to_ary didn't return an array" unless body.is_a?(Array)
+          end
+          # We offset this iteration intentionally,
+          # to optimize for the case where there's only one chunk.
+          buffer = nil
+          body.each do |part|
+            response.send_frame(buffer.to_s) if buffer
+            buffer = part
+          end
+
+          begin
+            response.send_and_close(buffer.to_s)
+          rescue StandardError
+            binding.b
+          end
+        else
+          response.send_and_close(body.to_s)
+        end
+      ensure
+        response.close_write
+        body.close if body.respond_to?(:close)
+      end
+
+      # A streaming body is one that responds to #call and not #each.
+      def streaming_body?(body)
+        body.respond_to?(:call) && !body.respond_to?(:each)
+      end
+    end
+  end
+end

data/lib/itsi/server/scheduler_interface.rb

@@ -0,0 +1,21 @@
+module Itsi
+  class Server
+    module SchedulerInterface
+      # Simple wrapper to instantiate a scheduler, start it,
+      # and immediate have it invoke a scheduler proc
+      def start_scheduler_loop(scheduler_class, scheduler_task)
+        scheduler = scheduler_class.new
+        Fiber.set_scheduler(scheduler)
+        [scheduler, Fiber.schedule(&scheduler_task)]
+      end
+
+      # When running in scheduler mode,
+      # each request is wrapped in a Fiber.
+      def schedule(app, request)
+        Fiber.schedule do
+          call(app, request)
+        end
+      end
+    end
+  end
+end

data/lib/itsi/server/signal_trap.rb

@@ -0,0 +1,24 @@
+module Itsi
+  module SignalTrap
+
+    DEFAULT_SIGNALS = ["DEFAULT", "", nil].freeze
+    INTERCEPTED_SIGNALS = ["INT"].freeze
+
+    def trap(signal, *args, &block)
+      unless INTERCEPTED_SIGNALS.include?(signal.to_s) && block.nil? && Itsi::Server.running?
+        return super(signal, *args, &block)
+      end
+
+      Itsi::Server.reset_signal_handlers
+      nil
+    end
+  end
+end
+
+[Kernel, Signal].each do |receiver|
+  receiver.singleton_class.prepend(Itsi::SignalTrap)
+end
+
+[Object].each do |receiver|
+  receiver.include(Itsi::SignalTrap)
+end

data/lib/itsi/server/version.rb

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

data/lib/itsi/server.rb

@@ -2,119 +2,85 @@
 
 require_relative "server/version"
 require_relative "server/itsi_server"
-require_relative "signals"
+require_relative "server/rack_interface"
+require_relative "server/signal_trap"
+require_relative "server/scheduler_interface"
+require_relative "server/rack/handler/itsi"
 require_relative "request"
 require_relative "stream_io"
-require_relative "server/rack/handler/itsi"
-require 'erb'
 
-DEFAULT_INDEX = IO.read(__dir__ + '/index.html.erb')
+# When you Run Itsi without a Rack app,
+# we start a tiny
+DEFAULT_INDEX = IO.read("#{__dir__}/index.html").freeze
+DEFAULT_BINDS = ["http://0.0.0.0:3000"].freeze
+DEFAULT_APP = lambda {
+  require "json"
+  lambda do |env|
+    headers, body = \
+      if env["itsi.response"].json?
+        [
+          { "Content-Type" => "application/json" },
+          [{ "message" => "You're running on Itsi!", "rack_env" => env,
+             "version" => Itsi::Server::VERSION }.to_json]
+        ]
+      else
+        [
+          { "Content-Type" => "text/html" },
+          [
+            format(
+              DEFAULT_INDEX,
+              REQUEST_METHOD: env["REQUEST_METHOD"],
+              PATH_INFO: env["PATH_INFO"],
+              SERVER_NAME: env["SERVER_NAME"],
+              SERVER_PORT: env["SERVER_PORT"],
+              REMOTE_ADDR: env["REMOTE_ADDR"],
+              HTTP_USER_AGENT: env["HTTP_USER_AGENT"]
+            )
+          ]
+        ]
+      end
+    [200, headers, body]
+  end
+}
 
 module Itsi
   class Server
+    extend RackInterface
+    extend SchedulerInterface
 
-    def self.running?
-      @running ||= false
-    end
-
-    def self.start(
-      app: ->(env){
-        [env['CONTENT_TYPE'], env['HTTP_ACCEPT']].include?('application/json') ?
-          [200, {"Content-Type" => "application/json"}, ["{\"message\": \"You're running on Itsi!\"}"]] :
-          [200, {"Content-Type" => "text/html"}, [
-            DEFAULT_INDEX % {
-              REQUEST_METHOD: env['REQUEST_METHOD'],
-              PATH_INFO: env['PATH_INFO'],
-              SERVER_NAME: env['SERVER_NAME'],
-              SERVER_PORT: env['SERVER_PORT'],
-              REMOTE_ADDR: env['REMOTE_ADDR'],
-              HTTP_USER_AGENT: env['HTTP_USER_AGENT']
-            }
-          ]]
-      },
-      binds: ['http://0.0.0.0:3000'],
-      **opts
-    )
-      server = new(app: ->{app}, binds: binds, **opts)
-      @running = true
-      Signal.trap('INT', 'DEFAULT')
-      server.start
-    ensure
-      @running = false
-    end
-
-    def self.call(app, request)
-      respond request, app.call(request.to_env)
-    end
-
-    def self.streaming_body?(body)
-      body.respond_to?(:call) && !body.respond_to?(:each)
-    end
-
-    def self.respond(request, (status, headers, body))
-      response = request.response
-
-      # Don't try and respond if we've been hijacked.
-      # The hijacker is now responsible for this.
-      return if request.hijacked
-
-      # 1. Set Status
-      response.status = status
-
-      # 2. Set Headers
-      headers.each do |key, value|
-        next response.add_header(key, value) unless value.is_a?(Array)
-
-        value.each do |v|
-          response.add_header(key, v)
-        end
+    class << self
+      def running?
+        !!@running
       end
 
-      # 3. Set Body
-      # As soon as we start setting the response
-      # the server will begin to stream it to the client.
-
-      # If we're partially hijacked or returned a streaming body,
-      # stream this response.
-
-      if (body_streamer = streaming_body?(body) ? body : headers.delete("rack.hijack"))
-        body_streamer.call(StreamIO.new(response))
-
-      # If we're enumerable with more than one chunk
-      # also stream, otherwise write in a single chunk
-      elsif body.respond_to?(:each) || body.respond_to?(:to_ary)
-        unless body.respond_to?(:each)
-          body = body.to_ary
-          raise "Body #to_ary didn't return an array" unless body.is_a?(Array)
-        end
-        # We offset this iteration intentionally,
-        # to optimize for the case where there's only one chunk.
-        buffer = nil
-        body.each do |part|
-          response.send_frame(buffer.to_s) if buffer
-          buffer = part
-        end
-
-        response.send_and_close(buffer.to_s)
-      else
-        response.send_and_close(body.to_s)
+      def build(
+        app: DEFAULT_APP[],
+        binds: DEFAULT_BINDS,
+        **opts
+      )
+        new(app: -> { app }, binds: binds, **opts)
       end
-    ensure
-      response.close_write
-      body.close if body.respond_to?(:close)
-    end
 
-    def self.start_scheduler_loop(scheduler_class, scheduler_task)
-      scheduler = scheduler_class.new
-      Fiber.set_scheduler(scheduler)
-      [scheduler, Fiber.schedule(&scheduler_task)]
-    end
+      def start_in_background_thread(silence: true, **opts)
+        start(background: true, silence: silence, **opts)
+      end
 
-    # If scheduler is enabled
-    # Each request is wrapped in a Fiber.
-    def self.schedule(app, request)
-      Fiber.schedule do
-        call(app, request)
+      def start(background: false, **opts)
+        build(**opts).tap do |server|
+          previous_handler = Signal.trap("INT", "DEFAULT")
+          @running = true
+          if background
+            Thread.new do
+              server.start
+              @running = false
+              Signal.trap("INT", previous_handler)
+            end
+          else
+            server.start
+            @running = false
+            Signal.trap("INT", previous_handler)
+          end
+        end
       end
     end
   end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: itsi-server
 version: !ruby/object:Gem::Version
-  version: 0.1.8
+  version: 0.1.9
 platform: ruby
 authors:
 - Wouter Coppieters
 bindir: exe
 cert_chain: []
-date: 2025-03-15 00:00:00.000000000 Z
+date: 2025-03-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -102,13 +102,15 @@ files:
 - ext/itsi_tracing/Cargo.lock
 - ext/itsi_tracing/Cargo.toml
 - ext/itsi_tracing/src/lib.rs
-- lib/itsi/index.html.erb
+- lib/itsi/index.html
 - lib/itsi/request.rb
 - lib/itsi/server.rb
 - lib/itsi/server/rack/handler/itsi.rb
+- lib/itsi/server/rack_interface.rb
+- lib/itsi/server/scheduler_interface.rb
 - lib/itsi/server/scheduler_mode.rb
+- lib/itsi/server/signal_trap.rb
 - lib/itsi/server/version.rb
-- lib/itsi/signals.rb
 - lib/itsi/stream_io.rb
 - sig/itsi_server.rbs
 homepage: https://itsi.fyi

data/lib/itsi/signals.rb

@@ -1,23 +0,0 @@
-module Itsi
-  module Signals
-    DEFAULT_SIGNALS = ["DEFAULT", ""].freeze
-    module SignalTrap
-      def self.trap(signal, *args, &block)
-        if DEFAULT_SIGNALS.include?(command.to_s) && block.nil?
-          Itsi::Server.reset_signal_handlers
-          nil
-        else
-          super(signal, *args, &block)
-        end
-      end
-    end
-  end
-end
-
-[Kernel, Signal].each do |receiver|
-  receiver.singleton_class.prepend(Itsi::Signals::SignalTrap)
-end
-
-[Object].each do |receiver|
-  receiver.include(Itsi::Signals::SignalTrap)
-end