puma 6.0.0-java → 6.0.1-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 207c639db6488ca310a34b3a36e3aad929e0092d51cae794c20b538e632387e0
-  data.tar.gz: aec4cb5abd8bd5ca672c4b8a277b80f922fe40ddc68abee0163c95e1d7f77361
+  metadata.gz: e45008f77ad673f462f748ef13f66208d1bb4653e961fb8195b0a03e075ba926
+  data.tar.gz: 18c15bbe55e9f64494f1913ac06d596ec86c6cf6fd60c05adab69731cfb0618e
 SHA512:
-  metadata.gz: 03d26c6cceb420d1b97b360d690c1d742c290c47b28e2f19bd121ffe8c3cc36fc7c081ea26a2c78c27e40243237b53358fd23ec829a4a3c669013ca4d8b2a49e
-  data.tar.gz: 286b9ea43b67608f73f55959e2e1c82dd5d56639c07117aaa4481d067a60a3b63199cf7dd5b540bb1754d0fe5acb12183cb5b26361c040d653615e84c80127c2
+  metadata.gz: 44cc45bbeee1c85a073e8739a7549786892f5743749d0e05cabeafb0a2bdba109ebb9230205495803f0a43e836a6a36899e8f82f3628a09759d060c697f19f87
+  data.tar.gz: cac44e115f618a71edac4f857f273b3d4906572c9f783202c5909bf01249b6f192797904e91a82cb70431731f1d1b6bdc99cd44567b12df75bf11a58aa1ca91a

data/History.md

@@ -1,4 +1,13 @@
-## 6.0.0 / 2022-10-XX
+## 6.0.1 / 2022-12-12
+ 
+* Bugfixes
+  * Handle waking up a closed selector in Reactor#add ([#3005])
+  * Fixup response processing, enumerable bodies ([#3004], [#3000])
+  * Correctly close app body for all code paths ([#3002], [#2999])
+* Refactor 
+  * Add IOBuffer to Client, remove from ThreadPool thread instances ([#3013])
+
+## 6.0.0 / 2022-10-14
 
 * Breaking Changes
   * Dropping Ruby 2.2 and 2.3 support (now 2.4+) ([#2919])
@@ -9,6 +18,9 @@
   * Prefix all environment variables with `PUMA_` ([#2924], [#2853])
   * Removed some constants ([#2957], [#2958], [#2959], [#2960])
   * The following classes are now part of Puma's private API: `Client`, `Cluster::Worker`, `Cluster::Worker`, `HandleRequest`. ([#2988])
+  * Configuration constants like `DefaultRackup` removed ([#2928])
+  * Extracted `LogWriter` from `Events` ([#2798])
+  * Only accept the standard 8 HTTP methods, others rejected with 501. ([#2932])
 
 * Features
   * Increase throughput on large (100kb+) response bodies by 3-10x ([#2896], [#2892])
@@ -34,7 +46,6 @@
 
 * Refactor
   * log_writer.rb - add internal_write method ([#2888])
-  * [WIP] Refactor: Split out LogWriter from Events (no logic change) ([#2798])
   * Extract prune_bundler code into it's own class. ([#2797])
   * Refactor Launcher#run to increase readability (no logic change) ([#2795])
   * Ruby 3.2 will have native IO#wait_* methods, don't require io/wait ([#2903])
@@ -1915,6 +1926,12 @@ be added back in a future date when a java Puma::MiniSSL is added.
 * Bugfixes
   * Your bugfix goes here <Most recent on the top, like GitHub> (#Github Number)
 
+[#3005]:https://github.com/puma/puma/pull/3005     "PR by @JuanitoFatas, merged 2022-11-04"
+[#3013]:https://github.com/puma/puma/pull/3013     "PR by @MSP-Greg, merged 2022-11-13"
+[#3004]:https://github.com/puma/puma/pull/3004     "PR by @MSP-Greg, merged 2022-11-24"
+[#3000]:https://github.com/puma/puma/issues/3000   "Issue by @dentarg, closed 2022-11-24"
+[#3002]:https://github.com/puma/puma/pull/3002     "PR by @MSP-Greg, merged 2022-11-03"
+[#2999]:https://github.com/puma/puma/issues/2999   "Issue by @aymeric-ledorze, closed 2022-11-03"
 [#2919]:https://github.com/puma/puma/pull/2919     "PR by @MSP-Greg, merged 2022-08-30"
 [#2652]:https://github.com/puma/puma/issues/2652   "Issue by @Roguelazer, closed 2022-09-04"
 [#2653]:https://github.com/puma/puma/pull/2653     "PR by @Roguelazer, closed 2022-03-07"
@@ -1928,7 +1945,10 @@ be added back in a future date when a java Puma::MiniSSL is added.
 [#2958]:https://github.com/puma/puma/pull/2958     "PR by @JuanitoFatas, merged 2022-09-16"
 [#2959]:https://github.com/puma/puma/pull/2959     "PR by @JuanitoFatas, merged 2022-09-16"
 [#2960]:https://github.com/puma/puma/pull/2960     "PR by @JuanitoFatas, merged 2022-09-16"
-[#2988]:https://github.com/puma/puma/issues/2988   "Issue by @MSP-Greg, merged 2022-10-12"
+[#2988]:https://github.com/puma/puma/pull/2988     "PR by @MSP-Greg, merged 2022-10-12"
+[#2928]:https://github.com/puma/puma/pull/2928     "PR by @nateberkopec, merged 2022-09-10"
+[#2798]:https://github.com/puma/puma/pull/2798     "PR by @johnnyshields, merged 2022-02-05"
+[#2932]:https://github.com/puma/puma/pull/2932     "PR by @mrzasa, merged 2022-09-12"
 [#2896]:https://github.com/puma/puma/pull/2896     "PR by @MSP-Greg, merged 2022-09-13"
 [#2892]:https://github.com/puma/puma/pull/2892     "PR by @guilleiguaran, closed 2022-09-13"
 [#2923]:https://github.com/puma/puma/pull/2923     "PR by @nateberkopec, merged 2022-09-09"
@@ -1949,11 +1969,9 @@ be added back in a future date when a java Puma::MiniSSL is added.
 [#2904]:https://github.com/puma/puma/pull/2904     "PR by @kares, merged 2022-08-27"
 [#2884]:https://github.com/puma/puma/pull/2884     "PR by @kares, merged 2022-05-30"
 [#2897]:https://github.com/puma/puma/pull/2897     "PR by @Edouard-chin, merged 2022-08-27"
-[#2932]:https://github.com/puma/puma/pull/2932     "PR by @mrzasa, merged 2022-09-12"
 [#1441]:https://github.com/puma/puma/issues/1441   "Issue by @nirvdrum, closed 2022-09-12"
 [#2956]:https://github.com/puma/puma/pull/2956     "PR by @MSP-Greg, merged 2022-09-15"
 [#2888]:https://github.com/puma/puma/pull/2888     "PR by @MSP-Greg, merged 2022-06-01"
-[#2798]:https://github.com/puma/puma/pull/2798     "PR by @johnnyshields, merged 2022-02-05"
 [#2797]:https://github.com/puma/puma/pull/2797     "PR by @johnnyshields, merged 2022-02-01"
 [#2795]:https://github.com/puma/puma/pull/2795     "PR by @johnnyshields, merged 2022-01-31"
 [#2903]:https://github.com/puma/puma/pull/2903     "PR by @MSP-Greg, merged 2022-08-27"

data/docs/nginx.md

@@ -2,7 +2,7 @@
 
 This is a very common setup using an upstream. It was adapted from some Capistrano recipe I found on the Internet a while ago.
 
-```
+```nginx
 upstream myapp {
   server unix:///myapp/tmp/puma.sock;
 }

data/lib/puma/client.rb

@@ -9,6 +9,7 @@ class IO
 end
 
 require_relative 'detect'
+require_relative 'io_buffer'
 require 'tempfile'
 require 'forwardable'
 
@@ -65,6 +66,7 @@ module Puma
     def initialize(io, env=nil)
       @io = io
       @to_io = io.to_io
+      @io_buffer = IOBuffer.new
       @proto_env = env
       @env = env ? env.dup : nil
 
@@ -96,7 +98,7 @@ module Puma
     end
 
     attr_reader :env, :to_io, :body, :io, :timeout_at, :ready, :hijacked,
-                :tempfile
+                :tempfile, :io_buffer
 
     attr_writer :peerip
 
@@ -138,6 +140,7 @@ module Puma
 
     def reset(fast_check=true)
       @parser.reset
+      @io_buffer.reset
       @read_header = true
       @read_proxy = !!@expect_proxy_proto
       @env = @proto_env.dup

data/lib/puma/const.rb

@@ -100,7 +100,7 @@ module Puma
   # too taxing on performance.
   module Const
 
-    PUMA_VERSION = VERSION = "6.0.0".freeze
+    PUMA_VERSION = VERSION = "6.0.1".freeze
     CODE_NAME = "Sunflower".freeze
 
     PUMA_SERVER_STRING = ['puma', PUMA_VERSION, CODE_NAME].join(' ').freeze

data/lib/puma/dsl.rb

@@ -250,6 +250,7 @@ module Puma
     #
     # * Set the socket backlog depth with +backlog+, default is 1024.
     # * Set up an SSL certificate with +key+ & +cert+.
+    # * Set up an SSL certificate for mTLS with +key+, +cert+, +ca+ and +verify_mode+.
     # * Set whether to optimize for low latency instead of throughput with
     #   +low_latency+, default is to not optimize for low latency. This is done
     #   via +Socket::TCP_NODELAY+.
@@ -259,6 +260,8 @@ module Puma
     #   bind 'unix:///var/run/puma.sock?backlog=512'
     # @example SSL cert
     #   bind 'ssl://127.0.0.1:9292?key=key.key&cert=cert.pem'
+    # @example SSL cert for mutual TLS (mTLS)
+    #   bind 'ssl://127.0.0.1:9292?key=key.key&cert=cert.pem&ca=ca.pem&verify_mode=force_peer'
     # @example Disable optimization for low latency
     #   bind 'tcp://0.0.0.0:9292?low_latency=false'
     # @example Socket permissions

data/lib/puma/io_buffer.rb

@@ -22,6 +22,16 @@ module Puma
       read
     end
 
+    # Read & Reset - returns contents and resets
+    # @return [String] StringIO contents
+    def read_and_reset
+      rewind
+      str = read
+      truncate 0
+      rewind
+      str
+    end
+
     alias_method :clear, :reset
 
     # before Ruby 2.5, `write` would only take one argument

data/lib/puma/reactor.rb

@@ -50,7 +50,7 @@ module Puma
       @input << client
       @selector.wakeup
       true
-    rescue ClosedQueueError
+    rescue ClosedQueueError, IOError # Ignore if selector is already closed
       false
     end
 

data/lib/puma/request.rb

@@ -14,15 +14,18 @@ module Puma
   #
   module Request # :nodoc:
 
-    # determines whether to write body to io_buffer first, or straight to socket
-    # also fixes max size of chunked body read when bosy is an IO.
-    BODY_LEN_MAX   = 1_024 * 256
+    # Single element array body: smaller bodies are written to io_buffer first,
+    # then a single write from io_buffer. Larger sizes are written separately.
+    # Also fixes max size of chunked file body read.
+    BODY_LEN_MAX = 1_024 * 256
 
-    # size divide for using copy_stream on body
+    # File body: smaller bodies are combined with io_buffer, then written to
+    # socket.  Larger bodies are written separately using `copy_stream`
     IO_BODY_MAX = 1_024 * 64
 
-    # max size for io_buffer, force write when exceeded
-    IO_BUFFER_LEN_MAX = 1_024 * 1_024 * 4
+    # Array body: elements are collected in io_buffer.  When io_buffer's size
+    # exceeds value, they are written to the socket.
+    IO_BUFFER_LEN_MAX = 1_024 * 512
 
     SOCKET_WRITE_ERR_MSG = "Socket timeout writing data"
 
@@ -41,13 +44,14 @@ module Puma
     #
     # Finally, it'll return +true+ on keep-alive connections.
     # @param client [Puma::Client]
-    # @param io_buffer [Puma::IOBuffer]
     # @param requests [Integer]
     # @return [Boolean,:async]
     #
-    def handle_request(client, io_buffer, requests)
+    def handle_request(client, requests)
       env = client.env
+      io_buffer = client.io_buffer
       socket  = client.io   # io may be a MiniSSL::Socket
+      app_body = nil
 
       return false if closed_socket?(socket)
 
@@ -85,14 +89,18 @@ module Puma
 
       begin
         if SUPPORTED_HTTP_METHODS.include?(env[REQUEST_METHOD])
-          status, headers, res_body = @thread_pool.with_force_shutdown do
+          status, headers, app_body = @thread_pool.with_force_shutdown do
             @app.call(env)
           end
         else
           @log_writer.log "Unsupported HTTP method used: #{env[REQUEST_METHOD]}"
-          status, headers, res_body = [501, {}, ["#{env[REQUEST_METHOD]} method is not supported"]]
+          status, headers, app_body = [501, {}, ["#{env[REQUEST_METHOD]} method is not supported"]]
         end
 
+        # app_body needs to always be closed, hold value in case lowlevel_error
+        # is called
+        res_body = app_body
+
         return :async if client.hijacked
 
         status = status.to_i
@@ -114,60 +122,83 @@ module Puma
 
         status, headers, res_body = lowlevel_error(e, env, 500)
       end
-      prepare_response(status, headers, res_body, io_buffer, requests, client)
+      prepare_response(status, headers, res_body, requests, client)
+    ensure
+      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?
     end
 
     # Assembles the headers and prepares the body for actually sending the
-    # response via #fast_write_response.
+    # response via `#fast_write_response`.
     #
     # @param status [Integer] the status returned by the Rack application
     # @param headers [Hash] the headers returned by the Rack application
-    # @param app_body [Array] the body returned by the Rack application or
-    #   a call to `lowlevel_error`
-    # @param io_buffer [Puma::IOBuffer] modified in place
+    # @param res_body [Array] the body returned by the Rack application or
+    #   a call to `Server#lowlevel_error`
     # @param requests [Integer] number of inline requests handled
     # @param client [Puma::Client]
-    # @return [Boolean,:async]
-    def prepare_response(status, headers, app_body, io_buffer, requests, client)
+    # @return [Boolean,:async] keep-alive status or `:async`
+    def prepare_response(status, headers, res_body, requests, client)
       env = client.env
-      socket  = client.io
-
-      after_reply = env[RACK_AFTER_REPLY] || []
+      socket = client.io
+      io_buffer = client.io_buffer
 
       return false if closed_socket?(socket)
 
-      resp_info = str_headers(env, status, headers, app_body, io_buffer, requests, client)
+      # 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 = requests < @max_fast_inline ||
+        @thread_pool.busy_threads < @max_threads ||
+        !client.listener.to_io.wait_readable(0)
+
+      resp_info = str_headers(env, status, headers, res_body, io_buffer, force_keep_alive)
+
+      close_body = false
 
       # below converts app_body into body, dependent on app_body's characteristics, and
       # resp_info[:content_length] will be set if it can be determined
       if !resp_info[:content_length] && !resp_info[:transfer_encoding] && status != 204
-        if app_body.respond_to?(:to_ary)
-          length = 0
-          if array_body = app_body.to_ary
-            body = array_body.map { |part| length += part.bytesize; part }
-          elsif app_body.is_a?(::File) && app_body.respond_to?(:size)
-            length = app_body.size
-          elsif app_body.respond_to?(:each)
-            body = []
-            app_body.each { |part| length += part.bytesize; body << part }
-          end
-          resp_info[:content_length] = length
-        elsif app_body.is_a?(File) && app_body.respond_to?(:size)
-          resp_info[:content_length] = app_body.size
-          body = app_body
-        elsif app_body.respond_to?(:to_path) && app_body.respond_to?(:each) &&
-            File.readable?(fn = app_body.to_path)
+        if res_body.respond_to?(:to_ary) && (array_body = res_body.to_ary)
+          body = array_body
+          resp_info[:content_length] = body.sum(&:bytesize)
+        elsif res_body.is_a?(File) && res_body.respond_to?(:size)
+          body = res_body
+          resp_info[:content_length] = body.size
+        elsif res_body.respond_to?(:to_path) && res_body.respond_to?(:each) &&
+            File.readable?(fn = res_body.to_path)
           body = File.open fn, 'rb'
           resp_info[:content_length] = body.size
+          close_body = true
         else
-          body = app_body
+          body = res_body
         end
-      elsif !app_body.is_a?(::File) && app_body.respond_to?(:to_path) && app_body.respond_to?(:each) &&
-          File.readable?(fn = app_body.to_path)
+      elsif !res_body.is_a?(::File) && res_body.respond_to?(:to_path) && res_body.respond_to?(:each) &&
+          File.readable?(fn = res_body.to_path)
         body = File.open fn, 'rb'
         resp_info[:content_length] = body.size
+        close_body = true
+      elsif !res_body.is_a?(::File) && res_body.respond_to?(:filename) && res_body.respond_to?(:each) &&
+          res_body.respond_to?(:bytesize) && File.readable?(fn = res_body.filename)
+        # Sprockets::Asset
+        resp_info[:content_length] = res_body.bytesize unless resp_info[:content_length]
+        if res_body.to_hash[:source]   # use each to return @source
+          body = res_body
+        else                           # avoid each and use a File object
+          body = File.open fn, 'rb'
+          close_body = true
+        end
       else
-        body = app_body
+        body = res_body
       end
 
       line_ending = LINE_END
@@ -175,8 +206,8 @@ module Puma
       content_length = resp_info[:content_length]
       keep_alive     = resp_info[:keep_alive]
 
-      if app_body && !app_body.respond_to?(:each)
-        response_hijack = app_body
+      if res_body && !res_body.respond_to?(:each)
+        response_hijack = res_body
       else
         response_hijack = resp_info[:response_hijack]
       end
@@ -189,7 +220,8 @@ module Puma
         end
 
         io_buffer << LINE_END
-        fast_write_str socket, io_buffer.to_s
+        fast_write_str socket, io_buffer.read_and_reset
+        socket.flush
         return keep_alive
       end
       if content_length
@@ -203,25 +235,14 @@ module Puma
       io_buffer << line_ending
 
       if response_hijack
-        fast_write_str socket, io_buffer.to_s
+        fast_write_str socket, io_buffer.read_and_reset
         response_hijack.call socket
         return :async
       end
 
       fast_write_response socket, body, io_buffer, chunked, content_length.to_i
+      body.close if close_body
       keep_alive
-    ensure
-      io_buffer.reset
-      resp_info = nil
-      uncork_socket socket
-      app_body.close if app_body.respond_to? :close
-      client.tempfile&.unlink
-
-      begin
-        after_reply.each { |o| o.call }
-      rescue StandardError => e
-        @log_writer.debug_error e
-      end unless after_reply.empty?
     end
 
     # @param env [Hash] see Puma::Client#env, from request
@@ -237,10 +258,10 @@ module Puma
 
     # Used to write 'early hints', 'no body' responses, 'hijacked' responses,
     # and body segments (called by `fast_write_response`).
-    # Writes a string to an io (normally `Client#io`) using `write_nonblock`.
+    # Writes a string to a socket (normally `Client#io`) using `write_nonblock`.
     # Large strings may not be written in one pass, especially if `io` is a
     # `MiniSSL::Socket`.
-    # @param io [#write_nonblock] the io to write to
+    # @param socket [#write_nonblock] the request/response socket
     # @param str [String] the string written to the io
     # @raise [ConnectionError]
     #
@@ -249,7 +270,7 @@ module Puma
       byte_size = str.bytesize
       while n < byte_size
         begin
-          n += socket.syswrite(n.zero? ? str : str.byteslice(n..-1))
+          n += socket.write_nonblock(n.zero? ? str : str.byteslice(n..-1))
         rescue Errno::EAGAIN, Errno::EWOULDBLOCK
           unless socket.wait_writable WRITE_TIMEOUT
             raise ConnectionError, SOCKET_WRITE_ERR_MSG
@@ -267,39 +288,41 @@ module Puma
     # @param socket [#write] the response socket
     # @param body [Enumerable, File] the body object
     # @param io_buffer [Puma::IOBuffer] contains headers
-    # @param chunk [Boolean]
+    # @param chunked [Boolean]
+    # @paramn content_length [Integer
     # @raise [ConnectionError]
     #
     def fast_write_response(socket, body, io_buffer, chunked, content_length)
-      if body.is_a?(::File) || body.respond_to?(:read) || body.respond_to?(:readpartial)
+      if body.is_a?(::File) && body.respond_to?(:read)
         if chunked  # would this ever happen?
           while part = body.read(BODY_LEN_MAX)
             io_buffer.append part.bytesize.to_s(16), LINE_END, part, LINE_END
           end
-          io_buffer << CLOSE_CHUNKED
-          fast_write_str socket, io_buffer.to_s
+          fast_write_str socket, CLOSE_CHUNKED
         else
           if content_length <= IO_BODY_MAX
-            io_buffer.write body.sysread(content_length)
-            fast_write_str socket, io_buffer.to_s
+            io_buffer.write body.read(content_length)
+            fast_write_str socket, io_buffer.read_and_reset
           else
-            fast_write_str socket, io_buffer.to_s
+            fast_write_str socket, io_buffer.read_and_reset
             IO.copy_stream body, socket
           end
         end
-        body.close
       elsif body.is_a?(::Array) && body.length == 1
-        body_first = body.first
-        if body_first.is_a?(::String) && body_first.bytesize >= BODY_LEN_MAX
+        body_first = nil
+        # using body_first = body.first causes issues?
+        body.each { |str| body_first ||= str }
+
+        if body_first.is_a?(::String) && body_first.bytesize < BODY_LEN_MAX
+          # smaller body, write to io_buffer first
+          io_buffer.write body_first
+          fast_write_str socket, io_buffer.read_and_reset
+        else
           # large body, write both header & body to socket
-          fast_write_str socket, io_buffer.to_s
+          fast_write_str socket, io_buffer.read_and_reset
           fast_write_str socket, body_first
-        else
-          # smaller body, write to stream first
-          io_buffer.write body_first
-          fast_write_str socket, io_buffer.to_s
         end
-      else
+      elsif body.is_a?(::Array)
         # for array bodies, flush io_buffer to socket when size is greater than
         # IO_BUFFER_LEN_MAX
         if chunked
@@ -307,8 +330,7 @@ module Puma
             next if (byte_size = part.bytesize).zero?
             io_buffer.append byte_size.to_s(16), LINE_END, part, LINE_END
             if io_buffer.length > IO_BUFFER_LEN_MAX
-              fast_write_str socket, io_buffer.to_s
-              io_buffer.reset
+              fast_write_str socket, io_buffer.read_and_reset
             end
           end
           io_buffer.write CLOSE_CHUNKED
@@ -317,13 +339,31 @@ module Puma
             next if part.bytesize.zero?
             io_buffer.write part
             if io_buffer.length > IO_BUFFER_LEN_MAX
-              fast_write_str socket, io_buffer.to_s
-              io_buffer.reset
+              fast_write_str socket, io_buffer.read_and_reset
             end
           end
         end
-        fast_write_str(socket, io_buffer.to_s) unless io_buffer.length.zero?
+        # may write last body part for non-chunked, also headers if array is empty
+        fast_write_str(socket, io_buffer.read_and_reset) unless io_buffer.length.zero?
+      else
+        # for enum bodies
+        fast_write_str socket, io_buffer.read_and_reset
+        if chunked
+          body.each do |part|
+            next if (byte_size = part.bytesize).zero?
+             fast_write_str socket, (byte_size.to_s(16) << LINE_END)
+             fast_write_str socket, part
+             fast_write_str socket, LINE_END
+          end
+          fast_write_str socket, CLOSE_CHUNKED
+        else
+          body.each do |part|
+            next if part.bytesize.zero?
+            fast_write_str socket, part
+          end
+        end
       end
+      socket.flush
     rescue Errno::EAGAIN, Errno::EWOULDBLOCK
       raise ConnectionError, SOCKET_WRITE_ERR_MSG
     rescue  Errno::EPIPE, SystemCallError, IOError
@@ -496,12 +536,13 @@ module Puma
     # @param content_length [Integer,nil] content length if it can be determined from the
     #   response body
     # @param io_buffer [Puma::IOBuffer] modified inn place
-    # @param requests [Integer] number of inline requests handled
-    # @param client [Puma::Client]
+    # @param force_keep_alive [Boolean] 'anded' with keep_alive, based on system
+    #   status and `@max_fast_inline`
     # @return [Hash] resp_info
     # @version 5.0.3
     #
-    def str_headers(env, status, headers, res_body, io_buffer, requests, client)
+    def str_headers(env, status, headers, res_body, io_buffer, force_keep_alive)
+
       line_ending = LINE_END
       colon = COLON
 
@@ -544,13 +585,8 @@ module Puma
       # if running without request queueing
       resp_info[:keep_alive] &&= @queue_requests
 
-      # 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.
-      resp_info[:keep_alive] &&= requests < @max_fast_inline ||
-        @thread_pool.busy_threads < @max_threads ||
-        !client.listener.to_io.wait_readable(0)
+      # see prepare_response
+      resp_info[:keep_alive] &&= force_keep_alive
 
       resp_info[:response_hijack] = nil
 
@@ -560,7 +596,8 @@ module Puma
         case k.downcase
         when CONTENT_LENGTH2
           next if illegal_header_value?(vs)
-          resp_info[:content_length] = vs
+          # nil.to_i is 0, nil&.to_i is nil
+          resp_info[:content_length] = vs&.to_i
           next
         when TRANSFER_ENCODING
           resp_info[:allow_chunked] = false

data/lib/puma/server.rb

@@ -11,7 +11,6 @@ require_relative 'reactor'
 require_relative 'client'
 require_relative 'binder'
 require_relative 'util'
-require_relative 'io_buffer'
 require_relative 'request'
 
 require 'socket'
@@ -230,7 +229,7 @@ module Puma
 
       @status = :run
 
-      @thread_pool = ThreadPool.new(thread_name, @options) { |a, b| process_client a, b }
+      @thread_pool = ThreadPool.new(thread_name, @options) { |client| process_client client }
 
       if @queue_requests
         @reactor = Reactor.new(@io_selector_backend) { |c| reactor_wakeup c }
@@ -401,7 +400,7 @@ module Puma
     # returning.
     #
     # Return true if one or more requests were processed.
-    def process_client(client, buffer)
+    def process_client(client)
       # Advertise this server into the thread
       Thread.current[ThreadLocalKey] = self
 
@@ -427,15 +426,13 @@ module Puma
 
         while true
           @requests_count += 1
-          case handle_request(client, buffer, requests + 1)
+          case handle_request(client, requests + 1)
           when false
             break
           when :async
             close_socket = false
             break
           when true
-            buffer.reset
-
             ThreadPool.clean_thread_locals if clean_thread_locals
 
             requests += 1
@@ -469,7 +466,7 @@ module Puma
         # The ensure tries to close +client+ down
         requests > 0
       ensure
-        buffer.reset
+        client.io_buffer.reset
 
         begin
           client.close if close_socket

data/lib/puma/thread_pool.rb

@@ -45,7 +45,6 @@ module Puma
       @min = Integer(options[:min_threads])
       @max = Integer(options[:max_threads])
       @block = block
-      @extra = [::Puma::IOBuffer]
       @out_of_band = options[:out_of_band]
       @clean_thread_locals = options[:clean_thread_locals]
       @reaping_time = options[:reaping_time]
@@ -112,8 +111,6 @@ module Puma
         not_empty = @not_empty
         not_full = @not_full
 
-        extra = @extra.map { |i| i.new }
-
         while true
           work = nil
 
@@ -147,7 +144,7 @@ module Puma
           end
 
           begin
-            @out_of_band_pending = true if block.call(work, *extra)
+            @out_of_band_pending = true if block.call(work)
           rescue Exception => e
             STDERR.puts "Error reached top of thread-pool: #{e.message} (#{e.class})"
           end

data/lib/puma.rb

@@ -28,7 +28,7 @@ module Puma
   # not in minissl.rb
   HAS_SSL = const_defined?(:MiniSSL, false) && MiniSSL.const_defined?(:Engine, false)
 
-  HAS_UNIX_SOCKET = Object.const_defined? :UNIXSocket
+  HAS_UNIX_SOCKET = Object.const_defined?(:UNIXSocket) && !IS_WINDOWS
 
   if HAS_SSL
     require_relative 'puma/minissl'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: puma
 version: !ruby/object:Gem::Version
-  version: 6.0.0
+  version: 6.0.1
 platform: java
 authors:
 - Evan Phoenix
@@ -144,7 +144,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.29
+rubygems_version: 3.2.33
 signing_key:
 specification_version: 4
 summary: Puma is a simple, fast, threaded, and highly parallel HTTP 1.1 server for