itsi 0.1.0 → 0.1.3

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

@@ -0,0 +1,244 @@
+use super::{
+    bind::Bind,
+    listener::Listener,
+    serve_strategy::{cluster_mode::ClusterMode, single_mode::SingleMode},
+    signal::{clear_signal_handlers, reset_signal_handlers, 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 magnus::{
+    block::Proc,
+    error::Result,
+    scan_args::{get_kwargs, scan_args, Args, KwArgs},
+    value::{InnerValue, Opaque, ReprValue},
+    RHash, Ruby, Symbol, Value,
+};
+use parking_lot::Mutex;
+use std::{cmp::max, ops::Deref, sync::Arc};
+use tracing::{info, instrument};
+
+static DEFAULT_BIND: &str = "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: Opaque<Value>,
+    #[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>,
+}
+
+#[derive(Debug)]
+pub enum RequestJob {
+    ProcessRequest(ItsiRequest),
+    Shutdown,
+}
+
+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 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(),
+            &["app"],
+            &[
+                "workers",
+                "threads",
+                "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(),
+            &[],
+            &["worker_memory_limit"],
+        )?;
+
+        let config = ServerConfig {
+            app: Opaque::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>>>()?,
+            ),
+            before_fork: Mutex::new(args1.optional.5.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(args1.optional.6.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: args1.optional.7.clone(),
+            stream_body: args1.optional.8,
+            worker_memory_limit: args2.optional.0,
+        };
+
+        if let Some(scheduler_class) = args1.optional.7 {
+            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 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<ServeStrategy> {
+        let server = Arc::new(self);
+
+        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(),
+            )))
+        };
+        Ok(strategy)
+    }
+
+    pub fn start(&self) -> Result<()> {
+        reset_signal_handlers();
+        let rself = self.clone();
+        let listeners = self.listeners()?;
+        let listeners_clone = listeners.clone();
+        call_without_gvl(move || -> Result<()> {
+            let strategy = rself.build_strategy(listeners_clone)?;
+            if let Err(e) = strategy.run() {
+                error!("Error running server: {}", e);
+                strategy.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();
+        Ok(())
+    }
+}

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

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

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

@@ -0,0 +1,275 @@
+use super::bind::{Bind, BindAddress};
+use super::bind_protocol::BindProtocol;
+use super::io_stream::IoStream;
+use itsi_error::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_rustls::TlsAcceptor;
+
+pub(crate) enum Listener {
+    Tcp(TcpListener),
+    TcpTls((TcpListener, TlsAcceptor)),
+    Unix(UnixListener),
+    UnixTls((UnixListener, TlsAcceptor)),
+}
+
+pub(crate) enum TokioListener {
+    Tcp {
+        listener: TokioTcpListener,
+        host: String,
+        port: u16,
+    },
+    TcpTls {
+        listener: TokioTcpListener,
+        acceptor: TlsAcceptor,
+        host: String,
+        port: u16,
+    },
+    Unix {
+        listener: TokioUnixListener,
+    },
+    UnixTls {
+        listener: TokioUnixListener,
+        acceptor: TlsAcceptor,
+    },
+}
+
+impl TokioListener {
+    pub fn unbind(self) {
+        match self {
+            TokioListener::Tcp { listener, .. } => drop(listener.into_std().unwrap()),
+            TokioListener::TcpTls { listener, .. } => drop(listener.into_std().unwrap()),
+            TokioListener::Unix { listener } => drop(listener.into_std().unwrap()),
+            TokioListener::UnixTls { listener, .. } => drop(listener.into_std().unwrap()),
+        };
+    }
+    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
+    }
+
+    async fn accept_tls(listener: &TokioTcpListener, acceptor: &TlsAcceptor) -> Result<IoStream> {
+        let tcp_stream = listener.accept().await?;
+        Self::to_tokio_io(Stream::TcpStream(tcp_stream), Some(acceptor)).await
+    }
+
+    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: &TlsAcceptor,
+    ) -> Result<IoStream> {
+        let unix_stream = listener.accept().await?;
+        Self::to_tokio_io(Stream::UnixStream(unix_stream), Some(acceptor)).await
+    }
+
+    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)),
+                }),
+            },
+        }
+    }
+
+    pub(crate) fn scheme(&self) -> String {
+        match self {
+            TokioListener::Tcp { .. } => "http".to_string(),
+            TokioListener::TcpTls { .. } => "https".to_string(),
+            TokioListener::Unix { .. } => "http".to_string(),
+            TokioListener::UnixTls { .. } => "https".to_string(),
+        }
+    }
+
+    pub(crate) fn port(&self) -> u16 {
+        match self {
+            TokioListener::Tcp { port, .. } => *port,
+            TokioListener::TcpTls { port, .. } => *port,
+            TokioListener::Unix { .. } => 0,
+            TokioListener::UnixTls { .. } => 0,
+        }
+    }
+
+    pub(crate) fn host(&self) -> String {
+        match self {
+            TokioListener::Tcp { host, .. } => host.to_string(),
+            TokioListener::TcpTls { host, .. } => host.to_string(),
+            TokioListener::Unix { .. } => "unix".to_string(),
+            TokioListener::UnixTls { .. } => "unix".to_string(),
+        }
+    }
+}
+
+enum Stream {
+    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 unbind(self) {
+        match self {
+            Listener::Tcp(listener) => drop(listener),
+            Listener::TcpTls((listener, _)) => drop(listener),
+            Listener::Unix(listener) => drop(listener),
+            Listener::UnixTls((listener, _)) => drop(listener),
+        };
+    }
+    pub fn to_tokio_listener(&self) -> TokioListener {
+        match self {
+            Listener::Tcp(listener) => TokioListener::Tcp {
+                listener: TokioTcpListener::from_std(TcpListener::try_clone(listener).unwrap())
+                    .unwrap(),
+                host: listener
+                    .local_addr()
+                    .unwrap()
+                    .ip()
+                    .to_canonical()
+                    .to_string(),
+                port: listener.local_addr().unwrap().port(),
+            },
+            Listener::TcpTls((listener, acceptor)) => TokioListener::TcpTls {
+                listener: TokioTcpListener::from_std(TcpListener::try_clone(listener).unwrap())
+                    .unwrap(),
+                acceptor: acceptor.clone(),
+                host: listener
+                    .local_addr()
+                    .unwrap()
+                    .ip()
+                    .to_canonical()
+                    .to_string(),
+                port: listener.local_addr().unwrap().port(),
+            },
+            Listener::Unix(listener) => TokioListener::Unix {
+                listener: TokioUnixListener::from_std(UnixListener::try_clone(listener).unwrap())
+                    .unwrap(),
+            },
+            Listener::UnixTls((listener, acceptor)) => TokioListener::UnixTls {
+                listener: TokioUnixListener::from_std(UnixListener::try_clone(listener).unwrap())
+                    .unwrap(),
+                acceptor: acceptor.clone(),
+            },
+        }
+    }
+}
+
+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())?;
+                    let tls_acceptor = TlsAcceptor::from(Arc::new(bind.tls_config.unwrap()));
+                    Listener::TcpTls((tcp_listener, tls_acceptor))
+                }
+                _ => unreachable!(),
+            },
+            BindAddress::UnixSocket(path) => match bind.tls_config {
+                Some(tls_config) => {
+                    let tls_acceptor = TlsAcceptor::from(Arc::new(tls_config));
+                    Listener::UnixTls((connect_unix_socket(&path)?, tls_acceptor))
+                }
+                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_nonblocking(true).ok();
+    socket.set_nodelay(true).ok();
+    socket.set_recv_buffer_size(1_048_576).ok();
+    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/scheduler/ext/itsi_server/src/server/mod.rs

@@ -0,0 +1,11 @@
+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;