puma 6.6.1-java → 7.0.0-java

data/lib/puma/reactor.rb

@@ -15,6 +15,12 @@ module Puma
   #
   # The implementation uses a Queue to synchronize adding new objects from the internal select loop.
   class Reactor
+
+    # @!attribute [rw] reactor_max
+    #   Maximum number of clients in the selector.  Reset with calls to `Server.stats`.
+    attr_accessor :reactor_max
+    attr_reader :reactor_size
+
     # Create a new Reactor to monitor IO objects added by #add.
     # The provided block will be invoked when an IO has data available to read,
     # its timeout elapses, or when the Reactor shuts down.
@@ -29,6 +35,8 @@ module Puma
       @input = Queue.new
       @timeouts = []
       @block = block
+      @reactor_size = 0
+      @reactor_max = 0
     end
 
     # Run the internal select loop, using a background thread by default.
@@ -73,11 +81,15 @@ module Puma
           # Wakeup any registered object that receives incoming data.
           # Block until the earliest timeout or Selector#wakeup is called.
           timeout = (earliest = @timeouts.first) && earliest.timeout
-          @selector.select(timeout) {|mon| wakeup!(mon.value)}
+          monitor_wake_up = false
+          @selector.select(timeout) do |monitor|
+            monitor_wake_up = true
+            wakeup!(monitor.value)
+          end
 
           # Wakeup all objects that timed out.
-          timed_out = @timeouts.take_while {|t| t.timeout == 0}
-          timed_out.each { |c| wakeup! c }
+          timed_out = @timeouts.take_while { |client| client.timeout == 0 }
+          timed_out.each { |client| wakeup!(client) }
 
           unless @input.empty?
             until @input.empty?
@@ -94,7 +106,7 @@ module Puma
         # NoMethodError may be rarely raised when calling @selector.select, which
         # is odd.  Regardless, it may continue for thousands of calls if retried.
         # Also, when it raises, @selector.close also raises an error.
-        if NoMethodError === e
+        if !monitor_wake_up && NoMethodError === e
           close_selector = false
         else
           retry
@@ -108,6 +120,8 @@ module Puma
     # Start monitoring the object.
     def register(client)
       @selector.register(client.to_io, :r).value = client
+      @reactor_size += 1
+      @reactor_max = @reactor_size if @reactor_max < @reactor_size
       @timeouts << client
     rescue ArgumentError
       # unreadable clients raise error when processed by NIO
@@ -118,6 +132,7 @@ module Puma
     def wakeup!(client)
       if @block.call client
         @selector.deregister client.to_io
+        @reactor_size -= 1
         @timeouts.delete client
       end
     end

data/lib/puma/request.rb

@@ -52,6 +52,7 @@ module Puma
       io_buffer = client.io_buffer
       socket  = client.io   # io may be a MiniSSL::Socket
       app_body = nil
+      error = nil
 
       return false if closed_socket?(socket)
 
@@ -68,7 +69,7 @@ module Puma
       end
 
       env[HIJACK_P] = true
-      env[HIJACK] = client
+      env[HIJACK] = client.method :full_hijack
 
       env[RACK_INPUT] = client.body
       env[RACK_URL_SCHEME] ||= default_server_port(env) == PORT_443 ? HTTPS : HTTP
@@ -92,6 +93,7 @@ module Puma
       # array, we will invoke them when the request is done.
       #
       env[RACK_AFTER_REPLY] ||= []
+      env[RACK_RESPONSE_FINISHED] ||= []
 
       begin
         if @supported_http_methods == :any || @supported_http_methods.key?(env[REQUEST_METHOD])
@@ -119,15 +121,15 @@ module Puma
 
           return :async
         end
-      rescue ThreadPool::ForceShutdown => e
-        @log_writer.unknown_error e, client, "Rack app"
+      rescue ThreadPool::ForceShutdown => error
+        @log_writer.unknown_error error, client, "Rack app"
         @log_writer.log "Detected force shutdown of a thread"
 
-        status, headers, res_body = lowlevel_error(e, env, 503)
-      rescue Exception => e
-        @log_writer.unknown_error e, client, "Rack app"
+        status, headers, res_body = lowlevel_error(error, env, 503)
+      rescue Exception => error
+        @log_writer.unknown_error error, client, "Rack app"
 
-        status, headers, res_body = lowlevel_error(e, env, 500)
+        status, headers, res_body = lowlevel_error(error, env, 500)
       end
       prepare_response(status, headers, res_body, requests, client)
     ensure
@@ -144,6 +146,16 @@ module Puma
           end
         end
       end
+
+      if response_finished = env[RACK_RESPONSE_FINISHED]
+        response_finished.reverse_each do |o|
+          begin
+            o.call(env, status, headers, error)
+          rescue StandardError => e
+            @log_writer.debug_error e
+          end
+        end
+      end
     end
 
     # Assembles the headers and prepares the body for actually sending the
@@ -164,17 +176,7 @@ module Puma
       return false if closed_socket?(socket)
 
       # Close the connection after a reasonable number of inline requests
-      # 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 = 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
+      force_keep_alive = @enable_keep_alives && client.requests_served < @max_keep_alive
 
       resp_info = str_headers(env, status, headers, res_body, io_buffer, force_keep_alive)
 
@@ -267,7 +269,8 @@ module Puma
 
       fast_write_response socket, body, io_buffer, chunked, content_length.to_i
       body.close if close_body
-      keep_alive
+      # if we're shutting down, close keep_alive connections
+      !shutting_down? && keep_alive
     end
 
     # @param env [Hash] see Puma::Client#env, from request
@@ -478,7 +481,7 @@ module Puma
 
       # The legacy HTTP_VERSION header can be sent as a client header.
       # Rack v4 may remove using HTTP_VERSION.  If so, remove this line.
-      env[HTTP_VERSION] = env[SERVER_PROTOCOL]
+      env[HTTP_VERSION] = env[SERVER_PROTOCOL] if @env_set_http_version
     end
     private :normalize_env
 
@@ -585,7 +588,7 @@ module Puma
     #   response body
     # @param io_buffer [Puma::IOBuffer] modified inn place
     # @param force_keep_alive [Boolean] 'anded' with keep_alive, based on system
-    #   status and `@max_fast_inline`
+    #   status and `@max_keep_alive`
     # @return [Hash] resp_info
     # @version 5.0.3
     #
@@ -668,10 +671,10 @@ module Puma
         if ary
           ary.each do |v|
             next if illegal_header_value?(v)
-            io_buffer.append k, colon, v, line_ending
+            io_buffer.append k.downcase, colon, v, line_ending
           end
         else
-          io_buffer.append k, colon, line_ending
+          io_buffer.append k.downcase, colon, line_ending
         end
       end
 

data/lib/puma/runner.rb

@@ -33,7 +33,6 @@ module Puma
       @wakeup.write PIPE_WAKEUP unless @wakeup.closed?
 
     rescue SystemCallError, IOError
-      Puma::Util.purge_interrupt_queue
     end
 
     def development?
@@ -93,22 +92,6 @@ module Puma
       @control.binder.close_listeners if @control
     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
-        if defined?(RUBY_ENGINE_VERSION)
-          "#{RUBY_ENGINE} #{RUBY_ENGINE_VERSION} - ruby #{RUBY_VERSION}"
-        else
-          "#{RUBY_ENGINE} #{RUBY_VERSION}"
-        end
-      end
-    end
-
     def output_header(mode)
       min_t = @options[:min_threads]
       max_t = @options[:max_threads]
@@ -128,6 +111,14 @@ module Puma
       end
     end
 
+    def warn_ruby_mn_threads
+      return if !ENV.key?('RUBY_MN_THREADS')
+
+      log "! WARNING: Detected `RUBY_MN_THREADS=#{ENV['RUBY_MN_THREADS']}`"
+      log "! This setting is known to cause performance regressions with Puma."
+      log "! Consider disabling this environment variable: https://github.com/puma/puma/issues/3720"
+    end
+
     def redirected_io?
       @options[:redirect_stdout] || @options[:redirect_stderr]
     end

data/lib/puma/server.rb

@@ -12,14 +12,14 @@ require_relative 'client'
 require_relative 'binder'
 require_relative 'util'
 require_relative 'request'
+require_relative 'configuration'
 
 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)
+  # Add `Thread#puma_server` and `Thread#puma_server=`
+  Thread.attr_accessor(:puma_server)
 
   # The HTTP Server itself. Serves out a single Rack app.
   #
@@ -32,6 +32,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
 
@@ -77,6 +85,9 @@ module Puma
 
       @thread = nil
       @thread_pool = nil
+      @reactor = nil
+
+      @env_set_http_version = nil
 
       @options = if options.is_a?(UserFileDefaultOptions)
         options
@@ -94,11 +105,16 @@ 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]
 
+      if @options[:fiber_per_request]
+        singleton_class.prepend(FiberPerRequest)
+      end
+
       # make this a hash, since we prefer `key?` over `include?`
       @supported_http_methods =
         if @options[:supported_http_methods] == :any
@@ -114,7 +130,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 +181,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 +189,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 +209,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 +233,6 @@ module Puma
       @thread_pool&.spawned
     end
 
-
     # This number represents the number of requests that
     # the server is capable of taking right now.
     #
@@ -318,12 +330,16 @@ module Puma
     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
         pool = @thread_pool
         queue_requests = @queue_requests
         drain = options[:drain_on_shutdown] ? 0 : nil
+        max_flt = @max_threads.to_f
 
         addr_send_name, addr_value = case options[:remote_address]
         when :value
@@ -364,8 +380,20 @@ 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.
+                sleep 0.001 while pool.out_of_band_running
+
+                # only use delay when clustered and busy
+                if pool.busy_threads >= @max_threads
+                  if @clustered
+                    delay = 0.0001 * ((@reactor&.reactor_size || 0) + pool.busy_threads * 1.5)/max_flt
+                    sleep delay
+                  else
+                    # use small sleep for busy single worker
+                    sleep 0.0001
+                  end
+                end
 
                 io = begin
                   sock.accept_nonblock
@@ -447,14 +475,12 @@ module Puma
       # 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,39 +493,31 @@ module Puma
           client.finish(@first_data_timeout)
         end
 
-        while true
-          @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
+        @requests_count += 1
+        case handle_request(client, requests + 1)
+        when false
+        when :async
+          close_socket = false
+        when true
+          requests += 1
 
-            # 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
+          client.reset
 
-            next_request_ready = with_force_shutdown(client) do
-              client.reset(fast_check)
-            end
+          # 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
+            nil
+          end
 
-            unless next_request_ready
-              break unless @queue_requests
-              client.set_timeout @persistent_timeout
-              if @reactor.add client
-                close_socket = false
-                break
-              end
+          if next_request_ready
+            @thread_pool << client
+            close_socket = false
+          elsif @queue_requests
+            client.set_timeout @persistent_timeout
+            if @reactor.add client
+              close_socket = false
             end
           end
         end
@@ -514,7 +532,6 @@ module Puma
         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"
@@ -615,11 +632,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 +666,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 +685,16 @@ module Puma
       stats = @thread_pool&.stats || {}
       stats[:max_threads]    = @max_threads
       stats[:requests_count] = @requests_count
+      stats[:reactor_max] = @reactor.reactor_max
+      reset_max
       stats
     end
 
+    def reset_max
+      @reactor.reactor_max = 0
+      @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?