pitchfork 0.13.0 → 0.14.0

data/ext/pitchfork_http/pitchfork_http.rl

@@ -16,6 +16,7 @@
 #include "child_subreaper.h"
 
 void init_pitchfork_httpdate(void);
+void init_pitchfork_memory_page(VALUE);
 
 #define UH_FL_CHUNKED  0x1
 #define UH_FL_HASBODY  0x2
@@ -960,7 +961,7 @@ static VALUE HttpParser_rssget(VALUE self)
   assert(!NIL_P(var) && "missed global field"); \
 } while (0)
 
-void Init_pitchfork_http(void)
+RUBY_FUNC_EXPORTED void Init_pitchfork_http(void)
 {
   VALUE mPitchfork;
 
@@ -1024,5 +1025,6 @@ void Init_pitchfork_http(void)
 
   init_epollexclusive(mPitchfork);
   init_child_subreaper(mPitchfork);
+  init_pitchfork_memory_page(mPitchfork);
 }
 #undef SET_GLOBAL

data/lib/pitchfork/children.rb

@@ -4,29 +4,32 @@
 module Pitchfork
   # This class keep tracks of the state of all the master children.
   class Children
-    attr_reader :mold
+    attr_reader :mold, :service
     attr_accessor :last_generation
 
     def initialize
       @last_generation = 0
-      @children = {} # All children, including molds, indexed by PID.
+      @children = {} # All children, including molds and services, indexed by PID.
       @workers = {} # Workers indexed by their `nr`.
       @molds = {} # Molds, index by PID.
       @mold = nil # The latest mold, if any.
+      @service = nil
       @pending_workers = {} # Pending workers indexed by their `nr`.
       @pending_molds = {} # Worker promoted to mold, not yet acknowledged
     end
 
-    def refresh
-      @workers.each_value(&:refresh)
-      @molds.each_value(&:refresh)
-    end
-
     def register(child)
       # Children always start as workers, never molds, so we know they have a `#nr`.
+      unless child.nr
+        raise "[BUG] Trying to register a child without an `nr`: #{child.inspect}"
+      end
       @pending_workers[child.nr] = @workers[child.nr] = child
     end
 
+    def register_service(service)
+      @service = service
+    end
+
     def register_mold(mold)
       @pending_molds[mold.pid] = mold
       @children[mold.pid] = mold
@@ -44,6 +47,11 @@ module Pitchfork
         @pending_molds[mold.pid] = mold
         @children[mold.pid] = mold
         return mold
+      when Message::ServiceSpawned
+        service = @service
+        service.update(message)
+        @children[service.pid] = service
+        return service
       end
 
       child = @children[message.pid] || (message.nr && @workers[message.nr])
@@ -78,12 +86,17 @@ module Pitchfork
         @pending_molds.delete(child.pid)
         @molds.delete(child.pid)
         @workers.delete(child.nr)
+
         if @mold == child
           @pending_workers.reject! do |nr, worker|
             worker.generation == @mold.generation
           end
           @mold = nil
         end
+
+        if @service == child
+          @service = nil
+        end
       end
       child
     end
@@ -154,13 +167,5 @@ module Pitchfork
     def workers_count
       @workers.size
     end
-
-    def total_pss
-      total_pss = MemInfo.new(Process.pid).pss
-      @children.each do |_, worker|
-        total_pss += worker.meminfo.pss if worker.meminfo
-      end
-      total_pss
-    end
   end
 end

data/lib/pitchfork/configurator.rb

@@ -52,6 +52,8 @@ module Pitchfork
           "repead unknown process (#{status.inspect})"
         elsif worker.mold?
           "mold pid=#{worker.pid rescue 'unknown'} gen=#{worker.generation rescue 'unknown'} reaped (#{status.inspect})"
+        elsif worker.service?
+          "service pid=#{worker.pid rescue 'unknown'} gen=#{worker.generation rescue 'unknown'} reaped (#{status.inspect})"
         else
           "worker=#{worker.nr rescue 'unknown'} pid=#{worker.pid rescue 'unknown'} gen=#{worker.generation rescue 'unknown'} reaped (#{status.inspect})"
         end
@@ -75,6 +77,8 @@ module Pitchfork
       :check_client_connection => false,
       :rewindable_input => true,
       :client_body_buffer_size => Pitchfork::Const::MAX_BODY,
+      :before_service_worker_ready => nil,
+      :before_service_worker_exit => nil,
     }
     #:startdoc:
 
@@ -176,6 +180,14 @@ module Pitchfork
       set_hook(:after_request_complete, block_given? ? block : args[0], 3)
     end
 
+    def before_service_worker_ready(&block)
+      set_hook(:before_service_worker_ready, block, 2)
+    end
+
+    def before_service_worker_exit(&block)
+      set_hook(:before_service_worker_exit, block, 2)
+    end
+
     def timeout(seconds, cleanup: 2)
       soft_timeout = set_int(:soft_timeout, seconds, 3)
       cleanup_timeout = set_int(:cleanup_timeout, cleanup, 2)

data/lib/pitchfork/http_parser.rb

@@ -27,7 +27,6 @@ module Pitchfork
     EMPTY_ARRAY = [].freeze
     @@input_class = Pitchfork::TeeInput
     @@check_client_connection = false
-    @@tcpi_inspect_ok = Socket.const_defined?(:TCP_INFO)
 
     def self.input_class
       @@input_class
@@ -108,80 +107,26 @@ module Pitchfork
       env.include?('rack.hijack_io')
     end
 
-    if Raindrops.const_defined?(:TCP_Info)
-      TCPI = Raindrops::TCP_Info.allocate
-
+    if Socket.const_defined?(:TCP_INFO) # Linux
       def check_client_connection(socket) # :nodoc:
         if TCPSocket === socket
-          # Raindrops::TCP_Info#get!, #state (reads struct tcp_info#tcpi_state)
-          raise Errno::EPIPE, "client closed connection".freeze,
-                EMPTY_ARRAY if closed_state?(TCPI.get!(socket).state)
-        else
-          write_http_header(socket)
-        end
-      end
-
-      if Raindrops.const_defined?(:TCP)
-        # raindrops 0.18.0+ supports FreeBSD + Linux using the same names
-        # Evaluate these hash lookups at load time so we can
-        # generate an opt_case_dispatch instruction
-        eval <<-EOS
-        def closed_state?(state) # :nodoc:
-          case state
-          when #{Raindrops::TCP[:ESTABLISHED]}
-            false
-          when #{Raindrops::TCP.values_at(
-                :CLOSE_WAIT, :TIME_WAIT, :CLOSE, :LAST_ACK, :CLOSING).join(',')}
-            true
-          else
-            false
-          end
-        end
-        EOS
-      else
-        # raindrops before 0.18 only supported TCP_INFO under Linux
-        def closed_state?(state) # :nodoc:
-          case state
-          when 1 # ESTABLISHED
-            false
-          when 8, 6, 7, 9, 11 # CLOSE_WAIT, TIME_WAIT, CLOSE, LAST_ACK, CLOSING
-            true
-          else
-            false
+          begin
+            tcp_info = socket.getsockopt(Socket::IPPROTO_TCP, Socket::TCP_INFO)
+          rescue IOError, SystemCallError
+            return write_http_header(socket)
           end
-        end
-      end
-    else
 
-      # Ruby 2.2+ can show struct tcp_info as a string Socket::Option#inspect.
-      # Not that efficient, but probably still better than doing unnecessary
-      # work after a client gives up.
-      def check_client_connection(socket) # :nodoc:
-        if TCPSocket === socket && @@tcpi_inspect_ok
-          opt = socket.getsockopt(Socket::IPPROTO_TCP, Socket::TCP_INFO).inspect
-          if opt =~ /\bstate=(\S+)/
-            raise Errno::EPIPE, "client closed connection".freeze,
-                  EMPTY_ARRAY if closed_state_str?($1)
-          else
-            @@tcpi_inspect_ok = false
-            write_http_header(socket)
+          case tcp_info.data.unpack1("C")
+          when 6, 7, 8, 9, 11 # TIME_WAIT, CLOSE, CLOSE_WAIT, LAST_ACK, CLOSING
+            raise Errno::EPIPE, "client closed connection", EMPTY_ARRAY
           end
-          opt.clear
         else
           write_http_header(socket)
         end
       end
-
-      def closed_state_str?(state)
-        case state
-        when 'ESTABLISHED'
-          false
-        # not a typo, ruby maps TCP_CLOSE (no 'D') to state=CLOSED (w/ 'D')
-        when 'CLOSE_WAIT', 'TIME_WAIT', 'CLOSED', 'LAST_ACK', 'CLOSING'
-          true
-        else
-          false
-        end
+    else
+      def check_client_connection(socket) # :nodoc:
+        write_http_header(socket)
       end
     end
 

data/lib/pitchfork/http_response.rb

@@ -65,7 +65,7 @@ module Pitchfork
             append_header(buf, key, value)
           end
         end
-        socket.write(buf << "\r\n".freeze)
+        socket.write(buf << "\r\n")
       end
 
       if hijack

data/lib/pitchfork/http_server.rb

@@ -77,7 +77,7 @@ module Pitchfork
 
     # :stopdoc:
     attr_accessor :app, :timeout, :timeout_signal, :soft_timeout, :cleanup_timeout, :spawn_timeout, :worker_processes,
-                  :before_fork, :after_worker_fork, :after_mold_fork,
+                  :before_fork, :after_worker_fork, :after_mold_fork, :before_service_worker_ready, :before_service_worker_exit,
                   :listener_opts, :children,
                   :orig_app, :config, :ready_pipe,
                   :default_middleware, :early_hints
@@ -95,32 +95,6 @@ module Pitchfork
 
     NOOP = '.'
 
-    # :startdoc:
-    # This Hash is considered a stable interface and changing its contents
-    # will allow you to switch between different installations of Pitchfork
-    # or even different installations of the same applications without
-    # downtime.  Keys of this constant Hash are described as follows:
-    #
-    # * 0 - the path to the pitchfork executable
-    # * :argv - a deep copy of the ARGV array the executable originally saw
-    # * :cwd - the working directory of the application, this is where
-    # you originally started Pitchfork.
-    # TODO: Can we get rid of this?
-    START_CTX = {
-      :argv => ARGV.map(&:dup),
-      0 => $0.dup,
-    }
-    # We favor ENV['PWD'] since it is (usually) symlink aware for Capistrano
-    # and like systems
-    START_CTX[:cwd] = begin
-      a = File.stat(pwd = ENV['PWD'])
-      b = File.stat(Dir.pwd)
-      a.ino == b.ino && a.dev == b.dev ? pwd : Dir.pwd
-    rescue
-      Dir.pwd
-    end
-    # :stopdoc:
-
     # Creates a working server on host:port (strange things happen if
     # port isn't a Number).  Use HttpServer::run to start the server and
     # HttpServer.run.join to join the thread that's processing
@@ -140,7 +114,7 @@ module Pitchfork
       self.config = Pitchfork::Configurator.new(options)
       self.listener_opts = {}
 
-      proc_name role: 'monitor', status: START_CTX[:argv].join(' ')
+      proc_name role: 'monitor', status: ARGV.join(' ')
 
       # We use @control_socket differently in the master and worker processes:
       #
@@ -173,7 +147,7 @@ module Pitchfork
         :QUIT, :INT, :TERM, :USR2, :TTIN, :TTOU ]
 
       Info.workers_count = worker_processes
-      SharedMemory.preallocate_drops(worker_processes)
+      SharedMemory.preallocate_pages(worker_processes)
     end
 
     # Runs the thing.  Returns self so you can run join on it
@@ -296,7 +270,7 @@ module Pitchfork
     def join
       @respawn = true
 
-      proc_name role: 'monitor', status: START_CTX[:argv].join(' ')
+      proc_name role: 'monitor', status: ARGV.join(' ')
 
       logger.info "master process ready" # test_exec.rb relies on this message
       if @ready_pipe
@@ -374,6 +348,9 @@ module Pitchfork
       when Message::MoldSpawned
         new_mold = @children.update(message)
         logger.info("mold pid=#{new_mold.pid} gen=#{new_mold.generation} spawned")
+      when Message::ServiceSpawned
+        new_service = @children.update(message)
+        logger.info("service pid=#{new_service.pid} gen=#{new_service.generation} spawned")
       when Message::MoldReady
         old_molds = @children.molds
         new_mold = @children.update(message)
@@ -429,6 +406,20 @@ module Pitchfork
       Process.exit
     end
 
+    def service_exit(service)
+      logger.info "service pid=#{service.pid} gen=#{service.generation} exiting"
+      proc_name status: "exiting"
+
+      if @before_service_worker_exit
+        begin
+          @before_service_worker_exit.call(self, service)
+        rescue => error
+          Pitchfork.log_error(logger, "before_service_worker_exit error", error)
+        end
+      end
+      Process.exit
+    end
+
     def rewindable_input
       Pitchfork::HttpParser.input_class.method_defined?(:rewind)
     end
@@ -590,6 +581,69 @@ module Pitchfork
       worker
     end
 
+    def service_loop(service)
+      readers = init_service_process(service)
+      waiter = prep_readers(readers)
+
+      ready = readers.dup
+
+      if @before_service_worker_ready
+        begin
+          @before_service_worker_ready.call(self, service)
+        rescue => error
+          Pitchfork.log_error(logger, "before_service_worker_ready", error)
+          Process.exit(1)
+        end
+      end
+
+      proc_name status: "ready"
+
+      while readers[0]
+        begin
+          service.update_deadline(@timeout)
+          while sock = ready.shift
+            # Pitchfork::Worker#accept_nonblock is not like accept(2) at all,
+            # but that will return false
+            client = sock.accept_nonblock(exception: false)
+
+            case client
+            when false, :wait_readable
+              # no message, keep looping
+            end
+
+            service.update_deadline(@timeout)
+          end
+
+          # timeout so we can update .deadline and keep parent from SIGKILL-ing us
+          service.update_deadline(@timeout)
+
+
+          waiter.get_readers(ready, readers, @timeout * 500) # to milliseconds, but halved
+        rescue => e
+          Pitchfork.log_error(@logger, "listen loop error", e) if readers[0]
+        end
+      end
+    end
+
+    def spawn_service(service, detach:)
+      logger.info("service gen=#{service.generation} spawning...")
+
+      # We set the deadline before spawning the child so that if for some
+      # reason it gets stuck before reaching the worker loop,
+      # the monitor process will kill it.
+      service.update_deadline(@spawn_timeout)
+      @before_fork&.call(self)
+      fork_sibling("spawn_service") do
+        service.pid = Process.pid
+
+        after_fork_internal
+        service_loop(service)
+        service_exit(service)
+      end
+
+      service
+    end
+
     def spawn_initial_mold
       mold = Worker.new(nil)
       mold.create_socketpair!
@@ -606,6 +660,21 @@ module Pitchfork
     end
 
     def spawn_missing_workers
+      if @before_service_worker_ready && !@children.service
+        service = Pitchfork::Service.new
+        if REFORKING_AVAILABLE
+          service.generation = @children.mold&.generation || 0
+
+          unless @children.mold&.spawn_service(service)
+            @logger.error("Failed to send a spawn_service command")
+          end
+        else
+          spawn_service(service, detach: false)
+        end
+
+        @children.register_service(service)
+      end
+
       worker_nr = -1
       until (worker_nr += 1) == @worker_processes
         if @children.nr_alive?(worker_nr)
@@ -643,9 +712,18 @@ module Pitchfork
     end
 
     def maintain_worker_count
-      (off = @children.workers_count - worker_processes) == 0 and return
-      off < 0 and return spawn_missing_workers
-      @children.each_worker { |w| w.nr >= worker_processes and w.soft_kill(:TERM) }
+      off = @children.workers_count - worker_processes
+      off -= 1 if @before_service_worker_ready && !@children.service
+
+      if off < 0
+        spawn_missing_workers
+      elsif off > 0
+        @children.each_worker do |worker|
+          if worker.nr >= worker_processes
+            worker.soft_kill(:TERM)
+          end
+        end
+      end
     end
 
     def restart_outdated_workers
@@ -658,6 +736,16 @@ module Pitchfork
       max_pending_workers = (worker_processes * 0.1).ceil
       workers_to_restart = max_pending_workers - @children.restarting_workers_count
 
+      if service = @children.service
+        if service.outdated?
+          if service.soft_kill(:TERM)
+            logger.info("Sent SIGTERM to service pid=#{service.pid} gen=#{service.generation}")
+          else
+            logger.info("Failed to send SIGTERM to service pid=#{service.pid} gen=#{service.generation}")
+          end
+        end
+      end
+
       if workers_to_restart > 0
         outdated_workers = @children.workers.select { |w| !w.exiting? && w.generation < @children.mold.generation }
         outdated_workers.each do |worker|
@@ -701,18 +789,14 @@ module Pitchfork
       rss = @request.response_start_sent
       buf = (rss ? "103 Early Hints\r\n" : "HTTP/1.1 103 Early Hints\r\n").b
       headers.each { |key, value| append_header(buf, key, value) }
-      buf << (rss ? "\r\nHTTP/1.1 ".freeze : "\r\n".freeze)
+      buf << (rss ? "\r\nHTTP/1.1 " : "\r\n")
       client.write(buf)
     end
 
     def e100_response_write(client, env)
-      # We use String#freeze to avoid allocations under Ruby 2.1+
-      # Not many users hit this code path, so it's better to reduce the
-      # constant table sizes even for Ruby 2.0 users who'll hit extra
-      # allocations here.
       client.write(@request.response_start_sent ?
-                   "100 Continue\r\n\r\nHTTP/1.1 ".freeze :
-                   "HTTP/1.1 100 Continue\r\n\r\n".freeze)
+                   "100 Continue\r\n\r\nHTTP/1.1 " :
+                   "HTTP/1.1 100 Continue\r\n\r\n")
       env.delete('HTTP_EXPECT')
     end
 
@@ -723,7 +807,11 @@ module Pitchfork
       @request = Pitchfork::HttpParser.new
       env = @request.read(client)
 
-      proc_name status: "requests: #{worker.requests_count}, processing: #{env["PATH_INFO"]}"
+      status = "requests: #{worker.requests_count}, processing: #{env["PATH_INFO"]}"
+      if request_id = env["HTTP_X_REQUEST_ID"]
+        status += ", request_id: #{request_id}"
+      end
+      proc_name status: status
 
       env["pitchfork.worker"] = worker
       timeout_handler.rack_env = env
@@ -817,6 +905,18 @@ module Pitchfork
       readers
     end
 
+    def init_service_process(service)
+      proc_name role: "(gen:#{service.generation}) mold", status: "init"
+      LISTENERS.each(&:close) # Don't appear as listening to incoming requests
+      service.register_to_master(@control_socket[1])
+      readers = [service]
+      trap(:QUIT) { nuke_listeners!(readers) }
+      trap(:TERM) { nuke_listeners!(readers) }
+      trap(:INT) { nuke_listeners!(readers); exit!(0) }
+      proc_name role: "(gen:#{service.generation}) service", status: "ready"
+      readers
+    end
+
     def init_mold_process(mold)
       proc_name role: "(gen:#{mold.generation}) mold", status: "init"
       after_mold_fork.call(self, mold)
@@ -830,7 +930,7 @@ module Pitchfork
 
     if Pitchfork.const_defined?(:Waiter)
       def prep_readers(readers)
-        Pitchfork::Waiter.prep_readers(readers)
+        Pitchfork::Info.keep_io(Pitchfork::Waiter.prep_readers(readers))
       end
     else
       require_relative 'select_waiter'
@@ -858,24 +958,25 @@ module Pitchfork
             # Pitchfork::Worker#accept_nonblock is not like accept(2) at all,
             # but that will return false
             client = sock.accept_nonblock(exception: false)
-            client = false if client == :wait_readable
-            if client
-              case client
-              when Message::PromoteWorker
-                if Info.fork_safe?
-                  spawn_mold(worker)
-                else
-                  logger.error("worker=#{worker.nr} gen=#{worker.generation} is no longer fork safe, can't refork")
-                end
-              when Message
-                worker.update(client)
+
+            case client
+            when false, :wait_readable
+              # no message, keep looping
+            when Message::PromoteWorker
+              if Info.fork_safe?
+                spawn_mold(worker)
               else
-                request_env = process_client(client, worker, prepare_timeout(worker))
-                @after_request_complete&.call(self, worker, request_env)
-                worker.increment_requests_count
+                logger.error("worker=#{worker.nr} gen=#{worker.generation} is no longer fork safe, can't refork")
               end
-              worker.update_deadline(@timeout)
+            when Message
+              worker.update(client)
+            else
+              request_env = process_client(client, worker, prepare_timeout(worker))
+              worker.increment_requests_count
+              @after_request_complete&.call(self, worker, request_env)
             end
+
+            worker.update_deadline(@timeout)
           end
 
           # timeout so we can update .deadline and keep parent from SIGKILL-ing us
@@ -958,6 +1059,22 @@ module Pitchfork
               rescue => error
                 raise BootFailure, error.message
               end
+            when Message::SpawnService
+              retries = 1
+              begin
+                spawn_service(Service.new(generation: mold.generation), detach: true)
+              rescue ForkFailure
+                if retries > 0
+                  @logger.fatal("mold pid=#{mold.pid} gen=#{mold.generation} Failed to spawn a service. Retrying.")
+                  retries -= 1
+                  retry
+                else
+                  @logger.fatal("mold pid=#{mold.pid} gen=#{mold.generation} Failed to spawn a service twice in a row. Corrupted mold process?")
+                  Process.exit(1)
+                end
+              rescue => error
+                raise BootFailure, error.message
+              end
             else
               logger.error("Unexpected mold message #{message.inspect}")
             end
@@ -1004,7 +1121,7 @@ module Pitchfork
       @proctitle_role = role if role
       @proctitle_status = status if status
 
-      Process.setproctitle("#{File.basename(START_CTX[0])} #{@proctitle_role} - #{@proctitle_status}")
+      Process.setproctitle("#{File.basename($PROGRAM_NAME)} #{@proctitle_role} - #{@proctitle_status}")
     end
 
     def bind_listeners!
@@ -1012,7 +1129,6 @@ module Pitchfork
       if listeners.empty?
         listeners << Pitchfork::Const::DEFAULT_LISTEN
         @init_listeners << Pitchfork::Const::DEFAULT_LISTEN
-        START_CTX[:argv] << "-l#{Pitchfork::Const::DEFAULT_LISTEN}"
       end
       listeners.each { |addr| listen(addr) }
       raise ArgumentError, "no listeners" if LISTENERS.empty?

data/lib/pitchfork/message.rb

@@ -122,12 +122,16 @@ module Pitchfork
 
   Message = Class.new(Struct)
   class Message
-    SpawnWorker = Message.new(:nr)
-    WorkerSpawned = Message.new(:nr, :pid, :generation, :pipe)
-    PromoteWorker = Message.new(:generation)
-    MoldSpawned = Message.new(:nr, :pid, :generation, :pipe)
-    MoldReady = Message.new(:nr, :pid, :generation)
+    SpawnWorker = new(:nr)
+    WorkerSpawned = new(:nr, :pid, :generation, :pipe)
+    PromoteWorker = new(:generation)
 
-    SoftKill = Message.new(:signum)
+    MoldSpawned = new(:nr, :pid, :generation, :pipe)
+    MoldReady = new(:nr, :pid, :generation)
+
+    SpawnService = new(:_) # Struct.new requires at least 1 member on Ruby < 3.3
+    ServiceSpawned = new(:pid, :generation, :pipe)
+
+    SoftKill = new(:signum)
   end
 end