itsi-server 0.1.1 → 0.1.18

data/Cargo.toml

@@ -0,0 +1,7 @@
+# This Cargo.toml is here to let externals tools (IDEs, etc.) know that this is
+# a Rust project. Your extensions dependencies should be added to the Cargo.toml
+# in the ext/ directory.
+
+[workspace]
+members = ["./ext/itsi_server"]
+resolver = "2"

data/README.md

@@ -1,3 +1,7 @@
+---
+type: docs
+---
+
 # ItsiServer
 
 TODO: Delete this and the text below, and describe your gem

data/Rakefile

@@ -3,7 +3,14 @@
 require "bundler/gem_tasks"
 require "minitest/test_task"
 
-Minitest::TestTask.create
+
+Minitest::TestTask.create(:test) do |t|
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.warning = false
+  t.test_globs = ['test/**/*.rb']
+  t.test_prelude = 'require "helpers/test_helper.rb"'
+end
 
 require "rubocop/rake_task"
 

data/_index.md

@@ -0,0 +1,6 @@
+---
+title: Itsi Server
+type: docs
+---
+
+## Foo

data/exe/itsi

@@ -1,59 +1,115 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
+require "itsi/server"
 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,
-  # Number of threads per worker
-  threads: 1,
-  # Graceful shutdown timeout
-  shutdown_timeout: 0.3,
-  # Binds
-  binds: ['http://0.0.0.0:3000']
+
+
+COMMANDS = {
+  "init" => "Initialize a new Itsi.rb server configuration file",
+  "status" => "Show the status of the server",
+  "start" => "Start the Isti server",
+  "serve" => "Start the Isti server",
+  "stop" => "Stop the server",
+  "reload" => "Reload the server",
+  "restart" => "Restart the server",
+  "add_worker" => "Add a new worker to the server cluster",
+  "remove_worker" => "Remove a worker from the server cluster",
+  "routes" => "Print the routes of the server",
+  "passfile" => "Manage hashed users and passwords in a passfile (like .htpasswd). [add, remove, list]",
+  "test_route" => "Test which route a request will be routed to",
+  "static" => "Serve static assets in the given directory"
 }
 
-options = DEFAULT_OPTIONS.to_a.select(&:last).to_h
+Itsi::Server::Config.prep_reexec!
+
+options = {}
 
-# Define the option parser
-OptionParser.new do |opts|
-  opts.banner = "Usage: script.rb [options]"
+parser = OptionParser.new do |opts|
+  opts.banner = "Usage: itsi [COMMAND] [options]"
 
-  opts.on("-w", "--workers WORKERS", Integer, "Number of workers (default: #{options[:workers]})") do |w|
+  opts.on("-C", "--config CONFIG_FILE", String, "Itsi Configuration file to use (default: Itsi.rb)") do |config_file|
+    options[:config_file] = config_file
+  end
+
+  opts.on("-w", "--workers WORKERS", Integer, "Number of workers") do |w|
     options[:workers] = w
   end
 
-  opts.on("-t", "--threads THREADS", Integer, "Number of threads (default: #{options[:threads]})") do |t|
+  opts.on("-d", "--daemonize", "Run the process as a daemon") do
+    Process.daemon(true)
+  end
+
+  opts.on("-t", "--threads THREADS", Integer, "Number of threads (default: 1)") do |t|
     options[:threads] = t
   end
 
-  opts.on("-h", "--host HOST", String, "Host to bind to (default: #{options[:host]})") do |h|
-    options[:host] = h
+  opts.on("--[no-]multithreaded-reactor", "Use a multithreaded reactor") do |mtr|
+    options[:multithreaded_reactor] = mtr
+  end
+
+  opts.on("-r", "--rackup_file FILE", String, "Rackup file to use (default: config.ru)") 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: 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: http://0.0.0.0:3000). You can specify this flag multiple times to bind to multiple addresses.") do |bind|
+    options[:binds] ||= []
+    options[:binds] << bind
+  end
+
+  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") do |kp|
-    options[:key_path] = kp
+  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,
@@ -61,24 +117,63 @@ OptionParser.new do |opts|
     options[:shutdown_timeout] = shutdown_timeout
   end
 
-  opts.on("--script_name SCRIPT_NAME", String, "Script name to inject into Rack ENV") do |script_name|
-    options[:script_name] = script_name
+
+  opts.on("--stream-body", TrueClass, "Stream body frames (default: false for best compatibility)") do |stream_body|
+    options[:stream_body] = stream_body
   end
 
-  opts.on("--help", "Show this help message") do
+  opts.on("-h", "--help", "Show this help message") do
     puts opts
+    puts "COMMAND: "
+    COMMANDS.each do |command, description|
+      puts "    #{command} - #{description}"
+    end
     exit
   end
-end.parse!
 
-# Parse the Rack application
-app, _ = Rack::Builder.parse_file("config.ru")
+  opts.on("--reexec PARAMS", String, "Reexec the server with the given parameters") do |params|
+    options[:reexec] = params
+  end
 
-puts "App is #{app}"
-# Make sure osprey is loaded, if not already loaded by the rack_app above.
-# Start the Osprey server
-require "itsi/server"
-Itsi::Server.new(
-  app: app,
-  **options
-).start
+  opts.on("--listeners LISTENERS", String, "Listeners for reexec") do |listeners|
+    options[:listeners] = listeners
+  end
+
+  opts.on("--passfile PASSFILE", String, "Passfile") do |passfile|
+    options[:passfile] = passfile
+  end
+
+  opts.on("--algorithm ALGORITHM", String, "Algorithm for password hashing") do |algorithm|
+    options[:algorithm] = algorithm
+  end
+end
+
+if ENV['COMP_LINE'] || ARGV.include?('--completion')
+  puts COMMANDS.keys
+  exit
+end
+
+parser.parse!
+
+case (command = ARGV.shift)
+when *COMMANDS.keys
+  required_arity = Itsi::Server.method(command).parameters&.select{|c| c.first == :req }&.length&.succ || 2
+  case required_arity
+  when 1 then Itsi::Server.send(command)
+  when 2 then Itsi::Server.send(command, options)
+  else
+    if ARGV.length != required_arity - 2
+      puts "Command #{command} requires #{required_arity - 2} subcommands. "
+      exit(0)
+    end
+    Itsi::Server.send(command, options, *ARGV)
+  end
+when nil
+  Itsi::Server.start(options)
+else
+  puts "Invalid command #{command}.\n"
+  puts "COMMAND: "
+  COMMANDS.each do |command, description|
+    puts "    #{command} - #{description}"
+  end
+end

data/ext/itsi_error/Cargo.toml

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

data/ext/itsi_error/src/lib.rs

@@ -1,49 +1,123 @@
+pub use anyhow::Context;
+use magnus::Error as MagnusError;
+use magnus::{
+    error::ErrorType,
+    exception::{self, arg_error, standard_error},
+};
 use thiserror::Error;
 
+pub static CLIENT_CONNECTION_CLOSED: &str = "Client disconnected";
 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("Jump")]
+
+    #[error("Client Connection Closed")]
+    ClientConnectionClosed,
+
+    #[error("Internal Error")]
+    InternalError(String),
+
+    #[error(transparent)]
+    Io(#[from] std::io::Error),
+
+    #[error(transparent)]
+    Rcgen(#[from] rcgen::Error),
+
+    #[error(transparent)]
+    HttpParse(#[from] httparse::Error),
+
+    #[error(transparent)]
+    NixErrno(#[from] nix::errno::Errno),
+
+    #[error(transparent)]
+    Nul(#[from] std::ffi::NulError),
+
+    #[error("Jump: {0}")]
     Jump(String),
+
+    #[error("Break")]
+    Break,
+
+    #[error("Pass")]
+    Pass,
+
+    #[error(transparent)]
+    Anyhow(#[from] anyhow::Error),
 }
 
-impl From<ItsiError> for magnus::Error {
-    fn from(err: ItsiError) -> Self {
-        magnus::Error::new(magnus::exception::runtime_error(), err.to_string())
+impl From<magnus::Error> for ItsiError {
+    fn from(err: magnus::Error) -> Self {
+        match err.error_type() {
+            ErrorType::Jump(tag) => ItsiError::Jump(tag.to_string()),
+            ErrorType::Error(_exception_class, cow) => ItsiError::ArgumentError(cow.to_string()),
+            ErrorType::Exception(exception) => ItsiError::ArgumentError(exception.to_string()),
+        }
     }
 }
 
-impl From<std::io::Error> for ItsiError {
-    fn from(err: std::io::Error) -> Self {
-        ItsiError::ArgumentError(err.to_string())
+pub trait IntoMagnusError {
+    fn into_magnus_error(self) -> MagnusError;
+}
+
+impl<T: std::error::Error> IntoMagnusError for T {
+    fn into_magnus_error(self) -> MagnusError {
+        MagnusError::new(standard_error(), self.to_string())
     }
 }
 
-impl From<rcgen::Error> for ItsiError {
-    fn from(err: rcgen::Error) -> Self {
-        ItsiError::ArgumentError(err.to_string())
+impl From<&str> for ItsiError {
+    fn from(s: &str) -> Self {
+        ItsiError::InternalError(s.to_owned())
     }
 }
 
-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<String> for ItsiError {
+    fn from(s: String) -> Self {
+        ItsiError::InternalError(s)
+    }
+}
+
+impl From<ItsiError> for magnus::Error {
+    fn from(err: ItsiError) -> Self {
+        match err {
+            ItsiError::InvalidInput(msg) => magnus::Error::new(arg_error(), msg),
+            ItsiError::InternalServerError(msg) => magnus::Error::new(standard_error(), msg),
+            ItsiError::InternalError(msg) => magnus::Error::new(standard_error(), msg),
+            ItsiError::UnsupportedProtocol(msg) => magnus::Error::new(arg_error(), msg),
+            ItsiError::ArgumentError(msg) => magnus::Error::new(arg_error(), msg),
+            ItsiError::Jump(msg) => magnus::Error::new(exception::local_jump_error(), msg),
+            ItsiError::ClientConnectionClosed => {
+                magnus::Error::new(exception::eof_error(), CLIENT_CONNECTION_CLOSED)
             }
+            ItsiError::Break => magnus::Error::new(exception::interrupt(), "Break"),
+            ItsiError::Pass => magnus::Error::new(exception::interrupt(), "Pass"),
+            ItsiError::Io(err) => err.into_magnus_error(),
+            ItsiError::Rcgen(err) => err.into_magnus_error(),
+            ItsiError::HttpParse(err) => err.into_magnus_error(),
+            ItsiError::NixErrno(err) => err.into_magnus_error(),
+            ItsiError::Nul(err) => err.into_magnus_error(),
+            ItsiError::Anyhow(err) => err.into_magnus_error(),
         }
     }
 }
+
+impl ItsiError {
+    pub fn new(error: impl Send + Sync + 'static + std::fmt::Display) -> Self {
+        ItsiError::InternalError(format!("{}", error))
+    }
+}
+
+unsafe impl Send for ItsiError {}
+unsafe impl Sync for ItsiError {}