puma 3.0.0.rc1 → 5.0.0.beta1

data/lib/puma/cli.rb

@@ -1,7 +1,13 @@
+# frozen_string_literal: true
+
 require 'optparse'
 require 'uri'
 
+require 'puma'
+require 'puma/configuration'
 require 'puma/launcher'
+require 'puma/const'
+require 'puma/events'
 
 module Puma
   class << self
@@ -44,21 +50,21 @@ module Puma
         @parser.parse! @argv
 
         if file = @argv.shift
-          @conf.configure do |c|
-            c.rackup file
+          @conf.configure do |user_config, file_config|
+            file_config.rackup file
           end
         end
       rescue UnsupportedOption
         exit 1
       end
 
-      @conf.configure do |c|
+      @conf.configure do |user_config, file_config|
         if @stdout || @stderr
-          c.stdout_redirect @stdout, @stderr, @append
+          user_config.stdout_redirect @stdout, @stderr, @append
         end
 
         if @control_url
-          c.activate_control_app @control_url, @control_options
+          user_config.activate_control_app @control_url, @control_options
         end
       end
 
@@ -74,33 +80,36 @@ module Puma
       @launcher.run
     end
 
-  private
+    private
     def unsupported(str)
       @events.error(str)
       raise UnsupportedOption
     end
 
+    def configure_control_url(command_line_arg)
+      if command_line_arg
+        @control_url = command_line_arg
+      elsif Puma.jruby?
+        unsupported "No default url available on JRuby"
+      end
+    end
+
     # Build the OptionParser object to handle the available options.
     #
 
     def setup_options
-      @conf = Configuration.new do |c|
+      @conf = Configuration.new do |user_config, file_config|
         @parser = OptionParser.new do |o|
           o.on "-b", "--bind URI", "URI to bind to (tcp://, unix://, ssl://)" do |arg|
-            c.bind arg
+            user_config.bind arg
           end
 
           o.on "-C", "--config PATH", "Load PATH as a config file" do |arg|
-            c.load arg
+            file_config.load arg
           end
 
-          o.on "--control URL", "The bind url to use for the control server",
-            "Use 'auto' to use temp unix server" do |arg|
-            if arg
-              @control_url = arg
-            elsif Puma.jruby?
-              unsupported "No default url available on JRuby"
-            end
+          o.on "--control-url URL", "The bind url to use for the control server. Use 'auto' to use temp unix server" do |arg|
+            configure_control_url(arg)
           end
 
           o.on "--control-token TOKEN",
@@ -108,22 +117,23 @@ module Puma
             @control_options[:auth_token] = arg
           end
 
-          o.on "-d", "--daemon", "Daemonize the server into the background" do
-            c.daemonize
-            c.quiet
-          end
-
           o.on "--debug", "Log lowlevel debugging information" do
-            c.debug
+            user_config.debug
           end
 
           o.on "--dir DIR", "Change to DIR before starting" do |d|
-            c.directory d
+            user_config.directory d
           end
 
           o.on "-e", "--environment ENVIRONMENT",
             "The environment to run the Rack app on (default development)" do |arg|
-            c.environment arg
+            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|
@@ -132,46 +142,54 @@ module Puma
 
           o.on "-p", "--port PORT", "Define the TCP port to bind to",
             "Use -b for more advanced options" do |arg|
-            c.bind "tcp://#{Configuration::DefaultTCPHost}:#{arg}"
+            user_config.bind "tcp://#{Configuration::DefaultTCPHost}:#{arg}"
           end
 
           o.on "--pidfile PATH", "Use PATH as a pidfile" do |arg|
-            c.pidfile arg
+            user_config.pidfile arg
           end
 
           o.on "--preload", "Preload the app. Cluster mode only" do
-            c.preload_app!
+            user_config.preload_app!
           end
 
           o.on "--prune-bundler", "Prune out the bundler env if possible" do
-            c.prune_bundler
+            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
 
-          o.on "-q", "--quiet", "Quiet down the output" do
-            c.quiet
+          o.on "-v", "--log-requests", "Log requests as they occur" do
+            user_config.log_requests
           end
 
           o.on "-R", "--restart-cmd CMD",
             "The puma command to run during a hot restart",
             "Default: inferred" do |cmd|
-            c.restart_command cmd
+            user_config.restart_command cmd
           end
 
           o.on "-S", "--state PATH", "Where to store the state details" do |arg|
-            c.state_path arg
+            user_config.state_path arg
           end
 
           o.on '-t', '--threads INT', "min:max threads to use (default 0:16)" do |arg|
             min, max = arg.split(":")
             if max
-              c.threads min, max
+              user_config.threads min, max
             else
-              c.threads 0, max
+              user_config.threads min, min
             end
           end
 
-          o.on "--tcp-mode", "Run the app in raw TCP mode instead of HTTP mode" do
-            c.tcp_mode!
+          o.on "--early-hints", "Enable early hints support" do
+            user_config.early_hints
           end
 
           o.on "-V", "--version", "Print the version information" do
@@ -181,11 +199,11 @@ module Puma
 
           o.on "-w", "--workers COUNT",
             "Activate cluster mode: How many worker processes to create" do |arg|
-            c.workers arg
+            user_config.workers arg
           end
 
           o.on "--tag NAME", "Additional text to display in process listing" do |arg|
-            c.tag arg
+            user_config.tag arg
           end
 
           o.on "--redirect-stdout FILE", "Redirect STDOUT to a specific file" do |arg|

data/lib/puma/client.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class IO
   # We need to use this for a jruby work around on both 1.8 and 1.9.
   # So this either creates the constant (on 1.8), or harmlessly
@@ -7,6 +9,8 @@ class IO
 end
 
 require 'puma/detect'
+require 'tempfile'
+require 'forwardable'
 
 if Puma::IS_JRUBY
   # We have to work around some OpenSSL buffer/io-readiness bugs
@@ -19,8 +23,25 @@ module Puma
 
   class ConnectionError < RuntimeError; end
 
+  # An instance of this class represents a unique request from a client.
+  # 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. 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 Forwardable
 
     def initialize(io, env=nil)
       @io = io
@@ -38,6 +59,7 @@ module Puma
       @ready = false
 
       @body = nil
+      @body_read_start = nil
       @buffer = nil
       @tempfile = nil
 
@@ -48,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,
@@ -57,6 +83,8 @@ module Puma
 
     attr_accessor :remote_addr_header
 
+    def_delegators :@io, :closed?
+
     def inspect
       "#<Puma::Client:0x#{object_id.to_s(16)} @ready=#{@ready.inspect}>"
     end
@@ -84,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)
@@ -96,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
 
@@ -106,66 +144,28 @@ module Puma
       begin
         @io.close
       rescue IOError
+        Thread.current.purge_interrupt_queue if Thread.current.respond_to? :purge_interrupt_queue
       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_body
-      @in_data_phase = true
-      body = @parser.body
-      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
-
-      @read_header = false
-
-      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
+      rescue SystemCallError, IOError, EOFError
         raise ConnectionError, "Connection error detected during read"
       end
 
+      # No data means a closed socket
+      unless data
+        @buffer = nil
+        set_ready
+        raise EOFError
+      end
+
       if @buffer
         @buffer << data
       else
@@ -180,7 +180,7 @@ module Puma
         raise HttpParserError,
           "HEADER is longer than allowed, aborting client early."
       end
-      
+
       false
     end
 
@@ -195,6 +195,13 @@ module Puma
           raise e
         end
 
+        # No data means a closed socket
+        unless data
+          @buffer = nil
+          set_ready
+          raise EOFError
+        end
+
         if @buffer
           @buffer << data
         else
@@ -231,17 +238,122 @@ 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.
+    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 && 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
+      end
+
       # Read an odd sized chunk so we can read even sized ones
       # after this
       remain = @body_remain
@@ -254,7 +366,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"
@@ -264,8 +376,7 @@ module Puma
       unless chunk
         @body.close
         @buffer = nil
-        @requests_served += 1
-        @ready = true
+        set_ready
         raise EOFError
       end
 
@@ -274,8 +385,7 @@ module Puma
       if remain <= 0
         @body.rewind
         @buffer = nil
-        @requests_served += 1
-        @ready = true
+        set_ready
         return true
       end
 
@@ -284,37 +394,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