itsi-server 0.1.1 → 0.1.2

data/ext/itsi_scheduler/src/itsi_scheduler/io_helpers.rs

@@ -0,0 +1,56 @@
+use std::os::fd::RawFd;
+
+use itsi_error::{ItsiError, Result};
+use mio::Interest;
+use nix::libc::{fcntl, poll, pollfd, F_GETFL, F_SETFL, O_NONBLOCK};
+
+use super::Readiness;
+
+pub fn set_nonblocking(fd: RawFd) -> itsi_error::Result<()> {
+    unsafe {
+        let flags = fcntl(fd, F_GETFL);
+        if flags < 0 {
+            return Err(ItsiError::ArgumentError(format!(
+                "fcntl(F_GETFL) error for fd {}: {}",
+                fd,
+                std::io::Error::last_os_error()
+            )));
+        }
+        let new_flags = flags | O_NONBLOCK;
+        if fcntl(fd, F_SETFL, new_flags) < 0 {
+            return Err(ItsiError::ArgumentError(format!(
+                "fcntl(F_SETFL) error for fd {}: {}",
+                fd,
+                std::io::Error::last_os_error()
+            )));
+        }
+    }
+    Ok(())
+}
+
+pub fn poll_readiness(fd: RawFd, events: i16) -> Option<Readiness> {
+    let mut pfd = pollfd {
+        fd,
+        events,
+        revents: 0,
+    };
+    let ret = unsafe { poll(&mut pfd as *mut pollfd, 1, 0) };
+    if ret > 0 {
+        return Some(Readiness(pfd.revents));
+    }
+    None
+}
+
+pub fn build_interest(events: i16) -> Result<Interest> {
+    let mut interest_opt = None;
+    if events & 1 != 0 {
+        interest_opt = Some(Interest::READABLE);
+    }
+    if events & 4 != 0 {
+        interest_opt = Some(match interest_opt {
+            Some(i) => i | Interest::WRITABLE,
+            None => Interest::WRITABLE,
+        });
+    }
+    interest_opt.ok_or_else(|| ItsiError::ArgumentError("No valid event specified".to_owned()))
+}

data/ext/itsi_scheduler/src/itsi_scheduler/io_waiter.rs

@@ -0,0 +1,44 @@
+use derive_more::Debug;
+use mio::{event::Source, unix::SourceFd, Interest, Token};
+use std::os::fd::RawFd;
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct IoWaiter {
+    pub fd: RawFd,
+    pub readiness: i16,
+    pub token: Token,
+}
+
+impl IoWaiter {
+    pub fn new(fd: RawFd, readiness: i16, token: Token) -> Self {
+        Self {
+            fd,
+            readiness,
+            token,
+        }
+    }
+}
+
+impl Source for IoWaiter {
+    fn register(
+        &mut self,
+        registry: &mio::Registry,
+        token: Token,
+        interests: Interest,
+    ) -> std::io::Result<()> {
+        SourceFd(&self.fd).register(registry, token, interests)
+    }
+
+    fn reregister(
+        &mut self,
+        registry: &mio::Registry,
+        token: Token,
+        interests: Interest,
+    ) -> std::io::Result<()> {
+        SourceFd(&self.fd).reregister(registry, token, interests)
+    }
+
+    fn deregister(&mut self, registry: &mio::Registry) -> std::io::Result<()> {
+        SourceFd(&self.fd).deregister(registry)
+    }
+}

data/ext/itsi_scheduler/src/itsi_scheduler/timer.rs

@@ -0,0 +1,44 @@
+use std::{
+    cmp::Ordering,
+    time::{Duration, Instant},
+};
+
+use mio::Token;
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Timer {
+    pub wake_time: Instant,
+    pub token: Token,
+}
+impl PartialOrd for Timer {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for Timer {
+    fn cmp(&self, other: &Self) -> Ordering {
+        // Reverse the order: a timer with an earlier wake_time should be considered greater.
+        other
+            .wake_time
+            .cmp(&self.wake_time)
+            .then_with(|| other.token.cmp(&self.token))
+    }
+}
+
+impl Timer {
+    pub fn new(wake_in: Duration, token: Token) -> Self {
+        Self {
+            wake_time: Instant::now() + wake_in,
+            token,
+        }
+    }
+
+    pub fn is_due(&self) -> bool {
+        self.wake_time <= Instant::now()
+    }
+
+    pub(crate) fn duration(&self) -> Option<Duration> {
+        self.wake_time.checked_duration_since(Instant::now())
+    }
+}

data/ext/itsi_scheduler/src/itsi_scheduler.rs

@@ -0,0 +1,308 @@
+mod io_helpers;
+mod io_waiter;
+mod timer;
+use io_helpers::{build_interest, poll_readiness, set_nonblocking};
+use io_waiter::IoWaiter;
+use itsi_error::ItsiError;
+use itsi_rb_helpers::{call_without_gvl, create_ruby_thread};
+use magnus::{
+    error::Result as MagnusResult,
+    value::{InnerValue, Opaque, ReprValue},
+    Module, RClass, Ruby, Value,
+};
+use mio::{Events, Poll, Token, Waker};
+use parking_lot::{Mutex, RwLock};
+use std::{
+    collections::{BinaryHeap, HashMap, VecDeque},
+    os::fd::RawFd,
+    sync::Arc,
+    time::Duration,
+};
+use timer::Timer;
+use tracing::{debug, info, warn};
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub(crate) struct Readiness(i16);
+
+impl std::fmt::Debug for ItsiScheduler {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("ItsiScheduler").finish()
+    }
+}
+
+const WAKE_TOKEN: Token = Token(0);
+
+#[magnus::wrap(class = "Itsi::Scheduler", free_immediately, size)]
+pub(crate) struct ItsiScheduler {
+    timers: Mutex<BinaryHeap<Timer>>,
+    io_waiters: Mutex<HashMap<Token, IoWaiter>>,
+    registry: Mutex<HashMap<RawFd, VecDeque<IoWaiter>>>,
+    poll: Mutex<Poll>,
+    events: Mutex<Events>,
+    waker: Mutex<Waker>,
+}
+
+impl Default for ItsiScheduler {
+    fn default() -> Self {
+        let poll = Poll::new().unwrap();
+        let waker = Waker::new(poll.registry(), WAKE_TOKEN).unwrap();
+        let events = Events::with_capacity(1024);
+
+        ItsiScheduler {
+            timers: Mutex::new(BinaryHeap::new()),
+            io_waiters: Mutex::new(HashMap::new()),
+            registry: Mutex::new(HashMap::new()),
+            poll: Mutex::new(poll),
+            events: Mutex::new(events),
+            waker: Mutex::new(waker),
+        }
+    }
+}
+
+impl ItsiScheduler {
+    pub fn initialize(&self) {}
+
+    pub fn wake(&self) -> MagnusResult<()> {
+        self.waker.lock().wake().map_err(|_| {
+            magnus::Error::new(
+                magnus::exception::exception(),
+                "Failed to wake the scheduler",
+            )
+        })?;
+        Ok(())
+    }
+    pub fn register_io_wait(
+        &self,
+        io_obj: i32,
+        events: i16,
+        timeout: Option<f64>,
+        token: usize,
+    ) -> MagnusResult<Option<i16>> {
+        debug!(
+            "Registering IO Wait for {:?}, {:?}, {:?}, {:?}",
+            io_obj, events, timeout, token
+        );
+        let fd: RawFd = io_obj;
+
+        let readiness = poll_readiness(fd, events).unwrap_or(Readiness(0));
+        if readiness == Readiness(events) {
+            return Ok(Some(readiness.0));
+        }
+
+        set_nonblocking(fd)?;
+        let interest = build_interest(events)?;
+        let token = Token(token);
+        let mut waiter = IoWaiter::new(fd, events, token);
+        self.io_waiters.lock().insert(token, waiter.clone());
+        let mut binding = self.registry.lock();
+        let queue = binding.entry(fd).or_default();
+
+        queue.push_back(waiter.clone());
+
+        if queue.len() == 1 {
+            self.poll
+                .lock()
+                .registry()
+                .register(&mut waiter, token, interest)
+                .map_err(|e| ItsiError::ArgumentError(format!("register error: {}", e)))?;
+        }
+        Ok(None)
+    }
+
+    pub fn start_timer(&self, timeout: Option<f64>, token: usize) {
+        if timeout.is_some_and(|t| t >= 0.0) {
+            let timer_entry = Timer::new(Duration::from_secs_f64(timeout.unwrap()), Token(token));
+            self.timers.lock().push(timer_entry);
+        }
+    }
+    pub fn has_pending_io(&self) -> bool {
+        !self.timers.lock().is_empty() || !self.io_waiters.lock().is_empty()
+    }
+
+    pub fn class_info(msg: String) {
+        info!(msg);
+    }
+
+    pub fn info(&self, msg: String) {
+        info!(msg);
+    }
+
+    pub fn warn(&self, msg: String) {
+        warn!(msg);
+    }
+
+    pub fn debug(&self, msg: String) {
+        debug!(msg);
+    }
+
+    pub fn fetch_due_events(&self) -> MagnusResult<Option<Vec<(usize, i16)>>> {
+        call_without_gvl(|| {
+            let timeout = if let Some(timer) = self.timers.lock().peek() {
+                timer.duration().or(Some(Duration::ZERO))
+            } else {
+                None
+            };
+            let mut due_fibers: Option<Vec<(usize, i16)>> = None;
+            let mut io_waiters = self.io_waiters.lock();
+            if !io_waiters.is_empty() || timeout.is_none() {
+                let mut events = self.events.lock();
+                {
+                    let mut poll = self.poll.lock();
+                    poll.poll(&mut events, timeout)
+                        .map_err(|e| ItsiError::ArgumentError(format!("poll error: {}", e)))?;
+                };
+
+                for event in events.iter() {
+                    let token = event.token();
+                    if token == WAKE_TOKEN {
+                        continue;
+                    }
+
+                    let waiter = io_waiters.remove(&token);
+                    if waiter.is_none() {
+                        continue;
+                    }
+                    let mut waiter = waiter.unwrap();
+                    let mut evt_readiness = 0;
+                    if event.is_readable() {
+                        evt_readiness |= 1;
+                    }
+                    if event.is_priority() {
+                        evt_readiness |= 2;
+                    }
+                    if event.is_writable() {
+                        evt_readiness |= 4
+                    }
+                    self.poll
+                        .lock()
+                        .registry()
+                        .deregister(&mut waiter)
+                        .map_err(|_| {
+                            ItsiError::ArgumentError("Failed to deregister".to_string())
+                        })?;
+
+                    due_fibers
+                        .get_or_insert_default()
+                        .push((waiter.token.0, evt_readiness));
+
+                    let mut binding = self.registry.lock();
+                    // Pop the current item for the current waiter off the queue
+                    let queue = binding.get_mut(&(waiter.fd)).unwrap();
+                    queue.pop_front();
+
+                    if let Some(head) = queue.get_mut(0) {
+                        // Register the next item in the queue if there is one.
+                        let interest = build_interest(head.readiness)?;
+                        self.poll
+                            .lock()
+                            .registry()
+                            .register(head, head.token, interest)
+                            .map_err(|_| {
+                                ItsiError::ArgumentError("Failed to deregister".to_string())
+                            })?;
+                    } else {
+                        // Otherwise we drop the queue altogether.
+                        binding.remove(&waiter.fd);
+                    }
+                }
+                return Ok(due_fibers);
+            }
+            Ok(None)
+        })
+    }
+
+    pub fn run_blocking_in_thread<T, F>(&self, ruby: &Ruby, work: F) -> MagnusResult<Option<T>>
+    where
+        T: Send + Sync + std::fmt::Debug + 'static,
+        F: FnOnce() -> Option<T> + Send + 'static,
+    {
+        let result: Arc<RwLock<Option<T>>> = Arc::new(RwLock::new(None));
+        let result_clone = Arc::clone(&result);
+
+        let current_fiber = Opaque::from(ruby.fiber_current());
+        let scheduler = Opaque::from(
+            ruby.module_kernel()
+                .const_get::<_, RClass>("Fiber")
+                .unwrap()
+                .funcall::<_, _, Value>("scheduler", ())
+                .unwrap(),
+        );
+
+        create_ruby_thread(move || {
+            call_without_gvl(|| {
+                let outcome = work();
+                *result_clone.write() = outcome;
+            });
+
+            let ruby = Ruby::get().unwrap();
+            scheduler
+                .get_inner_with(&ruby)
+                .funcall::<_, _, Value>("unblock", (None::<String>, current_fiber))
+                .unwrap();
+        });
+
+        scheduler
+            .get_inner_with(ruby)
+            .funcall::<_, _, Value>("block", (None::<Value>, None::<u64>))?;
+
+        let result_opt = Arc::try_unwrap(result).unwrap().write().take();
+        Ok(result_opt)
+    }
+
+    pub fn address_resolve(
+        ruby: &Ruby,
+        rself: &Self,
+        hostname: String,
+    ) -> MagnusResult<Option<Vec<String>>> {
+        let result: Option<Vec<String>> = rself.run_blocking_in_thread(ruby, move || {
+            use std::net::ToSocketAddrs;
+            let addrs_res = (hostname.as_str(), 0).to_socket_addrs();
+            match addrs_res {
+                Ok(addrs) => {
+                    let ips: Vec<String> = addrs.map(|s| s.ip().to_string()).collect();
+                    Some(ips)
+                }
+                Err(_) => None,
+            }
+        })?;
+        Ok(result)
+    }
+
+    pub fn fetch_due_timers(&self) -> MagnusResult<Option<Vec<usize>>> {
+        call_without_gvl(|| {
+            let mut timers = self.timers.lock();
+            let mut io_waiters = self.io_waiters.lock();
+            let mut due_fibers: Option<Vec<usize>> = None;
+            while let Some(timer) = timers.peek() {
+                if timer.is_due() {
+                    due_fibers.get_or_insert_default().push(timer.token.0);
+                    if let Some(waiter) = io_waiters.remove(&timer.token) {
+                        let mut binding = self.registry.lock();
+                        // Pop the current item for the current waiter off the queue
+                        let queue = binding.get_mut(&waiter.fd).unwrap();
+                        queue.pop_front();
+
+                        if let Some(head) = queue.get_mut(0) {
+                            // Register the next item in the queue if there is one.
+                            let interest = build_interest(head.readiness)?;
+                            self.poll
+                                .lock()
+                                .registry()
+                                .register(head, head.token, interest)
+                                .map_err(|_| {
+                                    ItsiError::ArgumentError("Failed to deregister".to_string())
+                                })?;
+                        } else {
+                            // Otherwise we drop the queue altogether.
+                            binding.remove(&waiter.fd);
+                        }
+                    }
+                    timers.pop();
+                } else {
+                    break;
+                }
+            }
+            Ok(due_fibers)
+        })
+    }
+}

data/ext/itsi_scheduler/src/lib.rs

@@ -0,0 +1,38 @@
+use itsi_scheduler::ItsiScheduler;
+use magnus::{function, method, Class, Error, Module, Object, Ruby};
+mod itsi_scheduler;
+
+#[magnus::init]
+fn init(ruby: &Ruby) -> Result<(), Error> {
+    itsi_tracing::init();
+    let module = ruby.define_module("Itsi")?;
+    let scheduler = module.define_class("Scheduler", ruby.class_object())?;
+    scheduler.define_singleton_method("info", function!(ItsiScheduler::class_info, 1))?;
+    scheduler.define_alloc_func::<ItsiScheduler>();
+    scheduler.define_method("initialize", method!(ItsiScheduler::initialize, 0))?;
+    scheduler.define_method("wake", method!(ItsiScheduler::wake, 0))?;
+    scheduler.define_method(
+        "register_io_wait",
+        method!(ItsiScheduler::register_io_wait, 4),
+    )?;
+    scheduler.define_method("info", method!(ItsiScheduler::info, 1))?;
+    scheduler.define_method("debug", method!(ItsiScheduler::debug, 1))?;
+    scheduler.define_method("warn", method!(ItsiScheduler::warn, 1))?;
+    scheduler.define_method("start_timer", method!(ItsiScheduler::start_timer, 2))?;
+    scheduler.define_method(
+        "address_resolve",
+        method!(ItsiScheduler::address_resolve, 1),
+    )?;
+    scheduler.define_method("has_pending_io?", method!(ItsiScheduler::has_pending_io, 0))?;
+
+    scheduler.define_method(
+        "fetch_due_timers",
+        method!(ItsiScheduler::fetch_due_timers, 0),
+    )?;
+    scheduler.define_method(
+        "fetch_due_events",
+        method!(ItsiScheduler::fetch_due_events, 0),
+    )?;
+
+    Ok(())
+}

data/ext/itsi_server/Cargo.toml

@@ -10,7 +10,7 @@ publish = false
 crate-type = ["cdylib"]
 
 [dependencies]
-magnus = { version = "0.7.1", features = ["bytes"] }
+magnus = { version = "0.7.1", features = ["bytes", "rb-sys"] }
 itsi_tracing = { path = "../itsi_tracing" }
 itsi_rb_helpers = { path = "../itsi_rb_helpers" }
 itsi_error = { path = "../itsi_error" }
@@ -26,4 +26,16 @@ hyper = { version = "1.5.0", features = ["full", "server", "http1", "http2"] }
 tokio = { version = "1", features = ["full"] }
 hyper-util = { version = "0.1.10", features = ["full"] }
 derive_more = { version = "2.0.1", features = ["debug"] }
-http = "1.2.0"
+http = "1.3.1"
+crossbeam = "0.8.4"
+futures = "0.3.31"
+nix = { version = "0.29.0", features = ["socket", "uio", "signal"] }
+pin-project = "1.1.9"
+rb-sys = "0.9.111"
+tracing = "0.1.41"
+tokio-util = "0.7.13"
+tokio-stream = "0.1.17"
+httparse = "1.10.1"
+async-channel = "2.3.1"
+tempfile = "3.18.0"
+sysinfo = "0.33.1"

data/ext/itsi_server/extconf.rb

@@ -3,4 +3,4 @@
 require "mkmf"
 require "rb_sys/mkmf"
 
-create_rust_makefile("itsi_server/itsi_server")
+create_rust_makefile("server/itsi_server")

data/ext/itsi_server/src/body_proxy/big_bytes.rs

@@ -0,0 +1,104 @@
+use bytes::Bytes;
+use magnus::{IntoValue, Ruby, Value};
+use std::io::{Result as IoResult, Write};
+use std::path::PathBuf;
+use tempfile::NamedTempFile;
+
+const THRESHOLD: usize = 1024 * 1024; // 1 MB
+
+/// An container that holds data in memory if it’s small, or in a temporary file on disk if it exceeds THRESHOLD.
+/// Used for providing Rack input data.
+pub enum BigBytes {
+    InMemory(Vec<u8>),
+    OnDisk(NamedTempFile),
+}
+
+/// The result type for reading the contents of a `BigBytes` value.
+pub enum BigBytesReadResult {
+    /// When the data is stored in memory, returns the cached bytes.
+    InMemory(Vec<u8>),
+    /// When the data is stored on disk, returns the path to the temporary file.
+    OnDisk(PathBuf),
+}
+
+impl BigBytes {
+    /// Creates a new, empty BigBytes instance (initially in memory).
+    pub fn new() -> Self {
+        BigBytes::InMemory(Vec::new())
+    }
+
+    /// Reads the entire contents that have been written.
+    ///
+    /// - If stored in memory, returns a clone of the bytes.
+    /// - If stored on disk, returns the file path of the temporary file.
+    pub fn read(&self) -> IoResult<BigBytesReadResult> {
+        match self {
+            BigBytes::InMemory(vec) => Ok(BigBytesReadResult::InMemory(vec.clone())),
+            BigBytes::OnDisk(temp_file) => {
+                // Flush to be safe, then return the file path.
+                temp_file.as_file().sync_all()?;
+                Ok(BigBytesReadResult::OnDisk(temp_file.path().to_path_buf()))
+            }
+        }
+    }
+
+    pub fn as_value(&self) -> Value {
+        match self {
+            BigBytes::InMemory(bytes) => {
+                let bytes = Bytes::from(bytes.to_owned());
+                bytes.into_value()
+            }
+            BigBytes::OnDisk(path) => {
+                let ruby = Ruby::get().unwrap();
+                let rarray = ruby.ary_new();
+                rarray.push(path.path().to_str().unwrap().into_value()).ok();
+                rarray.into_value()
+            }
+        }
+    }
+}
+
+impl Drop for BigBytes {
+    fn drop(&mut self) {
+        match self {
+            BigBytes::InMemory(_) => {}
+            BigBytes::OnDisk(path) => {
+                let _ = std::fs::remove_file(path);
+            }
+        }
+    }
+}
+
+impl Default for BigBytes {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl Write for BigBytes {
+    fn write(&mut self, buf: &[u8]) -> IoResult<usize> {
+        match self {
+            BigBytes::InMemory(vec) => {
+                // Check if writing the new bytes would exceed the threshold.
+                if vec.len() + buf.len() > THRESHOLD {
+                    let mut tmp = NamedTempFile::new()?;
+                    tmp.write_all(vec)?;
+                    tmp.write_all(buf)?;
+                    *self = BigBytes::OnDisk(tmp);
+                    Ok(buf.len())
+                } else {
+                    vec.extend_from_slice(buf);
+                    Ok(buf.len())
+                }
+            }
+            BigBytes::OnDisk(tmp_file) => tmp_file.write(buf),
+        }
+    }
+
+    fn flush(&mut self) -> IoResult<()> {
+        match self {
+            BigBytes::InMemory(_) => Ok(()),
+            BigBytes::OnDisk(tmp_file) => tmp_file.flush(),
+        }
+    }
+}