itsi 0.1.7 → 0.1.9

data/crates/itsi_server/Cargo.toml

@@ -19,6 +19,7 @@ parking_lot = "0.12.3"
 rustls-pemfile = "2.2.0"
 tokio-rustls = "0.26.2"
 bytes = "1.3"
+tokio-rustls-acme = "0.6.0"
 rcgen = { version = "0.13.2", features = ["x509-parser", "pem"] }
 base64 = "0.22.1"
 http-body-util = "0.1.2"
@@ -39,7 +40,6 @@ httparse = "1.10.1"
 async-channel = "2.3.1"
 tempfile = "3.18.0"
 sysinfo = "0.33.1"
-tokio-rustls-acme = "0.6.0"
 rustls = "0.23.23"
 fs2 = "0.4.3"
 ring = "0.17.14"

data/crates/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/crates/itsi_server/src/request/itsi_request.rs

@@ -6,14 +6,14 @@ use crate::{
     response::itsi_response::ItsiResponse,
     server::{
         itsi_server::{RequestJob, Server},
-        listener::{SockAddr, TokioListener},
+        listener::{ListenerInfo, SockAddr},
         serve_strategy::single_mode::RunningPhase,
     },
 };
 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;
@@ -44,11 +44,12 @@ pub struct ItsiRequest {
     pub remote_addr: String,
     pub version: String,
     #[debug(skip)]
-    pub(crate) listener: Arc<TokioListener>,
+    pub(crate) listener: Arc<ListenerInfo>,
     #[debug(skip)]
     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,
@@ -128,7 +137,7 @@ impl ItsiRequest {
         hyper_request: Request<Incoming>,
         sender: async_channel::Sender<RequestJob>,
         server: Arc<Server>,
-        listener: Arc<TokioListener>,
+        listener: Arc<ListenerInfo>,
         addr: SockAddr,
         shutdown_rx: watch::Receiver<RunningPhase>,
     ) -> itsi_error::Result<Response<BoxBody<Bytes, Infallible>>> {
@@ -153,7 +162,7 @@ impl ItsiRequest {
         request: Request<Incoming>,
         sock_addr: SockAddr,
         server: Arc<Server>,
-        listener: Arc<TokioListener>,
+        listener: Arc<ListenerInfo>,
     ) -> (ItsiRequest, mpsc::Receiver<Option<Bytes>>) {
         let (parts, body) = request.into_parts();
         let body = if server.stream_body.is_some_and(|f| f) {
@@ -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,
@@ -231,7 +259,7 @@ impl ItsiRequest {
             .uri
             .host()
             .map(|host| host.to_string())
-            .unwrap_or_else(|| self.listener.host()))
+            .unwrap_or_else(|| self.listener.host.clone()))
     }
 
     pub(crate) fn scheme(&self) -> MagnusResult<String> {
@@ -240,7 +268,7 @@ impl ItsiRequest {
             .uri
             .scheme()
             .map(|scheme| scheme.to_string())
-            .unwrap_or_else(|| self.listener.scheme()))
+            .unwrap_or_else(|| self.listener.scheme.clone()))
     }
 
     pub(crate) fn headers(&self) -> MagnusResult<Vec<(String, &str)>> {
@@ -264,7 +292,7 @@ impl ItsiRequest {
     }
 
     pub(crate) fn port(&self) -> MagnusResult<u16> {
-        Ok(self.parts.uri.port_u16().unwrap_or(self.listener.port()))
+        Ok(self.parts.uri.port_u16().unwrap_or(self.listener.port))
     }
 
     pub(crate) fn body(&self) -> MagnusResult<Value> {

data/crates/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/crates/itsi_server/src/server/bind.rs

@@ -9,6 +9,7 @@ use std::{
     path::PathBuf,
     str::FromStr,
 };
+
 #[derive(Debug, Clone)]
 pub enum BindAddress {
     Ip(IpAddr),
@@ -129,13 +130,13 @@ impl FromStr for Bind {
             BindProtocol::Unix => None,
             BindProtocol::Unixs => Some(configure_tls(host, &options)?),
         };
-
-        Ok(Self {
+        let bind = Self {
             address,
             port,
             protocol,
             tls_config,
-        })
+        };
+        Ok(bind)
     }
 }
 

data/crates/itsi_server/src/server/itsi_server.rs

@@ -2,24 +2,26 @@ 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};
 
-static DEFAULT_BIND: &str = "localhost:3000";
+static DEFAULT_BIND: &str = "http://localhost:3000";
 
 #[magnus::wrap(class = "Itsi::Server", free_immediately, size)]
 #[derive(Clone)]
@@ -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,31 +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(())
         })?;
-        if let Ok(listeners) = Arc::try_unwrap(listeners) {
-            listeners.into_iter().for_each(|listener| {
-                if let Ok(listener) = Arc::try_unwrap(listener) {
-                    listener.unbind()
-                };
-            });
-        }
         clear_signal_handlers();
+        self.strategy.write().take();
+        info!("Server stopped");
         Ok(())
     }
 }