puma 3.4.0 → 3.12.0

data/lib/puma/cluster.rb

@@ -1,8 +1,24 @@
 require 'puma/runner'
+require 'puma/util'
+require 'puma/plugin'
+
 require 'time'
 
 module Puma
+  # This class is instantiated by the `Puma::Launcher` and used
+  # to boot and serve a Ruby application when puma "workers" are needed
+  # i.e. when using multi-processes. For example `$ puma -w 5`
+  #
+  # At the core of this class is running an instance of `Puma::Server` which
+  # gets created via the `start_server` method from the `Puma::Runner` class
+  # that this inherits from.
+  #
+  # An instance of this class will spawn the number of processes passed in
+  # via the `spawn_workers` method call. Each worker will have it's own
+  # instance of a `Puma::Server`.
   class Cluster < Runner
+    WORKER_CHECK_INTERVAL = 5
+
     def initialize(cli, events)
       super cli, events
 
@@ -19,7 +35,7 @@ module Puma
       @workers.each { |x| x.term }
 
       begin
-        Process.waitall
+        @workers.each { |w| Process.waitpid(w.pid) }
       rescue Interrupt
         log "! Cancelled waiting for workers"
       end
@@ -110,6 +126,7 @@ module Puma
 
     def spawn_workers
       diff = @options[:workers] - @workers.size
+      return if diff < 1
 
       master = Process.pid
 
@@ -135,6 +152,21 @@ module Puma
       end
     end
 
+    def cull_workers
+      diff = @workers.size - @options[:workers]
+      return if diff < 1
+
+      debug "Culling #{diff.inspect} workers"
+
+      workers_to_cull = @workers[-diff,diff]
+      debug "Workers to cull: #{workers_to_cull.inspect}"
+
+      workers_to_cull.each do |worker|
+        log "- Worker #{worker.index} (pid: #{worker.pid}) terminating"
+        worker.term
+      end
+    end
+
     def next_worker_index
       all_positions =  0...@options[:workers]
       occupied_positions = @workers.map { |w| w.index }
@@ -149,7 +181,7 @@ module Puma
     def check_workers(force=false)
       return if !force && @next_check && @next_check >= Time.now
 
-      @next_check = Time.now + 5
+      @next_check = Time.now + WORKER_CHECK_INTERVAL
 
       any = false
 
@@ -175,6 +207,7 @@ module Puma
 
       @workers.delete_if(&:dead?)
 
+      cull_workers
       spawn_workers
 
       if all_workers_booted?
@@ -202,12 +235,13 @@ module Puma
       begin
         @wakeup.write "!" unless @wakeup.closed?
       rescue SystemCallError, IOError
+        Thread.current.purge_interrupt_queue if Thread.current.respond_to? :purge_interrupt_queue
       end
     end
 
     def worker(index, master)
-      title = "puma: cluster worker #{index}: #{master}"
-      title << " [#{@options[:tag]}]" if @options[:tag] && !@options[:tag].empty?
+      title  = "puma: cluster worker #{index}: #{master}"
+      title += " [#{@options[:tag]}]" if @options[:tag] && !@options[:tag].empty?
       $0 = title
 
       Signal.trap "SIGINT", "IGNORE"
@@ -245,6 +279,7 @@ module Puma
       begin
         @worker_write << "b#{Process.pid}\n"
       rescue SystemCallError, IOError
+        Thread.current.purge_interrupt_queue if Thread.current.respond_to? :purge_interrupt_queue
         STDERR.puts "Master seems to have exited, exiting."
         return
       end
@@ -253,13 +288,16 @@ module Puma
         base_payload = "p#{Process.pid}"
 
         while true
-          sleep 5
+          sleep WORKER_CHECK_INTERVAL
           begin
-            b = server.backlog
-            r = server.running
-            payload = %Q!#{base_payload}{ "backlog":#{b}, "running":#{r} }\n!
+            b = server.backlog || 0
+            r = server.running || 0
+            t = server.pool_capacity || 0
+            m = server.max_threads || 0
+            payload = %Q!#{base_payload}{ "backlog":#{b}, "running":#{r}, "pool_capacity":#{t}, "max_threads": #{m} }\n!
             io << payload
           rescue IOError
+            Thread.current.purge_interrupt_queue if Thread.current.respond_to? :purge_interrupt_queue
             break
           end
         end
@@ -315,7 +353,7 @@ module Puma
     def stats
       old_worker_count = @workers.count { |w| w.phase != @phase }
       booted_worker_count = @workers.count { |w| w.booted? }
-      worker_status = '[' + @workers.map{ |w| %Q!{ "pid": #{w.pid}, "index": #{w.index}, "phase": #{w.phase}, "booted": #{w.booted?}, "last_checkin": "#{w.last_checkin.utc.iso8601}", "last_status": #{w.last_status} }!}.join(",") + ']'
+      worker_status = '[' + @workers.map { |w| %Q!{ "pid": #{w.pid}, "index": #{w.index}, "phase": #{w.phase}, "booted": #{w.booted?}, "last_checkin": "#{w.last_checkin.utc.iso8601}", "last_status": #{w.last_status} }!}.join(",") + ']'
       %Q!{ "workers": #{@workers.size}, "phase": #{@phase}, "booted_workers": #{booted_worker_count}, "old_workers": #{old_worker_count}, "worker_status": #{worker_status} }!
     end
 
@@ -323,7 +361,7 @@ module Puma
       @options[:preload_app]
     end
 
-    # We do this in a separate method to keep the lambad scope
+    # We do this in a separate method to keep the lambda scope
     # of the signals handlers as small as possible.
     def setup_signals
       Signal.trap "SIGCHLD" do
@@ -337,7 +375,6 @@ module Puma
 
       Signal.trap "TTOU" do
         @options[:workers] -= 1 if @options[:workers] >= 2
-        @workers.last.term
         wakeup!
       end
 
@@ -351,7 +388,10 @@ module Puma
           log "Early termination of worker"
           exit! 0
         else
+          stop_workers
           stop
+
+          raise SignalException, "SIGTERM"
         end
       end
     end
@@ -413,10 +453,12 @@ module Puma
 
       redirect_io
 
-      start_control
+      Plugins.fire_background
 
       @launcher.write_state
 
+      start_control
+
       @master_read, @worker_write = read, @wakeup
 
       @launcher.config.run_hooks :before_fork, nil
@@ -443,7 +485,7 @@ module Puma
 
             force_check = false
 
-            res = IO.select([read], nil, nil, 5)
+            res = IO.select([read], nil, nil, WORKER_CHECK_INTERVAL)
 
             if res
               req = read.read_nonblock(1)

data/lib/puma/commonlogger.rb

@@ -21,6 +21,13 @@ module Puma
     #   %{%s - %s [%s] "%s %s%s %s" %d %s\n} %
     FORMAT = %{%s - %s [%s] "%s %s%s %s" %d %s %0.4f\n}
 
+    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
+
     def initialize(app, logger=nil)
       @app = app
       @logger = logger
@@ -42,36 +49,23 @@ module Puma
       [status, header, body]
     end
 
-    HIJACK_FORMAT = %{%s - %s [%s] "%s %s%s %s" HIJACKED -1 %0.4f\n}
-
     private
 
     def log_hijacking(env, status, header, began_at)
       now = Time.now
 
-      logger = @logger || env['rack.errors']
-      logger.write HIJACK_FORMAT % [
+      msg = HIJACK_FORMAT % [
         env['HTTP_X_FORWARDED_FOR'] || env["REMOTE_ADDR"] || "-",
         env["REMOTE_USER"] || "-",
         now.strftime("%d/%b/%Y %H:%M:%S"),
-        env["REQUEST_METHOD"],
-        env["PATH_INFO"],
-        env["QUERY_STRING"].empty? ? "" : "?"+env["QUERY_STRING"],
+        env[REQUEST_METHOD],
+        env[PATH_INFO],
+        env[QUERY_STRING].empty? ? "" : "?#{env[QUERY_STRING]}",
         env["HTTP_VERSION"],
         now - began_at ]
-    end
 
-    PATH_INFO      = 'PATH_INFO'.freeze
-    REQUEST_METHOD = 'REQUEST_METHOD'.freeze
-    SCRIPT_NAME    = 'SCRIPT_NAME'.freeze
-    QUERY_STRING   = 'QUERY_STRING'.freeze
-    CACHE_CONTROL  = 'Cache-Control'.freeze
-    CONTENT_LENGTH = 'Content-Length'.freeze
-    CONTENT_TYPE   = 'Content-Type'.freeze
-
-    GET  = 'GET'.freeze
-    HEAD = 'HEAD'.freeze
-    
+      write(msg)
+    end
 
     def log(env, status, header, began_at)
       now = Time.now
@@ -83,13 +77,18 @@ module Puma
         now.strftime("%d/%b/%Y:%H:%M:%S %z"),
         env[REQUEST_METHOD],
         env[PATH_INFO],
-        env[QUERY_STRING].empty? ? "" : "?"+env[QUERY_STRING],
+        env[QUERY_STRING].empty? ? "" : "?#{env[QUERY_STRING]}",
         env["HTTP_VERSION"],
         status.to_s[0..3],
         length,
         now - began_at ]
 
+      write(msg)
+    end
+
+    def write(msg)
       logger = @logger || env['rack.errors']
+
       # Standard library logger doesn't support write but it supports << which actually
       # calls to write on the log device without formatting
       if logger.respond_to?(:write)

data/lib/puma/compat.rb

@@ -6,13 +6,9 @@ class String
   end
 
   unless method_defined? :byteslice
-    if RUBY_VERSION < '1.9'
-      alias_method :byteslice, :[]
-    else
-      def byteslice(*arg)
-        enc = self.encoding
-        self.dup.force_encoding(Encoding::ASCII_8BIT).slice(*arg).force_encoding(enc)
-      end
+    def byteslice(*arg)
+      enc = self.encoding
+      self.dup.force_encoding(Encoding::ASCII_8BIT).slice(*arg).force_encoding(enc)
     end
   end
 end

data/lib/puma/configuration.rb

@@ -1,5 +1,6 @@
 require 'puma/rack/builder'
 require 'puma/plugin'
+require 'puma/const'
 
 module Puma
 
@@ -12,147 +13,147 @@ module Puma
     DefaultWorkerShutdownTimeout = 30
   end
 
-  class LeveledOptions
-    def initialize(default_options, user_options)
-      @cur = user_options
-      @set = [@cur]
-      @defaults = default_options.dup
-    end
-
-    def initialize_copy(other)
-      @set = @set.map { |o| o.dup }
-      @cur = @set.last
-    end
-
-    def shift
-      @cur = {}
-      @set << @cur
-    end
+  # A class used for storing "leveled" configuration options.
+  #
+  # In this class any "user" specified options take precedence over any
+  # "file" specified options, take precedence over any "default" options.
+  #
+  # User input is prefered over "defaults":
+  #   user_options    = { foo: "bar" }
+  #   default_options = { foo: "zoo" }
+  #   options = UserFileDefaultOptions.new(user_options, default_options)
+  #   puts options[:foo]
+  #   # => "bar"
+  #
+  # All values can be accessed via `all_of`
+  #
+  #   puts options.all_of(:foo)
+  #   # => ["bar", "zoo"]
+  #
+  # A "file" option can be set. This config will be prefered over "default" options
+  # but will defer to any available "user" specified options.
+  #
+  #   user_options    = { foo: "bar" }
+  #   default_options = { rackup: "zoo.rb" }
+  #   options = UserFileDefaultOptions.new(user_options, default_options)
+  #   options.file_options[:rackup] = "sup.rb"
+  #   puts options[:rackup]
+  #   # => "sup.rb"
+  #
+  # The "default" options can be set via procs. These are resolved during runtime
+  # via calls to `finalize_values`
+  class UserFileDefaultOptions
+    def initialize(user_options, default_options)
+      @user_options    = user_options
+      @file_options    = {}
+      @default_options = default_options
+    end
+
+    attr_reader :user_options, :file_options, :default_options
 
     def [](key)
-      @set.each do |o|
-        if o.key? key
-          return o[key]
-        end
-      end
-
-      v = @defaults[key]
-      if v.respond_to? :call
-        v.call
-      else
-        v
-      end
-    end
-
-    def fetch(key, default=nil)
-      val = self[key]
-      return val if val
-      default
-    end
-
-    attr_reader :cur
-
-    def all_of(key)
-      all = []
-
-      @set.each do |o|
-        if v = o[key]
-          if v.kind_of? Array
-            all += v
-          else
-            all << v
-          end
-        end
-      end
-
-      all
+      return user_options[key]    if user_options.key?(key)
+      return file_options[key]    if file_options.key?(key)
+      return default_options[key] if default_options.key?(key)
     end
 
-    def []=(key, val)
-      @cur[key] = val
+    def []=(key, value)
+      user_options[key] = value
     end
 
-    def key?(key)
-      @set.each do |o|
-        if o.key? key
-          return true
-        end
-      end
-
-      @default.key? key
+    def fetch(key, default_value = nil)
+      self[key] || default_value
     end
 
-    def merge!(o)
-      o.each do |k,v|
-        @cur[k]= v
-      end
-    end
-
-    def flatten
-      options = {}
-
-      @set.each do |o|
-        o.each do |k,v|
-          options[k] ||= v
-        end
-      end
-
-      options
-    end
+    def all_of(key)
+      user    = user_options[key]
+      file    = file_options[key]
+      default = default_options[key]
 
-    def explain
-      indent = ""
+      user    = [user]    unless user.is_a?(Array)
+      file    = [file]    unless file.is_a?(Array)
+      default = [default] unless default.is_a?(Array)
 
-      @set.each do |o|
-        o.keys.sort.each do |k|
-          puts "#{indent}#{k}: #{o[k].inspect}"
-        end
+      user.compact!
+      file.compact!
+      default.compact!
 
-        indent = "  #{indent}"
-      end
+      user + file + default
     end
 
-    def force_defaults
-      @defaults.each do |k,v|
+    def finalize_values
+      @default_options.each do |k,v|
         if v.respond_to? :call
-          @defaults[k] = v.call
+          @default_options[k] = v.call
         end
       end
     end
   end
 
+  # The main configuration class of Puma.
+  #
+  # It can be initialized with a set of "user" options and "default" options.
+  # Defaults will be merged with `Configuration.puma_default_options`.
+  #
+  # This class works together with 2 main other classes the `UserFileDefaultOptions`
+  # which stores configuration options in order so the precedence is that user
+  # set configuration wins over "file" based configuration wins over "default"
+  # configuration. These configurations are set via the `DSL` class. This
+  # class powers the Puma config file syntax and does double duty as a configuration
+  # DSL used by the `Puma::CLI` and Puma rack handler.
+  #
+  # It also handles loading plugins.
+  #
+  # > Note: `:port` and `:host` are not valid keys. By they time they make it to the
+  #   configuration options they are expected to be incorporated into a `:binds` key.
+  #   Under the hood the DSL maps `port` and `host` calls to `:binds`
+  #
+  #   config = Configuration.new({}) do |user_config, file_config, default_config|
+  #     user_config.port 3003
+  #   end
+  #   config.load
+  #   puts config.options[:port]
+  #   # => 3003
+  #
+  # It is expected that `load` is called on the configuration instance after setting
+  # config. This method expands any values in `config_file` and puts them into the
+  # correct configuration option hash.
+  #
+  # Once all configuration is complete it is expected that `clamp` will be called
+  # on the instance. This will expand any procs stored under "default" values. This
+  # is done because an environment variable may have been modified while loading
+  # configuration files.
   class Configuration
     include ConfigDefault
 
-    def self.from_file(path)
-      cfg = new
+    def initialize(user_options={}, default_options = {}, &block)
+      default_options = self.puma_default_options.merge(default_options)
 
-      DSL.new(cfg.options, cfg)._load_from path
+      @options     = UserFileDefaultOptions.new(user_options, default_options)
+      @plugins     = PluginLoader.new
+      @user_dsl    = DSL.new(@options.user_options, self)
+      @file_dsl    = DSL.new(@options.file_options, self)
+      @default_dsl = DSL.new(@options.default_options, self)
 
-      return cfg
-    end
-
-    def initialize(options={}, &blk)
-      @options = LeveledOptions.new(default_options, options)
-
-      @plugins = PluginLoader.new
-
-      if blk
-        configure(&blk)
+      if block
+        configure(&block)
       end
     end
 
     attr_reader :options, :plugins
 
-    def configure(&blk)
-      @options.shift
-      DSL.new(@options, self)._run(&blk)
+    def configure
+      yield @user_dsl, @file_dsl, @default_dsl
+    ensure
+      @user_dsl._offer_plugins
+      @file_dsl._offer_plugins
+      @default_dsl._offer_plugins
     end
 
     def initialize_copy(other)
-      @conf = nil
+      @conf        = nil
       @cli_options = nil
-      @options = @options.dup
+      @options     = @options.dup
     end
 
     def flatten
@@ -164,7 +165,7 @@ module Puma
       self
     end
 
-    def default_options
+    def puma_default_options
       {
         :min_threads => 0,
         :max_threads => 16,
@@ -179,37 +180,37 @@ module Puma
         :worker_shutdown_timeout => DefaultWorkerShutdownTimeout,
         :remote_address => :socket,
         :tag => method(:infer_tag),
-        :environment => lambda { ENV['RACK_ENV'] || "development" },
+        :environment => -> { ENV['RACK_ENV'] || "development" },
         :rackup => DefaultRackup,
-        :logger => STDOUT
+        :logger => STDOUT,
+        :persistent_timeout => Const::PERSISTENT_TIMEOUT,
+        :first_data_timeout => Const::FIRST_DATA_TIMEOUT
       }
     end
 
     def load
-      files = @options.all_of(:config_files)
+      config_files.each { |config_file| @file_dsl._load_from(config_file) }
 
-      if files.empty?
-        imp = %W(config/puma/#{@options[:environment]}.rb config/puma.rb).find { |f|
-          File.exist?(f)
-        }
+      @options
+    end
 
-        files << imp
-      elsif files == ["-"]
-        files = []
-      end
+    def config_files
+      files = @options.all_of(:config_files)
 
-      files.each do |f|
-        @options.shift
+      return [] if files == ['-']
+      return files if files.any?
 
-        DSL.load @options, self, f
+      first_default_file = %W(config/puma/#{environment_str}.rb config/puma.rb).find do |f|
+        File.exist?(f)
       end
+
+      [first_default_file]
     end
 
     # Call once all configuration (included from rackup files)
     # is loaded to flesh out any defaults
     def clamp
-      @options.shift
-      @options.force_defaults
+      @options.finalize_values
     end
 
     # Injects the Configuration object into the env
@@ -245,10 +246,12 @@ module Puma
         require 'puma/tcp_logger'
 
         logger = @options[:logger]
-        return TCPLogger.new(logger, found, @options[:log_requests])
+        quiet = !@options[:log_requests]
+        return TCPLogger.new(logger, found, quiet)
       end
 
       if @options[:log_requests]
+        require 'puma/commonlogger'
         logger = @options[:logger]
         found = CommonLogger.new(found, logger)
       end
@@ -261,6 +264,10 @@ module Puma
       @options[:environment]
     end
 
+    def environment_str
+      environment.respond_to?(:call) ? environment.call : environment
+    end
+
     def load_plugin(name)
       @plugins.create name
     end
@@ -308,17 +315,15 @@ module Puma
     def load_rackup
       raise "Missing rackup file '#{rackup}'" unless File.exist?(rackup)
 
-      @options.shift
-
       rack_app, rack_options = rack_builder.parse_file(rackup)
-      @options.merge!(rack_options)
+      @options.file_options.merge!(rack_options)
 
       config_ru_binds = []
       rack_options.each do |k, v|
         config_ru_binds << v if k.to_s.start_with?("bind")
       end
 
-      @options[:binds] = config_ru_binds unless config_ru_binds.empty?
+      @options.file_options[:binds] = config_ru_binds unless config_ru_binds.empty?
 
       rack_app
     end
@@ -340,7 +345,7 @@ module Puma
       end
 
       if bytes
-        token = ""
+        token = "".dup
         bytes.each_byte { |b| token << b.to_s(16) }
       else
         token = (0..count).to_a.map { rand(255).to_s(16) }.join