raptor 0.25.0 → 0.27.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

@@ -67,8 +67,11 @@ module Raptor
       worker_shutdown_timeout: 30,
       refork_after: (RUBY_PLATFORM.include?("linux") ? 1000 : nil),
       before_fork: [].freeze,
+      after_fork: [].freeze,
       before_worker_boot: [].freeze,
       before_worker_shutdown: [].freeze,
+      after_worker_drain: [].freeze,
+      after_worker_exit: [].freeze,
       before_refork: [].freeze,
       plugins: [].freeze,
       stats_file: "tmp/raptor.json",
@@ -175,11 +178,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 +312,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,26 +68,23 @@ 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
     # @rbs @worker_shutdown_timeout: Integer
     # @rbs @before_fork: Array[Proc]
+    # @rbs @after_fork: Array[Proc]
     # @rbs @before_worker_boot: Array[Proc]
     # @rbs @before_worker_shutdown: Array[Proc]
+    # @rbs @after_worker_drain: Array[Proc]
+    # @rbs @after_worker_exit: Array[Proc]
     # @rbs @before_refork: Array[Proc]
     # @rbs @stats_file: String?
     # @rbs @control_server: ControlServer?
@@ -103,12 +95,12 @@ 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
     # @rbs @shutdown: bool
     # @rbs @workers: Hash[Integer, Integer]
+    # @rbs @worker_indices: Hash[Integer, Integer]
     # @rbs @timed_out: Set[Integer]
     # @rbs @stats: Stats
     # @rbs @started_at: Float
@@ -158,9 +150,12 @@ module Raptor
     # @option options [Integer] :worker_drain_timeout seconds a worker waits for in-flight requests during shutdown before force-killing app threads
     # @option options [Integer] :worker_shutdown_timeout seconds to wait for graceful worker exit before force-killing
     # @option options [Integer, Array<Integer>, nil] :refork_after request-count threshold(s) at which a warm worker is promoted to a fork source for phased refork; nil or 0 disables. Requires `PR_SET_CHILD_SUBREAPER` (Linux)
-    # @option options [Array<Proc>] :before_fork procs called in the master before every worker fork
+    # @option options [Array<Proc>] :before_fork procs called in the master before each direct worker fork, not seed forks
+    # @option options [Array<Proc>] :after_fork procs called in the master after each direct fork attempt, including failures
     # @option options [Array<Proc>] :before_worker_boot procs called with the worker index before it begins serving
     # @option options [Array<Proc>] :before_worker_shutdown procs called with the worker index before its graceful shutdown
+    # @option options [Array<Proc>] :after_worker_drain procs called with the worker index after draining, before exit or seed promotion
+    # @option options [Array<Proc>] :after_worker_exit procs called in the master after reaping, with the worker index, pid, and Process::Status
     # @option options [Array<Proc>] :before_refork procs called in a worker before it transitions to a seed
     # @option options [Array<String, Symbol>] :plugins plugins to load and start in order
     # @option options [String, nil] :stats_file path to write per-worker stats JSON, or nil to disable
@@ -178,26 +173,23 @@ 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]
       @worker_shutdown_timeout = options[:worker_shutdown_timeout]
       @before_fork = options[:before_fork] = Array(options[:before_fork]).dup
+      @after_fork = options[:after_fork] = Array(options[:after_fork]).dup
       @before_worker_boot = options[:before_worker_boot] = Array(options[:before_worker_boot]).dup
       @before_worker_shutdown = options[:before_worker_shutdown] = Array(options[:before_worker_shutdown]).dup
+      @after_worker_drain = options[:after_worker_drain] = Array(options[:after_worker_drain]).dup
+      @after_worker_exit = options[:after_worker_exit] = Array(options[:after_worker_exit]).dup
       @before_refork = options[:before_refork] = Array(options[:before_refork]).dup
       @stats_file = options[:stats_file]
       @control_server = ControlServer.new(options[:control_url]) { stats_hash } if options[:control_url]
@@ -208,7 +200,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]
 
@@ -227,6 +218,7 @@ module Raptor
 
       @shutdown = false
       @workers = {}
+      @worker_indices = {}
       @timed_out = Set.new
       @stats = Stats.new(@worker_count)
       @started_at = Process.clock_gettime(Process::CLOCK_REALTIME)
@@ -457,15 +449,34 @@ module Raptor
         pid = spawn_worker_via_seed(index)
         if pid
           @workers[index] = pid
+          @worker_indices[pid] = index
           return
         end
         Log.warn "Seed (#{@seed_pid}) failed to fork worker #{index}, falling back to direct fork"
         @seed_pid = nil
       end
 
-      @before_fork.each(&:call)
-      pid = fork { run_worker(index, @phase) }
-      @workers[index] = pid
+      master_pid = Process.pid
+      begin
+        @before_fork.each(&:call)
+        pid = fork { run_worker(index, @phase) }
+        @workers[index] = pid
+        @worker_indices[pid] = index
+      ensure
+        if Process.pid == master_pid
+          error = $!
+          @after_fork.each do |hook|
+            hook.call
+          rescue => hook_error
+            if error
+              Log.rescued_error(hook_error)
+            else
+              error = hook_error
+            end
+          end
+          raise error if error
+        end
+      end
     end
 
     # Asks the seed to fork a new worker at the given index, returning the
@@ -530,19 +541,20 @@ module Raptor
     #
     # @rbs (Integer pid, Process::Status status) -> void
     def reap_pid(pid, status)
+      index = @worker_indices.delete(pid)
+      return unless index
+
+      active = @workers[index] == pid
       if pid == @seed_pid
         Log.info "Seed (#{pid}) exited, #{exit_description(status)}"
         @seed_pid = nil
-        return
       end
 
-      index = @workers.key(pid)
-      return unless index
-
-      @workers.delete(index)
+      @workers.delete(index) if active
       @timed_out.delete(pid)
+      @after_worker_exit.each { |hook| hook.parameters.empty? ? hook.call : hook.call(index, pid, status) }
 
-      unless @shutdown
+      if active && !@shutdown
         Log.warn "Restarting worker #{index} (#{pid}), #{exit_description(status)}"
         spawn_worker(index)
       end
@@ -674,7 +686,11 @@ module Raptor
       pids = @workers.values + [@seed_pid].compact
       Log.warn "Force-killing #{pids.size} process(es) after #{@worker_shutdown_timeout}s"
       pids.each { |pid| Process.kill("KILL", pid) rescue nil }
-      pids.each { |pid| Process.wait(pid) rescue nil }
+      pids.each do |pid|
+        _, status = Process.wait2(pid)
+        reap_pid(pid, status)
+      rescue Errno::ECHILD
+      end
     end
 
     # Kills workers that have stopped checking in. A booted worker that
@@ -850,7 +866,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 +882,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 +889,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 +911,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 +926,21 @@ 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)
+      @after_worker_drain.each { |hook| hook.parameters.empty? ? hook.call : hook.call(index) }
       # 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 +983,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