puma 5.2.2 → 6.3.0

data/lib/puma/cluster.rb

@@ -1,12 +1,10 @@
 # frozen_string_literal: true
 
-require 'puma/runner'
-require 'puma/util'
-require 'puma/plugin'
-require 'puma/cluster/worker_handle'
-require 'puma/cluster/worker'
-
-require 'time'
+require_relative 'runner'
+require_relative 'util'
+require_relative 'plugin'
+require_relative 'cluster/worker_handle'
+require_relative 'cluster/worker'
 
 module Puma
   # This class is instantiated by the `Puma::Launcher` and used
@@ -17,8 +15,8 @@ module Puma
   # via the `spawn_workers` method call. Each worker will have it's own
   # instance of a `Puma::Server`.
   class Cluster < Runner
-    def initialize(cli, events)
-      super cli, events
+    def initialize(launcher)
+      super(launcher)
 
       @phase = 0
       @workers = []
@@ -27,6 +25,10 @@ module Puma
       @phased_restart = false
     end
 
+    # Returns the list of cluster worker handles.
+    # @return [Array<Puma::Cluster::WorkerHandle>]
+    attr_reader :workers
+
     def stop_workers
       log "- Gracefully shutting down workers..."
       @workers.each { |x| x.term }
@@ -43,6 +45,7 @@ module Puma
     end
 
     def start_phased_restart
+      @events.fire_on_restart!
       @phase += 1
       log "- Starting phased worker restart, phase: #{@phase}"
 
@@ -91,7 +94,7 @@ module Puma
 
     # @version 5.0.0
     def spawn_worker(idx, master)
-      @launcher.config.run_hooks :before_worker_fork, idx, @launcher.events
+      @config.run_hooks(:before_worker_fork, idx, @log_writer)
 
       pid = fork { worker(idx, master) }
       if !pid
@@ -100,31 +103,49 @@ module Puma
         exit! 1
       end
 
-      @launcher.config.run_hooks :after_worker_fork, idx, @launcher.events
+      @config.run_hooks(:after_worker_fork, idx, @log_writer)
       pid
     end
 
     def cull_workers
       diff = @workers.size - @options[:workers]
       return if diff < 1
+      debug "Culling #{diff} workers"
 
-      debug "Culling #{diff.inspect} workers"
-
-      workers_to_cull = @workers[-diff,diff]
-      debug "Workers to cull: #{workers_to_cull.inspect}"
+      workers = workers_to_cull(diff)
+      debug "Workers to cull: #{workers.inspect}"
 
-      workers_to_cull.each do |worker|
+      workers.each do |worker|
         log "- Worker #{worker.index} (PID: #{worker.pid}) terminating"
         worker.term
       end
     end
 
+    def workers_to_cull(diff)
+      workers = @workers.sort_by(&:started_at)
+
+      # In fork_worker mode, worker 0 acts as our master process.
+      # We should avoid culling it to preserve copy-on-write memory gains.
+      workers.reject! { |w| w.index == 0 } if @options[:fork_worker]
+
+      workers[cull_start_index(diff), diff]
+    end
+
+    def cull_start_index(diff)
+      case @options[:worker_culling_strategy]
+      when :oldest
+        0
+      else # :youngest
+        -diff
+      end
+    end
+
     # @!attribute [r] next_worker_index
     def next_worker_index
-      all_positions =  0...@options[:workers]
-      occupied_positions = @workers.map { |w| w.index }
-      available_positions = all_positions.to_a - occupied_positions
-      available_positions.first
+      occupied_positions = @workers.map(&:index)
+      idx = 0
+      idx += 1 until !occupied_positions.include?(idx)
+      idx
     end
 
     def all_workers_booted?
@@ -134,7 +155,7 @@ module Puma
     def check_workers
       return if @next_check >= Time.now
 
-      @next_check = Time.now + Const::WORKER_CHECK_INTERVAL
+      @next_check = Time.now + @options[:worker_check_interval]
 
       timeout_workers
       wait_workers
@@ -157,20 +178,10 @@ module Puma
         end
       end
 
-      @next_check = [
-        @workers.reject(&:term?).map(&:ping_timeout).min,
-        @next_check
-      ].compact.min
-    end
-
-    def wakeup!
-      return unless @wakeup
+      t = @workers.reject(&:term?)
+      t.map!(&:ping_timeout)
 
-      begin
-        @wakeup.write "!" unless @wakeup.closed?
-      rescue SystemCallError, IOError
-        Thread.current.purge_interrupt_queue if Thread.current.respond_to? :purge_interrupt_queue
-      end
+      @next_check = [t.min, @next_check].compact.min
     end
 
     def worker(index, master)
@@ -200,8 +211,8 @@ module Puma
       stop
     end
 
-    def phased_restart
-      return false if @options[:preload_app]
+    def phased_restart(refork = false)
+      return false if @options[:preload_app] && !refork
 
       @phased_restart = true
       wakeup!
@@ -217,7 +228,7 @@ module Puma
     def stop_blocked
       @status = :stop if @status == :run
       wakeup!
-      @control.stop(true) if @control
+      @control&.stop true
       Process.waitall
     end
 
@@ -239,24 +250,24 @@ module Puma
       old_worker_count = @workers.count { |w| w.phase != @phase }
       worker_status = @workers.map do |w|
         {
-          started_at: w.started_at.utc.iso8601,
+          started_at: utc_iso8601(w.started_at),
           pid: w.pid,
           index: w.index,
           phase: w.phase,
           booted: w.booted?,
-          last_checkin: w.last_checkin.utc.iso8601,
+          last_checkin: utc_iso8601(w.last_checkin),
           last_status: w.last_status,
         }
       end
 
       {
-        started_at: @started_at.utc.iso8601,
+        started_at: utc_iso8601(@started_at),
         workers: @workers.size,
         phase: @phase,
         booted_workers: worker_status.count { |w| w[:booted] },
         old_workers: old_worker_count,
         worker_status: worker_status,
-      }
+      }.merge(super)
     end
 
     def preload?
@@ -268,7 +279,7 @@ module Puma
       if (worker = @workers.find { |w| w.index == 0 })
         worker.phase += 1
       end
-      phased_restart
+      phased_restart(true)
     end
 
     # We do this in a separate method to keep the lambda scope
@@ -281,7 +292,7 @@ module Puma
 
         # Auto-fork after the specified number of requests.
         if (fork_requests = @options[:fork_worker].to_i) > 0
-          @launcher.events.register(:ping!) do |w|
+          @events.register(:ping!) do |w|
             fork_worker! if w.index == 0 &&
               w.phase == 0 &&
               w.last_status[:requests_count] >= fork_requests
@@ -317,7 +328,7 @@ module Puma
 
           stop_workers
           stop
-
+          @events.fire_on_stopped!
           raise(SignalException, "SIGTERM") if @options[:raise_exception_on_sigterm]
           exit 0 # Clean exit, workers were stopped
         end
@@ -332,16 +343,22 @@ module Puma
       # This is aligned with the output from Runner, see Runner#output_header
       log "*      Workers: #{@options[:workers]}"
 
-      # Threads explicitly marked as fork safe will be ignored.
-      # Used in Rails, but may be used by anyone.
-      before = Thread.list.reject { |t| t.thread_variable_get(:fork_safe) }
-
       if preload?
+        # Threads explicitly marked as fork safe will be ignored. Used in Rails,
+        # but may be used by anyone. Note that we need to explicit
+        # Process::Waiter check here because there's a bug in Ruby 2.6 and below
+        # where calling thread_variable_get on a Process::Waiter will segfault.
+        # We can drop that clause once those versions of Ruby are no longer
+        # supported.
+        fork_safe = ->(t) { !t.is_a?(Process::Waiter) && t.thread_variable_get(:fork_safe) }
+
+        before = Thread.list.reject(&fork_safe)
+
         log "*     Restarts: (\u2714) hot (\u2716) phased"
         log "* Preloading application"
         load_and_bind
 
-        after = Thread.list.reject { |t| t.thread_variable_get(:fork_safe) }
+        after = Thread.list.reject(&fork_safe)
 
         if after.size > before.size
           threads = (after - before)
@@ -357,12 +374,12 @@ module Puma
       else
         log "*     Restarts: (\u2714) hot (\u2714) phased"
 
-        unless @launcher.config.app_configured?
+        unless @config.app_configured?
           error "No application configured, nothing to run"
           exit 1
         end
 
-        @launcher.binder.parse @options[:binds], self
+        @launcher.binder.parse @options[:binds]
       end
 
       read, @wakeup = Puma::Util.pipe
@@ -382,6 +399,8 @@ module Puma
 
       log "Use Ctrl-C to stop"
 
+      single_worker_warning
+
       redirect_io
 
       Plugins.fire_background
@@ -392,8 +411,7 @@ module Puma
 
       @master_read, @worker_write = read, @wakeup
 
-      @launcher.config.run_hooks :before_fork, nil, @launcher.events
-      Puma::Util.nakayoshi_gc @events if @options[:nakayoshi_fork]
+      @config.run_hooks(:before_fork, nil, @log_writer)
 
       spawn_workers
 
@@ -403,19 +421,21 @@ module Puma
 
       begin
         booted = false
+        in_phased_restart = false
+        workers_not_booted = @options[:workers]
 
         while @status == :run
           begin
             if @phased_restart
               start_phased_restart
               @phased_restart = false
+              in_phased_restart = true
+              workers_not_booted = @options[:workers]
             end
 
             check_workers
 
-            res = IO.select([read], nil, nil, [0, @next_check - Time.now].max)
-
-            if res
+            if read.wait_readable([0, @next_check - Time.now].max)
               req = read.read_nonblock(1)
 
               @next_check = Time.now if req == "!"
@@ -434,18 +454,20 @@ module Puma
                 case req
                 when "b"
                   w.boot!
-                  log "- Worker #{w.index} (PID: #{pid}) booted, phase: #{w.phase}"
+                  log "- Worker #{w.index} (PID: #{pid}) booted in #{w.uptime.round(2)}s, phase: #{w.phase}"
                   @next_check = Time.now
+                  workers_not_booted -= 1
                 when "e"
                   # external term, see worker method, Signal.trap "SIGTERM"
-                  w.instance_variable_set :@term, true
+                  w.term!
                 when "t"
                   w.term unless w.term?
                 when "p"
                   w.ping!(result.sub(/^\d+/,'').chomp)
-                  @launcher.events.fire(:ping!, w)
+                  @events.fire(:ping!, w)
                   if !booted && @workers.none? {|worker| worker.last_status.empty?}
-                    @launcher.events.fire_on_booted!
+                    @events.fire_on_booted!
+                    debug_loaded_extensions("Loaded Extensions - master:") if @log_writer.debug?
                     booted = true
                   end
                 end
@@ -453,6 +475,11 @@ module Puma
                 log "! Out-of-sync worker list, no #{pid} worker"
               end
             end
+            if in_phased_restart && workers_not_booted.zero?
+              @events.fire_on_booted!
+              debug_loaded_extensions("Loaded Extensions - master:") if @log_writer.debug?
+              in_phased_restart = false
+            end
 
           rescue Interrupt
             @status = :stop
@@ -470,6 +497,15 @@ module Puma
 
     private
 
+    def single_worker_warning
+      return if @options[:workers] != 1 || @options[:silence_single_worker_warning]
+
+      log "! WARNING: Detected running cluster mode with 1 worker."
+      log "! Running Puma in cluster mode with a single worker is often a misconfiguration."
+      log "! Consider running Puma in single-mode (workers = 0) in order to reduce memory overhead."
+      log "! Set the `silence_single_worker_warning` option to silence this warning message."
+    end
+
     # loops thru @workers, removing workers that exited, and calling
     # `#term` if needed
     def wait_workers
@@ -499,7 +535,12 @@ module Puma
     def timeout_workers
       @workers.each do |w|
         if !w.term? && w.ping_timeout <= Time.now
-          log "! Terminating timed out worker: #{w.pid}"
+          details = if w.booted?
+                      "(worker failed to check in within #{@options[:worker_timeout]} seconds)"
+                    else
+                      "(worker failed to boot within #{@options[:worker_boot_timeout]} seconds)"
+                    end
+          log "! Terminating timed out worker #{details}: #{w.pid}"
           w.kill
         end
       end

data/lib/puma/commonlogger.rb

@@ -3,7 +3,7 @@
 module Puma
   # Rack::CommonLogger forwards every request to the given +app+, and
   # logs a line in the
-  # {Apache common log format}[https://httpd.apache.org/docs/1.3/logs.html#common]
+  # {Apache common log format}[https://httpd.apache.org/docs/2.4/logs.html#common]
   # to the +logger+.
   #
   # If +logger+ is nil, CommonLogger will fall back +rack.errors+, which is
@@ -16,7 +16,7 @@ module Puma
   # (which is called without arguments in order to make the error appear for
   # sure)
   class CommonLogger
-    # Common Log Format: https://httpd.apache.org/docs/1.3/logs.html#common
+    # Common Log Format: https://httpd.apache.org/docs/2.4/logs.html#common
     #
     #   lilith.local - - [07/Aug/2006 23:58:02 -0400] "GET / HTTP/1.1" 500 -
     #
@@ -25,10 +25,17 @@ module Puma
 
     HIJACK_FORMAT = %{%s - %s [%s] "%s %s%s %s" HIJACKED -1 %0.4f\n}
 
-    CONTENT_LENGTH = 'Content-Length'.freeze
-    PATH_INFO      = 'PATH_INFO'.freeze
-    QUERY_STRING   = 'QUERY_STRING'.freeze
-    REQUEST_METHOD = 'REQUEST_METHOD'.freeze
+    LOG_TIME_FORMAT = '%d/%b/%Y:%H:%M:%S %z'
+
+    CONTENT_LENGTH       = 'Content-Length' # should be lower case from app,
+                                            # Util::HeaderHash allows mixed
+    HTTP_VERSION         = Const::HTTP_VERSION
+    HTTP_X_FORWARDED_FOR = Const::HTTP_X_FORWARDED_FOR
+    PATH_INFO            = Const::PATH_INFO
+    QUERY_STRING         = Const::QUERY_STRING
+    REMOTE_ADDR          = Const::REMOTE_ADDR
+    REMOTE_USER          = 'REMOTE_USER'
+    REQUEST_METHOD       = Const::REQUEST_METHOD
 
     def initialize(app, logger=nil)
       @app = app
@@ -57,13 +64,13 @@ module Puma
       now = Time.now
 
       msg = HIJACK_FORMAT % [
-        env['HTTP_X_FORWARDED_FOR'] || env["REMOTE_ADDR"] || "-",
-        env["REMOTE_USER"] || "-",
-        now.strftime("%d/%b/%Y %H:%M:%S"),
+        env[HTTP_X_FORWARDED_FOR] || env[REMOTE_ADDR] || "-",
+        env[REMOTE_USER] || "-",
+        now.strftime(LOG_TIME_FORMAT),
         env[REQUEST_METHOD],
         env[PATH_INFO],
         env[QUERY_STRING].empty? ? "" : "?#{env[QUERY_STRING]}",
-        env["HTTP_VERSION"],
+        env[HTTP_VERSION],
         now - began_at ]
 
       write(msg)
@@ -74,13 +81,13 @@ module Puma
       length = extract_content_length(header)
 
       msg = FORMAT % [
-        env['HTTP_X_FORWARDED_FOR'] || env["REMOTE_ADDR"] || "-",
-        env["REMOTE_USER"] || "-",
-        now.strftime("%d/%b/%Y:%H:%M:%S %z"),
+        env[HTTP_X_FORWARDED_FOR] || env[REMOTE_ADDR] || "-",
+        env[REMOTE_USER] || "-",
+        now.strftime(LOG_TIME_FORMAT),
         env[REQUEST_METHOD],
         env[PATH_INFO],
         env[QUERY_STRING].empty? ? "" : "?#{env[QUERY_STRING]}",
-        env["HTTP_VERSION"],
+        env[HTTP_VERSION],
         status.to_s[0..3],
         length,
         now - began_at ]

data/lib/puma/configuration.rb

@@ -1,20 +1,11 @@
 # frozen_string_literal: true
 
-require 'puma/rack/builder'
-require 'puma/plugin'
-require 'puma/const'
+require_relative 'rack/builder'
+require_relative 'plugin'
+require_relative 'const'
+# note that dsl is loaded at end of file, requires ConfigDefault constants
 
 module Puma
-
-  module ConfigDefault
-    DefaultRackup = "config.ru"
-
-    DefaultTCPHost = "0.0.0.0"
-    DefaultTCPPort = 9292
-    DefaultWorkerTimeout = 60
-    DefaultWorkerShutdownTimeout = 30
-  end
-
   # A class used for storing "leveled" configuration options.
   #
   # In this class any "user" specified options take precedence over any
@@ -135,7 +126,50 @@ module Puma
   # is done because an environment variable may have been modified while loading
   # configuration files.
   class Configuration
-    include ConfigDefault
+    DEFAULTS = {
+      auto_trim_time: 30,
+      binds: ['tcp://0.0.0.0:9292'.freeze],
+      clean_thread_locals: false,
+      debug: false,
+      early_hints: nil,
+      environment: 'development'.freeze,
+      # Number of seconds to wait until we get the first data for the request
+      first_data_timeout: 30,
+      io_selector_backend: :auto,
+      log_requests: false,
+      logger: STDOUT,
+      # How many requests to attempt inline before sending a client back to
+      # the reactor to be subject to normal ordering. The idea here is that
+      # we amortize the cost of going back to the reactor for a well behaved
+      # but very "greedy" client across 10 requests. This prevents a not
+      # well behaved client from monopolizing the thread forever.
+      max_fast_inline: 10,
+      max_threads: Puma.mri? ? 5 : 16,
+      min_threads: 0,
+      mode: :http,
+      mutate_stdout_and_stderr_to_sync_on_write: true,
+      out_of_band: [],
+      # Number of seconds for another request within a persistent session.
+      persistent_timeout: 20,
+      queue_requests: true,
+      rackup: 'config.ru'.freeze,
+      raise_exception_on_sigterm: true,
+      reaping_time: 1,
+      remote_address: :socket,
+      silence_single_worker_warning: false,
+      silence_fork_callback_warning: false,
+      tag: File.basename(Dir.getwd),
+      tcp_host: '0.0.0.0'.freeze,
+      tcp_port: 9292,
+      wait_for_less_busy_worker: 0.005,
+      worker_boot_timeout: 60,
+      worker_check_interval: 5,
+      worker_culling_strategy: :youngest,
+      worker_shutdown_timeout: 30,
+      worker_timeout: 60,
+      workers: 0,
+      http_content_length_limit: nil
+    }
 
     def initialize(user_options={}, default_options = {}, &block)
       default_options = self.puma_default_options.merge(default_options)
@@ -180,34 +214,22 @@ module Puma
       self
     end
 
-    # @version 5.0.0
-    def default_max_threads
-      Puma.mri? ? 5 : 16
+    def puma_default_options
+      defaults = DEFAULTS.dup
+      puma_options_from_env.each { |k,v| defaults[k] = v if v }
+      defaults
     end
 
-    def puma_default_options
+    def puma_options_from_env
+      min = ENV['PUMA_MIN_THREADS'] || ENV['MIN_THREADS']
+      max = ENV['PUMA_MAX_THREADS'] || ENV['MAX_THREADS']
+      workers = ENV['WEB_CONCURRENCY']
+
       {
-        :min_threads => Integer(ENV['PUMA_MIN_THREADS'] || ENV['MIN_THREADS'] || 0),
-        :max_threads => Integer(ENV['PUMA_MAX_THREADS'] || ENV['MAX_THREADS'] || default_max_threads),
-        :log_requests => false,
-        :debug => false,
-        :binds => ["tcp://#{DefaultTCPHost}:#{DefaultTCPPort}"],
-        :workers => Integer(ENV['WEB_CONCURRENCY'] || 0),
-        :mode => :http,
-        :worker_timeout => DefaultWorkerTimeout,
-        :worker_boot_timeout => DefaultWorkerTimeout,
-        :worker_shutdown_timeout => DefaultWorkerShutdownTimeout,
-        :remote_address => :socket,
-        :tag => method(:infer_tag),
-        :environment => -> { ENV['RACK_ENV'] || ENV['RAILS_ENV'] || "development" },
-        :rackup => DefaultRackup,
-        :logger => STDOUT,
-        :persistent_timeout => Const::PERSISTENT_TIMEOUT,
-        :first_data_timeout => Const::FIRST_DATA_TIMEOUT,
-        :raise_exception_on_sigterm => true,
-        :max_fast_inline => Const::MAX_FAST_INLINE,
-        :io_selector_backend => :auto,
-        :mutate_stdout_and_stderr_to_sync_on_write => true,
+        min_threads: min && Integer(min),
+        max_threads: max && Integer(max),
+        workers: workers && Integer(workers),
+        environment: ENV['APP_ENV'] || ENV['RACK_ENV'] || ENV['RAILS_ENV'],
       }
     end
 
@@ -223,7 +245,7 @@ module Puma
       return [] if files == ['-']
       return files if files.any?
 
-      first_default_file = %W(config/puma/#{environment_str}.rb config/puma.rb).find do |f|
+      first_default_file = %W(config/puma/#{@options[:environment]}.rb config/puma.rb).find do |f|
         File.exist?(f)
       end
 
@@ -266,7 +288,7 @@ module Puma
       found = options[:app] || load_rackup
 
       if @options[:log_requests]
-        require 'puma/commonlogger'
+        require_relative 'commonlogger'
         logger = @options[:logger]
         found = CommonLogger.new(found, logger)
       end
@@ -279,21 +301,25 @@ module Puma
       @options[:environment]
     end
 
-    def environment_str
-      environment.respond_to?(:call) ? environment.call : environment
-    end
-
     def load_plugin(name)
       @plugins.create name
     end
 
-    def run_hooks(key, arg, events)
+    # @param key [:Symbol] hook to run
+    # @param arg [Launcher, Int] `:on_restart` passes Launcher
+    #
+    def run_hooks(key, arg, log_writer, hook_data = nil)
       @options.all_of(key).each do |b|
         begin
-          b.call arg
+          if Array === b
+            hook_data[b[1]] ||= Hash.new
+            b[0].call arg, hook_data[b[1]]
+          else
+            b.call arg
+          end
         rescue => e
-          events.log "WARNING hook #{key} failed with exception (#{e.class}) #{e.message}"
-          events.debug e.backtrace.join("\n")
+          log_writer.log "WARNING hook #{key} failed with exception (#{e.class}) #{e.message}"
+          log_writer.debug e.backtrace.join("\n")
         end
       end
     end
@@ -311,10 +337,6 @@ module Puma
 
     private
 
-    def infer_tag
-      File.basename(Dir.getwd)
-    end
-
     # Load and use the normal Rack builder if we can, otherwise
     # fallback to our minimal version.
     def rack_builder
@@ -342,6 +364,8 @@ module Puma
       raise "Missing rackup file '#{rackup}'" unless File.exist?(rackup)
 
       rack_app, rack_options = rack_builder.parse_file(rackup)
+      rack_options = rack_options || {}
+
       @options.file_options.merge!(rack_options)
 
       config_ru_binds = []
@@ -362,4 +386,4 @@ module Puma
   end
 end
 
-require 'puma/dsl'
+require_relative 'dsl'