puma 3.12.2 → 4.2.1

data/ext/puma_http11/org/jruby/puma/IOBuffer.java

@@ -0,0 +1,72 @@
+package org.jruby.puma;
+
+import org.jruby.*;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.runtime.ObjectAllocator;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.util.ByteList;
+
+/**
+ * @author kares
+ */
+public class IOBuffer extends RubyObject {
+
+    private static final ObjectAllocator ALLOCATOR = new ObjectAllocator() {
+        public IRubyObject allocate(Ruby runtime, RubyClass klass) {
+            return new IOBuffer(runtime, klass);
+        }
+    };
+
+    public static void createIOBuffer(Ruby runtime) {
+        RubyModule mPuma = runtime.defineModule("Puma");
+        RubyClass cIOBuffer = mPuma.defineClassUnder("IOBuffer", runtime.getObject(), ALLOCATOR);
+        cIOBuffer.defineAnnotatedMethods(IOBuffer.class);
+    }
+
+    private static final int DEFAULT_SIZE = 4096;
+
+    final ByteList buffer = new ByteList(DEFAULT_SIZE);
+
+    IOBuffer(Ruby runtime, RubyClass klass) {
+        super(runtime, klass);
+    }
+
+    @JRubyMethod
+    public RubyInteger used(ThreadContext context) {
+        return context.runtime.newFixnum(buffer.getRealSize());
+    }
+
+    @JRubyMethod
+    public RubyInteger capacity(ThreadContext context) {
+        return context.runtime.newFixnum(buffer.unsafeBytes().length);
+    }
+
+    @JRubyMethod
+    public IRubyObject reset() {
+        buffer.setRealSize(0);
+        return this;
+    }
+
+    @JRubyMethod(name = { "to_s", "to_str" })
+    public RubyString to_s(ThreadContext context) {
+        return RubyString.newStringShared(context.runtime, buffer.unsafeBytes(), 0, buffer.getRealSize());
+    }
+
+    @JRubyMethod(name = "<<")
+    public IRubyObject add(IRubyObject str) {
+        addImpl(str.convertToString());
+        return this;
+    }
+
+    @JRubyMethod(rest = true)
+    public IRubyObject append(IRubyObject[] strs) {
+        for (IRubyObject str : strs) addImpl(str.convertToString());
+        return this;
+    }
+
+    private void addImpl(RubyString str) {
+        buffer.append(str.getByteList());
+    }
+
+}

data/ext/puma_http11/org/jruby/puma/MiniSSL.java

@@ -23,6 +23,7 @@ import javax.net.ssl.SSLPeerUnverifiedException;
 import javax.net.ssl.SSLSession;
 import java.io.FileInputStream;
 import java.io.IOException;
+import java.nio.Buffer;
 import java.nio.ByteBuffer;
 import java.security.KeyManagementException;
 import java.security.KeyStore;
@@ -65,7 +66,7 @@ public class MiniSSL extends RubyObject {
 
     public void clear() { buffer.clear(); }
     public void compact() { buffer.compact(); }
-    public void flip() { buffer.flip(); }
+    public void flip() { ((Buffer) buffer).flip(); }
     public boolean hasRemaining() { return buffer.hasRemaining(); }
     public int position() { return buffer.position(); }
 
@@ -89,7 +90,7 @@ public class MiniSSL extends RubyObject {
     public void resize(int newCapacity) {
       if (newCapacity > buffer.capacity()) {
         ByteBuffer dstTmp = ByteBuffer.allocate(newCapacity);
-        buffer.flip();
+        flip();
         dstTmp.put(buffer);
         buffer = dstTmp;
       } else {
@@ -101,7 +102,7 @@ public class MiniSSL extends RubyObject {
      * Drains the buffer to a ByteList, or returns null for an empty buffer
      */
     public ByteList asByteList() {
-      buffer.flip();
+      flip();
       if (!buffer.hasRemaining()) {
         buffer.clear();
         return null;
@@ -158,7 +159,17 @@ public class MiniSSL extends RubyObject {
     sslCtx.init(kmf.getKeyManagers(), tmf.getTrustManagers(), null);
     engine = sslCtx.createSSLEngine();
 
-    String[] protocols = new String[] { "TLSv1", "TLSv1.1", "TLSv1.2" };
+    String[] protocols;
+    if(miniSSLContext.callMethod(threadContext, "no_tlsv1").isTrue()) {
+        protocols = new String[] { "TLSv1.1", "TLSv1.2" };
+    } else {
+        protocols = new String[] { "TLSv1", "TLSv1.1", "TLSv1.2" };
+    }
+
+    if(miniSSLContext.callMethod(threadContext, "no_tlsv1_1").isTrue()) {
+        protocols = new String[] { "TLSv1.2" };
+    }
+
     engine.setEnabledProtocols(protocols);
     engine.setUseClientMode(false);
 

data/lib/puma.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Standard libraries
 require 'socket'
 require 'tempfile'
@@ -20,4 +22,10 @@ module Puma
   def self.stats
     @get_stats.stats
   end
+
+  # Thread name is new in Ruby 2.3
+  def self.set_thread_name(name)
+    return unless Thread.current.respond_to?(:name=)
+    Thread.current.name = "puma #{name}"
+  end
 end

data/lib/puma/accept_nonblock.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'openssl'
 
 module OpenSSL
@@ -13,7 +15,11 @@ module OpenSSL
             ssl.accept if @start_immediately
             ssl
           rescue SSLError => ex
-            sock.close
+            if ssl
+              ssl.close
+            else
+              sock.close
+            end
             raise ex
           end
         end

data/lib/puma/app/status.rb

@@ -1,26 +1,17 @@
+# frozen_string_literal: true
+
+require 'json'
+
 module Puma
   module App
+    # Check out {#call}'s source code to see what actions this web application
+    # can respond to.
     class Status
-      def initialize(cli)
-        @cli = cli
-        @auth_token = nil
-      end
       OK_STATUS = '{ "status": "ok" }'.freeze
 
-      attr_accessor :auth_token
-
-      def authenticate(env)
-        return true unless @auth_token
-        env['QUERY_STRING'].to_s.split(/&;/).include?("token=#{@auth_token}")
-      end
-
-      def rack_response(status, body, content_type='application/json')
-        headers = {
-          'Content-Type' => content_type,
-          'Content-Length' => body.bytesize.to_s
-        }
-
-        [status, headers, [body]]
+      def initialize(cli, token = nil)
+        @cli = cli
+        @auth_token = token
       end
 
       def call(env)
@@ -31,44 +22,59 @@ module Puma
         case env['PATH_INFO']
         when /\/stop$/
           @cli.stop
-          return rack_response(200, OK_STATUS)
+          rack_response(200, OK_STATUS)
 
         when /\/halt$/
           @cli.halt
-          return rack_response(200, OK_STATUS)
+          rack_response(200, OK_STATUS)
 
         when /\/restart$/
           @cli.restart
-          return rack_response(200, OK_STATUS)
+          rack_response(200, OK_STATUS)
 
         when /\/phased-restart$/
           if !@cli.phased_restart
-            return rack_response(404, '{ "error": "phased restart not available" }')
+            rack_response(404, '{ "error": "phased restart not available" }')
           else
-            return rack_response(200, OK_STATUS)
+            rack_response(200, OK_STATUS)
           end
 
         when /\/reload-worker-directory$/
           if !@cli.send(:reload_worker_directory)
-            return rack_response(404, '{ "error": "reload_worker_directory not available" }')
+            rack_response(404, '{ "error": "reload_worker_directory not available" }')
           else
-            return rack_response(200, OK_STATUS)
+            rack_response(200, OK_STATUS)
           end
 
         when /\/gc$/
           GC.start
-          return rack_response(200, OK_STATUS)
+          rack_response(200, OK_STATUS)
 
         when /\/gc-stats$/
-          json = "{" + GC.stat.map { |k, v| "\"#{k}\": #{v}" }.join(",") + "}"
-          return rack_response(200, json)
+          rack_response(200, GC.stat.to_json)
 
         when /\/stats$/
-          return rack_response(200, @cli.stats)
+          rack_response(200, @cli.stats)
         else
           rack_response 404, "Unsupported action", 'text/plain'
         end
       end
+
+      private
+
+      def authenticate(env)
+        return true unless @auth_token
+        env['QUERY_STRING'].to_s.split(/&;/).include?("token=#{@auth_token}")
+      end
+
+      def rack_response(status, body, content_type='application/json')
+        headers = {
+          'Content-Type' => content_type,
+          'Content-Length' => body.bytesize.to_s
+        }
+
+        [status, headers, [body]]
+      end
     end
   end
 end

data/lib/puma/binder.rb

@@ -42,7 +42,7 @@ module Puma
       @ios = []
     end
 
-    attr_reader :listeners, :ios
+    attr_reader :ios
 
     def env(sock)
       @envs.fetch(sock, @proto_env)
@@ -50,7 +50,6 @@ module Puma
 
     def close
       @ios.each { |i| i.close }
-      @unix_paths.each { |i| File.unlink i }
     end
 
     def import_from_env
@@ -104,7 +103,17 @@ module Puma
             bak = params.fetch('backlog', 1024).to_i
 
             io = add_tcp_listener uri.host, uri.port, opt, bak
-            logger.log "* Listening on #{str}"
+
+            @ios.each do |i|
+              next unless TCPServer === i
+              addr = if i.local_address.ipv6?
+                "[#{i.local_address.ip_unpack[0]}]:#{i.local_address.ip_unpack[1]}"
+              else
+                i.local_address.ip_unpack.join(':')
+              end
+
+              logger.log "* Listening on tcp://#{addr}"
+            end
           end
 
           @listeners << [str, io] if io
@@ -187,6 +196,9 @@ module Puma
             ctx.ssl_cipher_filter = params['ssl_cipher_filter'] if params['ssl_cipher_filter']
           end
 
+          ctx.no_tlsv1 = true if params['no_tlsv1'] == 'true'
+          ctx.no_tlsv1_1 = true if params['no_tlsv1_1'] == 'true'
+
           if params['verify_mode']
             ctx.verify_mode = case params['verify_mode']
                               when "peer"
@@ -349,7 +361,7 @@ module Puma
     # Tell the server to listen on +path+ as a UNIX domain socket.
     #
     def add_unix_listener(path, umask=nil, mode=nil, backlog=1024)
-      @unix_paths << path
+      @unix_paths << path unless File.exist? path
 
       # Let anyone connect by default
       umask ||= 0
@@ -387,7 +399,7 @@ module Puma
     end
 
     def inherit_unix_listener(path, fd)
-      @unix_paths << path
+      @unix_paths << path unless File.exist? path
 
       if fd.kind_of? TCPServer
         s = fd
@@ -403,5 +415,27 @@ module Puma
       s
     end
 
+    def close_listeners
+      @listeners.each do |l, io|
+        io.close
+        uri = URI.parse(l)
+        next unless uri.scheme == 'unix'
+        unix_path = "#{uri.host}#{uri.path}"
+        File.unlink unix_path if @unix_paths.include? unix_path
+      end
+    end
+
+    def close_unix_paths
+      @unix_paths.each { |up| File.unlink(up) if File.exist? up }
+    end
+
+    def redirects_for_restart
+      redirects = {:close_others => true}
+      @listeners.each_with_index do |(l, io), i|
+        ENV["PUMA_INHERIT_#{i}"] = "#{io.to_i}:#{l}"
+        redirects[io.to_i] = io.to_i
+      end
+      redirects
+    end
   end
 end

data/lib/puma/cli.rb

@@ -161,6 +161,10 @@ module Puma
             user_config.prune_bundler
           end
 
+          o.on "--extra-runtime-dependencies GEM1,GEM2", "Defines any extra needed gems when using --prune-bundler" do |arg|
+            c.extra_runtime_dependencies arg.split(',')
+          end
+
           o.on "-q", "--quiet", "Do not log requests internally (default true)" do
             user_config.quiet
           end

data/lib/puma/client.rb

@@ -9,8 +9,8 @@ class IO
 end
 
 require 'puma/detect'
-require 'puma/delegation'
 require 'tempfile'
+require 'forwardable'
 
 if Puma::IS_JRUBY
   # We have to work around some OpenSSL buffer/io-readiness bugs
@@ -24,19 +24,24 @@ module Puma
   class ConnectionError < RuntimeError; end
 
   # An instance of this class represents a unique request from a client.
-  # For example a web request from a browser or from CURL. This
+  # For example, this could be a web request from a browser or from CURL.
   #
   # An instance of `Puma::Client` can be used as if it were an IO object
-  # for example it is passed into `IO.select` inside of the `Puma::Reactor`.
-  # This is accomplished by the `to_io` method which gets called on any
-  # non-IO objects being used with the IO api such as `IO.select.
+  # by the reactor. The reactor is expected to call `#to_io`
+  # on any non-IO objects it polls. For example, nio4r internally calls
+  # `IO::try_convert` (which may call `#to_io`) when a new socket is
+  # registered.
   #
   # Instances of this class are responsible for knowing if
   # the header and body are fully buffered via the `try_to_finish` method.
   # They can be used to "time out" a response via the `timeout_at` reader.
   class Client
+    # The object used for a request with no body. All requests with
+    # no body share this one object since it has no state.
+    EmptyBody = NullIO.new
+
     include Puma::Const
-    extend  Puma::Delegation
+    extend Forwardable
 
     def initialize(io, env=nil)
       @io = io
@@ -54,6 +59,7 @@ module Puma
       @ready = false
 
       @body = nil
+      @body_read_start = nil
       @buffer = nil
       @tempfile = nil
 
@@ -64,6 +70,10 @@ module Puma
 
       @peerip = nil
       @remote_addr_header = nil
+
+      @body_remain = 0
+
+      @in_last_chunk = false
     end
 
     attr_reader :env, :to_io, :body, :io, :timeout_at, :ready, :hijacked,
@@ -73,7 +83,7 @@ module Puma
 
     attr_accessor :remote_addr_header
 
-    forward :closed?, :@io
+    def_delegators :@io, :closed?
 
     def inspect
       "#<Puma::Client:0x#{object_id.to_s(16)} @ready=#{@ready.inspect}>"
@@ -102,6 +112,9 @@ module Puma
       @tempfile = nil
       @parsed_bytes = 0
       @ready = false
+      @body_remain = 0
+      @peerip = nil
+      @in_last_chunk = false
 
       if @buffer
         @parsed_bytes = @parser.execute(@env, @buffer, @parsed_bytes)
@@ -114,9 +127,16 @@ module Puma
         end
 
         return false
-      elsif fast_check &&
-            IO.select([@to_io], nil, nil, FAST_TRACK_KA_TIMEOUT)
-        return try_to_finish
+      else
+        begin
+          if fast_check &&
+              IO.select([@to_io], nil, nil, FAST_TRACK_KA_TIMEOUT)
+            return try_to_finish
+          end
+        rescue IOError
+          # swallow it
+        end
+
       end
     end
 
@@ -128,165 +148,6 @@ module Puma
       end
     end
 
-    # The object used for a request with no body. All requests with
-    # no body share this one object since it has no state.
-    EmptyBody = NullIO.new
-
-    def setup_chunked_body(body)
-      @chunked_body = true
-      @partial_part_left = 0
-      @prev_chunk = ""
-
-      @body = Tempfile.new(Const::PUMA_TMP_BASE)
-      @body.binmode
-      @tempfile = @body
-
-      return decode_chunk(body)
-    end
-
-    def decode_chunk(chunk)
-      if @partial_part_left > 0
-        if @partial_part_left <= chunk.size
-          @body << chunk[0..(@partial_part_left-3)] # skip the \r\n
-          chunk = chunk[@partial_part_left..-1]
-        else
-          @body << chunk
-          @partial_part_left -= chunk.size
-          return false
-        end
-      end
-
-      if @prev_chunk.empty?
-        io = StringIO.new(chunk)
-      else
-        io = StringIO.new(@prev_chunk+chunk)
-        @prev_chunk = ""
-      end
-
-      while !io.eof?
-        line = io.gets
-        if line.end_with?("\r\n")
-          len = line.strip.to_i(16)
-          if len == 0
-            @body.rewind
-            rest = io.read
-            rest = rest[2..-1] if rest.start_with?("\r\n")
-            @buffer = rest.empty? ? nil : rest
-            @requests_served += 1
-            @ready = true
-            return true
-          end
-
-          len += 2
-
-          part = io.read(len)
-
-          unless part
-            @partial_part_left = len
-            next
-          end
-
-          got = part.size
-
-          case
-          when got == len
-            @body << part[0..-3] # to skip the ending \r\n
-          when got <= len - 2
-            @body << part
-            @partial_part_left = len - part.size
-          when got == len - 1 # edge where we get just \r but not \n
-            @body << part[0..-2]
-            @partial_part_left = len - part.size
-          end
-        else
-          @prev_chunk = line
-          return false
-        end
-      end
-
-      return false
-    end
-
-    def read_chunked_body
-      while true
-        begin
-          chunk = @io.read_nonblock(4096)
-        rescue Errno::EAGAIN
-          return false
-        rescue SystemCallError, IOError
-          raise ConnectionError, "Connection error detected during read"
-        end
-
-        # No chunk means a closed socket
-        unless chunk
-          @body.close
-          @buffer = nil
-          @requests_served += 1
-          @ready = true
-          raise EOFError
-        end
-
-        return true if decode_chunk(chunk)
-      end
-    end
-
-    def setup_body
-      if @env[HTTP_EXPECT] == CONTINUE
-        # TODO allow a hook here to check the headers before
-        # going forward
-        @io << HTTP_11_100
-        @io.flush
-      end
-
-      @read_header = false
-
-      body = @parser.body
-
-      te = @env[TRANSFER_ENCODING2]
-
-      if te && CHUNKED.casecmp(te) == 0
-        return setup_chunked_body(body)
-      end
-
-      @chunked_body = false
-
-      cl = @env[CONTENT_LENGTH]
-
-      unless cl
-        @buffer = body.empty? ? nil : body
-        @body = EmptyBody
-        @requests_served += 1
-        @ready = true
-        return true
-      end
-
-      remain = cl.to_i - body.bytesize
-
-      if remain <= 0
-        @body = StringIO.new(body)
-        @buffer = nil
-        @requests_served += 1
-        @ready = true
-        return true
-      end
-
-      if remain > MAX_BODY
-        @body = Tempfile.new(Const::PUMA_TMP_BASE)
-        @body.binmode
-        @tempfile = @body
-      else
-        # The body[0,0] trick is to get an empty string in the same
-        # encoding as body.
-        @body = StringIO.new body[0,0]
-      end
-
-      @body.write body
-
-      @body_remain = remain
-
-      return false
-    end
-
     def try_to_finish
       return read_body unless @read_header
 
@@ -294,15 +155,14 @@ module Puma
         data = @io.read_nonblock(CHUNK_SIZE)
       rescue Errno::EAGAIN
         return false
-      rescue SystemCallError, IOError
+      rescue SystemCallError, IOError, EOFError
         raise ConnectionError, "Connection error detected during read"
       end
 
       # No data means a closed socket
       unless data
         @buffer = nil
-        @requests_served += 1
-        @ready = true
+        set_ready
         raise EOFError
       end
 
@@ -338,8 +198,7 @@ module Puma
         # No data means a closed socket
         unless data
           @buffer = nil
-          @requests_served += 1
-          @ready = true
+          set_ready
           raise EOFError
         end
 
@@ -389,6 +248,84 @@ module Puma
       true
     end
 
+    def write_error(status_code)
+      begin
+        @io << ERROR_RESPONSE[status_code]
+      rescue StandardError
+      end
+    end
+
+    def peerip
+      return @peerip if @peerip
+
+      if @remote_addr_header
+        hdr = (@env[@remote_addr_header] || LOCALHOST_ADDR).split(/[\s,]/).first
+        @peerip = hdr
+        return hdr
+      end
+
+      @peerip ||= @io.peeraddr.last
+    end
+
+    private
+
+    def setup_body
+      @body_read_start = Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond)
+
+      if @env[HTTP_EXPECT] == CONTINUE
+        # TODO allow a hook here to check the headers before
+        # going forward
+        @io << HTTP_11_100
+        @io.flush
+      end
+
+      @read_header = false
+
+      body = @parser.body
+
+      te = @env[TRANSFER_ENCODING2]
+
+      if te && CHUNKED.casecmp(te) == 0
+        return setup_chunked_body(body)
+      end
+
+      @chunked_body = false
+
+      cl = @env[CONTENT_LENGTH]
+
+      unless cl
+        @buffer = body.empty? ? nil : body
+        @body = EmptyBody
+        set_ready
+        return true
+      end
+
+      remain = cl.to_i - body.bytesize
+
+      if remain <= 0
+        @body = StringIO.new(body)
+        @buffer = nil
+        set_ready
+        return true
+      end
+
+      if remain > MAX_BODY
+        @body = Tempfile.new(Const::PUMA_TMP_BASE)
+        @body.binmode
+        @tempfile = @body
+      else
+        # The body[0,0] trick is to get an empty string in the same
+        # encoding as body.
+        @body = StringIO.new body[0,0]
+      end
+
+      @body.write body
+
+      @body_remain = remain
+
+      return false
+    end
+
     def read_body
       if @chunked_body
         return read_chunked_body
@@ -416,8 +353,7 @@ module Puma
       unless chunk
         @body.close
         @buffer = nil
-        @requests_served += 1
-        @ready = true
+        set_ready
         raise EOFError
       end
 
@@ -426,8 +362,7 @@ module Puma
       if remain <= 0
         @body.rewind
         @buffer = nil
-        @requests_served += 1
-        @ready = true
+        set_ready
         return true
       end
 
@@ -436,37 +371,124 @@ module Puma
       false
     end
 
-    def write_400
-      begin
-        @io << ERROR_400_RESPONSE
-      rescue StandardError
+    def read_chunked_body
+      while true
+        begin
+          chunk = @io.read_nonblock(4096)
+        rescue IO::WaitReadable
+          return false
+        rescue SystemCallError, IOError
+          raise ConnectionError, "Connection error detected during read"
+        end
+
+        # No chunk means a closed socket
+        unless chunk
+          @body.close
+          @buffer = nil
+          set_ready
+          raise EOFError
+        end
+
+        return true if decode_chunk(chunk)
       end
     end
 
-    def write_408
-      begin
-        @io << ERROR_408_RESPONSE
-      rescue StandardError
-      end
+    def setup_chunked_body(body)
+      @chunked_body = true
+      @partial_part_left = 0
+      @prev_chunk = ""
+
+      @body = Tempfile.new(Const::PUMA_TMP_BASE)
+      @body.binmode
+      @tempfile = @body
+
+      return decode_chunk(body)
     end
 
-    def write_500
-      begin
-        @io << ERROR_500_RESPONSE
-      rescue StandardError
+    def decode_chunk(chunk)
+      if @partial_part_left > 0
+        if @partial_part_left <= chunk.size
+          if @partial_part_left > 2
+            @body << chunk[0..(@partial_part_left-3)] # skip the \r\n
+          end
+          chunk = chunk[@partial_part_left..-1]
+          @partial_part_left = 0
+        else
+          @body << chunk if @partial_part_left > 2 # don't include the last \r\n
+          @partial_part_left -= chunk.size
+          return false
+        end
       end
-    end
 
-    def peerip
-      return @peerip if @peerip
+      if @prev_chunk.empty?
+        io = StringIO.new(chunk)
+      else
+        io = StringIO.new(@prev_chunk+chunk)
+        @prev_chunk = ""
+      end
 
-      if @remote_addr_header
-        hdr = (@env[@remote_addr_header] || LOCALHOST_ADDR).split(/[\s,]/).first
-        @peerip = hdr
-        return hdr
+      while !io.eof?
+        line = io.gets
+        if line.end_with?("\r\n")
+          len = line.strip.to_i(16)
+          if len == 0
+            @in_last_chunk = true
+            @body.rewind
+            rest = io.read
+            last_crlf_size = "\r\n".bytesize
+            if rest.bytesize < last_crlf_size
+              @buffer = nil
+              @partial_part_left = last_crlf_size - rest.bytesize
+              return false
+            else
+              @buffer = rest[last_crlf_size..-1]
+              @buffer = nil if @buffer.empty?
+              set_ready
+              return true
+            end
+          end
+
+          len += 2
+
+          part = io.read(len)
+
+          unless part
+            @partial_part_left = len
+            next
+          end
+
+          got = part.size
+
+          case
+          when got == len
+            @body << part[0..-3] # to skip the ending \r\n
+          when got <= len - 2
+            @body << part
+            @partial_part_left = len - part.size
+          when got == len - 1 # edge where we get just \r but not \n
+            @body << part[0..-2]
+            @partial_part_left = len - part.size
+          end
+        else
+          @prev_chunk = line
+          return false
+        end
       end
 
-      @peerip ||= @io.peeraddr.last
+      if @in_last_chunk
+        set_ready
+        true
+      else
+        false
+      end
+    end
+
+    def set_ready
+      if @body_read_start
+        @env['puma.request_body_wait'] = Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond) - @body_read_start
+      end
+      @requests_served += 1
+      @ready = true
     end
   end
 end