itsi 0.1.0 → 0.1.2

data/gems/scheduler/test/test_network_io.rb

@@ -0,0 +1,274 @@
+# frozen_string_literal: true
+
+require "socket"
+require "timeout"
+require "debug"
+
+class TestNetworkIO < Minitest::Test
+  include Itsi::Scheduler::TestHelper
+
+  def test_tcp_echo
+    message = "Hello, Itsi!"
+    response = nil
+
+    with_scheduler do |_scheduler|
+      server = TCPServer.new("127.0.0.1", 0)
+      port = server.addr[1]
+
+      # Server fiber: accept one connection and echo data.
+      Fiber.schedule do
+        client = server.accept
+        data = client.read(message.size)
+        client.write(data)
+        client.close
+        server.close
+      end
+
+      # Client fiber: connect, send message, and read echo.
+      Fiber.schedule do
+        client = TCPSocket.new("127.0.0.1", port)
+        client.write(message)
+        response = client.read(message.size)
+        client.close
+      end
+    end
+
+    assert_equal message, response
+  end
+
+  def test_concurrent_tcp_clients
+    server = TCPServer.new("127.0.0.1", 0)
+    port = server.addr[1]
+    messages = %w[first second third fourth]
+    responses = {}
+
+    with_scheduler do |_scheduler|
+      # Server fiber: accept several connections.
+      Fiber.schedule do
+        messages.size.times do
+          client = server.accept
+          # Spawn a fiber for each connection to echo the data.
+          Fiber.schedule do
+            data = client.readpartial(1024)
+            client.write(data)
+            client.close
+          end
+        end
+        server.close
+      end
+
+      # Client fibers: connect concurrently and send messages.
+      messages.each do |msg|
+        Fiber.schedule do
+          sleep rand(0.01..0.05) # random delay for interleaving
+          client = TCPSocket.new("127.0.0.1", port)
+          client.write(msg)
+          responses[msg] = client.read(msg.size)
+          client.close
+        end
+      end
+    end
+
+    messages.each do |msg|
+      assert_equal msg, responses[msg]
+    end
+  end
+
+  def test_interleaved_network_and_sleep
+    server = TCPServer.new("127.0.0.1", 0)
+    port = server.addr[1]
+    responses = {}
+
+    with_scheduler do |_scheduler|
+      # Echo server that delays between chunks.
+      Fiber.schedule do
+        client = server.accept
+        data = "".dup
+        # Read in chunks until we have received 12 bytes.
+        while data.size < 12
+          begin
+            chunk = client.readpartial(3)
+          rescue EOFError
+            break
+          end
+          data << chunk
+          sleep 0.02 # delay between chunks
+        end
+        # Echo back the reversed data.
+        client.write(data.reverse)
+        client.close
+        server.close
+      end
+
+      # Client fiber: send data in small chunks.
+      Fiber.schedule do
+        sleep 0.05 # allow server to start
+        client = TCPSocket.new("127.0.0.1", port)
+        "HelloWorld!!".chars.each_slice(3) do |slice|
+          client.write(slice.join)
+          sleep 0.01
+        end
+        responses[:result] = client.read(12)
+        client.close
+      end
+    end
+
+    expected = "HelloWorld!!".reverse[0, 12]
+    assert_equal expected, responses[:result]
+  end
+
+  def test_tcp_timeout
+    server = TCPServer.new("127.0.0.1", 0)
+    port = server.addr[1]
+    result = nil
+
+    with_scheduler do |_scheduler|
+      # Server fiber: accept the connection but delay sending.
+      Fiber.schedule do
+        client = server.accept
+        sleep 0.2 # delay long enough to force a timeout on the client
+        client.write("late data")
+        client.close
+        server.close
+      end
+
+      # Client fiber: connect and wait for data with a short timeout.
+      Fiber.schedule do
+        sleep 0.05
+        client = TCPSocket.new("127.0.0.1", port)
+        result = if client.wait_readable(0.1)
+                   client.readpartial(1024)
+                 else
+                   nil
+                 end
+        client.close
+      end
+    end
+
+    # The client should time out (i.e. result remains nil) because the server waits too long.
+    assert_nil result
+  end
+
+  def test_multiple_fibers_on_same_socket
+    server = TCPServer.new("127.0.0.1", 0)
+    port = server.addr[1]
+    results = []
+
+    with_scheduler do |_scheduler|
+      # Server fiber: accept a connection and send a short message.
+      Fiber.schedule do
+        client1 = server.accept
+        client2 = server.accept
+        client1.write("network")
+        client2.write("network")
+        client1.close
+        client2.close
+        server.close
+      end
+
+      # Two separate client fibers using separate connections.
+      # (In many schedulers, if two fibers wait on the same IO object,
+      # only one may be resumed when data becomes available.)
+      2.times do |i|
+        Fiber.schedule do
+          sleep 0.001
+          client = TCPSocket.new("127.0.0.1", port)
+          res = client.wait_readable(0.05) ? "readable" : "timeout"
+          results << res
+          client.close
+        end
+      end
+    end
+
+    assert_equal 2, results.size
+    assert_includes results, "readable"
+  end
+
+  def test_two_fibers_only_one_connects
+    server = TCPServer.new("127.0.0.1", 0)
+    port = server.addr[1]
+    results = []
+
+    with_scheduler do |_scheduler|
+      # Server fiber: accept a connection and send a short message.
+      Fiber.schedule do
+        client1 = server.accept
+        client1.write("network")
+        client1.close
+        sleep 0.1
+        server.close
+      end
+
+      # Two separate client fibers using separate connections.
+      # (In many schedulers, if two fibers wait on the same IO object,
+      # only one may be resumed when data becomes available.)
+      2.times do |i|
+        Fiber.schedule do
+          sleep 0.001
+          client = TCPSocket.new("127.0.0.1", port)
+          res = client.wait_readable(0.05) ? "readable" : "timeout"
+          results << res
+          client.close
+        end
+      end
+    end
+
+    assert_equal 2, results.size
+    assert_includes results, "readable"
+    assert_includes results, "timeout"
+  end
+
+  def test_udp_and_tcp_interleaving
+    # Set up a UDP server.
+    udp_server = UDPSocket.new
+    udp_server.bind("127.0.0.1", 0)
+    udp_port = udp_server.addr[1]
+
+    # Set up a TCP server.
+    tcp_server = TCPServer.new("127.0.0.1", 0)
+    tcp_port = tcp_server.addr[1]
+
+    udp_result = nil
+    tcp_result = nil
+
+    with_scheduler do |_scheduler|
+      # UDP server fiber: wait for a datagram.
+      Fiber.schedule do
+        udp_result = udp_server.recvfrom(1024)[0]
+        udp_server.close
+      end
+
+      # TCP server fiber: accept a connection and read data.
+      Fiber.schedule do
+        client = tcp_server.accept
+        tcp_result = client.readpartial(1024)
+        client.close
+        tcp_server.close
+      end
+
+      # UDP client fiber: send a datagram.
+      Fiber.schedule do
+        sleep 0.02
+        udp_client = UDPSocket.new
+        udp_client.send("udp data", 0, "127.0.0.1", udp_port)
+        udp_client.close
+      end
+
+      # TCP client fiber: connect and send data.
+      Fiber.schedule do
+        sleep 0.02
+        client = TCPSocket.new("127.0.0.1", tcp_port)
+        client.write("tcp data")
+        client.close
+      end
+
+      # Additional fiber to interleave a sleep.
+      Fiber.schedule do
+        sleep 0.05
+      end
+    end
+
+    assert_equal "udp data", udp_result
+    assert_equal "tcp data", tcp_result
+  end
+end

data/gems/scheduler/test/test_process_wait.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+require 'debug'
+
+
+class TestProcessWait < Minitest::Test
+  include Itsi::Scheduler::TestHelper
+
+  def test_process_wait
+    start_time = Time.now
+    pids = []
+
+    with_scheduler do |_scheduler|
+      3.times do
+        pids << Process.spawn("sleep 0.25")
+      end
+      3.times do |i|
+        Fiber.schedule do
+          Process.wait(pids[i])
+        end
+      end
+    end
+    end_time = Time.now
+    assert_in_delta(0.25, end_time - start_time, 0.1)
+
+  end
+end

data/gems/server/exe/itsi

@@ -1,27 +1,32 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
-
 require "optparse"
-require "rack"
-require "etc"
 
 # Default options used when starting Osprey from the CLI using `osprey`
 DEFAULT_OPTIONS = {
   # Number of workers
-  workers: Etc.nprocessors,
+  workers: 1,
   # Number of threads per worker
   threads: 1,
   # Graceful shutdown timeout
-  shutdown_timeout: 0.3,
+  shutdown_timeout: 5,
   # Binds
-  binds: ['http://0.0.0.0:3000']
+  binds: ["http://0.0.0.0:3000"],
+  # Preload
+  preload: true,
+  # Rackup file
+  rackup_file: "config.ru",
+  # Scheduler class
+  scheduler_class: nil,
+  # Whether to stream the body or not
+  stream_body: false
 }
 
 options = DEFAULT_OPTIONS.to_a.select(&:last).to_h
 
 # Define the option parser
 OptionParser.new do |opts|
-  opts.banner = "Usage: script.rb [options]"
+  opts.banner = "Usage: itsi [options]"
 
   opts.on("-w", "--workers WORKERS", Integer, "Number of workers (default: #{options[:workers]})") do |w|
     options[:workers] = w
@@ -31,29 +36,64 @@ OptionParser.new do |opts|
     options[:threads] = t
   end
 
-  opts.on("-h", "--host HOST", String, "Host to bind to (default: #{options[:host]})") do |h|
-    options[:host] = h
+  opts.on("-r", "--rackup_file FILE", String, "Rackup file to use (default: #{options[:rackup_file]})") do |rf|
+    options[:rackup_file] = rf
   end
 
-  opts.on("-p", "--port PORT", Integer, "Port for the application (default: #{options[:port]})") do |p|
-    options[:port] = p
+  opts.on("--worker-memory-limit MEMORY_LIMIT", Integer,
+          "Memory limit for each worker (default: #{options[:worker_memory_limit] || 'None'}). If this limit is breached the worker is gracefully restarted") do |ml|
+    options[:worker_memory_limit] = ml
   end
 
-  opts.on("-f", "--use_fiber_scheduler PORT", TrueClass,
-          "Port for the application (default: #{options[:use_scheduler]})") do |p|
-    options[:use_scheduler] = p
+  opts.on("-f", "--fiber_scheduler [CLASS_NAME]", [String], "Scheduler class to use (default: nil). Provide blank or true to use Itsi::Scheduler, or a classname to use an alternative scheduler") do |scheduler_class|
+    if scheduler_class.nil? || scheduler_class == "true"
+      options[:scheduler_class] = "Itsi::Scheduler"
+    elsif scheduler_class == "false"
+      options.delete(:scheduler_class)
+    else
+      options[:scheduler_class] = scheduler_class
+    end
   end
 
-  opts.on("--http_port HTTP_PORT", Integer, "HTTP port for the application (default: #{options[:http_port]})") do |hp|
-    options[:http_port] = hp
+  opts.on("--preload [true, false, :bundle_group_name]", String, " Toggle preloading the application") do |preload|
+    if preload == "true"
+      options[:preload] = true
+    elsif preload == "false"
+      options[:preload] = false
+    else
+      # Not supported yet
+    end
   end
 
-  opts.on("-c", "--cert_path CERT_PATH", String, "Path to the SSL certificate file") do |cp|
-    options[:cert_path] = cp
+
+  opts.on("-b", "--bind BIND", String, "Bind address (default: #{options[:binds].join(", ")}). You can specify this flag multiple times to bind to multiple addresses.") do |bind|
+    options[:binds].pop if options[:binds].first.frozen?
+    options[:binds] << bind
   end
 
-  opts.on("-k", "--key_path KEY_PATH", String, "Path to the SSL key file") do |kp|
-    options[:key_path] = kp
+  opts.on("-c", "--cert_path CERT_PATH", String,
+          "Path to the SSL certificate file (must follow a --bind option). You can specify this flag multiple times.") do |cp|
+    raise OptionParser::InvalidOption, "--cert_path must follow a --bind" if options[:binds].empty?
+    require "uri"
+
+    # Modify the last bind entry to add/update the cert query parameter
+    uri = URI.parse("http://#{options[:binds].last}") # Ensure valid URI parsing
+    params = URI.decode_www_form(uri.query.to_s).to_h
+    params["cert"] = cp
+    query_string = params.map { |k, v| "#{k}=#{v}" }.join("&")
+    options[:binds][-1] = "#{uri.host}?#{query_string}"
+  end
+
+  opts.on("-k", "--key_path KEY_PATH", String, "Path to the SSL key file (must follow a --bind option). You can specify this flag multiple times.") do |kp|
+    raise OptionParser::InvalidOption, "--key_path must follow a --bind" if options[:binds].empty?
+    require "uri"
+
+    # Modify the last bind entry to add/update the key query parameter
+    uri = URI.parse("http://#{options[:binds].last}") # Ensure valid URI parsing
+    params = URI.decode_www_form(uri.query.to_s).to_h
+    params["key"] = kp
+    query_string = params.map { |k, v| "#{k}=#{v}" }.join("&")
+    options[:binds][-1] = "#{uri.host}?#{query_string}"
   end
 
   opts.on("--shutdown_timeout SHUTDOWN_TIMEOUT", String,
@@ -65,20 +105,40 @@ OptionParser.new do |opts|
     options[:script_name] = script_name
   end
 
-  opts.on("--help", "Show this help message") do
+  opts.on("--stream-body", TrueClass, "Stream body frames (default: false for best compatibility)") do |stream_body|
+    options[:stream_body] = stream_body
+  end
+
+  opts.on("-h", "--help", "Show this help message") do
     puts opts
     exit
   end
 end.parse!
 
-# Parse the Rack application
-app, _ = Rack::Builder.parse_file("config.ru")
+# Rack app loader, invoked per worker.
+# This is a no-op if preloading is enabled (we just return the preloaded app).
+preloader = \
+  if options[:preload]
+    require "rack"
+
+    app = Array(Rack::Builder.parse_file(options[:rackup_file])).first
+    require_relative "../lib/itsi/server/scheduler_mode" if options[:scheduler_class]
+    app.method(:itself).to_proc
+  else
+    lambda do
+      require "rack"
+
+      app = Array(Rack::Builder.parse_file(options[:rackup_file])).first
+      require_relative "../lib/itsi/server/scheduler_mode" if options[:scheduler_class]
+      app
+    end
+  end
 
-puts "App is #{app}"
-# Make sure osprey is loaded, if not already loaded by the rack_app above.
-# Start the Osprey server
+# Make sure Itsi is loaded, if not already loaded by the rack_app above.
+# Start the Itsi server
 require "itsi/server"
+
 Itsi::Server.new(
-  app: app,
-  **options
+  app: preloader,
+  **options.except(:preload, :rackup_file)
 ).start

data/gems/server/ext/itsi_error/Cargo.toml

@@ -7,3 +7,5 @@ edition = "2024"
 thiserror = "2.0.11"
 magnus = { version = "0.7.1" }
 rcgen = "0.13.2"
+nix = "0.29.0"
+httparse = "1.10.1"

data/gems/server/ext/itsi_error/src/from.rs

@@ -0,0 +1,70 @@
+use crate::ItsiError;
+use std::ffi::NulError;
+
+pub static CLIENT_CONNECTION_CLOSED: &str = "Client disconnected";
+
+impl From<httparse::Error> for ItsiError {
+    fn from(err: httparse::Error) -> Self {
+        ItsiError::ArgumentError(err.to_string())
+    }
+}
+
+impl From<nix::errno::Errno> for ItsiError {
+    fn from(err: nix::errno::Errno) -> Self {
+        ItsiError::ArgumentError(err.to_string())
+    }
+}
+
+impl From<std::io::Error> for ItsiError {
+    fn from(err: std::io::Error) -> Self {
+        ItsiError::ArgumentError(err.to_string())
+    }
+}
+
+impl From<rcgen::Error> for ItsiError {
+    fn from(err: rcgen::Error) -> Self {
+        ItsiError::ArgumentError(err.to_string())
+    }
+}
+
+impl From<NulError> for ItsiError {
+    fn from(err: NulError) -> Self {
+        ItsiError::ArgumentError(err.to_string())
+    }
+}
+
+impl From<magnus::Error> for ItsiError {
+    fn from(err: magnus::Error) -> Self {
+        match err.error_type() {
+            magnus::error::ErrorType::Jump(tag) => ItsiError::Jump(tag.to_string()),
+            magnus::error::ErrorType::Error(_exception_class, cow) => {
+                ItsiError::ArgumentError(cow.to_string())
+            }
+            magnus::error::ErrorType::Exception(exception) => {
+                ItsiError::ArgumentError(exception.to_string())
+            }
+        }
+    }
+}
+
+impl From<ItsiError> for magnus::Error {
+    fn from(err: ItsiError) -> Self {
+        match err {
+            ItsiError::InvalidInput(msg) => magnus::Error::new(magnus::exception::arg_error(), msg),
+            ItsiError::InternalServerError(msg) => {
+                magnus::Error::new(magnus::exception::exception(), msg)
+            }
+            ItsiError::UnsupportedProtocol(msg) => {
+                magnus::Error::new(magnus::exception::arg_error(), msg)
+            }
+            ItsiError::ArgumentError(msg) => {
+                magnus::Error::new(magnus::exception::arg_error(), msg)
+            }
+            ItsiError::Jump(msg) => magnus::Error::new(magnus::exception::local_jump_error(), msg),
+            ItsiError::Break() => magnus::Error::new(magnus::exception::interrupt(), "Break"),
+            ItsiError::ClientConnectionClosed => {
+                magnus::Error::new(magnus::exception::eof_error(), CLIENT_CONNECTION_CLOSED)
+            }
+        }
+    }
+}

data/gems/server/ext/itsi_error/src/lib.rs

@@ -1,49 +1,22 @@
+pub mod from;
 use thiserror::Error;
 
 pub type Result<T> = std::result::Result<T, ItsiError>;
 
 #[derive(Error, Debug)]
 pub enum ItsiError {
-    #[error("Invalid input")]
+    #[error("Invalid input {0}")]
     InvalidInput(String),
-    #[error("Internal server error")]
-    InternalServerError,
-    #[error("Unsupported protocol")]
+    #[error("Internal server error {0}")]
+    InternalServerError(String),
+    #[error("Unsupported protocol {0}")]
     UnsupportedProtocol(String),
-    #[error("Argument error")]
+    #[error("Argument error: {0}")]
     ArgumentError(String),
+    #[error("Client Connection Closed")]
+    ClientConnectionClosed,
     #[error("Jump")]
     Jump(String),
-}
-
-impl From<ItsiError> for magnus::Error {
-    fn from(err: ItsiError) -> Self {
-        magnus::Error::new(magnus::exception::runtime_error(), err.to_string())
-    }
-}
-
-impl From<std::io::Error> for ItsiError {
-    fn from(err: std::io::Error) -> Self {
-        ItsiError::ArgumentError(err.to_string())
-    }
-}
-
-impl From<rcgen::Error> for ItsiError {
-    fn from(err: rcgen::Error) -> Self {
-        ItsiError::ArgumentError(err.to_string())
-    }
-}
-
-impl From<magnus::Error> for ItsiError {
-    fn from(err: magnus::Error) -> Self {
-        match err.error_type() {
-            magnus::error::ErrorType::Jump(tag) => ItsiError::Jump(tag.to_string()),
-            magnus::error::ErrorType::Error(_exception_class, cow) => {
-                ItsiError::ArgumentError(cow.to_string())
-            }
-            magnus::error::ErrorType::Exception(exception) => {
-                ItsiError::ArgumentError(exception.to_string())
-            }
-        }
-    }
+    #[error("Break")]
+    Break(),
 }

data/gems/server/ext/itsi_instrument_entry/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "itsi_instrument_entry"
+version = "0.1.0"
+edition = "2021"
+authors = ["Wouter Coppieters <wc@pico.net.nz>"]
+license = "MIT"
+publish = false
+
+
+[lib]
+proc-macro = true
+[dependencies]
+proc-macro2 = "1.0"
+quote = "1.0"
+syn = { version = "1.0", features = ["full"] }

data/gems/server/ext/itsi_instrument_entry/src/lib.rs

@@ -0,0 +1,31 @@
+use proc_macro::TokenStream;
+use proc_macro2::TokenStream as TokenStream2;
+use quote::quote;
+use syn::{parse_macro_input, ItemFn};
+
+#[proc_macro_attribute]
+pub fn instrument_with_entry(attr: TokenStream, item: TokenStream) -> TokenStream {
+    let attr_tokens = TokenStream2::from(attr);
+    let input_fn = parse_macro_input!(item as ItemFn);
+    let attrs = input_fn.attrs;
+    let vis = input_fn.vis;
+    let sig = input_fn.sig;
+    let block = input_fn.block;
+    let output = quote! {
+        #[cfg(debug_assertions)]
+        #[tracing::instrument(#attr_tokens)]
+        #(#attrs)*
+        #vis #sig {
+            tracing::trace!("");
+            #block
+        }
+
+        #[cfg(not(debug_assertions))]
+        #(#attrs)*
+        #vis #sig {
+            #block
+        }
+    };
+
+    output.into()
+}

data/gems/server/ext/itsi_rb_helpers/Cargo.toml

@@ -4,5 +4,7 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
+cfg-if = "1.0.0"
 magnus = { version = "0.7.1", features = ["rb-sys", "bytes"] }
+nix = "0.29.0"
 rb-sys = "0.9.105"