itsi 0.1.11 → 0.1.12

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

@@ -1,174 +0,0 @@
-use super::{
-    bind_protocol::BindProtocol,
-    tls::{configure_tls, ItsiTlsAcceptor},
-};
-use itsi_error::ItsiError;
-use std::{
-    collections::HashMap,
-    net::{IpAddr, Ipv4Addr, Ipv6Addr, ToSocketAddrs},
-    path::PathBuf,
-    str::FromStr,
-};
-
-#[derive(Debug, Clone)]
-pub enum BindAddress {
-    Ip(IpAddr),
-    UnixSocket(PathBuf),
-}
-
-impl Default for BindAddress {
-    fn default() -> Self {
-        BindAddress::Ip(IpAddr::V4(Ipv4Addr::UNSPECIFIED))
-    }
-}
-
-#[derive(Default, Clone)]
-#[magnus::wrap(class = "Itsi::Bind")]
-pub struct Bind {
-    pub address: BindAddress,
-    pub port: Option<u16>, // None for Unix Sockets
-    pub protocol: BindProtocol,
-    pub tls_config: Option<ItsiTlsAcceptor>,
-}
-
-impl std::fmt::Debug for Bind {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match &self.address {
-            BindAddress::Ip(ip) => match self.protocol {
-                BindProtocol::Unix | BindProtocol::Unixs => {
-                    write!(f, "{}://{}", self.protocol, ip)
-                }
-                BindProtocol::Https if self.port == Some(443) => {
-                    write!(f, "{}://{}", self.protocol, ip)
-                }
-                BindProtocol::Http if self.port == Some(80) => {
-                    write!(f, "{}://{}", self.protocol, ip)
-                }
-                _ => match self.port {
-                    Some(port) => write!(f, "{}://{}:{}", self.protocol, ip, port),
-                    None => write!(f, "{}://{}", self.protocol, ip),
-                },
-            },
-            BindAddress::UnixSocket(path) => {
-                write!(f, "{}://{}", self.protocol, path.display())
-            }
-        }
-    }
-}
-
-/// We can build a Bind from a string in the format `protocol://host:port?options`
-/// E.g.
-/// *`https://example.com:443?tls_cert=/path/to/cert.pem&tls_key=/path/to/key.pem`
-/// *`unix:///path/to/socket.sock`
-/// *`http://example.com:80`
-/// *`https://[::]:80`
-impl FromStr for Bind {
-    type Err = ItsiError;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let (protocol, remainder) = if let Some((proto, rest)) = s.split_once("://") {
-            (proto.parse::<BindProtocol>()?, rest)
-        } else {
-            (BindProtocol::Https, s)
-        };
-
-        let (url, options) = if let Some((base, options)) = remainder.split_once('?') {
-            (base, parse_bind_options(options))
-        } else {
-            (remainder, HashMap::new())
-        };
-
-        let (host, port) = if url.starts_with('[') {
-            // IPv6 with brackets `[::]:port`
-            if let Some(end) = url.find(']') {
-                let host = &url[1..end]; // Extract `::`
-                let port = url[end + 1..]
-                    .strip_prefix(':')
-                    .and_then(|p| p.parse().ok());
-                (host, port)
-            } else {
-                return Err(ItsiError::InvalidInput(
-                    "Invalid IPv6 address format".to_owned(),
-                ));
-            }
-        } else if let Some((h, p)) = url.rsplit_once(':') {
-            // Check if `h` is an IPv6 address before assuming it's a port
-            if h.contains('.') || h.parse::<Ipv4Addr>().is_ok() {
-                (h, p.parse::<u16>().ok()) // IPv4 case
-            } else if h.parse::<Ipv6Addr>().is_ok() {
-                // If it's IPv6, require brackets for port
-                return Err(ItsiError::InvalidInput(
-                    "IPv6 addresses must use [ ] when specifying a port".to_owned(),
-                ));
-            } else {
-                (h, p.parse::<u16>().ok()) // Treat as a hostname
-            }
-        } else {
-            (url, None)
-        };
-
-        let address = if let Ok(ip) = host.parse::<IpAddr>() {
-            BindAddress::Ip(ip)
-        } else {
-            match protocol {
-                BindProtocol::Https | BindProtocol::Http => resolve_hostname(host)
-                    .map(BindAddress::Ip)
-                    .ok_or(ItsiError::ArgumentError(format!(
-                        "Failed to resolve hostname {}",
-                        host
-                    )))?,
-                BindProtocol::Unix | BindProtocol::Unixs => BindAddress::UnixSocket(host.into()),
-            }
-        };
-
-        let port = match protocol {
-            BindProtocol::Http => port.or(Some(80)),
-            BindProtocol::Https => port.or(Some(443)),
-            BindProtocol::Unix => None,
-            BindProtocol::Unixs => None,
-        };
-
-        let tls_config = match protocol {
-            BindProtocol::Http => None,
-            BindProtocol::Https => Some(configure_tls(host, &options)?),
-            BindProtocol::Unix => None,
-            BindProtocol::Unixs => Some(configure_tls(host, &options)?),
-        };
-        let bind = Self {
-            address,
-            port,
-            protocol,
-            tls_config,
-        };
-        Ok(bind)
-    }
-}
-
-fn parse_bind_options(query: &str) -> HashMap<String, String> {
-    query
-        .split('&')
-        .filter_map(|pair| pair.split_once('='))
-        .map(|(k, v)| (k.to_owned(), v.to_owned()))
-        .collect()
-}
-
-/// Attempts to resolve a hostname into an IP address.
-fn resolve_hostname(hostname: &str) -> Option<IpAddr> {
-    (hostname, 0)
-        .to_socket_addrs()
-        .ok()?
-        .find_map(|addr| {
-            if addr.is_ipv6() {
-                Some(addr.ip()) // Prefer IPv6
-            } else {
-                None
-            }
-        })
-        .or_else(|| {
-            (hostname, 0)
-                .to_socket_addrs()
-                .ok()?
-                .map(|addr| addr.ip())
-                .next()
-        }) // Fallback to IPv4
-}

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

@@ -1,37 +0,0 @@
-use itsi_error::ItsiError;
-use std::str::FromStr;
-
-#[derive(Debug, Default, Clone)]
-pub enum BindProtocol {
-    #[default]
-    Https,
-    Http,
-    Unix,
-    Unixs,
-}
-
-impl FromStr for BindProtocol {
-    type Err = ItsiError;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        match s {
-            "http" => Ok(BindProtocol::Http),
-            "https" => Ok(BindProtocol::Https),
-            "unix" => Ok(BindProtocol::Unix),
-            "tls" => Ok(BindProtocol::Unixs),
-            _ => Err(ItsiError::UnsupportedProtocol(s.to_string())),
-        }
-    }
-}
-
-impl std::fmt::Display for BindProtocol {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let s = match self {
-            BindProtocol::Https => "https",
-            BindProtocol::Http => "http",
-            BindProtocol::Unix => "unix",
-            BindProtocol::Unixs => "tls",
-        };
-        write!(f, "{}", s)
-    }
-}

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

@@ -1,104 +0,0 @@
-use super::listener::SockAddr;
-use pin_project::pin_project;
-use tokio::net::{TcpStream, UnixStream};
-use tokio_rustls::server::TlsStream;
-
-use std::os::unix::io::{AsRawFd, RawFd};
-use std::pin::Pin;
-use std::task::{Context, Poll};
-use tokio::io::{AsyncRead, AsyncWrite};
-
-#[pin_project(project = IoStreamEnumProj)]
-pub enum IoStream {
-    Tcp {
-        #[pin]
-        stream: TcpStream,
-        addr: SockAddr,
-    },
-    TcpTls {
-        #[pin]
-        stream: TlsStream<TcpStream>,
-        addr: SockAddr,
-    },
-    Unix {
-        #[pin]
-        stream: UnixStream,
-        addr: SockAddr,
-    },
-    UnixTls {
-        #[pin]
-        stream: TlsStream<UnixStream>,
-        addr: SockAddr,
-    },
-}
-
-impl IoStream {
-    pub fn addr(&self) -> SockAddr {
-        match self {
-            IoStream::Tcp { addr, .. } => addr.clone(),
-            IoStream::TcpTls { addr, .. } => addr.clone(),
-            IoStream::Unix { addr, .. } => addr.clone(),
-            IoStream::UnixTls { addr, .. } => addr.clone(),
-        }
-    }
-}
-
-impl AsyncRead for IoStream {
-    fn poll_read(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-        buf: &mut tokio::io::ReadBuf<'_>,
-    ) -> Poll<std::io::Result<()>> {
-        match self.project() {
-            IoStreamEnumProj::Tcp { stream, .. } => stream.poll_read(cx, buf),
-            IoStreamEnumProj::TcpTls { stream, .. } => stream.poll_read(cx, buf),
-            IoStreamEnumProj::Unix { stream, .. } => stream.poll_read(cx, buf),
-            IoStreamEnumProj::UnixTls { stream, .. } => stream.poll_read(cx, buf),
-        }
-    }
-}
-
-impl AsyncWrite for IoStream {
-    fn poll_write(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-        buf: &[u8],
-    ) -> Poll<std::io::Result<usize>> {
-        match self.project() {
-            IoStreamEnumProj::Tcp { stream, .. } => stream.poll_write(cx, buf),
-            IoStreamEnumProj::TcpTls { stream, .. } => stream.poll_write(cx, buf),
-            IoStreamEnumProj::Unix { stream, .. } => stream.poll_write(cx, buf),
-            IoStreamEnumProj::UnixTls { stream, .. } => stream.poll_write(cx, buf),
-        }
-    }
-
-    fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<std::io::Result<()>> {
-        match self.project() {
-            IoStreamEnumProj::Tcp { stream, .. } => stream.poll_flush(cx),
-            IoStreamEnumProj::TcpTls { stream, .. } => stream.poll_flush(cx),
-            IoStreamEnumProj::Unix { stream, .. } => stream.poll_flush(cx),
-            IoStreamEnumProj::UnixTls { stream, .. } => stream.poll_flush(cx),
-        }
-    }
-
-    fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<std::io::Result<()>> {
-        match self.project() {
-            IoStreamEnumProj::Tcp { stream, .. } => stream.poll_shutdown(cx),
-            IoStreamEnumProj::TcpTls { stream, .. } => stream.poll_shutdown(cx),
-            IoStreamEnumProj::Unix { stream, .. } => stream.poll_shutdown(cx),
-            IoStreamEnumProj::UnixTls { stream, .. } => stream.poll_shutdown(cx),
-        }
-    }
-}
-
-impl AsRawFd for IoStream {
-    fn as_raw_fd(&self) -> RawFd {
-        // For immutable access, we can simply pattern-match on self.
-        match self {
-            IoStream::Tcp { stream, .. } => stream.as_raw_fd(),
-            IoStream::TcpTls { stream, .. } => stream.get_ref().0.as_raw_fd(),
-            IoStream::Unix { stream, .. } => stream.as_raw_fd(),
-            IoStream::UnixTls { stream, .. } => stream.get_ref().0.as_raw_fd(),
-        }
-    }
-}

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

@@ -1,288 +0,0 @@
-use super::{
-    bind::Bind,
-    listener::Listener,
-    serve_strategy::{cluster_mode::ClusterMode, single_mode::SingleMode},
-    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, HeapVal, HeapValue};
-use itsi_tracing::{error, run_silently};
-use magnus::{
-    block::Proc,
-    error::Result,
-    scan_args::{get_kwargs, scan_args, Args, KwArgs, ScanArgsKw, ScanArgsOpt, ScanArgsRequired},
-    value::ReprValue,
-    ArgList, RArray, RHash, Ruby, Symbol, Value,
-};
-use parking_lot::{Mutex, RwLock};
-use std::{cmp::max, collections::HashMap, ops::Deref, sync::Arc};
-use tracing::{info, instrument};
-
-static DEFAULT_BIND: &str = "http://localhost:3000";
-
-#[magnus::wrap(class = "Itsi::Server", free_immediately, size)]
-#[derive(Clone)]
-pub struct Server {
-    pub config: Arc<ServerConfig>,
-}
-
-impl Deref for Server {
-    type Target = ServerConfig;
-
-    fn deref(&self) -> &Self::Target {
-        &self.config
-    }
-}
-
-#[derive(Debug)]
-pub struct ServerConfig {
-    #[debug(skip)]
-    pub app: HeapVal,
-    #[allow(unused)]
-    pub workers: u8,
-    #[allow(unused)]
-    pub threads: u8,
-    #[allow(unused)]
-    pub shutdown_timeout: f64,
-    pub script_name: String,
-    pub(crate) binds: Mutex<Vec<Bind>>,
-    #[debug(skip)]
-    pub hooks: HashMap<String, HeapValue<Proc>>,
-    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,
-    pub oob_gc_responses_threshold: Option<u64>,
-}
-
-#[derive(Debug)]
-pub enum RequestJob {
-    ProcessRequest(ItsiRequest),
-    Shutdown,
-}
-
-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,
-{
-    let symbols: Vec<Symbol> = primaries
-        .iter()
-        .chain(rest.iter())
-        .map(|&name| Symbol::new(name))
-        .collect();
-
-    let hash = scan_args
-        .keywords
-        .funcall::<_, _, RHash>("slice", symbols.into_arg_list_with(&Ruby::get().unwrap()))
-        .unwrap();
-
-    get_kwargs(hash, primaries, rest)
-}
-
-impl Server {
-    #[instrument(
-        name = "Itsi",
-        parent=None,
-        skip(args),
-        fields(workers = 1, threads = 1, shutdown_timeout = 5)
-    )]
-    pub fn new(args: &[Value]) -> Result<Self> {
-        let scan_args: Args<(), (), (), (), RHash, ()> = scan_args(args)?;
-
-        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<
-            (),
-            (
-                // Hooks
-                Option<RHash>,
-                // Scheduler Class
-                Option<String>,
-                // Worker Memory Limit
-                Option<u64>,
-                // Out-of-band GC Responses Threshold
-                Option<u64>,
-                // Silence
-                Option<bool>,
-            ),
-            (),
-        >;
-
-        let args1: Args1 = extract_args(
-            &scan_args,
-            &["app"],
-            &[
-                "workers",
-                "threads",
-                "shutdown_timeout",
-                "script_name",
-                "binds",
-                "stream_body",
-            ],
-        )?;
-
-        let args2: Args2 = extract_args(
-            &scan_args,
-            &[],
-            &[
-                "hooks",
-                "scheduler_class",
-                "worker_memory_limit",
-                "oob_gc_responses_threshold",
-                "silence",
-            ],
-        )?;
-
-        let hooks = args2
-            .optional
-            .0
-            .map(|rhash| -> Result<HashMap<String, HeapValue<Proc>>> {
-                let mut hook_map: HashMap<String, HeapValue<Proc>> = HashMap::new();
-                for pair in rhash.enumeratorize::<_, ()>("each", ()) {
-                    if let Some(pair_value) = RArray::from_value(pair?) {
-                        if let (Ok(key), Ok(value)) =
-                            (pair_value.entry::<Value>(0), pair_value.entry::<Proc>(1))
-                        {
-                            hook_map.insert(key.to_string(), HeapValue::from(value));
-                        }
-                    }
-                }
-                Ok(hook_map)
-            })
-            .transpose()?
-            .unwrap_or_default();
-
-        let config = ServerConfig {
-            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),
-            script_name: args1.optional.3.unwrap_or("".to_string()),
-            binds: Mutex::new(
-                args1
-                    .optional
-                    .4
-                    .unwrap_or_else(|| vec![DEFAULT_BIND.to_string()])
-                    .into_iter()
-                    .map(|s| s.parse())
-                    .collect::<itsi_error::Result<Vec<Bind>>>()?,
-            ),
-            stream_body: args1.optional.5,
-            hooks,
-            scheduler_class: args2.optional.1.clone(),
-            worker_memory_limit: args2.optional.2,
-            strategy: RwLock::new(None),
-            oob_gc_responses_threshold: args2.optional.3,
-            silence: args2.optional.4.is_some_and(|s| s),
-        };
-
-        if !config.silence {
-            if let Some(scheduler_class) = args2.optional.1 {
-                info!(scheduler_class, fiber_scheduler = true);
-            } else {
-                info!(fiber_scheduler = false);
-            }
-        }
-
-        Ok(Server {
-            config: Arc::new(config),
-        })
-    }
-
-    #[instrument(name = "Bind", skip_all, fields(binds=format!("{:?}", self.config.binds.lock())))]
-    pub(crate) fn build_listeners(&self) -> Result<Vec<Listener>> {
-        let listeners = self
-            .config
-            .binds
-            .lock()
-            .iter()
-            .cloned()
-            .map(Listener::try_from)
-            .collect::<std::result::Result<Vec<Listener>, _>>()?
-            .into_iter()
-            .collect::<Vec<_>>();
-        info!("Bound {:?} listeners", listeners.len());
-        Ok(listeners)
-    }
-
-    pub(crate) fn build_strategy(self) -> Result<()> {
-        let listeners = self.build_listeners()?;
-        let server = Arc::new(self);
-        let server_clone = server.clone();
-
-        let strategy = if server.config.workers == 1 {
-            ServeStrategy::Single(Arc::new(SingleMode::new(
-                server,
-                listeners,
-                SIGNAL_HANDLER_CHANNEL.0.clone(),
-            )?))
-        } else {
-            ServeStrategy::Cluster(Arc::new(ClusterMode::new(
-                server,
-                listeners,
-                SIGNAL_HANDLER_CHANNEL.0.clone(),
-            )))
-        };
-
-        *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();
-        call_without_gvl(move || -> Result<()> {
-            rself.clone().build_strategy()?;
-            if let Err(e) = rself.strategy.read().as_ref().unwrap().run() {
-                error!("Error running server: {}", e);
-                rself.strategy.read().as_ref().unwrap().stop()?;
-            }
-            Ok(())
-        })?;
-        clear_signal_handlers();
-        self.strategy.write().take();
-        info!("Server stopped");
-        Ok(())
-    }
-}

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

@@ -1,9 +0,0 @@
-#[derive(Debug, Clone)]
-pub enum LifecycleEvent {
-    Start,
-    Shutdown,
-    Restart,
-    IncreaseWorkers,
-    DecreaseWorkers,
-    ForceShutdown,
-}