raptor 0.24.0 → 0.26.0

data/lib/raptor/binder.rb

@@ -176,12 +176,18 @@ module Raptor
     #
     # @rbs () -> void
     def parse
-      @uri_listeners = @bind_uris.to_h do |bind_uri|
+      @listeners = []
+      @uri_listeners = {}
+      @bind_uris.each do |bind_uri|
         uri = URI.parse(bind_uri)
         filenos = @inherited_fds[bind_uri]
-        [bind_uri, filenos ? restore_listeners(uri, filenos) : create_listeners(uri)]
+        listeners = filenos ? restore_listeners(uri, filenos) : create_listeners(uri)
+        @uri_listeners[bind_uri] = listeners
+        @listeners.concat(listeners)
       end
-      @listeners = @uri_listeners.values.flatten
+    rescue
+      close
+      raise
     end
 
     # Creates fresh listeners for the given URI.
@@ -241,7 +247,9 @@ module Raptor
     # @rbs (String? host, Integer? port) -> Array[TCPServer]
     def create_tcp_listeners(host, port)
       if host == "localhost"
-        return loopback_addresses.flat_map { |address| create_tcp_listeners(address, port) }
+        listeners = []
+        loopback_addresses.each { |address| listeners.concat(create_tcp_listeners(address, port)) }
+        return listeners
       end
 
       host = host[1..-2] if host&.start_with?("[")
@@ -258,6 +266,10 @@ module Raptor
       tcp_server = TCPServer.for_fd(socket.fileno)
       socket.autoclose = false
       [tcp_server]
+    rescue
+      listeners&.each(&:close)
+      socket&.close
+      raise
     end
 
     # Creates a Unix domain server socket at the given path. Removes stale
@@ -306,8 +318,8 @@ module Raptor
     #
     # @rbs (String? host, Integer? port, Hash[String, String] ssl_params) -> Array[SslListener]
     def create_ssl_listeners(host, port, ssl_params)
-      tcp_servers = create_tcp_listeners(host, port)
       ssl_context = build_ssl_context(ssl_params)
+      tcp_servers = create_tcp_listeners(host, port)
       tcp_servers.map { |tcp_server| SslListener.new(tcp_server: tcp_server, ssl_context: ssl_context) }
     end
 

data/lib/raptor/cli.rb

@@ -175,11 +175,38 @@ module Raptor
     #
     # @rbs () -> void
     def run
-      @command == :stats ? run_stats : Cluster.run(@options)
+      if @command == :stats
+        run_stats
+      elsif @options[:workers].zero?
+        run_embedded
+      else
+        Cluster.run(@options)
+      end
     end
 
     private
 
+    # Serves in the CLI process until interrupted or terminated.
+    #
+    # @rbs () -> void
+    def run_embedded
+      require_relative "embedded"
+
+      $stdout.sync = true
+      $stderr.sync = true
+
+      Dir.chdir(@options[:chdir]) if @options[:chdir]
+      app = @options[:app] || Rack::Builder.parse_file(@options[:rackup])
+      server = Embedded.new(app, **@options, log: true).start
+      handlers = ["INT", "TERM"].to_h do |signal|
+        [signal, trap(signal) { Thread.new { server.shutdown } }]
+      end
+      server.join
+    ensure
+      server&.shutdown
+      handlers&.each { |signal, handler| trap(signal, handler) }
+    end
+
     # Reads and prints the stats file.
     #
     # @return [void]
@@ -282,7 +309,7 @@ module Raptor
           @options[:drain_accept_queue] = bool
         end
 
-        opts.on("-w", "--workers NUM", Integer, "Number of worker processes (default: #{DEFAULT_WORKER_COUNT})") do |num|
+        opts.on("-w", "--workers NUM", Integer, "Number of worker processes, or 0 for in-process serving (default: #{DEFAULT_WORKER_COUNT})") do |num|
           @options[:workers] = num
         end
 

data/lib/raptor/cluster.rb

@@ -4,24 +4,19 @@
 require "json"
 require "time"
 
-require "atomic-ruby/atomic_thread_pool"
 require "concurrent/utility/processor_counter"
 require "rack/builder"
-require "ractor-pool"
 
 require_relative "binder"
 require_relative "control_server"
-require_relative "http1"
-require_relative "http2"
 require_relative "log"
 require_relative "plugin"
 require_relative "raptor_native"
-require_relative "reactor"
 require_relative "reuseport_bpf"
-require_relative "server"
 require_relative "stats"
 require_relative "systemd"
 require_relative "version"
+require_relative "worker"
 
 module Raptor
   # Forks and supervises worker processes. Handles graceful shutdown on
@@ -73,19 +68,13 @@ module Raptor
       (cores.to_f / worker_count).round.clamp(1, HTTP2_RACTOR_COUNT_CAP)
     end
 
-    # @rbs @drain_accept_queue: bool
     # @rbs @worker_count: Integer
     # @rbs @http1_ractor_count: Integer
     # @rbs @http2_ractor_count: Integer
     # @rbs @thread_count: Integer
     # @rbs @max_thread_count: (Integer | Float)?
     # @rbs @cpu_affinity: bool
-    # @rbs @clean_thread_locals: bool
-    # @rbs @clean_fiber_locals: bool
     # @rbs @environment: String
-    # @rbs @connection_options: Hash[Symbol, untyped]
-    # @rbs @http1_options: Hash[Symbol, untyped]
-    # @rbs @http2_options: Hash[Symbol, untyped]
     # @rbs @worker_boot_timeout: Integer
     # @rbs @worker_timeout: Integer
     # @rbs @worker_drain_timeout: Integer
@@ -103,7 +92,6 @@ module Raptor
     # @rbs @access_log_io: IO?
     # @rbs @launch_command: String?
     # @rbs @launch_argv: Array[String]?
-    # @rbs @on_error: (^(Hash[String, untyped]?, Exception) -> void)?
     # @rbs @binder: Binder
     # @rbs @server_port: Integer
     # @rbs @app: untyped
@@ -178,19 +166,13 @@ module Raptor
     def initialize(options)
       @options = options = options.dup
       @plugins = []
-      @drain_accept_queue = options[:drain_accept_queue]
       @worker_count = options[:workers]
       @http1_ractor_count = options[:http1][:ractors] || self.class.default_http1_ractor_count(@worker_count)
       @http2_ractor_count = options[:http2][:ractors] || self.class.default_http2_ractor_count(@worker_count)
       @thread_count = options[:threads]
       @max_thread_count = options[:max_threads]
       @cpu_affinity = options[:cpu_affinity]
-      @clean_thread_locals = options[:clean_thread_locals]
-      @clean_fiber_locals = options[:clean_fiber_locals]
       @environment = options[:environment] || ENV["RAILS_ENV"] || ENV["RACK_ENV"] || "development"
-      @connection_options = options[:connection]
-      @http1_options = options[:http1]
-      @http2_options = options[:http2]
       @worker_boot_timeout = options[:worker_boot_timeout]
       @worker_timeout = options[:worker_timeout]
       @worker_drain_timeout = options[:worker_drain_timeout]
@@ -208,7 +190,6 @@ module Raptor
       @access_log_io = nil
       @launch_command = options[:launch_command]
       @launch_argv = options[:launch_argv]
-      @on_error = options[:on_error]
 
       Dir.chdir(options[:chdir]) if options[:chdir]
 
@@ -850,7 +831,6 @@ module Raptor
       CPU.pin(index) if @cpu_affinity && CPU.count >= @worker_count
 
       started_at = Process.clock_gettime(Process::CLOCK_REALTIME)
-      request_count = 0
 
       @stats.write(
         index,
@@ -867,70 +847,6 @@ module Raptor
 
       @before_worker_boot.each { |hook| hook.parameters.empty? ? hook.call : hook.call(index) }
 
-      reactor = nil
-
-      counting_app = ->(env) {
-        request_count += 1
-        @app.call(env)
-      }
-      thread_pool = AtomicThreadPool.new(size: @thread_count, max_size: @max_thread_count)
-      http1 = Http1.new(
-        counting_app,
-        @server_port,
-        connection_options: @connection_options,
-        http1_options: @http1_options,
-        access_log_io: @access_log_io,
-        clean_thread_locals: @clean_thread_locals,
-        clean_fiber_locals: @clean_fiber_locals,
-        on_error: @on_error
-      )
-      http2 = Http2.new(
-        counting_app,
-        @server_port,
-        connection_options: @connection_options,
-        http2_options: @http2_options,
-        access_log_io: @access_log_io,
-        clean_thread_locals: @clean_thread_locals,
-        clean_fiber_locals: @clean_fiber_locals,
-        on_error: @on_error
-      )
-      http1_ractor_pool = RactorPool.new(
-        size: @http1_ractor_count,
-        worker: http1.parser_worker,
-        name: "HTTP/1.1"
-      ) do |parsed_result|
-        begin
-          http1.handle_parsed_request(parsed_result, reactor, thread_pool)
-        rescue => error
-          Log.rescued_error(error)
-        end
-      end
-
-      http2_ractor_pool = if @binder.http2?
-        RactorPool.new(
-          size: @http2_ractor_count,
-          worker: http2.parser_worker,
-          name: "HTTP/2"
-        ) do |parsed_result|
-          begin
-            http2.handle_parsed_request(parsed_result, reactor, thread_pool)
-          rescue => error
-            Log.rescued_error(error)
-          end
-        end
-      end
-
-      reactor = Reactor.new(
-        http1,
-        http1_ractor_pool,
-        http2_ractor_pool,
-        thread_pool,
-        connection_options: @connection_options,
-        http1_options: @http1_options,
-        http2_options: @http2_options
-      )
-      reactor_thread = reactor.run
-
       bpf_listeners = if @bpf_active
         ReuseportBPF.enable_load_reporting(index)
         ReuseportBPF.create_worker_listeners(index, @binder.socket_backlog)
@@ -938,17 +854,17 @@ module Raptor
         []
       end
 
-      server = Server.new(
-        reactor,
-        thread_pool,
-        http1,
-        http2,
-        connection_options: @connection_options,
-        drain_accept_queue: @drain_accept_queue,
+      worker = Worker.new(
+        @app,
         listeners: bpf_listeners + @binder.listeners,
+        port: @server_port,
+        options: @options,
+        http1_ractors: @http1_ractor_count,
+        http2_ractors: @http2_ractor_count,
+        access_log_io: @access_log_io,
         worker_index: (index if @bpf_active)
       )
-      server_thread = server.run
+      worker.start
 
       Log.info "Worker #{index} booted"
 
@@ -960,10 +876,10 @@ module Raptor
             index,
             pid: Process.pid,
             phase: phase,
-            requests: request_count,
-            backlog: reactor.backlog,
-            busy_threads: thread_pool.active_count,
-            thread_capacity: thread_pool.size,
+            requests: worker.requests,
+            backlog: worker.reactor.backlog,
+            busy_threads: worker.thread_pool.active_count,
+            thread_capacity: worker.thread_pool.size,
             started_at: started_at,
             last_checkin: Process.clock_gettime(Process::CLOCK_REALTIME),
             booted: true
@@ -975,30 +891,20 @@ module Raptor
       end
 
       until shutdown_requested || promote_to_seed
-        break unless server_thread.alive? && reactor_thread.alive?
+        break unless worker.running?
 
         sleep 0.5
       end
 
       if promote_to_seed
         @before_refork.each(&:call)
-        server.stop_accepting
       else
         @before_worker_shutdown.each { |hook| hook.parameters.empty? ? hook.call : hook.call(index) }
-        server.shutdown
       end
 
-      server_thread.join
+      worker.shutdown(close_listeners: !promote_to_seed)
       # A seed never accepts again, and the workers it forks bind their own.
       bpf_listeners.each(&:close) if promote_to_seed
-      http1.shutdown
-      http2.shutdown(reactor)
-      reactor.drain_detached_bodies(@worker_drain_timeout)
-      drain_thread_pool(thread_pool)
-      reactor.shutdown
-      reactor_thread.join
-      http1_ractor_pool.shutdown
-      http2_ractor_pool&.shutdown
       stats_thread.join
 
       run_seed_loop(index) if promote_to_seed
@@ -1041,27 +947,6 @@ module Raptor
     rescue Errno::EPIPE, IOError
     end
 
-    # Shuts down the worker's application thread pool, force-killing the
-    # underlying threads if in-flight requests have not finished within
-    # `worker_drain_timeout` seconds.
-    #
-    # @param thread_pool [AtomicThreadPool] the worker's thread pool
-    # @return [void]
-    #
-    # @rbs (AtomicThreadPool thread_pool) -> void
-    def drain_thread_pool(thread_pool)
-      drain_thread = Thread.new do
-        Thread.current.name = "Thread Pool Drain"
-
-        thread_pool.shutdown
-      end
-      return if drain_thread.join(@worker_drain_timeout)
-
-      Log.warn "Force-killing in-flight app threads after #{@worker_drain_timeout}s drain timeout"
-      thread_pool.instance_variable_get(:@threads).each(&:kill)
-      drain_thread.join
-    end
-
     # Returns a human-readable description of how a process exited.
     #
     # @param status [Process::Status] the exit status of the process

data/lib/raptor/embedded.rb

@@ -0,0 +1,159 @@
+# rbs_inline: enabled
+# frozen_string_literal: true
+
+require "atomic-ruby/atom"
+require "atomic-ruby/atomic_condition_variable"
+
+require_relative "cli"
+require_relative "worker"
+
+module Raptor
+  # Serves an existing Rack application in the caller's process without
+  # installing signal handlers or changing process-wide configuration.
+  #
+  class Embedded
+    # @rbs @app: untyped
+    # @rbs @options: Hash[Symbol, untyped]
+    # @rbs @binds: Array[String]
+    # @rbs @log: bool
+    # @rbs @lifecycle_owner: Atom
+    # @rbs @lifecycle_available: AtomicConditionVariable
+    # @rbs @started: bool
+    # @rbs @stopped: bool
+    # @rbs @binder: Binder?
+    # @rbs @worker: Worker?
+
+    attr_reader :port #: Integer
+    attr_reader :addresses #: Array[String]
+
+    # Creates an in-process server. A port of zero selects an available port.
+    # Thread and protocol options follow the regular server configuration.
+    # Set log to report startup information.
+    #
+    # @rbs (untyped app, ?host: String, ?port: Integer, ?log: bool, **untyped options) -> void
+    def initialize(app, host: "127.0.0.1", port: 0, log: false, **options)
+      @app = app
+      @port = port
+      @log = log
+      @addresses = []
+      @options = CLI::DEFAULT_OPTIONS.merge(options)
+      CLI::NESTED_OPTION_KEYS.each do |key|
+        @options[key] = CLI::DEFAULT_OPTIONS[key].merge(options[key] || {})
+      end
+      @options[:max_threads] = CLI.parse_max_threads(@options[:max_threads], threads: @options[:threads])
+      @binds = options[:binds] || ["tcp://#{host}:#{port}"]
+      @lifecycle_owner = Atom.new(nil)
+      @lifecycle_available = AtomicConditionVariable.new
+      @started = false
+      @stopped = false
+    end
+
+    # Starts serving and returns once the request-handling stack is ready.
+    # Startup errors are raised in the calling thread.
+    #
+    # @rbs () -> Embedded
+    def start
+      with_lifecycle do
+        raise ThreadError, "server has already been started or stopped" if @started || @stopped
+
+        @started = true
+        begin
+          @binder = Binder.new(@binds, socket_backlog: @options[:socket_backlog])
+          @port = @binder.server_port
+          @addresses = @binder.addresses
+          @worker = Worker.new(
+            @app,
+            listeners: @binder.listeners,
+            port: @port,
+            options: @options,
+            http1_ractors: @options[:http1][:ractors] || Cluster.default_http1_ractor_count(1),
+            http2_ractors: @options[:http2][:ractors] || Cluster.default_http2_ractor_count(1)
+          )
+          @worker.start
+        rescue
+          @stopped = true
+          @binder&.close
+          raise
+        end
+        log_initialization if @log
+      end
+
+      self
+    end
+
+    # Starts serving and waits until shutdown.
+    #
+    # @rbs () -> void
+    def run
+      start
+      join
+    end
+
+    # Drains requests and closes the server's sockets, threads, and Ractors.
+    # Calling shutdown more than once has no effect.
+    #
+    # @rbs () -> void
+    def shutdown
+      with_lifecycle do
+        return if @stopped
+
+        @stopped = true
+        begin
+          @worker&.shutdown
+        ensure
+          @binder&.close
+        end
+      end
+    end
+
+    # Waits for termination and propagates serving thread failures.
+    #
+    # @rbs () -> void
+    def join
+      worker = with_lifecycle { @worker }
+      raise ThreadError, "server has not been started" unless worker
+
+      worker.join
+    ensure
+      shutdown if worker
+    end
+
+    private
+
+    # @rbs () -> void
+    def log_initialization
+      environment = @options[:environment] || ENV["RAILS_ENV"] || ENV["RACK_ENV"] || "development"
+      thread_count = @options[:threads]
+      max_threads = @options[:max_threads]
+      thread_limit = if max_threads == Float::INFINITY
+        " (scaling, no limit)"
+      elsif max_threads > thread_count
+        " (scaling up to #{max_threads})"
+      else
+        ""
+      end
+
+      Log.info "Server initializing:"
+      Log.info "├─ Version: #{VERSION}"
+      Log.info "├─ Ruby Version: #{RUBY_DESCRIPTION}"
+      Log.info "├─ Environment: #{environment}"
+      Log.info "├─ PID: #{Process.pid}"
+      Log.info "├─ #{thread_count} worker thread#{"s" if thread_count > 1}#{thread_limit}"
+      Log.info "└─ Listening on #{@addresses.join(", ")}"
+    end
+
+    # @rbs () { () -> untyped } -> untyped
+    def with_lifecycle
+      thread = Thread.current
+      @lifecycle_available.wait do
+        @lifecycle_owner.swap { |owner| owner || thread }.equal?(thread)
+      end
+      yield
+    ensure
+      if @lifecycle_owner.value.equal?(thread)
+        @lifecycle_owner.swap { nil }
+        @lifecycle_available.broadcast
+      end
+    end
+  end
+end