itsi 0.1.0

data/crates/itsi_server/src/request/itsi_request.rs

@@ -0,0 +1,143 @@
+use std::{collections::HashMap, sync::Arc};
+
+use crate::server::listener::{Listener, SockAddr};
+use bytes::Bytes;
+use http::request::Parts;
+use http_body_util::BodyExt;
+use hyper::{body::Incoming, Request};
+use magnus::error::Result;
+
+#[magnus::wrap(class = "Itsi::Request", free_immediately, size)]
+#[derive(Debug)]
+pub struct ItsiRequest {
+    pub path: String,
+    pub script_name: String,
+    pub query_string: String,
+    pub method: String,
+    pub version: String,
+    pub rack_protocol: Vec<String>,
+    pub host: String,
+    pub scheme: String,
+    pub headers: HashMap<String, String>,
+    pub remote_addr: String,
+    pub port: u16,
+    pub body: Bytes,
+    pub parts: Parts,
+}
+
+impl ItsiRequest {
+    pub(crate) async fn build_from(
+        request: Request<Incoming>,
+        sock_addr: SockAddr,
+        script_name: String,
+        listener: Arc<Listener>,
+    ) -> Self {
+        let (parts, body) = request.into_parts();
+        let method = parts.method.to_string();
+        let port = parts.uri.port_u16().unwrap_or(listener.port());
+        let query_string = parts.uri.query().unwrap_or("").to_string();
+        let rack_protocol = parts
+            .headers
+            .get("upgrade")
+            .or_else(|| parts.headers.get("protocol"))
+            .map(|value| {
+                value
+                    .to_str()
+                    .unwrap_or("")
+                    .split(',')
+                    .map(|s| s.trim().to_owned())
+                    .collect::<Vec<String>>()
+            })
+            .unwrap_or_else(|| vec!["http".to_string()]);
+
+        let host = parts
+            .uri
+            .host()
+            .map(ToOwned::to_owned)
+            .unwrap_or_else(|| listener.host());
+
+        let scheme = parts
+            .uri
+            .scheme()
+            .map(|s| s.to_string())
+            .unwrap_or_else(|| listener.scheme());
+
+        let headers = parts
+            .headers
+            .iter()
+            .map(|(k, v)| (k.to_string(), v.to_str().unwrap_or("").to_string()))
+            .collect();
+
+        let path = parts
+            .uri
+            .path()
+            .strip_prefix(&script_name)
+            .unwrap_or(parts.uri.path())
+            .to_string();
+
+        let version = format!("{:?}", parts.version);
+        let body = body.collect().await.unwrap().to_bytes();
+
+        Self {
+            remote_addr: sock_addr.to_string(),
+            body,
+            parts,
+            script_name,
+            query_string,
+            method,
+            headers,
+            path,
+            version,
+            rack_protocol,
+            host,
+            scheme,
+            port,
+        }
+    }
+}
+
+impl ItsiRequest {
+    pub(crate) fn path(&self) -> Result<String> {
+        Ok(self.path.clone())
+    }
+
+    pub(crate) fn script_name(&self) -> Result<String> {
+        Ok(self.script_name.clone())
+    }
+
+    pub(crate) fn query_string(&self) -> Result<String> {
+        Ok(self.query_string.clone())
+    }
+
+    pub(crate) fn method(&self) -> Result<String> {
+        Ok(self.method.clone())
+    }
+
+    pub(crate) fn version(&self) -> Result<String> {
+        Ok(self.version.clone())
+    }
+
+    pub(crate) fn rack_protocol(&self) -> Result<Vec<String>> {
+        Ok(self.rack_protocol.clone())
+    }
+
+    pub(crate) fn host(&self) -> Result<String> {
+        Ok(self.host.clone())
+    }
+
+    pub(crate) fn headers(&self) -> Result<HashMap<String, String>> {
+        Ok(self.headers.clone())
+    }
+
+    pub(crate) fn remote_addr(&self) -> Result<String> {
+        Ok(self.remote_addr.clone())
+    }
+
+    pub(crate) fn port(&self) -> Result<u16> {
+        Ok(self.port)
+    }
+
+    pub(crate) fn body(&self) -> Result<Bytes> {
+        Ok(self.body.clone())
+    }
+}

data/crates/itsi_server/src/request/mod.rs

@@ -0,0 +1 @@
+pub mod itsi_request;

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

@@ -0,0 +1,138 @@
+use super::{tls::configure_tls, transfer_protocol::TransferProtocol};
+use itsi_error::ItsiError;
+use std::{
+    collections::HashMap,
+    net::{IpAddr, Ipv4Addr, Ipv6Addr, ToSocketAddrs},
+    path::PathBuf,
+    str::FromStr,
+};
+use tokio_rustls::rustls::ServerConfig;
+
+// Support binding to either IP or Unix Socket
+#[derive(Debug, Clone)]
+pub enum BindAddress {
+    Ip(IpAddr),
+    UnixSocket(PathBuf),
+}
+
+impl Default for BindAddress {
+    fn default() -> Self {
+        BindAddress::Ip(IpAddr::V4(Ipv4Addr::UNSPECIFIED))
+    }
+}
+
+#[derive(Debug, Default, Clone)]
+#[magnus::wrap(class = "Itsi::Bind")]
+pub struct Bind {
+    pub address: BindAddress,
+    pub port: Option<u16>, // None for Unix Sockets
+    pub protocol: TransferProtocol,
+    pub tls_config: Option<ServerConfig>,
+}
+
+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::<TransferProtocol>()?, rest)
+        } else {
+            (TransferProtocol::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, None) // Treat as a hostname
+            }
+        } else {
+            (url, None)
+        };
+
+        let address = if let Ok(ip) = host.parse::<IpAddr>() {
+            BindAddress::Ip(ip)
+        } else {
+            resolve_hostname(host)
+                .map(BindAddress::Ip)
+                .unwrap_or(BindAddress::Ip(IpAddr::V4(Ipv4Addr::UNSPECIFIED)))
+        };
+        let (port, address) = match protocol {
+            TransferProtocol::Http => (port.or(Some(80)), address),
+            TransferProtocol::Https => (port.or(Some(443)), address),
+            TransferProtocol::Unix => (None, BindAddress::UnixSocket(host.into())),
+        };
+
+        let tls_config = if let TransferProtocol::Http = protocol {
+            None
+        } else if let TransferProtocol::Https = protocol {
+            Some(configure_tls(host, &options)?)
+        } else if options.contains_key("cert") {
+            Some(configure_tls(host, &options)?)
+        } else {
+            None
+        };
+
+        Ok(Self {
+            address,
+            port,
+            protocol,
+            tls_config,
+        })
+    }
+}
+
+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()?
+        .filter_map(|addr| {
+            if addr.is_ipv6() {
+                Some(addr.ip()) // Prefer IPv6
+            } else {
+                None
+            }
+        })
+        .next()
+        .or_else(|| {
+            (hostname, 0)
+                .to_socket_addrs()
+                .ok()?
+                .map(|addr| addr.ip())
+                .next()
+        }) // Fallback to IPv4
+}

data/crates/itsi_server/src/server/itsi_ca/itsi_ca.crt

@@ -0,0 +1,32 @@
+-----BEGIN CERTIFICATE-----
+MIIFgTCCA2mgAwIBAgIUe316+G3qdkcWtRxYKlNBEAEenzAwDQYJKoZIhvcNAQEL
+BQAwUDELMAkGA1UEBhMCVVMxDTALBgNVBAgMBEl0c2kxDTALBgNVBAcMBEl0c2kx
+EDAOBgNVBAoMB0l0c2kgQ0ExETAPBgNVBAMMCGl0c2kuZnlpMB4XDTI1MDIyODAy
+NTkyNVoXDTM1MDIyNjAyNTkyNVowUDELMAkGA1UEBhMCVVMxDTALBgNVBAgMBEl0
+c2kxDTALBgNVBAcMBEl0c2kxEDAOBgNVBAoMB0l0c2kgQ0ExETAPBgNVBAMMCGl0
+c2kuZnlpMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAzKAK2RIvnATa
+pOxNYubaGjOx8z4thxwWM/KxMqI8gABmgRFTa99n1vrTenlfdX4PcoRyCXEJ3krh
+nPsRmP1nnUS1BEIX4Ha9xVPIy0UoP0JN1a4kVInejZe2ZTcpRv8k2KlkafIw0ISt
+/hSoopNV2SESCMDxx2e3F9d4wzHmkfs2+6k+12TTYkkifXaXgSOXm91a5ABqTfa8
+wS6td/zmwv6W5RNBU3kS3TsqoKjc0xdu25aifJ40i/+82b5OOWhWt+psSPlTZb+Y
+5elMhlh8Hjs52S3u48wz5joPsBi9r4yLYGhgB+AiW+b+y0uss7EiTQR24U+CroEB
+4c1LA4qTgQPUvUIXyyFGC3lPsjKHGiEitbIT4sDQOz3nMMvT0FIP7DPtiSAuyx0I
+J6/3+/QQ/8dzGqZskolKTSWGToOysNWcIxbbBprDAXYseOTJvREVpwC/Qra5OUqU
+6P8K72yp2hSCu/5EQwV3kwKMw0JmjJFyaL8SC2GJnueWWCIIZjYdc0ZAA9Dvl9eo
+SfQA4emLjUcScFpj8kv3Iu5tGJxnO1gqJ4JV+NKJ/09AxXvFYpNhaBXJ0xUOTA8/
+vBTkAs9hTFV1IFIgJNP5CxEbkWr5FcFYUKAopFhDKfQkXGCKEn4s3wuNqUuzEEdE
+Sx2YVV8XKbb9eKpHN5cQ6ljeFvanKpMCAwEAAaNTMFEwHQYDVR0OBBYEFIaKuU5Z
+CCv9JAsdqvHyR5QnE1OdMB8GA1UdIwQYMBaAFIaKuU5ZCCv9JAsdqvHyR5QnE1Od
+MA8GA1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcNAQELBQADggIBAGslKyiOzrJzfVEA
+HwJu/4CpDs7MpZuzAJ/AS0shWR3qlpHJUn6c/NIaQBfmVIo+vfxTvwV+ih6tZ+4A
+HmIZrCQm7rn5uQm2Q9G++JQ0RgQfLngnz3FBL+aERW2wxw1vOcPwg8JWCeGUSCd4
+Lj4jtpvlniS5uIiCD2GYxRIub401egX60XAiHdR0k6rS2dKxab9vMKW28RvRddak
+YCk7UKSXOZlj39XVH/JCB8+4IokDLTikpoAUqiNfytO+kx9+1JHKti8NjSQJwjqO
+JtBd1OD2ziQqd0gVKjr3J4IwIBv3Yl3GGUi3c5HVyDejriPciPrK+4G6a4IDGiyG
+rQRTzTR98ILsPX5uvOJadF1TAyZpS8oN7xFM8BnKfdpB34x3p9KgBqk34dRIXxbF
+nM3AJRT5dHlcHkn6z1snFqRHko4QvG0bSHlZFepogLG9yOGB0B1Hp4JPTSimEb6f
+b+CL5o8mXzAMRDIzdjTkBM/nQg5NMoXaXvmKypw/zIYI/ffb6Kwu/Y6gWmXubQrA
+fJ95Ssb14RKtmW6IDmHD5mNpybjhoSzwtBZyuHAyVZT/5P8/QHNkMBwpfQsevY5f
+FmOcAZIq9bHTBvn5SNNvi2NxZfTRD7sTMogXgqKKcxwe2rs52IYecamNekQMjrPL
+jI16bCLO/G1NaQ+N9YFL4TGfvbCe
+-----END CERTIFICATE-----

data/crates/itsi_server/src/server/itsi_ca/itsi_ca.key

@@ -0,0 +1,52 @@
+-----BEGIN PRIVATE KEY-----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+-----END PRIVATE KEY-----

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

@@ -0,0 +1,182 @@
+use super::{
+    bind::Bind,
+    listener::{Listener, SockAddr},
+};
+use crate::{request::itsi_request::ItsiRequest, ITSI_SERVER};
+use bytes::Bytes;
+use derive_more::Debug;
+use http_body_util::{combinators::BoxBody, Empty};
+use hyper::{
+    body::Incoming, header::HeaderName, service::service_fn, HeaderMap, Request, Response,
+    StatusCode,
+};
+use hyper_util::{rt::TokioExecutor, server::conn::auto::Builder};
+use itsi_tracing::{error, info};
+use magnus::{
+    error::Result,
+    scan_args::{get_kwargs, scan_args, Args, KwArgs},
+    value::{Opaque, ReprValue},
+    RHash, Ruby, Value,
+};
+use parking_lot::Mutex;
+use std::{collections::HashMap, convert::Infallible, sync::Arc};
+use tokio::runtime::Builder as RuntimeBuilder;
+use tokio::task::JoinSet;
+
+#[magnus::wrap(class = "Itsi::Server", free_immediately, size)]
+#[derive(Debug)]
+pub struct Server {
+    #[debug(skip)]
+    app: Opaque<Value>,
+    #[allow(unused)]
+    workers: u16,
+    #[allow(unused)]
+    threads: u16,
+    #[allow(unused)]
+    shutdown_timeout: f64,
+    script_name: String,
+    pub(crate) binds: Mutex<Vec<Bind>>,
+}
+
+impl Server {
+    pub fn new(args: &[Value]) -> Result<Self> {
+        type OptionalArgs = (
+            Option<u16>,
+            Option<u16>,
+            Option<f64>,
+            Option<String>,
+            Option<Vec<String>>,
+        );
+
+        let scan_args: Args<(), (), (), (), RHash, ()> = scan_args(args)?;
+        let args: KwArgs<(Value,), OptionalArgs, ()> = get_kwargs(
+            scan_args.keywords,
+            &["app"],
+            &[
+                "workers",
+                "threads",
+                "shutdown_timeout",
+                "script_name",
+                "binds",
+            ],
+        )?;
+        let server = Server {
+            app: Opaque::from(args.required.0),
+            workers: args.optional.0.unwrap_or(1),
+            threads: args.optional.1.unwrap_or(1),
+            shutdown_timeout: args.optional.2.unwrap_or(5.0),
+            script_name: args.optional.3.unwrap_or("".to_string()),
+            binds: Mutex::new(
+                args.optional
+                    .4
+                    .unwrap_or_else(|| vec!["localhost:3000".to_string()])
+                    .into_iter()
+                    .map(|s| s.parse().unwrap_or_else(|_| Bind::default()))
+                    .collect(),
+            ),
+        };
+        Ok(server)
+    }
+
+    pub(crate) async fn process_request(
+        hyper_request: Request<Incoming>,
+        app: Opaque<Value>,
+        script_name: String,
+        listener: Arc<Listener>,
+        addr: SockAddr,
+    ) -> itsi_error::Result<Response<BoxBody<Bytes, Infallible>>> {
+        let request = ItsiRequest::build_from(hyper_request, addr, script_name, listener).await;
+        let ruby = Ruby::get().unwrap();
+        let server = ruby.get_inner(&ITSI_SERVER);
+        let response: Result<(u16, HashMap<String, String>, Value)> =
+            server.funcall("call", (app, request));
+        if let Ok((status, headers_raw, body)) = response {
+            let mut body_buf = vec![];
+            for body_chunk in body.enumeratorize("each", ()) {
+                body_buf.push(body_chunk.unwrap().to_string())
+            }
+            body.check_funcall::<_, _, Value>("close", ());
+            let boxed_body = BoxBody::new(body_buf.join(""));
+            let mut response = Response::new(boxed_body);
+            let mut headers = HeaderMap::new();
+            headers_raw.into_iter().for_each(|(key, value)| {
+                let header_name: HeaderName = key.parse().unwrap();
+                headers.insert(header_name, value.parse().unwrap());
+            });
+            *response.headers_mut() = headers;
+            *response.status_mut() = StatusCode::from_u16(status).unwrap();
+            Ok(response)
+        } else {
+            let mut response = Response::new(BoxBody::new(Empty::new()));
+            *response.status_mut() = StatusCode::BAD_REQUEST;
+            Ok(response)
+        }
+    }
+
+    pub fn start(&self) {
+        let mut builder: RuntimeBuilder = RuntimeBuilder::new_current_thread();
+        let runtime = builder
+            .thread_name("itsi-server-accept-loop")
+            .thread_stack_size(3 * 1024 * 1024)
+            .enable_io()
+            .enable_time()
+            .build()
+            .expect("Failed to build Tokio runtime");
+
+        runtime.block_on(async {
+            let server = Arc::new(Builder::new(TokioExecutor::new()));
+            let listeners: Vec<Listener> = self
+                .binds
+                .lock()
+                .iter()
+                .cloned()
+                .map(Listener::from)
+                .collect::<Vec<_>>();
+
+            let mut set = JoinSet::new();
+
+            for listener in listeners {
+                let app = self.app;
+                let server_clone = server.clone();
+                let listener_clone = Arc::new(listener);
+                let script_name = self.script_name.clone();
+
+                set.spawn(async move {
+                    loop {
+                        let server = server_clone.clone();
+                        let listener = listener_clone.clone();
+                        let script_name = script_name.clone();
+                        let (stream, addr) = match listener.accept().await {
+                            Ok(stream) => stream,
+                            Err(e) => {
+                                error!("Failed to accept connection: {:?}", e);
+                                continue;
+                            }
+                        };
+
+                        tokio::spawn(async move {
+                            if let Err(e) = server
+                                .serve_connection_with_upgrades(
+                                    stream,
+                                    service_fn(move |hyper_request: Request<Incoming>| {
+                                        Server::process_request(
+                                            hyper_request,
+                                            app,
+                                            script_name.clone(),
+                                            listener.clone(),
+                                            addr.clone(),
+                                        )
+                                    }),
+                                )
+                                .await
+                            {
+                                info!("Closed connection due to: {:?}", e);
+                            }
+                        });
+                    }
+                });
+            }
+            while let Some(_res) = set.join_next().await {}
+        })
+    }
+}