puma 5.6.9 → 6.0.0

data/lib/puma/dsl.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'puma/const'
-require 'puma/util'
+require_relative 'const'
+require_relative 'util'
 
 module Puma
   # The methods that are available for use inside the configuration file.
@@ -32,8 +32,24 @@ module Puma
   # You can also find many examples being used by the test suite in
   # +test/config+.
   #
+  # Puma v6 adds the option to specify a key name (String or Symbol) to the
+  # hooks that run inside the forked workers.  All the hooks run inside the
+  # {Puma::Cluster::Worker#run} method.
+  #
+  # Previously, the worker index and the LogWriter instance were passed to the
+  # hook blocks/procs.  If a key name is specified, a hash is passed as the last
+  # parameter.  This allows storage of data, typically objects that are created
+  # before the worker that need to be passed to the hook when the worker is shutdown.
+  #
+  # The following hooks have been updated:
+  #
+  #     | DSL Method         |  Options Key            | Fork Block Location |
+  #     | on_worker_boot     | :before_worker_boot     | inside, before      |
+  #     | on_worker_shutdown | :before_worker_shutdown | inside, after       |
+  #     | on_refork          | :before_refork          | inside              |
+  #
   class DSL
-    include ConfigDefault
+    ON_WORKER_KEY = [String, Symbol].freeze
 
     # convenience method so logic can be used in CI
     # @see ssl_bind
@@ -52,25 +68,53 @@ module Puma
       backlog_str = opts[:backlog] ? "&backlog=#{Integer(opts[:backlog])}" : ''
 
       if defined?(JRUBY_VERSION)
-        ssl_cipher_list = opts[:ssl_cipher_list] ?
-          "&ssl_cipher_list=#{opts[:ssl_cipher_list]}" : nil
+        cipher_suites = opts[:ssl_cipher_list] ? "&ssl_cipher_list=#{opts[:ssl_cipher_list]}" : nil # old name
+        cipher_suites = "#{cipher_suites}&cipher_suites=#{opts[:cipher_suites]}" if opts[:cipher_suites]
+        protocols = opts[:protocols] ? "&protocols=#{opts[:protocols]}" : nil
 
         keystore_additions = "keystore=#{opts[:keystore]}&keystore-pass=#{opts[:keystore_pass]}"
+        keystore_additions = "#{keystore_additions}&keystore-type=#{opts[:keystore_type]}" if opts[:keystore_type]
+        if opts[:truststore]
+          truststore_additions = "&truststore=#{opts[:truststore]}"
+          truststore_additions = "#{truststore_additions}&truststore-pass=#{opts[:truststore_pass]}" if opts[:truststore_pass]
+          truststore_additions = "#{truststore_additions}&truststore-type=#{opts[:truststore_type]}" if opts[:truststore_type]
+        end
 
-        "ssl://#{host}:#{port}?#{keystore_additions}#{ssl_cipher_list}" \
+        "ssl://#{host}:#{port}?#{keystore_additions}#{truststore_additions}#{cipher_suites}#{protocols}" \
           "&verify_mode=#{verify}#{tls_str}#{ca_additions}#{backlog_str}"
       else
-        ssl_cipher_filter = opts[:ssl_cipher_filter] ?
-          "&ssl_cipher_filter=#{opts[:ssl_cipher_filter]}" : nil
-
-        v_flags = (ary = opts[:verification_flags]) ?
-          "&verification_flags=#{Array(ary).join ','}" : nil
-
-        cert_flags = (cert = opts[:cert]) ? "cert=#{Puma::Util.escape(opts[:cert])}" : nil
-        key_flags = (cert = opts[:key]) ? "&key=#{Puma::Util.escape(opts[:key])}" : nil
+        ssl_cipher_filter = opts[:ssl_cipher_filter] ? "&ssl_cipher_filter=#{opts[:ssl_cipher_filter]}" : nil
+        v_flags = (ary = opts[:verification_flags]) ? "&verification_flags=#{Array(ary).join ','}" : nil
+
+        cert_flags = (cert = opts[:cert]) ? "cert=#{Puma::Util.escape(cert)}" : nil
+        key_flags = (key = opts[:key]) ? "&key=#{Puma::Util.escape(key)}" : nil
+
+        reuse_flag =
+          if (reuse = opts[:reuse])
+            if reuse == true
+              '&reuse=dflt'
+            elsif reuse.is_a?(Hash) && (reuse.key?(:size) || reuse.key?(:timeout))
+              val = +''
+              if (size = reuse[:size]) && Integer === size
+                val << size.to_s
+              end
+              if (timeout = reuse[:timeout]) && Integer === timeout
+                val << ",#{timeout}"
+              end
+              if val.empty?
+                nil
+              else
+                "&reuse=#{val}"
+              end
+            else
+              nil
+            end
+          else
+            nil
+          end
 
-        "ssl://#{host}:#{port}?#{cert_flags}#{key_flags}" \
-          "#{ssl_cipher_filter}&verify_mode=#{verify}#{tls_str}#{ca_additions}#{v_flags}#{backlog_str}"
+        "ssl://#{host}:#{port}?#{cert_flags}#{key_flags}#{ssl_cipher_filter}" \
+          "#{reuse_flag}&verify_mode=#{verify}#{tls_str}#{ca_additions}#{v_flags}#{backlog_str}"
       end
     end
 
@@ -106,7 +150,7 @@ module Puma
     end
 
     def default_host
-      @options[:default_host] || Configuration::DefaultTCPHost
+      @options[:default_host] || Configuration::DEFAULTS[:tcp_host]
     end
 
     def inject(&blk)
@@ -452,6 +496,10 @@ module Puma
     # Puma will assume you are using the +localhost+ gem and try to load the
     # appropriate files.
     #
+    # When using the options hash parameter, the `reuse:` value is either
+    # `true`, which sets reuse 'on' with default values, or a hash, with `:size`
+    # and/or `:timeout` keys, each with integer values.
+    #
     # @example
     #   ssl_bind '127.0.0.1', '9292', {
     #     cert: path_to_cert,
@@ -459,6 +507,7 @@ module Puma
     #     ssl_cipher_filter: cipher_filter, # optional
     #     verify_mode: verify_mode,         # default 'none'
     #     verification_flags: flags,        # optional, not supported by JRuby
+    #     reuse: true                       # optional
     #   }
     #
     # @example Using self-signed certificate with the +localhost+ gem:
@@ -468,6 +517,7 @@ module Puma
     #   ssl_bind '127.0.0.1', '9292', {
     #     cert_pem: File.read(path_to_cert),
     #     key_pem: File.read(path_to_key),
+    #     reuse: {size: 2_000, timeout: 20} # optional
     #   }
     #
     # @example For JRuby, two keys are required: +keystore+ & +keystore_pass+
@@ -560,9 +610,8 @@ module Puma
     #   on_worker_boot do
     #     puts 'Before worker boot...'
     #   end
-    def on_worker_boot(&block)
-      @options[:before_worker_boot] ||= []
-      @options[:before_worker_boot] << block
+    def on_worker_boot(key = nil, &block)
+      process_hook :before_worker_boot, key, block, 'on_worker_boot'
     end
 
     # Code to run immediately before a worker shuts
@@ -577,9 +626,8 @@ module Puma
     #   on_worker_shutdown do
     #     puts 'On worker shutdown...'
     #   end
-    def on_worker_shutdown(&block)
-      @options[:before_worker_shutdown] ||= []
-      @options[:before_worker_shutdown] << block
+    def on_worker_shutdown(key = nil, &block)
+      process_hook :before_worker_shutdown, key, block, 'on_worker_shutdown'
     end
 
     # Code to run in the master right before a worker is started. The worker's
@@ -593,8 +641,7 @@ module Puma
     #     puts 'Before worker fork...'
     #   end
     def on_worker_fork(&block)
-      @options[:before_worker_fork] ||= []
-      @options[:before_worker_fork] << block
+      process_hook :before_worker_fork, nil, block, 'on_worker_fork'
     end
 
     # Code to run in the master after a worker has been started. The worker's
@@ -608,8 +655,7 @@ module Puma
     #     puts 'After worker fork...'
     #   end
     def after_worker_fork(&block)
-      @options[:after_worker_fork] ||= []
-      @options[:after_worker_fork] << block
+      process_hook :after_worker_fork, nil, block, 'after_worker_fork'
     end
 
     alias_method :after_worker_boot, :after_worker_fork
@@ -632,9 +678,8 @@ module Puma
     #   end
     # @version 5.0.0
     #
-    def on_refork(&block)
-      @options[:before_refork] ||= []
-      @options[:before_refork] << block
+    def on_refork(key = nil, &block)
+      process_hook :before_refork, key, block, 'on_refork'
     end
 
     # Code to run out-of-band when the worker is idle.
@@ -647,8 +692,7 @@ module Puma
     #
     # This can be called multiple times to add several hooks.
     def out_of_band(&block)
-      @options[:out_of_band] ||= []
-      @options[:out_of_band] << block
+      process_hook :out_of_band, nil, block, 'out_of_band'
     end
 
     # The directory to operate out of.
@@ -778,7 +822,7 @@ module Puma
     #
     def worker_timeout(timeout)
       timeout = Integer(timeout)
-      min = @options.fetch(:worker_check_interval, Puma::ConfigDefault::DefaultWorkerCheckInterval)
+      min = @options.fetch(:worker_check_interval, Configuration::DEFAULTS[:worker_check_interval])
 
       if timeout <= min
         raise "The minimum worker_timeout must be greater than the worker reporting interval (#{min})"
@@ -882,13 +926,16 @@ module Puma
     # There are 5 possible values:
     #
     # 1. **:socket** (the default) - read the peername from the socket using the
-    #    syscall. This is the normal behavior.
+    #    syscall. This is the normal behavior. If this fails for any reason (e.g.,
+    #    if the peer disconnects between the connection being accepted and the getpeername
+    #    system call), Puma will return "0.0.0.0"
     # 2. **:localhost** - set the remote address to "127.0.0.1"
     # 3. **header: <http_header>**- set the remote address to the value of the
     #    provided http header. For instance:
     #    `set_remote_address header: "X-Real-IP"`.
     #    Only the first word (as separated by spaces or comma) is used, allowing
-    #    headers such as X-Forwarded-For to be used as well.
+    #    headers such as X-Forwarded-For to be used as well. If this header is absent,
+    #    Puma will fall back to the behavior of :socket
     # 4. **proxy_protocol: :v1**- set the remote address to the value read from the
     #    HAproxy PROXY protocol, version 1. If the request does not have the PROXY
     #    protocol attached to it, will fall back to :socket
@@ -942,23 +989,6 @@ module Puma
       @options[:fork_worker] = Integer(after_requests)
     end
 
-    # When enabled, Puma will GC 4 times before forking workers.
-    # If available (Ruby 2.7+), we will also call GC.compact.
-    # Not recommended for non-MRI Rubies.
-    #
-    # Based on the work of Koichi Sasada and Aaron Patterson, this option may
-    # decrease memory utilization of preload-enabled cluster-mode Pumas. It will
-    # also increase time to boot and fork. See your logs for details on how much
-    # time this adds to your boot process. For most apps, it will be less than one
-    # second.
-    #
-    # @see Puma::Cluster#nakayoshi_gc
-    # @version 5.0.0
-    #
-    def nakayoshi_fork(enabled=true)
-      @options[:nakayoshi_fork] = enabled
-    end
-
     # The number of requests to attempt inline before sending a client back to
     # the reactor to be subject to normal ordering.
     #
@@ -1008,5 +1038,16 @@ module Puma
         end
       end
     end
+
+    def process_hook(options_key, key, block, meth)
+      @options[options_key] ||= []
+      if ON_WORKER_KEY.include? key.class
+        @options[options_key] << [block, key.to_sym]
+      elsif key.nil?
+        @options[options_key] << block
+      else
+        raise "'#{method}' key must be String or Symbol"
+      end
+    end
   end
 end

data/lib/puma/error_logger.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'puma/const'
+require_relative 'const'
 
 module Puma
   # The implementation of a detailed error logging.
@@ -13,6 +13,8 @@ module Puma
 
     REQUEST_FORMAT = %{"%s %s%s" - (%s)}
 
+    LOG_QUEUE = Queue.new
+
     def initialize(ioerr)
       @ioerr = ioerr
 
@@ -31,7 +33,7 @@ module Puma
     #   and before all remaining info.
     #
     def info(options={})
-      log title(options)
+      internal_write title(options)
     end
 
     # Print occurred error details only if
@@ -53,7 +55,7 @@ module Puma
       string_block << request_dump(req) if request_parsed?(req)
       string_block << error.backtrace if error
 
-      log string_block.join("\n")
+      internal_write string_block.join("\n")
     end
 
     def title(options={})
@@ -93,12 +95,18 @@ module Puma
       req && req.env[REQUEST_METHOD]
     end
 
-    private
-
-    def log(str)
-      ioerr.puts str
-
-      ioerr.flush unless ioerr.sync
+    def internal_write(str)
+      LOG_QUEUE << str
+      while (w_str = LOG_QUEUE.pop(true)) do
+        begin
+          @ioerr.is_a?(IO) and @ioerr.wait_writable(1)
+          @ioerr.write "#{w_str}\n"
+          @ioerr.flush unless @ioerr.sync
+        rescue Errno::EPIPE, Errno::EBADF, IOError
+        end
+      end
+    rescue ThreadError
     end
+    private :internal_write
   end
 end

data/lib/puma/events.rb

@@ -1,52 +1,23 @@
 # frozen_string_literal: true
 
-require "puma/null_io"
-require 'puma/error_logger'
-require 'stringio'
-
 module Puma
-  # The default implement of an event sink object used by Server
-  # for when certain kinds of events occur in the life of the server.
-  #
-  # The methods available are the events that the Server fires.
-  #
-  class Events
-    class DefaultFormatter
-      def call(str)
-        str
-      end
-    end
-
-    class PidFormatter
-      def call(str)
-        "[#{$$}] #{str}"
-      end
-    end
-
-    # Create an Events object that prints to +stdout+ and +stderr+.
-    #
-    def initialize(stdout, stderr)
-      @formatter = DefaultFormatter.new
-      @stdout = stdout
-      @stderr = stderr
 
-      @debug = ENV.key? 'PUMA_DEBUG'
-      @error_logger = ErrorLogger.new(@stderr)
+  # This is an event sink used by `Puma::Server` to handle
+  # lifecycle events such as :on_booted, :on_restart, and :on_stopped.
+  # Using `Puma::DSL` it is possible to register callback hooks
+  # for each event type.
+  class Events
 
+    def initialize
       @hooks = Hash.new { |h,k| h[k] = [] }
     end
 
-    attr_reader :stdout, :stderr
-    attr_accessor :formatter
-
     # Fire callbacks for the named hook
-    #
     def fire(hook, *args)
       @hooks[hook].each { |t| t.call(*args) }
     end
 
     # Register a callback for a given hook
-    #
     def register(hook, obj=nil, &blk)
       if obj and blk
         raise "Specify either an object or a block, not both"
@@ -59,79 +30,6 @@ module Puma
       h
     end
 
-    # Write +str+ to +@stdout+
-    #
-    def log(str)
-      @stdout.puts format(str) if @stdout.respond_to? :puts
-
-      @stdout.flush unless @stdout.sync
-    rescue Errno::EPIPE
-    end
-
-    def write(str)
-      @stdout.write format(str)
-    end
-
-    def debug(str)
-      log("% #{str}") if @debug
-    end
-
-    # Write +str+ to +@stderr+
-    #
-    def error(str)
-      @error_logger.info(text: format("ERROR: #{str}"))
-      exit 1
-    end
-
-    def format(str)
-      formatter.call(str)
-    end
-
-    # An HTTP connection error has occurred.
-    # +error+ a connection exception, +req+ the request,
-    # and +text+ additional info
-    # @version 5.0.0
-    #
-    def connection_error(error, req, text="HTTP connection error")
-      @error_logger.info(error: error, req: req, text: text)
-    end
-
-    # An HTTP parse error has occurred.
-    # +error+ a parsing exception,
-    # and +req+ the request.
-    #
-    def parse_error(error, req)
-      @error_logger.info(error: error, req: req, text: 'HTTP parse error, malformed request')
-    end
-
-    # An SSL error has occurred.
-    # @param error <Puma::MiniSSL::SSLError>
-    # @param ssl_socket <Puma::MiniSSL::Socket>
-    #
-    def ssl_error(error, ssl_socket)
-      peeraddr = ssl_socket.peeraddr.last rescue "<unknown>"
-      peercert = ssl_socket.peercert
-      subject = peercert ? peercert.subject : nil
-      @error_logger.info(error: error, text: "SSL error, peer: #{peeraddr}, peer cert: #{subject}")
-    end
-
-    # An unknown error has occurred.
-    # +error+ an exception object, +req+ the request,
-    # and +text+ additional info
-    #
-    def unknown_error(error, req=nil, text="Unknown error")
-      @error_logger.info(error: error, req: req, text: text)
-    end
-
-    # Log occurred error debug dump.
-    # +error+ an exception object, +req+ the request,
-    # and +text+ additional info
-    # @version 5.0.0
-    #
-    def debug_error(error, req=nil, text="")
-      @error_logger.debug(error: error, req: req, text: text)
-    end
-
     def on_booted(&block)
       register(:on_booted, &block)
     end
@@ -155,23 +53,5 @@ module Puma
     def fire_on_stopped!
       fire(:on_stopped)
     end
-
-    DEFAULT = new(STDOUT, STDERR)
-
-    # Returns an Events object which writes its status to 2 StringIO
-    # objects.
-    #
-    def self.strings
-      Events.new StringIO.new, StringIO.new
-    end
-
-    def self.stdio
-      Events.new $stdout, $stderr
-    end
-
-    def self.null
-      n = NullIO.new
-      Events.new n, n
-    end
   end
 end

data/lib/puma/io_buffer.rb

@@ -1,11 +1,36 @@
 # frozen_string_literal: true
 
+require 'stringio'
+
 module Puma
-  class IOBuffer < String
-    def append(*args)
-      args.each { |a| concat(a) }
+  class IOBuffer < StringIO
+    def initialize
+      super.binmode
+    end
+
+    def empty?
+      length.zero?
+    end
+
+    def reset
+      truncate 0
+      rewind
     end
 
-    alias reset clear
+    def to_s
+      rewind
+      read
+    end
+
+    alias_method :clear, :reset
+
+    # before Ruby 2.5, `write` would only take one argument
+    if RUBY_VERSION >= '2.5' && RUBY_ENGINE != 'truffleruby'
+      alias_method :append, :write
+    else
+      def append(*strs)
+        strs.each { |str| write str }
+      end
+    end
   end
 end

data/lib/puma/jruby_restart.rb

@@ -16,7 +16,8 @@ module Puma
     def self.chdir_exec(dir, argv)
       chdir(dir)
       cmd = argv.first
-      argv = ([:string] * argv.size).zip(argv).flatten
+      argv = ([:string] * argv.size).zip(argv)
+      argv.flatten!
       argv << :string
       argv << nil
       execlp(cmd, *argv)

data/lib/puma/launcher/bundle_pruner.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module Puma
+  class Launcher
+
+    # This class is used to pickup Gemfile changes during
+    # application restarts.
+    class BundlePruner
+
+      def initialize(original_argv, extra_runtime_dependencies, log_writer)
+        @original_argv = Array(original_argv)
+        @extra_runtime_dependencies = Array(extra_runtime_dependencies)
+        @log_writer = log_writer
+      end
+
+      def prune
+        return if ENV['PUMA_BUNDLER_PRUNED']
+        return unless defined?(Bundler)
+
+        require_rubygems_min_version!
+
+        unless puma_wild_path
+          log "! Unable to prune Bundler environment, continuing"
+          return
+        end
+
+        dirs = paths_to_require_after_prune
+
+        log '* Pruning Bundler environment'
+        home = ENV['GEM_HOME']
+        bundle_gemfile = Bundler.original_env['BUNDLE_GEMFILE']
+        bundle_app_config = Bundler.original_env['BUNDLE_APP_CONFIG']
+
+        with_unbundled_env do
+          ENV['GEM_HOME'] = home
+          ENV['BUNDLE_GEMFILE'] = bundle_gemfile
+          ENV['PUMA_BUNDLER_PRUNED'] = '1'
+          ENV["BUNDLE_APP_CONFIG"] = bundle_app_config
+          args = [Gem.ruby, puma_wild_path, '-I', dirs.join(':')] + @original_argv
+          # Ruby 2.0+ defaults to true which breaks socket activation
+          args += [{:close_others => false}]
+          Kernel.exec(*args)
+        end
+      end
+
+      private
+
+      def require_rubygems_min_version!
+        min_version = Gem::Version.new('2.2')
+
+        return if min_version <= Gem::Version.new(Gem::VERSION)
+
+        raise "prune_bundler is not supported on your version of RubyGems. " \
+              "You must have RubyGems #{min_version}+ to use this feature."
+      end
+
+      def puma_wild_path
+        puma_lib_dir = puma_require_paths.detect { |x| File.exist? File.join(x, '../bin/puma-wild') }
+        File.expand_path(File.join(puma_lib_dir, '../bin/puma-wild'))
+      end
+
+      def with_unbundled_env
+        bundler_ver = Gem::Version.new(Bundler::VERSION)
+        if bundler_ver < Gem::Version.new('2.1.0')
+          Bundler.with_clean_env { yield }
+        else
+          Bundler.with_unbundled_env { yield }
+        end
+      end
+
+      def paths_to_require_after_prune
+        puma_require_paths + extra_runtime_deps_paths
+      end
+
+      def extra_runtime_deps_paths
+        t = @extra_runtime_dependencies.map do |dep_name|
+          if (spec = spec_for_gem(dep_name))
+            require_paths_for_gem(spec)
+          else
+            log "* Could not load extra dependency: #{dep_name}"
+            nil
+          end
+        end
+        t.flatten!; t.compact!; t
+      end
+
+      def puma_require_paths
+        require_paths_for_gem(spec_for_gem('puma'))
+      end
+
+      def spec_for_gem(gem_name)
+        Bundler.rubygems.loaded_specs(gem_name)
+      end
+
+      def require_paths_for_gem(gem_spec)
+        gem_spec.full_require_paths
+      end
+
+      def log(str)
+        @log_writer.log(str)
+      end
+    end
+  end
+end