puma 2.16.0 → 3.11.4

data/lib/puma/server.rb

@@ -57,19 +57,19 @@ module Puma
 
       @min_threads = 0
       @max_threads = 16
-      @auto_trim_time = 1
+      @auto_trim_time = 30
       @reaping_time = 1
 
       @thread = nil
       @thread_pool = nil
+      @early_hints = nil
 
-      @persistent_timeout = PERSISTENT_TIMEOUT
+      @persistent_timeout = options.fetch(:persistent_timeout, PERSISTENT_TIMEOUT)
+      @first_data_timeout = options.fetch(:first_data_timeout, FIRST_DATA_TIMEOUT)
 
       @binder = Binder.new(events)
       @own_binder = true
 
-      @first_data_timeout = FIRST_DATA_TIMEOUT
-
       @leak_stack_on_error = true
 
       @options = options
@@ -78,13 +78,16 @@ module Puma
       ENV['RACK_ENV'] ||= "development"
 
       @mode = :http
+
+      @precheck_closing = true
     end
 
-    attr_accessor :binder, :leak_stack_on_error
+    attr_accessor :binder, :leak_stack_on_error, :early_hints
 
     forward :add_tcp_listener,  :@binder
     forward :add_ssl_listener,  :@binder
     forward :add_unix_listener, :@binder
+    forward :connected_port,    :@binder
 
     def inherit_binder(bind)
       @binder = bind
@@ -99,6 +102,8 @@ module Puma
     # packetizes our stream. This improves both latency and throughput.
     #
     if RUBY_PLATFORM =~ /linux/
+      UNPACK_TCP_STATE_FROM_TCP_INFO = "C".freeze
+
       # 6 == Socket::IPPROTO_TCP
       # 3 == TCP_CORK
       # 1/0 == turn on/off
@@ -106,6 +111,7 @@ module Puma
         begin
           socket.setsockopt(6, 3, 1) if socket.kind_of? TCPSocket
         rescue IOError, SystemCallError
+          Thread.current.purge_interrupt_queue if Thread.current.respond_to? :purge_interrupt_queue
         end
       end
 
@@ -113,6 +119,24 @@ module Puma
         begin
           socket.setsockopt(6, 3, 0) if socket.kind_of? TCPSocket
         rescue IOError, SystemCallError
+          Thread.current.purge_interrupt_queue if Thread.current.respond_to? :purge_interrupt_queue
+        end
+      end
+
+      def closed_socket?(socket)
+        return false unless socket.kind_of? TCPSocket
+        return false unless @precheck_closing
+
+        begin
+          tcp_info = socket.getsockopt(Socket::SOL_TCP, Socket::TCP_INFO)
+        rescue IOError, SystemCallError
+          Thread.current.purge_interrupt_queue if Thread.current.respond_to? :purge_interrupt_queue
+          @precheck_closing = false
+          false
+        else
+          state = tcp_info.unpack(UNPACK_TCP_STATE_FROM_TCP_INFO)[0]
+          # TIME_WAIT: 6, CLOSE: 7, CLOSE_WAIT: 8, LAST_ACK: 9, CLOSING: 11
+          (state >= 6 && state <= 9) || state == 11
         end
       end
     else
@@ -121,6 +145,10 @@ module Puma
 
       def uncork_socket(socket)
       end
+
+      def closed_socket?(socket)
+        false
+      end
     end
 
     def backlog
@@ -192,7 +220,11 @@ module Puma
                   # nothing
                 rescue Errno::ECONNABORTED
                   # client closed the socket even before accept
-                  io.close rescue nil
+                  begin
+                    io.close
+                  rescue
+                    Thread.current.purge_interrupt_queue if Thread.current.respond_to? :purge_interrupt_queue
+                  end
                 end
               end
             end
@@ -241,6 +273,10 @@ module Puma
       @thread_pool = ThreadPool.new(@min_threads,
                                     @max_threads,
                                     IOBuffer) do |client, buffer|
+
+        # Advertise this server into the thread
+        Thread.current[ThreadLocalKey] = self
+
         process_now = false
 
         begin
@@ -263,7 +299,7 @@ module Puma
           client.close
 
           @events.parse_error self, client.env, e
-        rescue ConnectionError
+        rescue ConnectionError, EOFError
           client.close
         else
           if process_now
@@ -334,13 +370,17 @@ module Puma
                     end
 
                     pool << client
-                    pool.wait_until_not_full unless queue_requests
+                    pool.wait_until_not_full
                   end
                 rescue SystemCallError
                   # nothing
                 rescue Errno::ECONNABORTED
                   # client closed the socket even before accept
-                  io.close rescue nil
+                  begin
+                    io.close
+                  rescue
+                    Thread.current.purge_interrupt_queue if Thread.current.respond_to? :purge_interrupt_queue
+                  end
                 end
               end
             end
@@ -353,7 +393,7 @@ module Puma
 
         graceful_shutdown if @status == :stop || @status == :restart
         if queue_requests
-          @reactor.clear! if @status == :restart
+          @reactor.clear!
           @reactor.shutdown
         end
       rescue Exception => e
@@ -398,6 +438,8 @@ module Puma
     #
     def process_client(client, buffer)
       begin
+
+        clean_thread_locals = @options[:clean_thread_locals]
         close_socket = true
 
         while true
@@ -411,6 +453,8 @@ module Puma
             return unless @queue_requests
             buffer.reset
 
+            ThreadPool.clean_thread_locals if clean_thread_locals
+
             unless client.reset(@status == :run)
               close_socket = false
               client.set_timeout @persistent_timeout
@@ -426,6 +470,8 @@ module Puma
 
       # SSL handshake error
       rescue MiniSSL::SSLError => e
+        lowlevel_error(e, client.env)
+
         ssl_socket = client.io
         addr = ssl_socket.peeraddr.last
         cert = ssl_socket.peercert
@@ -436,12 +482,16 @@ module Puma
 
       # The client doesn't know HTTP well
       rescue HttpParserError => e
+        lowlevel_error(e, client.env)
+
         client.write_400
 
         @events.parse_error self, client.env, e
 
       # Server error
       rescue StandardError => e
+        lowlevel_error(e, client.env)
+
         client.write_500
 
         @events.unknown_error self, e, "Read"
@@ -452,6 +502,7 @@ module Puma
         begin
           client.close if close_socket
         rescue IOError, SystemCallError
+          Thread.current.purge_interrupt_queue if Thread.current.respond_to? :purge_interrupt_queue
           # Already closed
         rescue StandardError => e
           @events.unknown_error self, e, "Client"
@@ -482,6 +533,10 @@ module Puma
         env[REQUEST_PATH] = uri.path
 
         raise "No REQUEST PATH" unless env[REQUEST_PATH]
+
+        # A nil env value will cause a LintError (and fatal errors elsewhere),
+        # so only set the env value if there actually is a value.
+        env[QUERY_STRING] = uri.query if uri.query
       end
 
       env[PATH_INFO] = env[REQUEST_PATH]
@@ -529,6 +584,8 @@ module Puma
       env = req.env
       client = req.io
 
+      return false if closed_socket?(client)
+
       normalize_env env, req
 
       env[PUMA_SOCKET] = client
@@ -547,6 +604,24 @@ module Puma
       env[RACK_INPUT] = body
       env[RACK_URL_SCHEME] =  env[HTTPS_KEY] ? HTTPS : HTTP
 
+      if @early_hints
+        env[EARLY_HINTS] = lambda { |headers|
+          fast_write client, "HTTP/1.1 103 Early Hints\r\n".freeze
+
+          headers.each_pair do |k, vs|
+            if vs.respond_to?(:to_s) && !vs.to_s.empty?
+              vs.to_s.split(NEWLINE).each do |v|
+                fast_write client, "#{k}: #{v}\r\n"
+              end
+            else
+              fast_write client, "#{k}: #{vs}\r\n"
+            end
+          end
+
+          fast_write client, "\r\n".freeze
+        }
+      end
+
       # A rack extension. If the app writes #call'ables to this
       # array, we will invoke them when the request is done.
       #
@@ -567,10 +642,18 @@ module Puma
 
             return :async
           end
-        rescue StandardError => e
+        rescue ThreadPool::ForceShutdown => e
+          @events.log "Detected force shutdown of a thread, returning 503"
           @events.unknown_error self, e, "Rack app"
 
-          status, headers, res_body = lowlevel_error(e)
+          status = 503
+          headers = {}
+          res_body = ["Request was internally terminated early\n"]
+
+        rescue Exception => e
+          @events.unknown_error self, e, "Rack app", env
+
+          status, headers, res_body = lowlevel_error(e, env)
         end
 
         content_length = nil
@@ -636,7 +719,7 @@ module Puma
             next
           end
 
-          if vs.respond_to?(:to_s)
+          if vs.respond_to?(:to_s) && !vs.to_s.empty?
             vs.to_s.split(NEWLINE).each do |v|
               lines.append k, colon, v, line_ending
             end
@@ -680,8 +763,8 @@ module Puma
 
         begin
           res_body.each do |part|
+            next if part.bytesize.zero?
             if chunked
-              next if part.bytesize.zero?
               fast_write client, part.bytesize.to_s(16)
               fast_write client, line_ending
               fast_write client, part
@@ -719,7 +802,7 @@ module Puma
     end
     private :fetch_status_code
 
-    # Given the requset +env+ from +client+ and the partial body +body+
+    # Given the request +env+ from +client+ and the partial body +body+
     # plus a potential Content-Length value +cl+, finish reading
     # the body and return it.
     #
@@ -775,9 +858,13 @@ module Puma
 
     # A fallback rack response if +@app+ raises as exception.
     #
-    def lowlevel_error(e)
+    def lowlevel_error(e, env)
       if handler = @options[:lowlevel_error_handler]
-        return handler.call(e)
+        if handler.arity == 1
+          return handler.call(e)
+        else
+          return handler.call(e, env)
+        end
       end
 
       if @leak_stack_on_error
@@ -827,38 +914,47 @@ module Puma
         @events.debug "Drained #{count} additional connections."
       end
 
-      @thread_pool.shutdown if @thread_pool
+      if @thread_pool
+        if timeout = @options[:force_shutdown_after]
+          @thread_pool.shutdown timeout.to_i
+        else
+          @thread_pool.shutdown
+        end
+      end
     end
 
-    # Stops the acceptor thread and then causes the worker threads to finish
-    # off the request queue before finally exiting.
-    #
-    def stop(sync=false)
+    def notify_safely(message)
       begin
-        @notify << STOP_COMMAND
+        @notify << message
       rescue IOError
-        # The server, in another thread, is shutting down
+         # The server, in another thread, is shutting down
+        Thread.current.purge_interrupt_queue if Thread.current.respond_to? :purge_interrupt_queue
+      rescue RuntimeError => e
+        # Temporary workaround for https://bugs.ruby-lang.org/issues/13239
+        if e.message.include?('IOError')
+          Thread.current.purge_interrupt_queue if Thread.current.respond_to? :purge_interrupt_queue
+        else
+          raise e
+        end
       end
+    end
+    private :notify_safely
 
+    # Stops the acceptor thread and then causes the worker threads to finish
+    # off the request queue before finally exiting.
+
+    def stop(sync=false)
+      notify_safely(STOP_COMMAND)
       @thread.join if @thread && sync
     end
 
     def halt(sync=false)
-      begin
-        @notify << HALT_COMMAND
-      rescue IOError
-        # The server, in another thread, is shutting down
-      end
-
+      notify_safely(HALT_COMMAND)
       @thread.join if @thread && sync
     end
 
     def begin_restart
-      begin
-        @notify << RESTART_COMMAND
-      rescue IOError
-        # The server, in another thread, is shutting down
-      end
+      notify_safely(RESTART_COMMAND)
     end
 
     def fast_write(io, str)
@@ -881,5 +977,15 @@ module Puma
       end
     end
     private :fast_write
+
+    ThreadLocalKey = :puma_server
+
+    def self.current
+      Thread.current[ThreadLocalKey]
+    end
+
+    def shutting_down?
+      @status == :stop || @status == :restart
+    end
   end
 end

data/lib/puma/single.rb

@@ -1,10 +1,12 @@
 require 'puma/runner'
+require 'puma/detect'
+require 'puma/plugin'
 
 module Puma
   class Single < Runner
     def stats
-      b = @server.backlog
-      r = @server.running
+      b = @server.backlog || 0
+      r = @server.running || 0
       %Q!{ "backlog": #{b}, "running": #{r} }!
     end
 
@@ -27,7 +29,12 @@ module Puma
     end
 
     def jruby_daemon?
-      daemon? and @cli.jruby?
+      daemon? and Puma.jruby?
+    end
+
+    def jruby_daemon_start
+      require 'puma/jruby_restart'
+      JRubyRestart.daemon_start(@restart_dir, @launcher.restart_args)
     end
 
     def run
@@ -39,6 +46,7 @@ module Puma
         if JRubyRestart.daemon?
           # load and bind before redirecting IO so errors show up on stdout/stderr
           load_and_bind
+          redirect_io
         end
 
         already_daemon = JRubyRestart.daemon_init
@@ -66,7 +74,7 @@ module Puma
             exit 1
           end
 
-          pid = @cli.jruby_daemon_start
+          jruby_daemon_start
           sleep
         end
       else
@@ -79,7 +87,9 @@ module Puma
         load_and_bind
       end
 
-      @cli.write_state
+      Plugins.fire_background
+
+      @launcher.write_state
 
       start_control
 
@@ -90,7 +100,7 @@ module Puma
         redirect_io
       end
 
-      @cli.events.fire_on_booted!
+      @launcher.events.fire_on_booted!
 
       begin
         server.run.join

data/lib/puma/state_file.rb

@@ -0,0 +1,29 @@
+require 'yaml'
+
+module Puma
+  class StateFile
+    def initialize
+      @options = {}
+    end
+
+    def save(path)
+      File.write path, YAML.dump(@options)
+    end
+
+    def load(path)
+      @options = YAML.load File.read(path)
+    end
+
+    FIELDS = %w!control_url control_auth_token pid!
+
+    FIELDS.each do |f|
+      define_method f do
+        @options[f]
+      end
+
+      define_method "#{f}=" do |v|
+        @options[f] = v
+      end
+    end
+  end
+end

data/lib/puma/tcp_logger.rb

@@ -11,7 +11,14 @@ module Puma
     def log(who, str)
       now = Time.now.strftime("%d/%b/%Y %H:%M:%S")
 
-      @logger.puts "#{now} - #{who} - #{str}"
+      log_str = "#{now} - #{who} - #{str}"
+
+      case @logger
+      when IO
+        @logger.puts log_str
+      when Events
+        @logger.log log_str
+      end
     end
 
     def call(env, socket)

data/lib/puma/thread_pool.rb

@@ -4,6 +4,13 @@ module Puma
   # A simple thread pool management object.
   #
   class ThreadPool
+    class ForceShutdown < RuntimeError
+    end
+
+    # How long, after raising the ForceShutdown of a thread during
+    # forced shutdown mode, to wait for the thread to try and finish
+    # up its work before leaving the thread to die on the vine.
+    SHUTDOWN_GRACE_TIME = 5 # seconds
 
     # Maintain a minimum of +min+ and maximum of +max+ threads
     # in the pool.
@@ -45,6 +52,12 @@ module Puma
     attr_reader :spawned, :trim_requested
     attr_accessor :clean_thread_locals
 
+    def self.clean_thread_locals
+      Thread.current.keys.each do |key| # rubocop: disable Performance/HashEachMethods
+        Thread.current[key] = nil unless key == :__recursive_key__
+      end
+    end
+
     # How many objects have yet to be processed by the pool?
     #
     def backlog
@@ -58,7 +71,9 @@ module Puma
     def spawn_thread
       @spawned += 1
 
-      th = Thread.new do
+      th = Thread.new(@spawned) do |spawned|
+        # Thread name is new in Ruby 2.3
+        Thread.current.name = 'puma %03i' % spawned if Thread.current.respond_to?(:name=)
         todo  = @todo
         block = @block
         mutex = @mutex
@@ -77,6 +92,7 @@ module Puma
               if @trim_requested > 0
                 @trim_requested -= 1
                 continue = false
+                not_full.signal
                 break
               end
 
@@ -97,14 +113,13 @@ module Puma
           break unless continue
 
           if @clean_thread_locals
-            Thread.current.keys.each do |key|
-              Thread.current[key] = nil unless key == :__recursive_key__
-            end
+            ThreadPool.clean_thread_locals
           end
 
           begin
             block.call(work, *extra)
-          rescue Exception
+          rescue Exception => e
+            STDERR.puts "Error reached top of thread-pool: #{e.message} (#{e.class})"
           end
         end
 
@@ -140,7 +155,15 @@ module Puma
 
     def wait_until_not_full
       @mutex.synchronize do
-        until @todo.size - @waiting < @max - @spawned or @shutdown
+        while true
+          return if @shutdown
+          return if @waiting > 0
+
+          # If we can still spin up new threads and there
+          # is work queued, then accept more work until we would
+          # spin up the max number of threads.
+          return if @todo.size < @max - @spawned
+
           @not_full.wait @mutex
         end
       end
@@ -170,7 +193,9 @@ module Puma
           @spawned -= 1
         end
 
-        @workers -= dead_workers
+        @workers.delete_if do |w|
+          dead_workers.include?(w)
+        end
       end
     end
 
@@ -198,7 +223,7 @@ module Puma
       end
     end
 
-    def auto_trim!(timeout=5)
+    def auto_trim!(timeout=30)
       @auto_trim = AutoTrim.new(self, timeout)
       @auto_trim.start!
     end
@@ -234,7 +259,7 @@ module Puma
 
     # Tell all threads in the pool to exit and wait for them to finish.
     #
-    def shutdown
+    def shutdown(timeout=-1)
       threads = @mutex.synchronize do
         @shutdown = true
         @not_empty.broadcast
@@ -246,7 +271,32 @@ module Puma
         @workers.dup
       end
 
-      threads.each(&:join)
+      if timeout == -1
+        # Wait for threads to finish without force shutdown.
+        threads.each(&:join)
+      else
+        # Wait for threads to finish after n attempts (+timeout+).
+        # If threads are still running, it will forcefully kill them.
+        timeout.times do
+          threads.delete_if do |t|
+            t.join 1
+          end
+
+          if threads.empty?
+            break
+          else
+            sleep 1
+          end
+        end
+
+        threads.each do |t|
+          t.raise ForceShutdown
+        end
+
+        threads.each do |t|
+          t.join SHUTDOWN_GRACE_TIME
+        end
+      end
 
       @spawned = 0
       @workers = []

data/lib/puma/util.rb

@@ -1,10 +1,6 @@
 major, minor, patch = RUBY_VERSION.split('.').map { |v| v.to_i }
 
-if major == 1 && minor < 9
-  require 'puma/rack/backports/uri/common_18'
-elsif major == 1 && minor == 9 && patch == 2 && RUBY_PATCHLEVEL <= 328 && RUBY_ENGINE != 'jruby'
-  require 'puma/rack/backports/uri/common_192'
-elsif major == 1 && minor == 9 && patch == 3 && RUBY_PATCHLEVEL < 125
+if major == 1 && minor == 9 && patch == 3 && RUBY_PATCHLEVEL < 125
   require 'puma/rack/backports/uri/common_193'
 else
   require 'uri/common'

data/lib/puma.rb

@@ -1,7 +1,6 @@
 # Standard libraries
 require 'socket'
 require 'tempfile'
-require 'yaml'
 require 'time'
 require 'etc'
 require 'uri'
@@ -9,6 +8,16 @@ require 'stringio'
 
 require 'thread'
 
-# Ruby Puma
-require 'puma/const'
-require 'puma/server'
+module Puma
+  autoload :Const, 'puma/const'
+  autoload :Server, 'puma/server'
+  autoload :Launcher, 'puma/launcher'
+
+  def self.stats_object=(val)
+    @get_stats = val
+  end
+
+  def self.stats
+    @get_stats.stats
+  end
+end