puma 7.2.2-java → 8.0.0-java

data/lib/puma/server.rb

@@ -11,7 +11,7 @@ require_relative 'reactor'
 require_relative 'client'
 require_relative 'binder'
 require_relative 'util'
-require_relative 'request'
+require_relative 'response'
 require_relative 'configuration'
 require_relative 'cluster_accept_loop_delay'
 
@@ -31,15 +31,15 @@ module Puma
   # Each `Puma::Server` will have one reactor and one thread pool.
   class Server
     module FiberPerRequest
-      def handle_request(client, requests)
+      def handle_request(processor, client, requests)
         Fiber.new do
           super
         end.resume
       end
     end
 
-    include Puma::Const
-    include Request
+    include Const
+    include Response
 
     attr_reader :options
     attr_reader :thread
@@ -51,7 +51,7 @@ module Puma
     # @todo the following may be deprecated in the future
     attr_reader :auto_trim_time, :early_hints, :first_data_timeout,
       :leak_stack_on_error,
-      :persistent_timeout, :reaping_time, :shutdown_body_timeout
+      :persistent_timeout, :reaping_time
 
     attr_accessor :app
     attr_accessor :binder
@@ -98,8 +98,6 @@ module Puma
       @early_hints               = @options[:early_hints]
       @first_data_timeout        = @options[:first_data_timeout]
       @persistent_timeout        = @options[:persistent_timeout]
-      @shutdown_body_timeout     = @options[:shutdown_body_timeout]
-      @shutdown_body_deadline    = nil
       @idle_timeout              = @options[:idle_timeout]
       @min_threads               = @options[:min_threads]
       @max_threads               = @options[:max_threads]
@@ -260,9 +258,10 @@ module Puma
       @events.fire :state, :booting
 
       @status = :run
-      @shutdown_body_deadline = nil
 
-      @thread_pool = ThreadPool.new(thread_name, options, server: self) { |client| process_client client }
+      @thread_pool = ThreadPool.new(thread_name, options, server: self) do |processor, client|
+        process_client(processor, client)
+      end
 
       if @queue_requests
         @reactor = Reactor.new(@io_selector_backend) { |c|
@@ -307,15 +306,12 @@ module Puma
     # The method checks to see if it has the full header and body with
     # the `Puma::Client#try_to_finish` method. If the full request has been sent,
     # then the request is passed to the ThreadPool (`@thread_pool << client`)
-    # so that a "worker thread" can pick up the request and begin to execute application logic.
+    # so that a "processor thread" can pick up the request and begin to execute application logic.
     # The Client is then removed from the reactor (return `true`).
     #
     # If a client object times out, a 408 response is written, its connection is closed,
     # and the object is removed from the reactor (return `true`).
     #
-    # If the request cannot be read, the Client is passed to the ThreadPool with its
-    # `reactor_error` set, so that a processor thread writes the error response.
-    #
     # If the Reactor is shutting down, all Clients are either timed out or passed to the
     # ThreadPool, depending on their current state (#can_close?).
     #
@@ -324,32 +320,17 @@ module Puma
     # will wake up and again be checked to see if it's ready to be passed to the thread pool.
     def reactor_wakeup(client)
       shutdown = !@queue_requests
-      read = client.bytes_read
-      if client.try_to_finish { shutdown_body_limit } || (shutdown && !client.can_close?)
-        hand_to_thread_pool client
+      if client.try_to_finish || (shutdown && !client.can_close?)
+        @thread_pool << client
       elsif shutdown || client.timeout == 0
         client.timeout!
       else
-        client.set_timeout(@first_data_timeout) if client.bytes_read > read
+        client.set_timeout(@first_data_timeout)
         false
       end
-    rescue ConnectionError, EOFError
-      close_client_safely(client)
-      true
     rescue StandardError => e
-      # Writing the error response may block on a client that is not reading,
-      # so leave it to a thread pool thread.
-      client.reactor_error = e
-      hand_to_thread_pool client
-    end
-
-    def hand_to_thread_pool(client)
-      @thread_pool << client
-      true
-    rescue ThreadError
-      true
-    rescue StandardError
-      close_client_safely client
+      client_error(e, client)
+      close_client_safely(client)
       true
     end
 
@@ -380,16 +361,13 @@ module Puma
             ios = IO.select sockets, nil, nil, (shutting_down? ? 0 : @idle_timeout)
             unless ios
               unless shutting_down?
+                @idle_timeout_reached = true
+
                 if @clustered
-                  unless @idle_timeout_reached
-                    @idle_timeout_reached = true
-                    @worker_write << "#{PipeRequest::PIPE_IDLE}#{Process.pid}\n" rescue nil
-                  end
+                  @worker_write << "#{PipeRequest::PIPE_IDLE}#{Process.pid}\n" rescue nil
                   next
                 else
-                  @idle_timeout_reached = true
                   @log_writer.log "- Idle timeout reached"
-                  shutdown_body_deadline
                   @status = :stop
                 end
               end
@@ -423,11 +401,9 @@ module Puma
                   sock.accept_nonblock
                 rescue IO::WaitReadable
                   next
-                rescue Errno::EMFILE, Errno::ENFILE, Errno::ENOBUFS, Errno::ENOMEM => e
-                  accept_resource_error e
-                  next
                 end
                 drain += 1 if shutting_down?
+
                 client = new_client(io, sock)
                 client.send(addr_send_name, addr_value) if addr_value
                 pool << client
@@ -437,17 +413,11 @@ module Puma
             # In the case that any of the sockets are unexpectedly close.
             raise
           rescue StandardError => e
-            begin
-              @log_writer.unknown_error e, nil, "Listen loop"
-            rescue StandardError
-            end
+            @log_writer.unknown_error e, nil, "Listen loop"
           end
         end
 
-        begin
-          @log_writer.debug "Drained #{drain} additional connections." if drain
-        rescue StandardError
-        end
+        @log_writer.debug "Drained #{drain} additional connections." if drain
         @events.fire :state, @status
 
         if queue_requests
@@ -457,10 +427,7 @@ module Puma
 
         graceful_shutdown if @status == :stop || @status == :restart
       rescue Exception => e
-        begin
-          @log_writer.unknown_error e, nil, "Exception handling servers"
-        rescue StandardError
-        end
+        @log_writer.unknown_error e, nil, "Exception handling servers"
       ensure
         # Errno::EBADF is infrequently raised
         [@check, @notify].each do |io|
@@ -480,7 +447,9 @@ module Puma
     def new_client(io, sock)
       client = Client.new(io, @binder.env(sock))
       client.listener = sock
+      client.env_set_http_version = @env_set_http_version
       client.http_content_length_limit = @http_content_length_limit
+      client.supported_http_methods = @supported_http_methods
       client
     end
 
@@ -490,14 +459,12 @@ module Puma
 
       case cmd
       when STOP_COMMAND
-        shutdown_body_deadline
         @status = :stop
         return true
       when HALT_COMMAND
         @status = :halt
         return true
       when RESTART_COMMAND
-        shutdown_body_deadline
         @status = :restart
         return true
       end
@@ -508,22 +475,20 @@ module Puma
     # Given a connection on +client+, handle the incoming requests,
     # or queue the connection in the Reactor if no request is available.
     #
-    # This method is called from a ThreadPool worker thread.
+    # This method is called from a ThreadPool processor thread.
     #
     # This method supports HTTP Keep-Alive so it may, depending on if the client
     # indicates that it supports keep alive, wait for another request before
     # returning.
     #
     # Return true if one or more requests were processed.
-    def process_client(client)
+    def process_client(processor, client)
       close_socket = true
 
       requests = 0
 
       begin
-        raise client.reactor_error if client.reactor_error
-
-        if @queue_requests && !client.eagerly_finish { shutdown_body_limit }
+        if @queue_requests && !client.eagerly_finish
 
           client.set_timeout(@first_data_timeout)
           if @reactor.add client
@@ -533,14 +498,14 @@ module Puma
         end
 
         with_force_shutdown(client) do
-          client.finish(@first_data_timeout) { shutdown_body_limit }
+          client.finish(@first_data_timeout)
         end
 
         can_loop = true
         while can_loop
           can_loop = false
           @requests_count += 1
-          case handle_request(client, requests + 1)
+          case handle_request(processor, client, requests + 1)
           when :close
           when :async
             close_socket = false
@@ -554,7 +519,7 @@ module Puma
             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 { shutdown_body_limit } }
+              with_force_shutdown(client) { client.eagerly_finish }
             end
 
             if next_request_ready
@@ -586,25 +551,6 @@ module Puma
       end
     end
 
-    # Accepting fails while the process is out of file descriptors or memory.
-    # The connection stays in the backlog, so retrying at once would spin and
-    # log at full speed. Wait briefly and log at most once per second.
-    def accept_resource_error(error)
-      now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      if @accept_error_logged_at.nil? || now - @accept_error_logged_at >= 1
-        suffix = @accept_errors_suppressed.to_i > 0 ? " (#{@accept_errors_suppressed} more suppressed)" : ""
-        @accept_error_logged_at = now
-        @accept_errors_suppressed = 0
-        begin
-          @log_writer.unknown_error error, nil, "Listen loop#{suffix}"
-        rescue StandardError
-        end
-      else
-        @accept_errors_suppressed += 1
-      end
-      sleep ACCEPT_ERROR_DELAY
-    end
-
     # :nodoc:
     def close_client_safely(client)
       client.close
@@ -636,7 +582,7 @@ module Puma
         lowlevel_error(e, client.env)
         @log_writer.ssl_error e, client.io
       when HttpParserError
-        response_to_error(client, requests, e, 400)
+        response_to_error(client, requests, e, client.error_status_code || 400)
         @log_writer.parse_error e, client
       when HttpParserError501
         response_to_error(client, requests, e, 501)
@@ -669,50 +615,27 @@ module Puma
     end
 
     def response_to_error(client, requests, err, status_code)
-      status, headers, res_body = lowlevel_error(err, client.env, status_code)
+      # @todo remove sometime later
+      if status_code == 413
+        status = 413
+        res_body = ["Payload Too Large"]
+        headers = {}
+        headers[CONTENT_LENGTH2] = 17
+      else
+        status, headers, res_body = lowlevel_error(err, client.env, status_code)
+      end
       prepare_response(status, headers, res_body, requests, client)
     end
     private :response_to_error
 
-    def shutdown_body_deadline
-      @shutdown_body_deadline ||= Process.clock_gettime(Process::CLOCK_MONOTONIC) + @shutdown_body_timeout
-    end
-
-    def shutdown_body_limit
-      @shutdown_body_deadline
-    end
-
     # Wait for all outstanding requests to finish.
     #
     def graceful_shutdown
-      shutdown_body_deadline
-
-      if options[:shutdown_debug]
-        threads = Thread.list
-        total = threads.size
-
-        pid = Process.pid
-
-        $stdout.syswrite "#{pid}: === Begin thread backtrace dump ===\n"
-
-        threads.each_with_index do |t,i|
-          $stdout.syswrite "#{pid}: Thread #{i+1}/#{total}: #{t.inspect}\n"
-          $stdout.syswrite "#{pid}: #{t.backtrace.join("\n#{pid}: ")}\n\n"
-        end
-        $stdout.syswrite "#{pid}: === End thread backtrace dump ===\n"
-      end
-
       if @status != :restart
         @binder.close
       end
 
-      if @thread_pool
-        if timeout = options[:force_shutdown_after]
-          @thread_pool.shutdown timeout.to_f
-        else
-          @thread_pool.shutdown
-        end
-      end
+      @thread_pool.shutdown(options[:force_shutdown_after])
     end
 
     def notify_safely(message)
@@ -729,11 +652,10 @@ module Puma
     end
     private :notify_safely
 
-    # Stops the acceptor thread and then causes the worker threads to finish
+    # Stops the acceptor thread and then causes the processor threads to finish
     # off the request queue before finally exiting.
 
     def stop(sync=false)
-      shutdown_body_deadline
       notify_safely(STOP_COMMAND)
       @thread.join if @thread && sync
     end
@@ -744,7 +666,6 @@ module Puma
     end
 
     def begin_restart(sync=false)
-      shutdown_body_deadline
       notify_safely(RESTART_COMMAND)
       @thread.join if @thread && sync
     end
@@ -801,6 +722,49 @@ module Puma
       @binder.add_unix_listener path, umask, mode, backlog
     end
 
+    # Updates the minimum and maximum number of threads in the thread pool.
+    #
+    # This method allows dynamic adjustment of the thread pool size while the server
+    # is running. It validates the provided values and updates both the thread pool
+    # and the server's thread configuration.
+    #
+    # @param min [Integer] The minimum number of threads to maintain in the pool.
+    #   Defaults to the current minimum if not specified. Must be greater than 0
+    #   and less than or equal to max.
+    # @param max [Integer] The maximum number of threads allowed in the pool.
+    #   Defaults to the current maximum if not specified. Must be greater than or
+    #   equal to min.
+    #
+    # @return [void]
+    #
+    # @note If validation fails, a warning message is logged and no changes are made.
+    #
+    # @example Update both min and max threads
+    #   server.update_thread_pool_min_max(min: 2, max: 8)
+    #
+    # @example Update only the minimum threads
+    #   server.update_thread_pool_min_max(min: 4)
+    #
+    # @example Update only the maximum threads
+    #   server.update_thread_pool_min_max(max: 16)
+    #
+    def update_thread_pool_min_max(min: @min_threads, max: @max_threads)
+      if min > max
+        @log_writer.log "`min' value cannot be greater than `max' value."
+        return
+      end
+
+      if min < 0
+        @log_writer.log "`min' value cannot be less than 0"
+        return
+      end
+
+      @thread_pool&.with_mutex do
+        @thread_pool.min, @thread_pool.max = min, max
+        @min_threads, @max_threads = min, max
+      end
+    end
+
     # @!attribute [r] connected_ports
     def connected_ports
       @binder.connected_ports

data/lib/puma/server_plugin_control.rb

@@ -0,0 +1,32 @@
+module Puma
+  # ServerPluginControl provides a control interface for server plugins to
+  # interact with and manage server settings dynamically.
+  #
+  # This class acts as a facade between plugins and the Puma server,
+  # allowing plugins to safely modify server configuration and thread pool
+  # settings without direct access to the server's internal state.
+  #
+  class ServerPluginControl
+    def initialize(server)
+      @server = server
+    end
+
+    # Returns the maximum number of threads in the thread pool.
+    def max_threads
+      @server.max_threads
+    end
+
+    # Returns the minimum number of threads in the thread pool.
+    def min_threads
+      @server.min_threads
+    end
+
+    # Updates the minimum and maximum number of threads in the thread pool.
+    #
+    # @see Puma::Server#update_thread_pool_min_max
+    #
+    def update_thread_pool_min_max(min: max_threads, max: min_threads)
+      @server.update_thread_pool_min_max(min: min, max: max)
+    end
+  end
+end