itsi 0.1.9 → 0.1.12

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

@@ -1,294 +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};
-use itsi_tracing::{error, run_silently};
-use magnus::{
-    block::Proc,
-    error::Result,
-    scan_args::{get_kwargs, scan_args, Args, KwArgs, ScanArgsKw, ScanArgsOpt, ScanArgsRequired},
-    value::{InnerValue, Opaque, ReprValue},
-    ArgList, RHash, Ruby, Symbol, Value,
-};
-use parking_lot::{Mutex, RwLock};
-use std::{cmp::max, 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
-    }
-}
-type AfterFork = Mutex<Arc<Option<Box<dyn Fn() + Send + Sync>>>>;
-
-#[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 before_fork: Mutex<Option<Box<dyn FnOnce() + Send + Sync>>>,
-    #[debug(skip)]
-    pub after_fork: AfterFork,
-    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)]
-pub enum RequestJob {
-    ProcessRequest(ItsiRequest),
-    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",
-        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<
-            (),
-            (
-                // 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",
-                "threads",
-                "shutdown_timeout",
-                "script_name",
-                "binds",
-                "stream_body",
-            ],
-        )?;
-
-        let args2: Args2 = extract_args(
-            &scan_args,
-            &[],
-            &[
-                "before_fork",
-                "after_fork",
-                "scheduler_class",
-                "worker_memory_limit",
-                "silence",
-            ],
-        )?;
-
-        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,
-            before_fork: Mutex::new(args2.optional.0.map(|p| {
-                let opaque_proc = Opaque::from(p);
-                Box::new(move || {
-                    opaque_proc
-                        .get_inner_with(&Ruby::get().unwrap())
-                        .call::<_, Value>(())
-                        .unwrap();
-                }) as Box<dyn FnOnce() + Send + Sync>
-            })),
-            after_fork: Mutex::new(Arc::new(args2.optional.1.map(|p| {
-                let opaque_proc = Opaque::from(p);
-                Box::new(move || {
-                    opaque_proc
-                        .get_inner_with(&Ruby::get().unwrap())
-                        .call::<_, Value>(())
-                        .unwrap();
-                }) as Box<dyn Fn() + Send + Sync>
-            }))),
-            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 !config.silence {
-            if let Some(scheduler_class) = args2.optional.2 {
-                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<Arc<Vec<Arc<Listener>>>> {
-        let listeners = self
-            .config
-            .binds
-            .lock()
-            .iter()
-            .cloned()
-            .map(Listener::try_from)
-            .collect::<std::result::Result<Vec<Listener>, _>>()?
-            .into_iter()
-            .map(Arc::new)
-            .collect::<Vec<_>>();
-        info!("Bound {:?} listeners", listeners.len());
-        Ok(Arc::new(listeners))
-    }
-
-    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(
-                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();
-        let listeners = self.build_listeners()?;
-        let listeners_clone = listeners.clone();
-        call_without_gvl(move || -> Result<()> {
-            rself.clone().build_strategy(listeners_clone)?;
-            if let Err(e) = rself.clone().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/server/ext/itsi_server/src/server/lifecycle_event.rs

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

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

@@ -1,318 +0,0 @@
-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;
-use socket2::{Domain, Protocol, Socket, Type};
-use std::net::{IpAddr, SocketAddr, TcpListener};
-use std::sync::Arc;
-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;
-
-pub(crate) enum Listener {
-    Tcp(TcpListener),
-    TcpTls((TcpListener, ItsiTlsAcceptor)),
-    Unix(UnixListener),
-    UnixTls((UnixListener, ItsiTlsAcceptor)),
-}
-
-pub(crate) enum TokioListener {
-    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 listener_info(&self) -> ListenerInfo {
-        match self {
-            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
-            }
-        }
-    }
-
-    async fn accept_tcp(listener: &TokioTcpListener) -> Result<IoStream> {
-        let tcp_stream = listener.accept().await?;
-        Self::to_tokio_io(Stream::TcpStream(tcp_stream), None).await
-    }
-
-    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 {
-                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;
-                  }
-                }
-            }
-        }
-    }
-
-    async fn accept_tls(
-        listener: &TokioTcpListener,
-        acceptor: &ItsiTlsAcceptor,
-    ) -> Result<IoStream> {
-        let tcp_stream = listener.accept().await?;
-        match acceptor {
-            ItsiTlsAcceptor::Manual(tls_acceptor) => {
-                Self::to_tokio_io(Stream::TcpStream(tcp_stream), Some(tls_acceptor)).await
-            }
-            ItsiTlsAcceptor::Automatic(acme_acceptor, _, rustls_config) => {
-                let accept_future = acme_acceptor.accept(tcp_stream.0);
-                match accept_future.await {
-                    Ok(None) => Err(ItsiError::Pass()),
-                    Ok(Some(start_handshake)) => {
-                        let tls_stream = start_handshake.into_stream(rustls_config.clone()).await?;
-                        Ok(IoStream::TcpTls {
-                            stream: tls_stream,
-                            addr: SockAddr::Tcp(Arc::new(tcp_stream.1)),
-                        })
-                    }
-                    Err(error) => {
-                        error!(error = format!("{:?}", error));
-                        Err(ItsiError::Pass())
-                    }
-                }
-            }
-        }
-    }
-
-    async fn accept_unix(listener: &TokioUnixListener) -> Result<IoStream> {
-        let unix_stream = listener.accept().await?;
-        Self::to_tokio_io(Stream::UnixStream(unix_stream), None).await
-    }
-
-    async fn accept_unix_tls(
-        listener: &TokioUnixListener,
-        acceptor: &ItsiTlsAcceptor,
-    ) -> Result<IoStream> {
-        let unix_stream = listener.accept().await?;
-        match acceptor {
-            ItsiTlsAcceptor::Manual(tls_acceptor) => {
-                Self::to_tokio_io(Stream::UnixStream(unix_stream), Some(tls_acceptor)).await
-            }
-            ItsiTlsAcceptor::Automatic(_, _, _) => {
-                error!("Automatic TLS not supported on Unix sockets");
-                Err(ItsiError::UnsupportedProtocol(
-                    "Automatic TLS on Unix Sockets".to_owned(),
-                ))
-            }
-        }
-    }
-
-    async fn to_tokio_io(
-        input_stream: Stream,
-        tls_acceptor: Option<&TlsAcceptor>,
-    ) -> Result<IoStream> {
-        match tls_acceptor {
-            Some(acceptor) => match input_stream {
-                Stream::TcpStream((tcp_stream, socket_address)) => {
-                    match acceptor.accept(tcp_stream).await {
-                        Ok(tls_stream) => Ok(IoStream::TcpTls {
-                            stream: tls_stream,
-                            addr: SockAddr::Tcp(Arc::new(socket_address)),
-                        }),
-                        Err(err) => Err(err.into()),
-                    }
-                }
-                Stream::UnixStream((unix_stream, socket_address)) => {
-                    match acceptor.accept(unix_stream).await {
-                        Ok(tls_stream) => Ok(IoStream::UnixTls {
-                            stream: tls_stream,
-                            addr: SockAddr::Unix(Arc::new(socket_address)),
-                        }),
-                        Err(err) => Err(err.into()),
-                    }
-                }
-            },
-            None => match input_stream {
-                Stream::TcpStream((tcp_stream, socket_address)) => Ok(IoStream::Tcp {
-                    stream: tcp_stream,
-                    addr: SockAddr::Tcp(Arc::new(socket_address)),
-                }),
-                Stream::UnixStream((unix_stream, socket_address)) => Ok(IoStream::Unix {
-                    stream: unix_stream,
-                    addr: SockAddr::Unix(Arc::new(socket_address)),
-                }),
-            },
-        }
-    }
-}
-
-enum Stream {
-    TcpStream((TcpStream, SocketAddr)),
-    UnixStream((UnixStream, unix::SocketAddr)),
-}
-
-#[derive(Clone, Debug)]
-pub enum SockAddr {
-    Tcp(Arc<SocketAddr>),
-    Unix(Arc<unix::SocketAddr>),
-}
-impl std::fmt::Display for SockAddr {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            SockAddr::Tcp(socket_addr) => write!(f, "{}", socket_addr.ip().to_canonical()),
-            SockAddr::Unix(socket_addr) => match socket_addr.as_pathname() {
-                Some(path) => write!(f, "{:?}", path),
-                None => write!(f, ""),
-            },
-        }
-    }
-}
-
-impl Listener {
-    pub fn to_tokio_listener(&self) -> TokioListener {
-        match self {
-            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(),
-            ),
-        }
-    }
-}
-
-impl TryFrom<Bind> for Listener {
-    type Error = itsi_error::ItsiError;
-
-    fn try_from(bind: Bind) -> std::result::Result<Self, Self::Error> {
-        let bound = match bind.address {
-            BindAddress::Ip(addr) => match bind.protocol {
-                BindProtocol::Http => Listener::Tcp(connect_tcp_socket(addr, bind.port.unwrap())?),
-                BindProtocol::Https => {
-                    let tcp_listener = connect_tcp_socket(addr, bind.port.unwrap())?;
-                    Listener::TcpTls((tcp_listener, bind.tls_config.unwrap()))
-                }
-                _ => unreachable!(),
-            },
-            BindAddress::UnixSocket(path) => match bind.tls_config {
-                Some(tls_config) => Listener::UnixTls((connect_unix_socket(&path)?, tls_config)),
-                None => Listener::Unix(connect_unix_socket(&path)?),
-            },
-        };
-        Ok(bound)
-    }
-}
-
-fn connect_tcp_socket(addr: IpAddr, port: u16) -> Result<TcpListener> {
-    let domain = match addr {
-        IpAddr::V4(_) => Domain::IPV4,
-        IpAddr::V6(_) => Domain::IPV6,
-    };
-    let socket = Socket::new(domain, Type::STREAM, Some(Protocol::TCP))?;
-    let socket_address: SocketAddr = SocketAddr::new(addr, port);
-    socket.set_reuse_port(true).ok();
-    socket.set_reuse_address(true).ok();
-    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())
-}
-
-fn connect_unix_socket(path: &PathBuf) -> Result<UnixListener> {
-    let _ = std::fs::remove_file(path);
-    let socket = Socket::new(Domain::UNIX, Type::STREAM, None)?;
-    socket.set_nonblocking(true).ok();
-
-    let socket_address = socket2::SockAddr::unix(path)?;
-
-    info!("Binding to {:?}", path);
-    socket.bind(&socket_address)?;
-    socket.listen(1024)?;
-
-    Ok(socket.into())
-}

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

@@ -1,11 +0,0 @@
-pub mod bind;
-pub mod bind_protocol;
-pub mod io_stream;
-pub mod itsi_server;
-pub mod lifecycle_event;
-pub mod listener;
-pub mod process_worker;
-pub mod serve_strategy;
-pub mod signal;
-pub mod thread_worker;
-pub mod tls;