pitchfork 0.16.0 → 0.17.0

data/lib/pitchfork/configurator.rb

@@ -14,7 +14,7 @@ module Pitchfork
     include Pitchfork
 
     # :stopdoc:
-    attr_accessor :set, :config_file, :after_load
+    attr_accessor :set, :config_file
 
     # used to stash stuff for deferred processing of cli options in
     # config.ru.  Do not rely on
@@ -41,21 +41,17 @@ module Pitchfork
       :worker_processes => 1,
       :before_fork => nil,
       :after_worker_fork => lambda { |server, worker|
-        server.logger.info("worker=#{worker.nr} gen=#{worker.generation} pid=#{$$} spawned")
+        server.logger.info("#{worker.to_log} spawned")
       },
       :after_mold_fork => lambda { |server, worker|
-        server.logger.info("mold gen=#{worker.generation} pid=#{$$} spawned")
+        server.logger.info("#{worker.to_log} spawned")
       },
       :before_worker_exit => nil,
       :after_worker_exit => lambda { |server, worker, status|
         m = if worker.nil?
-          "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})"
+          "reaped unknown process (#{status.inspect})"
         else
-          "worker=#{worker.nr rescue 'unknown'} pid=#{worker.pid rescue 'unknown'} gen=#{worker.generation rescue 'unknown'} reaped (#{status.inspect})"
+          "#{worker.to_log} reaped (#{status.inspect})"
         end
         if status.success?
           server.logger.info(m)
@@ -64,10 +60,10 @@ module Pitchfork
         end
       },
       :after_worker_ready => lambda { |server, worker|
-        server.logger.info("worker=#{worker.nr} gen=#{worker.generation} ready")
+        server.logger.info("#{worker.to_log} ready")
       },
       :after_monitor_ready => lambda { |server|
-        server.logger.info("Monitor pid=#{Process.pid} ready")
+        server.logger.info("monitor pid=#{Process.pid} ready")
       },
       :after_worker_timeout => nil,
       :after_worker_hard_timeout => nil,
@@ -79,13 +75,14 @@ module Pitchfork
       :client_body_buffer_size => Pitchfork::Const::MAX_BODY,
       :before_service_worker_ready => nil,
       :before_service_worker_exit => nil,
+      :setpgid => false,
     }
     #:startdoc:
 
     def initialize(defaults = {}) #:nodoc:
       self.set = Hash.new(:unset)
       @use_defaults = defaults.delete(:use_defaults)
-      self.config_file = defaults.delete(:config_file)
+      self.config_file = defaults.delete(:config_file) { "config/pitchfork.rb" if File.exist?("config/pitchfork.rb") }
 
       set.merge!(DEFAULTS) if @use_defaults
       defaults.each { |key, value| self.__send__(key, value) }
@@ -207,6 +204,10 @@ module Pitchfork
       end
     end
 
+    def setpgid(bool)
+      set_bool(:setpgid, bool)
+    end
+
     def spawn_timeout(seconds)
       set_int(:spawn_timeout, seconds, 1)
     end

data/lib/pitchfork/http_server.rb

@@ -11,7 +11,7 @@ require 'pitchfork/info'
 module Pitchfork
   # This is the process manager of Pitchfork. This manages worker
   # processes which in turn handle the I/O and application process.
-  # Listener sockets are started in the master process and shared with
+  # Listener sockets are started in the monitor process and shared with
   # forked worker children.
   class HttpServer
     class TimeoutHandler
@@ -50,7 +50,7 @@ module Pitchfork
 
       def call(original_thread) # :nodoc:
         begin
-          @server.logger.error("worker=#{@worker.nr} pid=#{@worker.pid} timed out, exiting")
+          @server.logger.error("#{@worker.to_log} timed out, exiting")
           if @callback
             @callback.call(@server, @worker, Info.new(original_thread, @rack_env))
           end
@@ -80,7 +80,7 @@ module Pitchfork
     attr_accessor :app, :timeout, :timeout_signal, :soft_timeout, :cleanup_timeout, :spawn_timeout, :worker_processes,
                   :before_fork, :after_worker_fork, :after_mold_fork, :before_service_worker_ready, :before_service_worker_exit,
                   :listener_opts, :children,
-                  :orig_app, :config, :ready_pipe, :early_hints
+                  :orig_app, :config, :ready_pipe, :early_hints, :setpgid
     attr_writer   :after_worker_exit, :before_worker_exit, :after_worker_ready, :after_request_complete,
                   :refork_condition, :after_worker_timeout, :after_worker_hard_timeout, :after_monitor_ready
 
@@ -116,11 +116,11 @@ module Pitchfork
 
       proc_name role: 'monitor', status: ARGV.join(' ')
 
-      # We use @control_socket differently in the master and worker processes:
+      # We use @control_socket differently in the monitor and worker processes:
       #
-      # * The master process never closes or reinitializes this once
-      # initialized.  Signal handlers in the master process will write to
-      # it to wake up the master from IO.select in exactly the same manner
+      # * The monitor process never closes or reinitializes this once
+      # initialized.  Signal handlers in the monitor process will write to
+      # it to wake up the monitor from IO.select in exactly the same manner
       # djb describes in https://cr.yp.to/docs/selfpipe.html
       #
       # * The workers immediately close the pipe they inherit.  See the
@@ -142,7 +142,7 @@ module Pitchfork
       # attempt to connect to the listener(s)
       config.commit!(self, :skip => [:listeners, :pid])
       @orig_app = app
-      # list of signals we care about and trap in master.
+      # list of signals we care about and trap in monitor.
       @queue_sigs = [
         :QUIT, :INT, :TERM, :USR2, :TTIN, :TTOU ]
 
@@ -157,16 +157,16 @@ module Pitchfork
       # This socketpair is used to wake us up from select(2) in #join when signals
       # are trapped.  See trap_deferred.
       # It's also used by newly spawned children to send their soft_signal pipe
-      # to the master when they are spawned.
+      # to the monitor when they are spawned.
       @control_socket.replace(Pitchfork.socketpair)
       Info.keep_ios(@control_socket)
-      @master_pid = $$
+      @monitor_pid = $$
 
       # setup signal handlers before writing pid file in case people get
       # trigger happy and send signals as soon as the pid file exists.
       # Note that signals don't actually get handled until the #join method
-      @queue_sigs.each { |sig| trap(sig) { @sig_queue << sig; awaken_master } }
-      trap(:CHLD) { awaken_master }
+      @queue_sigs.each { |sig| trap(sig) { @sig_queue << sig; awaken_monitor } }
+      trap(:CHLD) { awaken_monitor }
 
       if REFORKING_AVAILABLE
         spawn_initial_mold
@@ -224,7 +224,7 @@ module Pitchfork
     # to delay between retries.
     # A negative value for +:tries+ indicates the listen will be
     # retried indefinitely, this is useful when workers belonging to
-    # different masters are spawned during a transparent upgrade.
+    # different monitors are spawned during a transparent upgrade.
     def listen(address, opt = listener_opts[address] || {})
       address = config.expand_addr(address)
       return if String === address && listener_names.include?(address)
@@ -291,7 +291,7 @@ module Pitchfork
 
       proc_name role: 'monitor', status: ARGV.join(' ')
 
-      logger.info "master process ready" # test_exec.rb relies on this message
+      logger.info "monitor process ready" # test_exec.rb relies on this message
       if @ready_pipe
         begin
           @ready_pipe.syswrite($$.to_s)
@@ -306,11 +306,11 @@ module Pitchfork
             break
           end
         rescue => e
-          Pitchfork.log_error(@logger, "master loop error", e)
+          Pitchfork.log_error(@logger, "monitor loop error", e)
         end
       end
       stop # gracefully shutdown all workers on our way out
-      logger.info "master complete status=#{@exit_status}"
+      logger.info "monitor complete status=#{@exit_status}"
       @exit_status
     end
 
@@ -326,7 +326,7 @@ module Pitchfork
 
       case message = @sig_queue.shift
       when nil
-        # avoid murdering workers after our master process (or the
+        # avoid murdering workers after our monitor process (or the
         # machine) comes out of suspend/hibernation
         if (@last_check + @timeout) >= (@last_check = Pitchfork.time_now)
           sleep_time = murder_lazy_workers
@@ -339,7 +339,7 @@ module Pitchfork
           restart_outdated_workers if REFORKING_AVAILABLE
         end
 
-        master_sleep(sleep_time) if sleep
+        monitor_sleep(sleep_time) if sleep
       when :QUIT, :TERM # graceful shutdown
         SharedMemory.shutting_down!
         logger.info "#{message} received, starting graceful shutdown"
@@ -363,19 +363,19 @@ module Pitchfork
       when Message::WorkerSpawned
         worker = @children.update(message)
         # TODO: should we send a message to the worker to acknowledge?
-        logger.info "worker=#{worker.nr} pid=#{worker.pid} gen=#{worker.generation} registered"
+        logger.info "#{worker.to_log} registered"
       when Message::MoldSpawned
         new_mold = @children.update(message)
-        logger.info("mold pid=#{new_mold.pid} gen=#{new_mold.generation} spawned")
+        logger.info("#{new_mold.to_log} spawned")
       when Message::ServiceSpawned
         new_service = @children.update(message)
-        logger.info("service pid=#{new_service.pid} gen=#{new_service.generation} spawned")
+        logger.info("#{new_service.to_log} spawned")
       when Message::MoldReady
         old_molds = @children.molds
         new_mold = @children.update(message)
-        logger.info("mold pid=#{new_mold.pid} gen=#{new_mold.generation} ready")
+        logger.info("#{new_mold.to_log} ready")
         old_molds.each do |old_mold|
-          logger.info("Terminating old mold pid=#{old_mold.pid} gen=#{old_mold.generation}")
+          logger.info("Terminating old #{old_mold.to_log}")
           old_mold.soft_kill(:TERM)
         end
       else
@@ -384,7 +384,7 @@ module Pitchfork
       end
     end
 
-    # Terminates all workers, but does not exit master process
+    # Terminates all workers, but does not exit monitor process
     def stop(graceful = true)
       proc_name role: 'monitor', status: 'shutting down'
       @respawn = false
@@ -413,7 +413,7 @@ module Pitchfork
     end
 
     def worker_exit(worker)
-      logger.info "worker=#{worker.nr} pid=#{worker.pid} gen=#{worker.generation} exiting"
+      logger.info "#{worker.to_log} exiting"
       proc_name status: "exiting"
 
       if @before_worker_exit
@@ -427,7 +427,7 @@ module Pitchfork
     end
 
     def service_exit(service)
-      logger.info "service pid=#{service.pid} gen=#{service.generation} exiting"
+      logger.info "#{service.to_log} exiting"
       proc_name status: "exiting"
 
       if @before_service_worker_exit
@@ -468,7 +468,7 @@ module Pitchfork
     private
 
     # wait for a signal handler to wake us up and then consume the pipe
-    def master_sleep(sec)
+    def monitor_sleep(sec)
       @control_socket[0].wait(sec) or return
       case message = @control_socket[0].recvmsg_nonblock(exception: false)
       when :wait_readable, NOOP
@@ -478,9 +478,9 @@ module Pitchfork
       end
     end
 
-    def awaken_master
-      return if $$ != @master_pid
-      @control_socket[1].sendmsg_nonblock(NOOP, exception: false) # wakeup master process from select
+    def awaken_monitor
+      return if $$ != @monitor_pid
+      @control_socket[1].sendmsg_nonblock(NOOP, exception: false) # wakeup monitor process from select
     end
 
     # reaps all unreaped workers
@@ -548,11 +548,7 @@ module Pitchfork
         end
       end
 
-      if child.mold?
-        logger.error "mold pid=#{child.pid} gen=#{child.generation} timed out, killing"
-      else
-        logger.error "worker=#{child.nr} pid=#{child.pid} gen=#{child.generation} timed out, killing"
-      end
+      logger.error "#{child.to_log} timed out, killing"
       @children.hard_kill(@timeout_signal.call(child.pid), child) # take no prisoners for hard timeout violations
     end
 
@@ -572,7 +568,7 @@ module Pitchfork
 
     def after_fork_internal
       @promotion_lock.at_fork
-      @control_socket[0].close_write # this is master-only, now
+      @control_socket[0].close_write # this is monitor-only, now
       @ready_pipe.close if @ready_pipe
       Pitchfork::Configurator::RACKUP.clear
       @ready_pipe = @init_listeners = nil
@@ -583,12 +579,13 @@ module Pitchfork
     end
 
     def spawn_worker(worker, detach:)
-      logger.info("worker=#{worker.nr} gen=#{worker.generation} spawning...")
+      logger.info("#{worker.to_log} 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.
       worker.update_deadline(@spawn_timeout)
+
       @before_fork&.call(self)
       fork_sibling("spawn_worker") do
         worker.pid = Process.pid
@@ -646,7 +643,7 @@ module Pitchfork
     end
 
     def spawn_service(service, detach:)
-      logger.info("service gen=#{service.generation} spawning...")
+      logger.info("#{service.to_log} spawning...")
 
       # We set the deadline before spawning the child so that if for some
       # reason it gets stuck before reaching the worker loop,
@@ -667,7 +664,7 @@ module Pitchfork
     def spawn_initial_mold
       mold = Worker.new(nil)
       mold.create_socketpair!
-      mold.pid = Pitchfork.clean_fork do
+      mold.pid = Pitchfork.clean_fork(setpgid: setpgid) do
         mold.pid = Process.pid
         @promotion_lock.try_lock
         mold.after_fork_in_child
@@ -712,7 +709,7 @@ module Pitchfork
           spawn_worker(worker, detach: false)
         end
         # We could directly register workers when we spawn from the
-        # master, like pitchfork does. However it is preferable to
+        # monitor, like pitchfork does. However it is preferable to
         # always go through the asynchronous registering process for
         # consistency.
         @children.register(worker)
@@ -724,7 +721,7 @@ module Pitchfork
 
     def wait_for_pending_workers
       while @children.pending_workers?
-        master_sleep(0.5)
+        monitor_sleep(0.5)
         if monitor_loop(false) == StopIteration
           return StopIteration
         end
@@ -759,9 +756,9 @@ module Pitchfork
       if service = @children.service
         if service.outdated?
           if service.soft_kill(:TERM)
-            logger.info("Sent SIGTERM to service pid=#{service.pid} gen=#{service.generation}")
+            logger.info("Sent SIGTERM to #{service.to_log}")
           else
-            logger.info("Failed to send SIGTERM to service pid=#{service.pid} gen=#{service.generation}")
+            logger.info("Failed to send SIGTERM to #{service.to_log}")
           end
         end
       end
@@ -770,10 +767,10 @@ module Pitchfork
         outdated_workers = @children.workers.select { |w| !w.exiting? && w.generation < @children.mold.generation }
         outdated_workers.each do |worker|
           if worker.soft_kill(:TERM)
-            logger.info("Sent SIGTERM to worker=#{worker.nr} pid=#{worker.pid} gen=#{worker.generation}")
+            logger.info("Sent SIGTERM to #{worker.to_log}")
             workers_to_restart -= 1
           else
-            logger.info("Failed to send SIGTERM to worker=#{worker.nr} pid=#{worker.pid} gen=#{worker.generation}")
+            logger.info("Failed to send SIGTERM to #{worker.to_log}")
           end
           break if workers_to_restart <= 0
         end
@@ -885,7 +882,6 @@ module Pitchfork
         end
       end
       timeout_handler.finished
-      env
     end
 
     def nuke_listeners!(readers)
@@ -895,14 +891,18 @@ module Pitchfork
       tmp.each { |io| io.close rescue nil } # break out of IO.select
     end
 
+    def reset_signal_handlers
+      [:QUIT, :TERM, :INT].each { |sig| trap(sig) { exit!(0) } }
+    end
+
     # gets rid of stuff the worker has no business keeping track of
     # to free some resources and drops all sig handlers.
-    # traps for USR2, and HUP may be set in the after_fork Proc
+    # traps for USR2, and HUP may be set in the after_worker_fork/after_mold_fork Procs
     # by the user.
     def init_worker_process(worker)
       proc_name role: "(gen:#{worker.generation}) worker[#{worker.nr}]", status: "init"
       worker.reset
-      worker.register_to_master(@control_socket[1])
+      worker.register_to_monitor(@control_socket[1])
       # we'll re-trap :QUIT and :TERM later for graceful shutdown iff we accept clients
       exit_sigs = [ :QUIT, :TERM, :INT ]
       exit_sigs.each { |sig| trap(sig) { exit!(0) } }
@@ -927,8 +927,8 @@ module Pitchfork
 
     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])
+      LISTENERS.each(&:close).clear # Don't appear as listening to incoming requests
+      service.register_to_monitor(@control_socket[1])
       readers = [service]
       trap(:QUIT) { nuke_listeners!(readers) }
       trap(:TERM) { nuke_listeners!(readers) }
@@ -971,6 +971,8 @@ module Pitchfork
 
       proc_name status: "ready"
 
+      worker.ready = true
+
       while readers[0]
         begin
           worker.update_deadline(@timeout)
@@ -986,7 +988,7 @@ module Pitchfork
               if Info.fork_safe?
                 spawn_mold(worker)
               else
-                logger.error("worker=#{worker.nr} gen=#{worker.generation} is no longer fork safe, can't refork")
+                logger.error("#{worker.to_log} is no longer fork safe, can't refork")
               end
             when Message
               worker.update(client)
@@ -1006,7 +1008,7 @@ module Pitchfork
             if @refork_condition.met?(worker, logger)
               proc_name status: "requests: #{worker.requests_count}, spawning mold"
               if spawn_mold(worker)
-                logger.info("worker=#{worker.nr} gen=#{worker.generation} Refork condition met, promoting ourselves")
+                logger.info("#{worker.to_log} refork condition met, promoting ourselves")
               end
               @refork_condition.backoff!
             end
@@ -1069,11 +1071,11 @@ module Pitchfork
                 spawn_worker(Worker.new(message.nr, generation: mold.generation), detach: true)
               rescue ForkFailure
                 if retries > 0
-                  @logger.fatal("mold pid=#{mold.pid} gen=#{mold.generation} Failed to spawn a worker. Retrying.")
+                  @logger.fatal("#{mold.to_log} failed to spawn a worker, retrying")
                   retries -= 1
                   retry
                 else
-                  @logger.fatal("mold pid=#{mold.pid} gen=#{mold.generation} Failed to spawn a worker twice in a row. Corrupted mold process?")
+                  @logger.fatal("#{mold.to_log} failed to spawn a worker twice in a row - corrupted mold process?")
                   Process.exit(1)
                 end
               rescue => error
@@ -1085,11 +1087,11 @@ module Pitchfork
                 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.")
+                  @logger.fatal("#{mold.to_log} 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?")
+                  @logger.fatal("#{mold.to_log} failed to spawn a service twice in a row - corrupted mold process?")
                   Process.exit(1)
                 end
               rescue => error
@@ -1163,12 +1165,14 @@ module Pitchfork
     FORK_TIMEOUT = 5
 
     def fork_sibling(role, &block)
+      reset_signal_handlers
+
       if REFORKING_AVAILABLE
         r, w = Pitchfork::Info.keep_ios(IO.pipe)
         # We double fork so that the new worker is re-attached back
-        # to the master.
+        # to the monitor.
         # This requires either PR_SET_CHILD_SUBREAPER which is exclusive to Linux 3.4
-        # or the master to be PID 1.
+        # or the monitor to be PID 1.
         if middle_pid = FORK_LOCK.synchronize { Process.fork } # parent
           w.close
           # We need to wait(2) so that the middle process doesn't end up a zombie.
@@ -1188,7 +1192,7 @@ module Pitchfork
         else # first child
           r.close
           Process.setproctitle("<pitchfork fork_sibling(#{role})>")
-          pid = Pitchfork.clean_fork do
+          pid = Pitchfork.clean_fork(setpgid: setpgid) do
             # detach into a grand child
             w.close
             yield
@@ -1203,7 +1207,7 @@ module Pitchfork
           exit!
         end
       else
-        Pitchfork.clean_fork(&block)
+        Pitchfork.clean_fork(setpgid: setpgid, &block)
       end
     end
 

data/lib/pitchfork/info.rb

@@ -98,13 +98,14 @@ module Pitchfork
       def live_workers_count
         now = Pitchfork.time_now(true)
         (0...workers_count).count do |nr|
-          SharedMemory.worker_deadline(nr).value > now
+          state = SharedMemory.worker_state(nr)
+          state.ready? && state.deadline > now
         end
       end
 
       # Returns true if the server is shutting down.
       # This can be useful to implement health check endpoints, so they
-      # can fail immediately after TERM/QUIT/INT was received by the master
+      # can fail immediately after TERM/QUIT/INT was received by the monitor
       # process.
       # Otherwise they may succeed while Pitchfork is draining requests causing
       # more requests to be sent.

data/lib/pitchfork/refork_condition.rb

@@ -19,7 +19,7 @@ module Pitchfork
           if worker.requests_count >= limit
             return false if backoff?
 
-            logger.info("worker=#{worker.nr} pid=#{worker.pid} processed #{worker.requests_count} requests, triggering a refork")
+            logger.info("#{worker.to_log} processed #{worker.requests_count} requests, triggering a refork")
             return true
           end
         end

data/lib/pitchfork/shared_memory.rb

@@ -44,20 +44,47 @@ module Pitchfork
       end
     end
 
-    def mold_deadline
-      self[MOLD_TICK_OFFSET]
+    class WorkerState
+      def initialize(field)
+        @field = field
+      end
+
+      def ready?
+        (@field.value & 1) == 1
+      end
+
+      def ready=(bool)
+        if bool
+          @field.value |= 1
+        else
+          @field.value &= ~1
+        end
+      end
+
+      def deadline=(value)
+        # Shift the value up and preserve the current ready bit.
+        @field.value = (value << 1) | (@field.value & 1)
+      end
+
+      def deadline
+        @field.value >> 1
+      end
+    end
+
+    def mold_state
+      WorkerState.new(self[MOLD_TICK_OFFSET])
     end
 
-    def mold_promotion_deadline
-      self[MOLD_PROMOTION_TICK_OFFSET]
+    def mold_promotion_state
+      WorkerState.new(self[MOLD_PROMOTION_TICK_OFFSET])
     end
 
-    def service_deadline
-      self[SERVICE_TICK_OFFSET]
+    def service_state
+      WorkerState.new(self[SERVICE_TICK_OFFSET])
     end
 
-    def worker_deadline(worker_nr)
-      self[WORKER_TICK_OFFSET + worker_nr]
+    def worker_state(worker_nr)
+      WorkerState.new(self[WORKER_TICK_OFFSET + worker_nr])
     end
 
     def [](offset)
@@ -75,4 +102,4 @@ module Pitchfork
       end
     end
   end
-end
+end

data/lib/pitchfork/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Pitchfork
-  VERSION = "0.16.0"
+  VERSION = "0.17.0"
   module Const
     UNICORN_VERSION = '6.1.0'
   end