puma 6.6.1-java → 7.1.0-java

data/lib/puma/server.rb

@@ -12,15 +12,13 @@ require_relative 'client'
 require_relative 'binder'
 require_relative 'util'
 require_relative 'request'
+require_relative 'configuration'
+require_relative 'cluster_accept_loop_delay'
 
 require 'socket'
 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 +30,14 @@ module Puma
   #
   # Each `Puma::Server` will have one reactor and one thread pool.
   class Server
+    module FiberPerRequest
+      def handle_request(client, requests)
+        Fiber.new do
+          super
+        end.resume
+      end
+    end
+
     include Puma::Const
     include Request
 
@@ -50,7 +56,6 @@ module Puma
     attr_accessor :app
     attr_accessor :binder
 
-
     # Create a server for the rack app +app+.
     #
     # +log_writer+ is a Puma::LogWriter object used to log info and error messages.
@@ -77,6 +82,9 @@ module Puma
 
       @thread = nil
       @thread_pool = nil
+      @reactor = nil
+
+      @env_set_http_version = nil
 
       @options = if options.is_a?(UserFileDefaultOptions)
         options
@@ -94,10 +102,19 @@ module Puma
       @min_threads               = @options[:min_threads]
       @max_threads               = @options[:max_threads]
       @queue_requests            = @options[:queue_requests]
-      @max_fast_inline           = @options[:max_fast_inline]
+      @max_keep_alive            = @options[:max_keep_alive]
       @enable_keep_alives        = @options[:enable_keep_alives]
+      @enable_keep_alives      &&= @queue_requests
       @io_selector_backend       = @options[:io_selector_backend]
       @http_content_length_limit = @options[:http_content_length_limit]
+      @cluster_accept_loop_delay = ClusterAcceptLoopDelay.new(
+        workers: @options[:workers],
+        max_delay: @options[:wait_for_less_busy_worker] || 0 # Real default is in Configuration::DEFAULTS, this is for unit testing
+      )
+
+      if @options[:fiber_per_request]
+        singleton_class.prepend(FiberPerRequest)
+      end
 
       # make this a hash, since we prefer `key?` over `include?`
       @supported_http_methods =
@@ -114,7 +131,7 @@ module Puma
       temp = !!(@options[:environment] =~ /\A(development|test)\z/)
       @leak_stack_on_error = @options[:environment] ? temp : true
 
-      @binder = Binder.new(log_writer)
+      @binder = Binder.new(log_writer, @options)
 
       ENV['RACK_ENV'] ||= "development"
 
@@ -165,7 +182,6 @@ module Puma
         begin
           skt.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_CORK, 1) if skt.kind_of? TCPSocket
         rescue IOError, SystemCallError
-          Puma::Util.purge_interrupt_queue
         end
       end
 
@@ -174,7 +190,6 @@ module Puma
         begin
           skt.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_CORK, 0) if skt.kind_of? TCPSocket
         rescue IOError, SystemCallError
-          Puma::Util.purge_interrupt_queue
         end
       end
     else
@@ -195,7 +210,6 @@ module Puma
         begin
           tcp_info = skt.getsockopt(Socket::IPPROTO_TCP, Socket::TCP_INFO)
         rescue IOError, SystemCallError
-          Puma::Util.purge_interrupt_queue
           @precheck_closing = false
           false
         else
@@ -220,7 +234,6 @@ module Puma
       @thread_pool&.spawned
     end
 
-
     # This number represents the number of requests that
     # the server is capable of taking right now.
     #
@@ -233,11 +246,6 @@ 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
@@ -251,10 +259,14 @@ module Puma
 
       @status = :run
 
-      @thread_pool = ThreadPool.new(thread_name, options) { |client| process_client client }
+      @thread_pool = ThreadPool.new(thread_name, options, server: self) { |client| process_client client }
 
       if @queue_requests
-        @reactor = Reactor.new(@io_selector_backend) { |c| reactor_wakeup c }
+        @reactor = Reactor.new(@io_selector_backend) { |c|
+          # Inversion of control, the reactor is calling a method on the server when it
+          # is done buffering a request or receives a new request from a keepalive connection.
+          self.reactor_wakeup(c)
+        }
         @reactor.run
       end
 
@@ -279,6 +291,9 @@ module Puma
     # This method is called from the Reactor thread when a queued Client receives data,
     # times out, or when the Reactor is shutting down.
     #
+    # While the code lives in the Server, the logic is executed on the reactor thread, independently
+    # from the server.
+    #
     # It is responsible for ensuring that a request has been completely received
     # before it starts to be processed by the ThreadPool. This may be known as read buffering.
     # If read buffering is not done, and no other read buffering is performed (such as by an application server
@@ -313,11 +328,14 @@ module Puma
       end
     rescue StandardError => e
       client_error(e, client)
-      client.close
+      close_client_safely(client)
       true
     end
 
     def handle_servers
+      @env_set_http_version = Object.const_defined?(:Rack) && ::Rack.respond_to?(:release) &&
+        Gem::Version.new(::Rack.release) < Gem::Version.new('3.1.0')
+
       begin
         check = @check
         sockets = [check] + @binder.ios
@@ -364,8 +382,18 @@ module Puma
               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]) if @clustered
+                # if ThreadPool out_of_band code is running, we don't want to add
+                # clients until the code is finished.
+                pool.wait_while_out_of_band_running
+
+                # A well rested herd (cluster) runs faster
+                if @cluster_accept_loop_delay.on? && (busy_threads_plus_todo = pool.busy_threads) > 0
+                  delay = @cluster_accept_loop_delay.calculate(
+                    max_threads: @max_threads,
+                    busy_threads_plus_todo: busy_threads_plus_todo
+                  )
+                  sleep(delay)
+                end
 
                 io = begin
                   sock.accept_nonblock
@@ -373,11 +401,9 @@ module Puma
                   next
                 end
                 drain += 1 if shutting_down?
-                pool << Client.new(io, @binder.env(sock)).tap { |c|
-                  c.listener = sock
-                  c.http_content_length_limit = @http_content_length_limit
-                  c.send(addr_send_name, addr_value) if addr_value
-                }
+                client = new_client(io, sock)
+                client.send(addr_send_name, addr_value) if addr_value
+                pool << client
               end
             end
           rescue IOError, Errno::EBADF
@@ -414,6 +440,14 @@ module Puma
       @events.fire :state, :done
     end
 
+    # :nodoc:
+    def new_client(io, sock)
+      client = Client.new(io, @binder.env(sock))
+      client.listener = sock
+      client.http_content_length_limit = @http_content_length_limit
+      client
+    end
+
     # :nodoc:
     def handle_check
       cmd = @check.read(1)
@@ -444,17 +478,12 @@ module Puma
     #
     # Return true if one or more requests were processed.
     def process_client(client)
-      # Advertise this server into the thread
-      Thread.current.puma_server = self
-
-      clean_thread_locals = options[:clean_thread_locals]
       close_socket = true
 
       requests = 0
 
       begin
-        if @queue_requests &&
-          !client.eagerly_finish
+        if @queue_requests && !client.eagerly_finish
 
           client.set_timeout(@first_data_timeout)
           if @reactor.add client
@@ -467,38 +496,40 @@ module Puma
           client.finish(@first_data_timeout)
         end
 
-        while true
+        can_loop = true
+        while can_loop
+          can_loop = false
           @requests_count += 1
           case handle_request(client, requests + 1)
           when false
-            break
           when :async
             close_socket = false
-            break
           when true
-            ThreadPool.clean_thread_locals if clean_thread_locals
-
             requests += 1
 
-            # As an optimization, try to read the next request from the
-            # socket for a short time before returning to the reactor.
-            fast_check = @status == :run
+            client.reset
 
-            # Always pass the client back to the reactor after a reasonable
-            # number of inline requests if there are other requests pending.
-            fast_check = false if requests >= @max_fast_inline &&
-              @thread_pool.backlog > 0
-
-            next_request_ready = with_force_shutdown(client) do
-              client.reset(fast_check)
+            # This indicates data exists in the client read buffer and there may be
+            # additional requests on it, so process them
+            next_request_ready = if client.has_back_to_back_requests?
+              with_force_shutdown(client) { client.process_back_to_back_requests }
+            else
+              with_force_shutdown(client) { client.eagerly_finish }
             end
 
-            unless next_request_ready
-              break unless @queue_requests
+            if next_request_ready
+              # When Puma has spare threads, allow this one to be monopolized
+              # Perf optimization for https://github.com/puma/puma/issues/3788
+              if @thread_pool.waiting > 0
+                can_loop = true
+              else
+                @thread_pool << client
+                close_socket = false
+              end
+            elsif @queue_requests
               client.set_timeout @persistent_timeout
               if @reactor.add client
                 close_socket = false
-                break
               end
             end
           end
@@ -511,17 +542,21 @@ module Puma
       ensure
         client.io_buffer.reset
 
-        begin
-          client.close if close_socket
-        rescue IOError, SystemCallError
-          Puma::Util.purge_interrupt_queue
-          # Already closed
-        rescue StandardError => e
-          @log_writer.unknown_error e, nil, "Client"
-        end
+        close_client_safely(client) if close_socket
       end
     end
 
+    # :nodoc:
+    def close_client_safely(client)
+      client.close
+    rescue IOError, SystemCallError
+      # Already closed
+    rescue MiniSSL::SSLError => e
+      @log_writer.ssl_error e, client.io
+    rescue StandardError => e
+      @log_writer.unknown_error e, nil, "Client"
+    end
+
     # Triggers a client timeout if the thread-pool shuts down
     # during execution of the provided block.
     def with_force_shutdown(client, &block)
@@ -615,11 +650,10 @@ module Puma
       @notify << message
     rescue IOError, NoMethodError, Errno::EPIPE, Errno::EBADF
       # The server, in another thread, is shutting down
-      Puma::Util.purge_interrupt_queue
     rescue RuntimeError => e
       # Temporary workaround for https://bugs.ruby-lang.org/issues/13239
       if e.message.include?('IOError')
-        Puma::Util.purge_interrupt_queue
+        # ignore
       else
         raise e
       end
@@ -650,7 +684,16 @@ module Puma
 
     # List of methods invoked by #stats.
     # @version 5.0.0
-    STAT_METHODS = [:backlog, :running, :pool_capacity, :max_threads, :requests_count, :busy_threads].freeze
+    STAT_METHODS = [
+      :backlog,
+      :running,
+      :pool_capacity,
+      :busy_threads,
+      :backlog_max,
+      :max_threads,
+      :requests_count,
+      :reactor_max,
+    ].freeze
 
     # Returns a hash of stats about the running server for reporting purposes.
     # @version 5.0.0
@@ -660,9 +703,16 @@ module Puma
       stats = @thread_pool&.stats || {}
       stats[:max_threads]    = @max_threads
       stats[:requests_count] = @requests_count
+      stats[:reactor_max] = @reactor.reactor_max if @reactor
+      reset_max
       stats
     end
 
+    def reset_max
+      @reactor.reactor_max = 0 if @reactor
+      @thread_pool&.reset_max
+    end
+
     # below are 'delegations' to binder
     # remove in Puma 7?
 

data/lib/puma/single.rb

@@ -53,9 +53,12 @@ module Puma
       server_thread = server.run
 
       log "Use Ctrl-C to stop"
+
+      warn_ruby_mn_threads
+
       redirect_io
 
-      @events.fire_on_booted!
+      @events.fire_after_booted!
 
       debug_loaded_extensions("Loaded Extensions:") if @log_writer.debug?
 

data/lib/puma/state_file.rb

@@ -32,10 +32,11 @@ module Puma
             "#{k}: \"#{v}\"\n" : "#{k}: #{v}\n")
         end
       end
+
       if permission
-        File.write path, contents, mode: 'wb:UTF-8'
-      else
         File.write path, contents, mode: 'wb:UTF-8', perm: permission
+      else
+        File.write path, contents, mode: 'wb:UTF-8'
       end
     end
 

data/lib/puma/thread_pool.rb

@@ -5,6 +5,10 @@ require 'thread'
 require_relative 'io_buffer'
 
 module Puma
+
+  # Add `Thread#puma_server` and `Thread#puma_server=`
+  Thread.attr_accessor(:puma_server)
+
   # Internal Docs for A simple thread pool management object.
   #
   # Each Puma "worker" has a thread pool to process requests.
@@ -25,19 +29,23 @@ module Puma
     # up its work before leaving the thread to die on the vine.
     SHUTDOWN_GRACE_TIME = 5 # seconds
 
+    attr_reader :out_of_band_running
+
     # Maintain a minimum of +min+ and maximum of +max+ threads
     # in the pool.
     #
     # The block passed is the work that will be performed in each
     # thread.
     #
-    def initialize(name, options = {}, &block)
+    def initialize(name, options = {}, server: nil, &block)
+      @server = server
+
       @not_empty = ConditionVariable.new
       @not_full = ConditionVariable.new
       @mutex = Mutex.new
+      @todo = Queue.new
 
-      @todo = []
-
+      @backlog_max = 0
       @spawned = 0
       @waiting = 0
 
@@ -50,7 +58,8 @@ module Puma
       @shutdown_grace_time = Float(options[:pool_shutdown_grace_time] || SHUTDOWN_GRACE_TIME)
       @block = block
       @out_of_band = options[:out_of_band]
-      @clean_thread_locals = options[:clean_thread_locals]
+      @out_of_band_running = false
+      @out_of_band_condvar = ConditionVariable.new
       @before_thread_start = options[:before_thread_start]
       @before_thread_exit = options[:before_thread_exit]
       @reaping_time = options[:reaping_time]
@@ -79,30 +88,37 @@ module Puma
 
     attr_reader :spawned, :trim_requested, :waiting
 
-    def self.clean_thread_locals
-      Thread.current.keys.each do |key| # rubocop: disable Style/HashEachMethods
-        Thread.current[key] = nil unless key == :__recursive_key__
-      end
-    end
-
     # generate stats hash so as not to perform multiple locks
     # @return [Hash] hash containing stat info from ThreadPool
     def stats
       with_mutex do
+        temp = @backlog_max
+        @backlog_max = 0
         { backlog: @todo.size,
           running: @spawned,
           pool_capacity: @waiting + (@max - @spawned),
-          busy_threads: @spawned - @waiting + @todo.size
+          busy_threads: @spawned - @waiting + @todo.size,
+          backlog_max: temp
         }
       end
     end
 
+    def reset_max
+      with_mutex { @backlog_max = 0 }
+    end
+
     # How many objects have yet to be processed by the pool?
     #
     def backlog
       with_mutex { @todo.size }
     end
 
+    # The maximum size of the backlog
+    #
+    def backlog_max
+      with_mutex { @backlog_max }
+    end
+
     # @!attribute [r] pool_capacity
     def pool_capacity
       waiting + (@max - spawned)
@@ -124,6 +140,9 @@ module Puma
       trigger_before_thread_start_hooks
       th = Thread.new(@spawned) do |spawned|
         Puma.set_thread_name '%s tp %03i' % [@name, spawned]
+        # Advertise server into the thread
+        Thread.current.puma_server = @server
+
         todo  = @todo
         block = @block
         mutex = @mutex
@@ -159,10 +178,6 @@ module Puma
             work = todo.shift
           end
 
-          if @clean_thread_locals
-            ThreadPool.clean_thread_locals
-          end
-
           begin
             @out_of_band_pending = true if block.call(work)
           rescue Exception => e
@@ -183,7 +198,7 @@ module Puma
 
       @before_thread_start.each do |b|
         begin
-          b.call
+          b[:block].call
         rescue Exception => e
           STDERR.puts "WARNING before_thread_start hook failed with exception (#{e.class}) #{e.message}"
         end
@@ -198,7 +213,7 @@ module Puma
 
       @before_thread_exit.each do |b|
         begin
-          b.call
+          b[:block].call
         rescue Exception => e
           STDERR.puts "WARNING before_thread_exit hook failed with exception (#{e.class}) #{e.message}"
         end
@@ -214,16 +229,27 @@ module Puma
 
       # we execute on idle hook when all threads are free
       return false unless @spawned == @waiting
-
-      @out_of_band.each(&:call)
+      @out_of_band_running = true
+      @out_of_band.each { |b| b[:block].call }
       true
     rescue Exception => e
       STDERR.puts "Exception calling out_of_band_hook: #{e.message} (#{e.class})"
       true
+    ensure
+      @out_of_band_running = false
+      @out_of_band_condvar.broadcast
     end
 
     private :trigger_out_of_band_hook
 
+    def wait_while_out_of_band_running
+      return unless @out_of_band_running
+
+      with_mutex do
+        @out_of_band_condvar.wait(@mutex) while @out_of_band_running
+      end
+    end
+
     # @version 5.0.0
     def with_mutex(&block)
       @mutex.owned? ?
@@ -239,6 +265,8 @@ module Puma
         end
 
         @todo << work
+        t = @todo.size
+        @backlog_max = t if t > @backlog_max
 
         if @waiting < @todo.size and @spawned < @max
           spawn_thread
@@ -248,69 +276,6 @@ module Puma
       end
     end
 
-    # This method is used by `Puma::Server` to let the server know when
-    # the thread pool can pull more requests from the socket and
-    # pass to the reactor.
-    #
-    # The general idea is that the thread pool can only work on a fixed
-    # number of requests at the same time. If it is already processing that
-    # number of requests then it is at capacity. If another Puma process has
-    # spare capacity, then the request can be left on the socket so the other
-    # worker can pick it up and process it.
-    #
-    # For example: if there are 5 threads, but only 4 working on
-    # requests, this method will not wait and the `Puma::Server`
-    # can pull a request right away.
-    #
-    # If there are 5 threads and all 5 of them are busy, then it will
-    # pause here, and wait until the `not_full` condition variable is
-    # signaled, usually this indicates that a request has been processed.
-    #
-    # It's important to note that even though the server might accept another
-    # request, it might not be added to the `@todo` array right away.
-    # For example if a slow client has only sent a header, but not a body
-    # then the `@todo` array would stay the same size as the reactor works
-    # to try to buffer the request. In that scenario the next call to this
-    # method would not block and another request would be added into the reactor
-    # by the server. This would continue until a fully buffered request
-    # makes it through the reactor and can then be processed by the thread pool.
-    def wait_until_not_full
-      with_mutex do
-        while true
-          return if @shutdown
-
-          # If we can still spin up new threads and there
-          # is work queued that cannot be handled by waiting
-          # threads, then accept more work until we would
-          # spin up the max number of threads.
-          return if busy_threads < @max
-
-          @not_full.wait @mutex
-        end
-      end
-    end
-
-    # @version 5.0.0
-    def wait_for_less_busy_worker(delay_s)
-      return unless delay_s && delay_s > 0
-
-      # Ruby MRI does GVL, this can result
-      # in processing contention when multiple threads
-      # (requests) are running concurrently
-      return unless Puma.mri?
-
-      with_mutex do
-        return if @shutdown
-
-        # do not delay, if we are not busy
-        return unless busy_threads > 0
-
-        # this will be signaled once a request finishes,
-        # which can happen earlier than delay
-        @not_full.wait @mutex, delay_s
-      end
-    end
-
     # If there are any free threads in the pool, tell one to go ahead
     # and exit. If +force+ is true, then a trim request is requested
     # even if all threads are being utilized.

data/lib/puma/util.rb

@@ -10,13 +10,6 @@ module Puma
       IO.pipe
     end
 
-    # An instance method on Thread has been provided to address https://bugs.ruby-lang.org/issues/13632,
-    # which currently affects some older versions of Ruby: 2.2.7 2.2.8 2.2.9 2.2.10 2.3.4 2.4.1
-    # Additional context: https://github.com/puma/puma/pull/1345
-    def purge_interrupt_queue
-      Thread.current.purge_interrupt_queue if Thread.current.respond_to? :purge_interrupt_queue
-    end
-
     # Escapes and unescapes a URI escaped string with
     # +encoding+. +encoding+ will be the target encoding of the string
     # returned, and it defaults to UTF-8

data/lib/puma.rb

@@ -75,4 +75,14 @@ module Puma
   def self.set_thread_name(name)
     Thread.current.name = "puma #{name}"
   end
+
+  # Shows deprecated warning for renamed methods.
+  # @example
+  #   Puma.deprecate_method_change :on_booted, __callee__, __method__
+  #
+  def self.deprecate_method_change(method_old, method_caller, method_new)
+    if method_old == method_caller
+      warn "Use '#{method_new}', '#{method_caller}' is deprecated and will be removed in v8"
+    end
+  end
 end

data/lib/rack/handler/puma.rb

@@ -32,7 +32,7 @@ module Puma
 
       @events = options[:events] || ::Puma::Events.new
 
-      conf = ::Puma::Configuration.new(options, default_options.merge({events: @events})) do |user_config, file_config, default_config|
+      conf = ::Puma::Configuration.new(options, default_options.merge({ events: @events })) do |user_config, file_config, default_config|
         if options.delete(:Verbose)
           begin
             require 'rack/commonlogger'  # Rack 1.x
@@ -72,7 +72,7 @@ module Puma
 
       log_writer = options.delete(:Silent) ? ::Puma::LogWriter.strings : ::Puma::LogWriter.stdio
 
-      launcher = ::Puma::Launcher.new(conf, :log_writer => log_writer, events: @events)
+      launcher = ::Puma::Launcher.new(conf, log_writer: log_writer, events: @events)
 
       yield launcher if block_given?
       begin