puma 6.4.0 → 6.6.1

data/lib/puma/error_logger.rb

@@ -15,14 +15,14 @@ module Puma
 
     LOG_QUEUE = Queue.new
 
-    def initialize(ioerr)
+    def initialize(ioerr, env: ENV)
       @ioerr = ioerr
 
-      @debug = ENV.key? 'PUMA_DEBUG'
+      @debug = env.key?('PUMA_DEBUG')
     end
 
-    def self.stdio
-      new $stderr
+    def self.stdio(env: ENV)
+      new($stderr, env: env)
     end
 
     # Print occurred error details.

data/lib/puma/jruby_restart.rb

@@ -6,22 +6,6 @@ module Puma
   module JRubyRestart
     extend FFI::Library
     ffi_lib 'c'
-
-    attach_function :execlp, [:string, :varargs], :int
     attach_function :chdir, [:string], :int
-    attach_function :fork, [], :int
-    attach_function :exit, [:int], :void
-    attach_function :setsid, [], :int
-
-    def self.chdir_exec(dir, argv)
-      chdir(dir)
-      cmd = argv.first
-      argv = ([:string] * argv.size).zip(argv)
-      argv.flatten!
-      argv << :string
-      argv << nil
-      execlp(cmd, *argv)
-      raise SystemCallError.new(FFI.errno)
-    end
   end
 end

data/lib/puma/launcher.rb

@@ -46,6 +46,8 @@ module Puma
       @original_argv = @argv.dup
       @config        = conf
 
+      env = launcher_args.delete(:env) || ENV
+
       @config.options[:log_writer] = @log_writer
 
       # Advertise the Configuration
@@ -62,7 +64,7 @@ module Puma
       # Load the systemd integration if we detect systemd's NOTIFY_SOCKET.
       # Skip this on JRuby though, because it is incompatible with the systemd
       # integration due to https://github.com/jruby/jruby/issues/6504
-      if ENV["NOTIFY_SOCKET"] && !Puma.jruby?
+      if ENV["NOTIFY_SOCKET"] && !Puma.jruby? && !ENV["PUMA_SKIP_SYSTEMD"]
         @config.plugins.create('systemd')
       end
 
@@ -105,7 +107,7 @@ module Puma
 
       @status = :run
 
-      log_config if ENV['PUMA_LOG_CONFIG']
+      log_config if env['PUMA_LOG_CONFIG']
     end
 
     attr_reader :binder, :log_writer, :events, :config, :options, :restart_dir
@@ -165,6 +167,13 @@ module Puma
         log "* phased-restart called but not available, restarting normally."
         return restart
       end
+
+      if @options.file_options[:tag].nil?
+        dir = File.realdirpath(@restart_dir)
+        @options[:tag] = File.basename(dir)
+        set_process_title
+      end
+
       true
     end
 
@@ -287,7 +296,9 @@ module Puma
         close_binder_listeners
 
         require_relative 'jruby_restart'
-        JRubyRestart.chdir_exec(@restart_dir, restart_args)
+        argv = restart_args
+        JRubyRestart.chdir(@restart_dir)
+        Kernel.exec(*argv)
       elsif Puma.windows?
         close_binder_listeners
 
@@ -408,12 +419,14 @@ module Puma
     end
 
     def setup_signals
-      begin
-        Signal.trap "SIGUSR2" do
-          restart
+      unless ENV["PUMA_SKIP_SIGUSR2"]
+        begin
+          Signal.trap "SIGUSR2" do
+            restart
+          end
+        rescue Exception
+          log "*** SIGUSR2 not implemented, signal based restart unavailable!"
         end
-      rescue Exception
-        log "*** SIGUSR2 not implemented, signal based restart unavailable!"
       end
 
       unless Puma.jruby?

data/lib/puma/log_writer.rb

@@ -31,31 +31,31 @@ module Puma
     attr_accessor :formatter, :custom_logger
 
     # Create a LogWriter that prints to +stdout+ and +stderr+.
-    def initialize(stdout, stderr)
+    def initialize(stdout, stderr, env: ENV)
       @formatter = DefaultFormatter.new
       @custom_logger = nil
       @stdout = stdout
       @stderr = stderr
 
-      @debug = ENV.key?('PUMA_DEBUG')
-      @error_logger = ErrorLogger.new(@stderr)
+      @debug = env.key?('PUMA_DEBUG')
+      @error_logger = ErrorLogger.new(@stderr, env: env)
     end
 
     DEFAULT = new(STDOUT, STDERR)
 
     # Returns an LogWriter object which writes its status to
     # two StringIO objects.
-    def self.strings
-      LogWriter.new(StringIO.new, StringIO.new)
+    def self.strings(env: ENV)
+      LogWriter.new(StringIO.new, StringIO.new, env: env)
     end
 
-    def self.stdio
-      LogWriter.new($stdout, $stderr)
+    def self.stdio(env: ENV)
+      LogWriter.new($stdout, $stderr, env: env)
     end
 
-    def self.null
+    def self.null(env: ENV)
       n = NullIO.new
-      LogWriter.new(n, n)
+      LogWriter.new(n, n, env: env)
     end
 
     # Write +str+ to +@stdout+

data/lib/puma/minissl/context_builder.rb

@@ -51,10 +51,13 @@ module Puma
             unless params['ca']
               log_writer.error "Please specify the SSL ca via 'ca='"
             end
+            # needed for Puma::MiniSSL::Socket#peercert, env['puma.peercert']
+            require 'openssl'
           end
 
           ctx.ca = params['ca'] if params['ca']
           ctx.ssl_cipher_filter = params['ssl_cipher_filter'] if params['ssl_cipher_filter']
+          ctx.ssl_ciphersuites = params['ssl_ciphersuites'] if params['ssl_ciphersuites'] && HAS_TLS1_3
 
           ctx.reuse = params['reuse'] if params['reuse']
         end

data/lib/puma/minissl.rb

@@ -184,6 +184,11 @@ module Puma
         @socket.peeraddr
       end
 
+      # OpenSSL is loaded in `MiniSSL::ContextBuilder` when
+      # `MiniSSL::Context#verify_mode` is not `VERIFY_NONE`.
+      # When `VERIFY_NONE`, `MiniSSL::Engine#peercert` is nil, regardless of
+      # whether the client sends a cert.
+      # @return [OpenSSL::X509::Certificate, nil]
       # @!attribute [r] peercert
       def peercert
         return @peercert if @peercert
@@ -284,6 +289,7 @@ module Puma
         attr_reader :cert_pem
         attr_reader :key_pem
         attr_accessor :ssl_cipher_filter
+        attr_accessor :ssl_ciphersuites
         attr_accessor :verification_flags
 
         attr_reader :reuse, :reuse_cache_size, :reuse_timeout

data/lib/puma/null_io.rb

@@ -16,15 +16,38 @@ module Puma
     def each
     end
 
+    def pos
+      0
+    end
+
     # Mimics IO#read with no data.
     #
-    def read(count = nil, _buffer = nil)
-      count && count > 0 ? nil : ""
+    def read(length = nil, buffer = nil)
+      if length.to_i < 0
+        raise ArgumentError, "(negative length #{length} given)"
+      end
+
+      buffer = if buffer.nil?
+        "".b
+      else
+        String.try_convert(buffer) or raise TypeError, "no implicit conversion of #{buffer.class} into String"
+      end
+      buffer.clear
+      if length.to_i > 0
+        nil
+      else
+        buffer
+      end
     end
 
     def rewind
     end
 
+    def seek(pos, whence = 0)
+      raise ArgumentError, "negative length #{pos} given" if pos.negative?
+      0
+    end
+
     def close
     end
 
@@ -57,5 +80,22 @@ module Puma
     def closed?
       false
     end
+
+    def set_encoding(enc)
+      self
+    end
+
+    # per rack spec
+    def external_encoding
+      Encoding::ASCII_8BIT
+    end
+
+    def binmode
+      self
+    end
+
+    def binmode?
+      true
+    end
   end
 end

data/lib/puma/request.rb

@@ -53,7 +53,6 @@ module Puma
       socket  = client.io   # io may be a MiniSSL::Socket
       app_body = nil
 
-
       return false if closed_socket?(socket)
 
       if client.http_content_length_limit_exceeded
@@ -135,13 +134,16 @@ module Puma
       io_buffer.reset
       uncork_socket client.io
       app_body.close if app_body.respond_to? :close
-      client.tempfile&.unlink
-      after_reply = env[RACK_AFTER_REPLY] || []
-      begin
-        after_reply.each { |o| o.call }
-      rescue StandardError => e
-        @log_writer.debug_error e
-      end unless after_reply.empty?
+      client&.tempfile_close
+      if after_reply = env[RACK_AFTER_REPLY]
+        after_reply.each do |o|
+          begin
+            o.call
+          rescue StandardError => e
+            @log_writer.debug_error e
+          end
+        end
+      end
     end
 
     # Assembles the headers and prepares the body for actually sending the
@@ -165,9 +167,14 @@ module Puma
       # if the server is at capacity and the listener has a new connection ready.
       # This allows Puma to service connections fairly when the number
       # of concurrent connections exceeds the size of the threadpool.
-      force_keep_alive = requests < @max_fast_inline ||
+      force_keep_alive = if @enable_keep_alives
+        requests < @max_fast_inline ||
         @thread_pool.busy_threads < @max_threads ||
         !client.listener.to_io.wait_readable(0)
+      else
+        # Always set force_keep_alive to false if the server has keep-alives not enabled.
+        false
+      end
 
       resp_info = str_headers(env, status, headers, res_body, io_buffer, force_keep_alive)
 
@@ -187,7 +194,8 @@ module Puma
           elsif res_body.is_a?(File) && res_body.respond_to?(:size)
             body = res_body
             content_length = body.size
-          elsif res_body.respond_to?(:to_path) && File.readable?(fn = res_body.to_path)
+          elsif res_body.respond_to?(:to_path) && (fn = res_body.to_path) &&
+              File.readable?(fn)
             body = File.open fn, 'rb'
             content_length = body.size
             close_body = true
@@ -195,7 +203,7 @@ module Puma
             body = res_body
           end
         elsif !res_body.is_a?(::File) && res_body.respond_to?(:to_path) &&
-            File.readable?(fn = res_body.to_path)
+            (fn = res_body.to_path) && File.readable?(fn = res_body.to_path)
           body = File.open fn, 'rb'
           content_length = body.size
           close_body = true
@@ -495,6 +503,11 @@ module Puma
     # compatibility, we'll convert them back. This code is written to
     # avoid allocation in the common case (ie there are no headers
     # with `,` in their names), that's why it has the extra conditionals.
+    #
+    # @note If a normalized version of a `,` header already exists, we ignore
+    #       the `,` version. This prevents clobbering headers managed by proxies
+    #       but not by clients (Like X-Forwarded-For).
+    #
     # @param env [Hash] see Puma::Client#env, from request, modifies in place
     # @version 5.0.3
     #
@@ -503,23 +516,31 @@ module Puma
       to_add = nil
 
       env.each do |k,v|
-        if k.start_with?("HTTP_") && k.include?(",") && k != "HTTP_TRANSFER,ENCODING"
+        if k.start_with?("HTTP_") && k.include?(",") && !UNMASKABLE_HEADERS.key?(k)
           if to_delete
             to_delete << k
           else
             to_delete = [k]
           end
 
+          new_k = k.tr(",", "_")
+          if env.key?(new_k)
+            next
+          end
+
           unless to_add
             to_add = {}
           end
 
-          to_add[k.tr(",", "_")] = v
+          to_add[new_k] = v
         end
       end
 
-      if to_delete
+      if to_delete # rubocop:disable Style/SafeNavigation
         to_delete.each { |k| env.delete(k) }
+      end
+
+      if to_add
         env.merge! to_add
       end
     end

data/lib/puma/runner.rb

@@ -8,6 +8,9 @@ module Puma
   # serve requests. This class spawns a new instance of `Puma::Server` via
   # a call to `start_server`.
   class Runner
+
+    include ::Puma::Const::PipeRequest
+
     def initialize(launcher)
       @launcher = launcher
       @log_writer = launcher.log_writer
@@ -27,7 +30,7 @@ module Puma
     def wakeup!
       return unless @wakeup
 
-      @wakeup.write "!" unless @wakeup.closed?
+      @wakeup.write PIPE_WAKEUP unless @wakeup.closed?
 
     rescue SystemCallError, IOError
       Puma::Util.purge_interrupt_queue
@@ -70,7 +73,7 @@ module Puma
 
       app = Puma::App::Status.new @launcher, token
 
-      # A Reactor is not created aand nio4r is not loaded when 'queue_requests: false'
+      # A Reactor is not created and nio4r is not loaded when 'queue_requests: false'
       # Use `nil` for events, no hooks in control server
       control = Puma::Server.new app, nil,
         { min_threads: 0, max_threads: 1, queue_requests: false, log_writer: @log_writer }
@@ -91,7 +94,10 @@ module Puma
     end
 
     # @!attribute [r] ruby_engine
+    # @deprecated Use `RUBY_DESCRIPTION` instead
     def ruby_engine
+      warn "Puma::Runner#ruby_engine is deprecated; use RUBY_DESCRIPTION instead. It will be removed in puma v7."
+
       if !defined?(RUBY_ENGINE) || RUBY_ENGINE == "ruby"
         "ruby #{RUBY_VERSION}-p#{RUBY_PATCHLEVEL}"
       else
@@ -109,7 +115,8 @@ module Puma
       environment = @options[:environment]
 
       log "Puma starting in #{mode} mode..."
-      log "* Puma version: #{Puma::Const::PUMA_VERSION} (#{ruby_engine}) (\"#{Puma::Const::CODE_NAME}\")"
+      log "* Puma version: #{Puma::Const::PUMA_VERSION} (\"#{Puma::Const::CODE_NAME}\")"
+      log "* Ruby version: #{RUBY_DESCRIPTION}"
       log "*  Min threads: #{min_t}"
       log "*  Max threads: #{max_t}"
       log "*  Environment: #{environment}"

data/lib/puma/sd_notify.rb

@@ -137,10 +137,7 @@ module Puma
       ENV.delete("NOTIFY_SOCKET") if unset_env
 
       begin
-        Addrinfo.unix(sock, :DGRAM).connect do |s|
-          s.close_on_exec = true
-          s.write(state)
-        end
+        Addrinfo.unix(sock, :DGRAM).connect { |s| s.write state }
       rescue StandardError => e
         raise NotifyError, "#{e.class}: #{e.message}", e.backtrace
       end

data/lib/puma/server.rb

@@ -18,6 +18,9 @@ require 'io/wait' unless Puma::HAS_NATIVE_IO_WAIT
 
 module Puma
 
+  # This method was private on Ruby 2.4 but became public on Ruby 2.5+:
+  Thread.send(:attr_accessor, :puma_server)
+
   # The HTTP Server itself. Serves out a single Rack app.
   #
   # This class is used by the `Puma::Single` and `Puma::Cluster` classes
@@ -32,6 +35,7 @@ module Puma
     include Puma::Const
     include Request
 
+    attr_reader :options
     attr_reader :thread
     attr_reader :log_writer
     attr_reader :events
@@ -46,7 +50,6 @@ module Puma
     attr_accessor :app
     attr_accessor :binder
 
-    THREAD_LOCAL_KEY = :puma_server
 
     # Create a server for the rack app +app+.
     #
@@ -81,6 +84,8 @@ module Puma
         UserFileDefaultOptions.new(options, Configuration::DEFAULTS)
       end
 
+      @clustered                 = (@options.fetch :workers, 0) > 0
+      @worker_write              = @options[:worker_write]
       @log_writer                = @options.fetch :log_writer, LogWriter.stdio
       @early_hints               = @options[:early_hints]
       @first_data_timeout        = @options[:first_data_timeout]
@@ -90,6 +95,7 @@ module Puma
       @max_threads               = @options[:max_threads]
       @queue_requests            = @options[:queue_requests]
       @max_fast_inline           = @options[:max_fast_inline]
+      @enable_keep_alives        = @options[:enable_keep_alives]
       @io_selector_backend       = @options[:io_selector_backend]
       @http_content_length_limit = @options[:http_content_length_limit]
 
@@ -117,6 +123,8 @@ module Puma
       @precheck_closing = true
 
       @requests_count = 0
+
+      @idle_timeout_reached = false
     end
 
     def inherit_binder(bind)
@@ -126,7 +134,7 @@ module Puma
     class << self
       # @!attribute [r] current
       def current
-        Thread.current[THREAD_LOCAL_KEY]
+        Thread.current.puma_server
       end
 
       # :nodoc:
@@ -225,6 +233,11 @@ module Puma
       @thread_pool&.pool_capacity
     end
 
+    # @!attribute [r] busy_threads
+    def busy_threads
+      @thread_pool&.busy_threads
+    end
+
     # Runs the server.
     #
     # If +background+ is true (the default) then a thread is spun
@@ -238,16 +251,15 @@ module Puma
 
       @status = :run
 
-      @thread_pool = ThreadPool.new(thread_name, @options) { |client| process_client client }
+      @thread_pool = ThreadPool.new(thread_name, options) { |client| process_client client }
 
       if @queue_requests
         @reactor = Reactor.new(@io_selector_backend) { |c| reactor_wakeup c }
         @reactor.run
       end
 
-
-      @thread_pool.auto_reap! if @options[:reaping_time]
-      @thread_pool.auto_trim! if @options[:auto_trim_time]
+      @thread_pool.auto_reap! if options[:reaping_time]
+      @thread_pool.auto_trim! if @min_threads != @max_threads && options[:auto_trim_time]
 
       @check, @notify = Puma::Util.pipe unless @notify
 
@@ -311,15 +323,15 @@ module Puma
         sockets = [check] + @binder.ios
         pool = @thread_pool
         queue_requests = @queue_requests
-        drain = @options[:drain_on_shutdown] ? 0 : nil
+        drain = options[:drain_on_shutdown] ? 0 : nil
 
-        addr_send_name, addr_value = case @options[:remote_address]
+        addr_send_name, addr_value = case options[:remote_address]
         when :value
-          [:peerip=, @options[:remote_address_value]]
+          [:peerip=, options[:remote_address_value]]
         when :header
-          [:remote_addr_header=, @options[:remote_address_header]]
+          [:remote_addr_header=, options[:remote_address_header]]
         when :proxy_protocol
-          [:expect_proxy_proto=, @options[:remote_address_proxy_protocol]]
+          [:expect_proxy_proto=, options[:remote_address_proxy_protocol]]
         else
           [nil, nil]
         end
@@ -328,16 +340,32 @@ module Puma
           begin
             ios = IO.select sockets, nil, nil, (shutting_down? ? 0 : @idle_timeout)
             unless ios
-              @status = :stop unless shutting_down?
+              unless shutting_down?
+                @idle_timeout_reached = true
+
+                if @clustered
+                  @worker_write << "#{PipeRequest::PIPE_IDLE}#{Process.pid}\n" rescue nil
+                  next
+                else
+                  @log_writer.log "- Idle timeout reached"
+                  @status = :stop
+                end
+              end
+
               break
             end
 
+            if @idle_timeout_reached && @clustered
+              @idle_timeout_reached = false
+              @worker_write << "#{PipeRequest::PIPE_IDLE}#{Process.pid}\n" rescue nil
+            end
+
             ios.first.each do |sock|
               if sock == check
                 break if handle_check
               else
                 pool.wait_until_not_full
-                pool.wait_for_less_busy_worker(@options[:wait_for_less_busy_worker])
+                pool.wait_for_less_busy_worker(options[:wait_for_less_busy_worker]) if @clustered
 
                 io = begin
                   sock.accept_nonblock
@@ -367,6 +395,7 @@ module Puma
           @queue_requests = false
           @reactor.shutdown
         end
+
         graceful_shutdown if @status == :stop || @status == :restart
       rescue Exception => e
         @log_writer.unknown_error e, nil, "Exception handling servers"
@@ -416,9 +445,9 @@ module Puma
     # Return true if one or more requests were processed.
     def process_client(client)
       # Advertise this server into the thread
-      Thread.current[THREAD_LOCAL_KEY] = self
+      Thread.current.puma_server = self
 
-      clean_thread_locals = @options[:clean_thread_locals]
+      clean_thread_locals = options[:clean_thread_locals]
       close_socket = true
 
       requests = 0
@@ -527,7 +556,7 @@ module Puma
     # A fallback rack response if +@app+ raises as exception.
     #
     def lowlevel_error(e, env, status=500)
-      if handler = @options[:lowlevel_error_handler]
+      if handler = options[:lowlevel_error_handler]
         if handler.arity == 1
           return handler.call(e)
         elsif handler.arity == 2
@@ -548,14 +577,13 @@ module Puma
     def response_to_error(client, requests, err, status_code)
       status, headers, res_body = lowlevel_error(err, client.env, status_code)
       prepare_response(status, headers, res_body, requests, client)
-      client.write_error(status_code)
     end
     private :response_to_error
 
     # Wait for all outstanding requests to finish.
     #
     def graceful_shutdown
-      if @options[:shutdown_debug]
+      if options[:shutdown_debug]
         threads = Thread.list
         total = threads.size
 
@@ -575,7 +603,7 @@ module Puma
       end
 
       if @thread_pool
-        if timeout = @options[:force_shutdown_after]
+        if timeout = options[:force_shutdown_after]
           @thread_pool.shutdown timeout.to_f
         else
           @thread_pool.shutdown
@@ -622,13 +650,17 @@ module Puma
 
     # List of methods invoked by #stats.
     # @version 5.0.0
-    STAT_METHODS = [:backlog, :running, :pool_capacity, :max_threads, :requests_count].freeze
+    STAT_METHODS = [:backlog, :running, :pool_capacity, :max_threads, :requests_count, :busy_threads].freeze
 
     # Returns a hash of stats about the running server for reporting purposes.
     # @version 5.0.0
     # @!attribute [r] stats
+    # @return [Hash] hash containing stat info from `Server` and `ThreadPool`
     def stats
-      STAT_METHODS.map {|name| [name, send(name) || 0]}.to_h
+      stats = @thread_pool&.stats || {}
+      stats[:max_threads]    = @max_threads
+      stats[:requests_count] = @requests_count
+      stats
     end
 
     # below are 'delegations' to binder

data/lib/puma/single.rb

@@ -17,7 +17,7 @@ module Puma
     def stats
       {
         started_at: utc_iso8601(@started_at)
-      }.merge(@server.stats).merge(super)
+      }.merge(@server&.stats || {}).merge(super)
     end
 
     def restart

data/lib/puma/state_file.rb

@@ -56,11 +56,11 @@ module Puma
     end
 
     ALLOWED_FIELDS.each do |f|
-      define_method f do
+      define_method f.to_sym do
         @options[f]
       end
 
-      define_method "#{f}=" do |v|
+      define_method :"#{f}=" do |v|
         @options[f] = v
       end
     end