raptor 0.22.3 → 0.24.0

data/ext/raptor_native/raptor_native.c

@@ -4,27 +4,26 @@
 
 #include "ruby.h"
 #include "ruby/io.h"
-#include <sys/uio.h>
+#include "ruby/thread.h"
 #include <errno.h>
 #include <limits.h>
+#include <sys/uio.h>
 
 #ifdef __linux__
 #include <sched.h>
 #include <sys/prctl.h>
-#include <unistd.h>
 #endif
 
 static VALUE eEAGAINWaitWritable;
 
-static VALUE raptor_native_writev_nonblock(VALUE self, VALUE io, VALUE strings) {
-  (void)self;
+static VALUE vector_io_writev_nonblock(VALUE self, VALUE io, VALUE strings) {
   Check_Type(strings, T_ARRAY);
   long len = RARRAY_LEN(strings);
   if (len == 0) return LONG2NUM(0);
   if (len > IOV_MAX) len = IOV_MAX;
 
   int fd = rb_io_descriptor(io);
-  struct iovec *iov = alloca(len * sizeof(struct iovec));
+  struct iovec *iov = ALLOCA_N(struct iovec, len);
 
   for (long i = 0; i < len; i++) {
     VALUE str = RARRAY_AREF(strings, i);
@@ -43,8 +42,9 @@ static VALUE raptor_native_writev_nonblock(VALUE self, VALUE io, VALUE strings)
   return LONG2NUM((long)written);
 }
 
-static VALUE raptor_native_pin_to_cpu(VALUE self, VALUE cpu) {
-  (void)self;
+// Pins the calling thread to the Nth CPU of its current affinity mask, so
+// worker indexes map onto the CPUs the process is actually allowed to use.
+static VALUE cpu_pin(VALUE self, VALUE cpu) {
 #ifdef __linux__
   int worker_index = NUM2INT(cpu);
   cpu_set_t current;
@@ -55,7 +55,10 @@ static VALUE raptor_native_pin_to_cpu(VALUE self, VALUE cpu) {
   int seen = 0;
   for (int candidate = 0; candidate < CPU_SETSIZE; candidate++) {
     if (!CPU_ISSET(candidate, &current)) continue;
-    if (seen == worker_index) { cpu_id = candidate; break; }
+    if (seen == worker_index) {
+      cpu_id = candidate;
+      break;
+    }
     seen++;
   }
   if (cpu_id < 0) return Qfalse;
@@ -66,13 +69,11 @@ static VALUE raptor_native_pin_to_cpu(VALUE self, VALUE cpu) {
   if (sched_setaffinity(0, sizeof(set), &set) < 0) rb_sys_fail("sched_setaffinity");
   return Qtrue;
 #else
-  (void)cpu;
   return Qfalse;
 #endif
 }
 
-static VALUE raptor_native_cpu_count(VALUE self) {
-  (void)self;
+static VALUE cpu_count(VALUE self) {
 #ifdef __linux__
   cpu_set_t set;
   CPU_ZERO(&set);
@@ -83,8 +84,24 @@ static VALUE raptor_native_cpu_count(VALUE self) {
 #endif
 }
 
-static VALUE raptor_native_enable_subreaper(VALUE self) {
-  (void)self;
+#ifdef __linux__
+static void *cpu_yield_without_gvl(void *unused) {
+  sched_yield();
+  return NULL;
+}
+#endif
+
+// Thread.pass cannot yield to native threads that have not rejoined
+// Ruby's ready queue.
+static VALUE cpu_yield(VALUE self) {
+  rb_thread_schedule();
+#ifdef __linux__
+  rb_thread_call_without_gvl(cpu_yield_without_gvl, NULL, NULL, NULL);
+#endif
+  return Qnil;
+}
+
+static VALUE subreaper_enable(VALUE self) {
 #if defined(__linux__) && defined(PR_SET_CHILD_SUBREAPER)
   if (prctl(PR_SET_CHILD_SUBREAPER, 1, 0, 0, 0) < 0) rb_sys_fail("prctl");
   return Qtrue;
@@ -96,18 +113,19 @@ static VALUE raptor_native_enable_subreaper(VALUE self) {
 RUBY_FUNC_EXPORTED void Init_raptor_native(void) {
   rb_ext_ractor_safe(true);
 
+  rb_global_variable(&eEAGAINWaitWritable);
+  eEAGAINWaitWritable = rb_const_get(rb_cIO, rb_intern("EAGAINWaitWritable"));
+
   VALUE mRaptor = rb_define_module("Raptor");
 
   VALUE mVectorIO = rb_define_module_under(mRaptor, "VectorIO");
-  rb_define_singleton_method(mVectorIO, "writev_nonblock", raptor_native_writev_nonblock, 2);
+  rb_define_singleton_method(mVectorIO, "writev_nonblock", vector_io_writev_nonblock, 2);
 
   VALUE mCPU = rb_define_module_under(mRaptor, "CPU");
-  rb_define_singleton_method(mCPU, "pin", raptor_native_pin_to_cpu, 1);
-  rb_define_singleton_method(mCPU, "count", raptor_native_cpu_count, 0);
+  rb_define_singleton_method(mCPU, "pin", cpu_pin, 1);
+  rb_define_singleton_method(mCPU, "count", cpu_count, 0);
+  rb_define_singleton_method(mCPU, "yield", cpu_yield, 0);
 
   VALUE mSubreaper = rb_define_module_under(mRaptor, "Subreaper");
-  rb_define_singleton_method(mSubreaper, "enable", raptor_native_enable_subreaper, 0);
-
-  eEAGAINWaitWritable = rb_const_get(rb_cIO, rb_intern("EAGAINWaitWritable"));
-  rb_global_variable(&eEAGAINWaitWritable);
+  rb_define_singleton_method(mSubreaper, "enable", subreaper_enable, 0);
 }

data/lib/rackup/handler/raptor.rb

@@ -1,8 +1,6 @@
 # rbs_inline: enabled
 # frozen_string_literal: true
 
-require "concurrent/utility/processor_counter"
-
 module Rackup
   module Handler
     # Rack handler for booting Raptor through Rackup, `rails server`, or any
@@ -18,7 +16,8 @@ module Rackup
       #
       # @param app [#call] the Rack application to serve
       # @param options [Hash] handler options provided by Rackup or the host
-      # @yield [cluster] the cluster instance, before it starts running
+      # @yield before the cluster starts running
+      # @yieldparam cluster [::Raptor::Cluster] the cluster instance
       # @return [void]
       #
       # @rbs (^(Hash[String, untyped]) -> [Integer, Hash[String, String | Array[String]], untyped] app, **untyped options) { (::Raptor::Cluster) -> void } -> void
@@ -62,7 +61,7 @@ module Rackup
       def self.build_cluster_options(app, options)
         defaults = DEFAULT_OPTIONS.dup
 
-        if user_supplied_options = options.delete(:user_supplied_options)
+        if (user_supplied_options = options.delete(:user_supplied_options))
           (options.keys - user_supplied_options).each do |key|
             defaults[key] = options.delete(key)
           end
@@ -71,7 +70,9 @@ module Rackup
         cli_defaults = ::Raptor::CLI::DEFAULT_OPTIONS
         config_path = options[:Config] || ::Raptor::CLI.default_config_path
         config = config_path ? ::Raptor::CLI.load_config_file(config_path) : {}
-        threads = (options[:Threads] || ENV["RAPTOR_THREADS"] || config[:threads] || cli_defaults[:threads]).to_i
+        environment_workers = Integer(ENV["RAPTOR_WORKERS"], 10) if ENV["RAPTOR_WORKERS"]
+        environment_threads = Integer(ENV["RAPTOR_THREADS"], 10) if ENV["RAPTOR_THREADS"]
+        threads = (options[:Threads] || environment_threads || config[:threads] || cli_defaults[:threads]).to_i
         max_threads = options[:MaxThreads] || ENV["RAPTOR_MAX_THREADS"] || config.fetch(:max_threads, cli_defaults[:max_threads])
 
         result = {
@@ -81,13 +82,13 @@ module Rackup
             config[:binds] || ["tcp://#{defaults[:Host]}:#{defaults[:Port]}"]
           end,
           socket_backlog: (config[:socket_backlog] || cli_defaults[:socket_backlog]).to_i,
-          drain_accept_queue: config.key?(:drain_accept_queue) ? config[:drain_accept_queue] : cli_defaults[:drain_accept_queue],
-          workers: (options[:Workers] || ENV["RAPTOR_WORKERS"] || config[:workers] || Concurrent.available_processor_count).to_i,
+          drain_accept_queue: config.fetch(:drain_accept_queue, cli_defaults[:drain_accept_queue]),
+          workers: (options[:Workers] || environment_workers || config[:workers] || cli_defaults[:workers]).to_i,
           threads: threads,
           max_threads: ::Raptor::CLI.parse_max_threads(max_threads, threads: threads),
-          cpu_affinity: config.key?(:cpu_affinity) ? config[:cpu_affinity] : cli_defaults[:cpu_affinity],
-          clean_thread_locals: config.key?(:clean_thread_locals) ? config[:clean_thread_locals] : cli_defaults[:clean_thread_locals],
-          clean_fiber_locals: config.key?(:clean_fiber_locals) ? config[:clean_fiber_locals] : cli_defaults[:clean_fiber_locals],
+          cpu_affinity: config.fetch(:cpu_affinity, cli_defaults[:cpu_affinity]),
+          clean_thread_locals: config.fetch(:clean_thread_locals, cli_defaults[:clean_thread_locals]),
+          clean_fiber_locals: config.fetch(:clean_fiber_locals, cli_defaults[:clean_fiber_locals]),
           app: app
         }
         result[:rackup] = config[:rackup] if config.key?(:rackup)
@@ -105,14 +106,15 @@ module Rackup
         result[:before_worker_boot] = config.fetch(:before_worker_boot, cli_defaults[:before_worker_boot])
         result[:before_worker_shutdown] = config.fetch(:before_worker_shutdown, cli_defaults[:before_worker_shutdown])
         result[:before_refork] = config.fetch(:before_refork, cli_defaults[:before_refork])
-        result[:stats_file] = config.key?(:stats_file) ? config[:stats_file] : cli_defaults[:stats_file]
+        result[:plugins] = config.fetch(:plugins, cli_defaults[:plugins])
+        result[:stats_file] = config.fetch(:stats_file, cli_defaults[:stats_file])
         result[:control_url] = config[:control_url] if config.key?(:control_url)
         result[:pid_file] = config[:pid_file] if config.key?(:pid_file)
         result[:stdout_file] = config[:stdout_file] if config.key?(:stdout_file)
         result[:stderr_file] = config[:stderr_file] if config.key?(:stderr_file)
         result[:access_log_file] = config[:access_log_file] if config.key?(:access_log_file)
         result[:on_error] = config[:on_error] if config.key?(:on_error)
-        result
+        config.merge(result)
       end
       private_class_method :build_cluster_options
     end

data/lib/raptor/binder.rb

@@ -1,6 +1,7 @@
 # rbs_inline: enabled
 # frozen_string_literal: true
 
+require "openssl"
 require "socket"
 require "uri"
 
@@ -56,17 +57,17 @@ module Raptor
     # Returns the array of bind URIs.
     #
     # @return [Array<String>]
-    attr_reader :bind_uris
+    attr_reader :bind_uris #: Array[String]
 
     # Returns the kernel `listen()` queue depth for TCP/SSL listeners.
     #
     # @return [Integer]
-    attr_reader :socket_backlog
+    attr_reader :socket_backlog #: Integer
 
     # Returns the array of listening sockets.
     #
     # @return [Array<TCPServer, UNIXServer, SslListener, H2cListener>]
-    attr_reader :listeners
+    attr_reader :listeners #: Array[TCPServer | UNIXServer | SslListener | H2cListener]
 
     # Creates a new Binder and binds each URI. `localhost` expands to both
     # IPv4 and IPv6 loopback; when `inherited_fds` supplies file descriptors
@@ -113,8 +114,8 @@ module Raptor
       end
     end
 
-    # Returns the port of the first TCP or SSL listener, or 0 when none
-    # is configured.
+    # Returns the port of the first TCP, SSL, or cleartext HTTP/2 listener,
+    # or 0 when none is configured.
     #
     # @return [Integer]
     #
@@ -185,7 +186,7 @@ module Raptor
 
     # Creates fresh listeners for the given URI.
     #
-    # @param uri [URI] the parsed bind URI
+    # @param uri [URI::Generic] the parsed bind URI
     # @return [Array<TCPServer, UNIXServer, SslListener, H2cListener>]
     # @raise [UnknownBindSchemeError] if the URI scheme is not supported
     #
@@ -208,7 +209,7 @@ module Raptor
     # Reconstructs listeners for the given URI from inherited file
     # descriptors.
     #
-    # @param uri [URI] the parsed bind URI the FDs were bound to
+    # @param uri [URI::Generic] the parsed bind URI the FDs were bound to
     # @param filenos [Array<Integer>] file descriptors to wrap
     # @return [Array<TCPServer, UNIXServer, SslListener, H2cListener>]
     # @raise [UnknownBindSchemeError] if the URI scheme is not supported
@@ -240,7 +241,7 @@ module Raptor
     # @rbs (String? host, Integer? port) -> Array[TCPServer]
     def create_tcp_listeners(host, port)
       if host == "localhost"
-        return loopback_addresses.map { |address| create_tcp_listeners(address, port) }.flatten
+        return loopback_addresses.flat_map { |address| create_tcp_listeners(address, port) }
       end
 
       host = host[1..-2] if host&.start_with?("[")
@@ -250,6 +251,7 @@ module Raptor
       socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEADDR, true)
       socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEPORT, true) if Socket.const_defined?(:SO_REUSEPORT)
       socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
+      socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_DEFER_ACCEPT, 1) if Socket.const_defined?(:TCP_DEFER_ACCEPT)
       socket.bind(addrinfo)
       socket.listen(@socket_backlog)
 
@@ -299,7 +301,7 @@ module Raptor
     #
     # @param host [String, nil] hostname or IP address to bind to
     # @param port [Integer, nil] port number to bind to
-    # @param ssl_params [Hash<String, String>] SSL options (`cert` and `key` file paths)
+    # @param ssl_params [Hash{String => String}] SSL options (`cert` and `key` file paths)
     # @return [Array<SslListener>] array containing the created SSL listener(s)
     #
     # @rbs (String? host, Integer? port, Hash[String, String] ssl_params) -> Array[SslListener]
@@ -312,13 +314,11 @@ module Raptor
     # Builds a frozen `OpenSSL::SSL::SSLContext` configured for HTTP/2 and
     # HTTP/1.1 ALPN negotiation.
     #
-    # @param ssl_params [Hash<String, String>] SSL options ("cert" and "key" paths)
+    # @param ssl_params [Hash{String => String}] SSL options (`cert` and `key` file paths)
     # @return [OpenSSL::SSL::SSLContext]
     #
     # @rbs (Hash[String, String] ssl_params) -> OpenSSL::SSL::SSLContext
     def build_ssl_context(ssl_params)
-      require "openssl"
-
       OpenSSL::SSL::SSLContext.new.tap do |ssl_context|
         ssl_context.cert = OpenSSL::X509::Certificate.new(File.read(ssl_params["cert"]))
         ssl_context.key = OpenSSL::PKey.read(File.read(ssl_params["key"]))

data/lib/raptor/cli.rb

@@ -7,6 +7,7 @@ require "optparse"
 require "concurrent/utility/processor_counter"
 
 require_relative "cluster"
+require_relative "version"
 
 module Raptor
   # Command-line interface for the Raptor web server.
@@ -48,18 +49,18 @@ module Raptor
         write_timeout: 5,
         max_body_size: nil,
         body_spool_threshold: 1024 * 1024
-      },
+      }.freeze,
       http1: {
         ractors: nil,
         persistent_data_timeout: 65,
         max_keepalive_requests: 1000
-      },
+      }.freeze,
       http2: {
         ractors: nil,
         max_concurrent_streams: 100,
         keepalive_interval: 10,
         keepalive_timeout: 5
-      },
+      }.freeze,
       worker_boot_timeout: 60,
       worker_timeout: 60,
       worker_drain_timeout: 25,
@@ -69,12 +70,13 @@ module Raptor
       before_worker_boot: [].freeze,
       before_worker_shutdown: [].freeze,
       before_refork: [].freeze,
+      plugins: [].freeze,
       stats_file: "tmp/raptor.json",
       control_url: nil,
       pid_file: nil,
       stdout_file: nil,
       stderr_file: nil,
-      access_log_file: nil,
+      access_log_file: nil
     }.freeze
 
     DEFAULT_CONFIG_PATHS = ["raptor.rb", "config/raptor.rb"].freeze
@@ -131,17 +133,17 @@ module Raptor
       max_threads
     end
 
-    # @rbs @command: Symbol
     # @rbs @options: Hash[Symbol, untyped]
+    # @rbs @command: Symbol
     # @rbs @parser: OptionParser
 
-    # Creates a new CLI instance from `argv`. A rackup file may be given
-    # as the first positional argument; every other value is parsed as a
-    # flag.
+    # Creates a new CLI from `argv`. A rackup file may be given as the
+    # first positional argument; every other value is parsed as a flag.
     #
     # @param argv [Array<String>] command-line arguments to parse
     # @return [void]
     # @raise [OptionParser::ParseError] if invalid options are provided
+    # @raise [ArgumentError] if the config file or max threads value is invalid
     #
     # @rbs (Array[String] argv) -> void
     def initialize(argv)
@@ -203,7 +205,7 @@ module Raptor
       end
     end
 
-    # Returns the path from a `-c`/`--config` flag in `argv`, recognising
+    # Returns the path from a `-c`/`--config` flag in `argv`, recognizing
     # all four OptionParser-accepted forms (`-c PATH`, `-cPATH`,
     # `--config PATH`, `--config=PATH`).
     #
@@ -258,6 +260,8 @@ module Raptor
     #
     # @rbs () -> OptionParser
     def create_parser
+      cli_binds = []
+
       OptionParser.new do |opts|
         opts.banner = "Usage: raptor [options] [rackup file]"
 
@@ -266,11 +270,8 @@ module Raptor
         end
 
         opts.on("-b", "--bind URI", String, "Bind address (default: tcp://0.0.0.0:9292)") do |bind|
-          if @options[:binds].equal?(DEFAULT_OPTIONS[:binds])
-            @options[:binds] = [bind]
-          else
-            @options[:binds] << bind
-          end
+          cli_binds << bind
+          @options[:binds] = cli_binds
         end
 
         opts.on("--socket-backlog NUM", Integer, "Socket listen backlog (default: 1024)") do |num|
@@ -333,7 +334,7 @@ module Raptor
           @options[:connection][:body_spool_threshold] = bytes
         end
 
-        opts.on("--http1-ractors NUM", Integer, "Number of HTTP/1.1 pipeline ractors per worker (default: `round(cores / workers)`, clamped to 1..3)") do |num|
+        opts.on("--http1-ractors NUM", Integer, "Number of HTTP/1.1 pipeline ractors per worker (default: `round(cores / workers)`, clamped to 1..#{Cluster::HTTP1_RACTOR_COUNT_CAP})") do |num|
           @options[:http1][:ractors] = num
         end
 
@@ -345,7 +346,7 @@ module Raptor
           @options[:http1][:max_keepalive_requests] = num
         end
 
-        opts.on("--http2-ractors NUM", Integer, "Number of HTTP/2 pipeline ractors per worker (default: `round(cores / workers)`, clamped to 1..2)") do |num|
+        opts.on("--http2-ractors NUM", Integer, "Number of HTTP/2 pipeline ractors per worker (default: `round(cores / workers)`, clamped to 1..#{Cluster::HTTP2_RACTOR_COUNT_CAP})") do |num|
           @options[:http2][:ractors] = num
         end
 
@@ -377,7 +378,7 @@ module Raptor
           @options[:worker_shutdown_timeout] = timeout
         end
 
-        opts.on("--refork-after NUM", Integer, "Refork workers from a warmed source after any worker crosses NUM requests; 0 disables (default: 1000)") do |num|
+        opts.on("--refork-after NUM", Integer, "Refork workers from a warmed source after any worker crosses NUM requests; 0 disables (default: 1000 on Linux, off elsewhere)") do |num|
           @options[:refork_after] = num
         end
 
@@ -411,7 +412,7 @@ module Raptor
         end
 
         opts.on("-v", "--version", "Show version") do
-          puts Raptor::VERSION
+          puts VERSION
           exit
         end
       end