itsi-server 0.2.22-aarch64-linux

data/ext/itsi_server/src/ruby_types/itsi_server.rs

@@ -0,0 +1,102 @@
+use crate::server::{
+    lifecycle_event::LifecycleEvent,
+    serve_strategy::{cluster_mode::ClusterMode, single_mode::SingleMode, ServeStrategy},
+    signal::{clear_signal_handlers, reset_signal_handlers, send_lifecycle_event},
+};
+use itsi_rb_helpers::{call_without_gvl, print_rb_backtrace};
+use itsi_server_config::ItsiServerConfig;
+use itsi_tracing::{error, run_silently};
+use magnus::{block::Proc, error::Result, RHash, Ruby};
+use parking_lot::Mutex;
+use std::{path::PathBuf, sync::Arc};
+use tracing::{info, instrument};
+mod file_watcher;
+pub mod itsi_server_config;
+#[magnus::wrap(class = "Itsi::Server", free_immediately, size)]
+#[derive(Clone, Default)]
+pub struct ItsiServer {
+    pub config: Arc<Mutex<Option<Arc<ItsiServerConfig>>>>,
+}
+
+impl ItsiServer {
+    pub fn initialize(
+        &self,
+        cli_params: RHash,
+        itsifile_path: Option<PathBuf>,
+        itsi_config_proc: Option<Proc>,
+    ) -> Result<()> {
+        let ruby = Ruby::get().map_err(|_| {
+            magnus::Error::new(
+                magnus::Ruby::get().unwrap().exception_runtime_error(),
+                "Failed to acquire Ruby VM handle",
+            )
+        })?;
+        let config = Arc::new(ItsiServerConfig::new(
+            &ruby,
+            cli_params,
+            itsifile_path,
+            itsi_config_proc,
+        )?);
+        *self.config.lock() = Some(config);
+        Ok(())
+    }
+
+    pub fn stop(&self) -> Result<()> {
+        send_lifecycle_event(LifecycleEvent::Shutdown);
+        Ok(())
+    }
+
+    fn config(&self) -> Result<Arc<ItsiServerConfig>> {
+        self.config.lock().as_ref().cloned().ok_or_else(|| {
+            magnus::Error::new(
+                magnus::Ruby::get().unwrap().exception_runtime_error(),
+                "Itsi::Server not initialized",
+            )
+        })
+    }
+
+    #[instrument(skip(self))]
+    pub fn start(&self) -> Result<()> {
+        let server_config = self.config()?;
+        server_config.server_params.read().setup_listeners()?;
+        let result = if server_config.server_params.read().silence {
+            run_silently(|| self.build_and_run_strategy())
+        } else {
+            info!("Itsi - Rolling into action. ⚪💨");
+            self.build_and_run_strategy()
+        };
+        if let Err(e) = result {
+            error!("Error starting server: {:?}", e);
+            if let Some(err_value) = e.value() {
+                print_rb_backtrace(err_value);
+            }
+            return Err(e);
+        }
+        Ok(())
+    }
+
+    pub(crate) fn build_strategy(&self) -> Result<ServeStrategy> {
+        let server_config = self.config()?;
+        Ok(if server_config.server_params.read().workers > 1 {
+            ServeStrategy::Cluster(Arc::new(ClusterMode::new(server_config)))
+        } else {
+            ServeStrategy::Single(Arc::new(SingleMode::new(server_config, 0)?))
+        })
+    }
+
+    fn build_and_run_strategy(&self) -> Result<()> {
+        reset_signal_handlers();
+        call_without_gvl(move || -> Result<()> {
+            let strategy = self.build_strategy()?;
+            if let Err(e) = strategy.clone().run() {
+                error!("Error running server: {}", e);
+                send_lifecycle_event(LifecycleEvent::Shutdown);
+                strategy.stop()?;
+            }
+            Ok(())
+        })?;
+        clear_signal_handlers();
+        info!("Server stopped");
+        Ok(())
+    }
+}

data/ext/itsi_server/src/ruby_types/mod.rs

@@ -0,0 +1,48 @@
+use magnus::{value::Lazy, Module, RClass, RModule};
+
+pub mod itsi_body_proxy;
+pub mod itsi_grpc_call;
+pub mod itsi_grpc_response_stream;
+pub mod itsi_http_request;
+pub mod itsi_http_response;
+pub mod itsi_server;
+
+pub static ITSI_MODULE: Lazy<RModule> = Lazy::new(|ruby| ruby.define_module("Itsi").unwrap());
+pub static ITSI_SERVER: Lazy<RClass> = Lazy::new(|ruby| {
+    ruby.get_inner(&ITSI_MODULE)
+        .define_class("Server", ruby.class_object())
+        .unwrap()
+});
+
+pub static ITSI_SERVER_CONFIG: Lazy<RModule> =
+    Lazy::new(|ruby| ruby.get_inner(&ITSI_SERVER).const_get("Config").unwrap());
+
+pub static ITSI_REQUEST: Lazy<RClass> = Lazy::new(|ruby| {
+    ruby.get_inner(&ITSI_MODULE)
+        .define_class("HttpRequest", ruby.class_object())
+        .unwrap()
+});
+
+pub static ITSI_RESPONSE: Lazy<RClass> = Lazy::new(|ruby| {
+    ruby.get_inner(&ITSI_MODULE)
+        .define_class("HttpResponse", ruby.class_object())
+        .unwrap()
+});
+
+pub static ITSI_BODY_PROXY: Lazy<RClass> = Lazy::new(|ruby| {
+    ruby.get_inner(&ITSI_MODULE)
+        .define_class("BodyProxy", ruby.class_object())
+        .unwrap()
+});
+
+pub static ITSI_GRPC_CALL: Lazy<RClass> = Lazy::new(|ruby| {
+    ruby.get_inner(&ITSI_MODULE)
+        .define_class("GrpcCall", ruby.class_object())
+        .unwrap()
+});
+
+pub static ITSI_GRPC_RESPONSE_STREAM: Lazy<RClass> = Lazy::new(|ruby| {
+    ruby.get_inner(&ITSI_MODULE)
+        .define_class("GrpcResponseStream", ruby.class_object())
+        .unwrap()
+});

data/ext/itsi_server/src/server/binds/bind.rs

@@ -0,0 +1,204 @@
+use super::{
+    bind_protocol::BindProtocol,
+    tls::{configure_tls, ItsiTlsAcceptor},
+};
+use crate::prelude::*;
+use itsi_error::ItsiError;
+use std::{
+    collections::HashMap,
+    net::{IpAddr, Ipv4Addr, Ipv6Addr, ToSocketAddrs},
+    path::PathBuf,
+    str::FromStr,
+};
+use tracing::{instrument, Level};
+
+#[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<TlsOptions>,
+}
+
+#[derive(Default, Clone)]
+pub struct TlsOptions {
+    pub host: String,
+    pub options: HashMap<String, String>,
+}
+
+impl TlsOptions {
+    pub fn build_acceptor(&self) -> Result<ItsiTlsAcceptor> {
+        configure_tls(&self.host, &self.options)
+    }
+}
+
+impl Bind {
+    pub fn listener_address_string(&self) -> String {
+        match &self.address {
+            BindAddress::Ip(ip) => format!("tcp://{}:{}", ip.to_canonical(), self.port.unwrap()),
+            BindAddress::UnixSocket(path) => {
+                format!("unix://{}", path.as_path().to_str().unwrap())
+            }
+        }
+    }
+}
+
+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::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;
+
+    #[instrument(ret(level = Level::DEBUG))]
+    fn from_str(s: &str) -> std::result::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(TlsOptions {
+                host: host.to_owned(),
+                options,
+            }),
+            BindProtocol::Unix => None,
+            BindProtocol::Unixs => Some(TlsOptions {
+                host: host.to_owned(),
+                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.
+#[instrument(ret(level = Level::DEBUG))]
+fn resolve_hostname(hostname: &str) -> Option<IpAddr> {
+    (hostname, 0)
+        .to_socket_addrs()
+        .ok()?
+        .find_map(|addr| {
+            if addr.is_ipv4() {
+                Some(addr.ip()) // Prefer IPv4
+            } else {
+                None
+            }
+        })
+        .or_else(|| {
+            (hostname, 0)
+                .to_socket_addrs()
+                .ok()?
+                .map(|addr| addr.ip())
+                .next()
+        }) // Fallback to IPv4
+}

data/ext/itsi_server/src/server/binds/bind_protocol.rs

@@ -0,0 +1,37 @@
+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)
+    }
+}