puma 4.1.1 → 5.0.0

data/lib/puma/cli.rb

@@ -80,7 +80,7 @@ module Puma
       @launcher.run
     end
 
-  private
+    private
     def unsupported(str)
       @events.error(str)
       raise UnsupportedOption
@@ -112,21 +112,11 @@ module Puma
             configure_control_url(arg)
           end
 
-          # alias --control-url for backwards-compatibility
-          o.on "--control URL", "DEPRECATED alias for --control-url" do |arg|
-            configure_control_url(arg)
-          end
-
           o.on "--control-token TOKEN",
             "The token to use as authentication for the control server" do |arg|
             @control_options[:auth_token] = arg
           end
 
-          o.on "-d", "--daemon", "Daemonize the server into the background" do
-            user_config.daemonize
-            user_config.quiet
-          end
-
           o.on "--debug", "Log lowlevel debugging information" do
             user_config.debug
           end
@@ -140,6 +130,12 @@ module Puma
             user_config.environment arg
           end
 
+          o.on "-f", "--fork-worker=[REQUESTS]", OptionParser::DecimalInteger,
+            "Fork new workers from existing worker. Cluster mode only",
+            "Auto-refork after REQUESTS (default 1000)" do |*args|
+            user_config.fork_worker(*args.compact)
+          end
+
           o.on "-I", "--include PATH", "Specify $LOAD_PATH directories" do |arg|
             $LOAD_PATH.unshift(*arg.split(':'))
           end
@@ -161,6 +157,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|
+            user_config.extra_runtime_dependencies arg.split(',')
+          end
+
           o.on "-q", "--quiet", "Do not log requests internally (default true)" do
             user_config.quiet
           end
@@ -188,10 +188,6 @@ module Puma
             end
           end
 
-          o.on "--tcp-mode", "Run the app in raw TCP mode instead of HTTP mode" do
-            user_config.tcp_mode!
-          end
-
           o.on "--early-hints", "Enable early hints support" do
             user_config.early_hints
           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,11 +24,11 @@ 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
-  # by the reactor, that's because the latter is expected to call `#to_io`
-  # on any non-IO objects it polls. For example nio4r internally calls
+  # 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.
   #
@@ -36,8 +36,12 @@ module Puma
   # 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
@@ -79,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}>"
@@ -144,185 +148,12 @@ 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
-          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
-
-      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
-            @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
-
-      if @in_last_chunk
-        set_ready
-        true
-      else
-        false
-      end
-    end
-
-    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 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 try_to_finish
       return read_body unless @read_header
 
       begin
         data = @io.read_nonblock(CHUNK_SIZE)
-      rescue Errno::EAGAIN
+      rescue IO::WaitReadable
         return false
       rescue SystemCallError, IOError, EOFError
         raise ConnectionError, "Connection error detected during read"
@@ -407,16 +238,127 @@ module Puma
         return false unless IO.select([@to_io], nil, nil, 0)
         try_to_finish
       end
+
+      # For documentation, see https://github.com/puma/puma/issues/1754
+      send(:alias_method, :jruby_eagerly_finish, :eagerly_finish)
     end # IS_JRUBY
 
-    def finish
+    def finish(timeout)
       return true if @ready
       until try_to_finish
-        IO.select([@to_io], nil, nil)
+        can_read = begin
+          IO.select([@to_io], nil, nil, timeout)
+        rescue ThreadPool::ForceShutdown
+          nil
+        end
+        unless can_read
+          write_error(408) if in_data_phase
+          raise ConnectionError
+        end
       end
       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_IP).split(/[\s,]/).first
+        @peerip = hdr
+        return hdr
+      end
+
+      @peerip ||= @io.peeraddr.last
+    end
+
+    # Returns true if the persistent connection can be closed immediately
+    # without waiting for the configured idle/shutdown timeout.
+    # @version 5.0.0
+    #
+    def can_close?
+      # Allow connection to close if it's received at least one full request
+      # and hasn't received any data for a future request.
+      #
+      # From RFC 2616 section 8.1.4:
+      # Servers SHOULD always respond to at least one request per connection,
+      # if at all possible.
+      @requests_served > 0 && @parsed_bytes == 0
+    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
+        if te.include?(",")
+          te.split(",").each do |part|
+            if CHUNKED.casecmp(part.strip) == 0
+              return setup_chunked_body(body)
+            end
+          end
+        elsif CHUNKED.casecmp(te) == 0
+          return setup_chunked_body(body)
+        end
+      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
@@ -434,7 +376,7 @@ module Puma
 
       begin
         chunk = @io.read_nonblock(want)
-      rescue Errno::EAGAIN
+      rescue IO::WaitReadable
         return false
       rescue SystemCallError, IOError
         raise ConnectionError, "Connection error detected during read"
@@ -462,45 +404,144 @@ module Puma
       false
     end
 
-    def set_ready
-      if @body_read_start
-        @env['puma.request_body_wait'] = Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond) - @body_read_start
+    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
+
+        if decode_chunk(chunk)
+          @env[CONTENT_LENGTH] = @chunked_content_length
+          return true
+        end
       end
-      @requests_served += 1
-      @ready = true
     end
 
-    def write_400
-      begin
-        @io << ERROR_400_RESPONSE
-      rescue StandardError
+    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
+      @chunked_content_length = 0
+
+      if decode_chunk(body)
+        @env[CONTENT_LENGTH] = @chunked_content_length
+        return true
       end
     end
 
-    def write_408
-      begin
-        @io << ERROR_408_RESPONSE
-      rescue StandardError
-      end
+    # @version 5.0.0
+    def write_chunk(str)
+      @chunked_content_length += @body.write(str)
     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
+            write_chunk(chunk[0..(@partial_part_left-3)]) # skip the \r\n
+          end
+          chunk = chunk[@partial_part_left..-1]
+          @partial_part_left = 0
+        else
+          if @partial_part_left > 2
+            if @partial_part_left == chunk.size + 1
+              # Don't include the last \r
+              write_chunk(chunk[0..(@partial_part_left-3)])
+            else
+              # don't include the last \r\n
+              write_chunk(chunk)
+            end
+          end
+          @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
+            write_chunk(part[0..-3]) # to skip the ending \r\n
+          when got <= len - 2
+            write_chunk(part)
+            @partial_part_left = len - part.size
+          when got == len - 1 # edge where we get just \r but not \n
+            write_chunk(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