puma 3.0.0.rc1 → 5.0.0.beta1

data/lib/puma/runner.rb

@@ -1,4 +1,13 @@
+# frozen_string_literal: true
+
+require 'puma/server'
+require 'puma/const'
+require 'puma/minissl/context_builder'
+
 module Puma
+  # Generic class that is used by `Puma::Cluster` and `Puma::Single` to
+  # serve requests. This class spawns a new instance of `Puma::Server` via
+  # a call to `start_server`.
   class Runner
     def initialize(cli, events)
       @launcher = cli
@@ -6,16 +15,17 @@ module Puma
       @options = cli.options
       @app = nil
       @control = nil
-    end
-
-    def daemon?
-      @options[:daemon]
+      @started_at = Time.now
     end
 
     def development?
       @options[:environment] == "development"
     end
 
+    def test?
+      @options[:environment] == "test"
+    end
+
     def log(str)
       @events.log str
     end
@@ -38,41 +48,35 @@ module Puma
 
       require 'puma/app/status'
 
-      uri = URI.parse str
-
-      app = Puma::App::Status.new @launcher
-
       if token = @options[:control_auth_token]
-        app.auth_token = token unless token.empty? or token == :none
+        token = nil if token.empty? || token == 'none'
       end
 
+      app = Puma::App::Status.new @launcher, token
+
       control = Puma::Server.new app, @launcher.events
       control.min_threads = 0
       control.max_threads = 1
 
-      case uri.scheme
-      when "tcp"
-        log "* Starting control server on #{str}"
-        control.add_tcp_listener uri.host, uri.port
-      when "unix"
-        log "* Starting control server on #{str}"
-        path = "#{uri.host}#{uri.path}"
-        mask = @options[:control_url_umask]
-
-        control.add_unix_listener path, mask
-      else
-        error "Invalid control URI: #{str}"
-      end
+      control.binder.parse [str], self, 'Starting control server'
 
       control.run
       @control = control
     end
 
+    def close_control_listeners
+      @control.binder.close_listeners if @control
+    end
+
     def ruby_engine
       if !defined?(RUBY_ENGINE) || RUBY_ENGINE == "ruby"
         "ruby #{RUBY_VERSION}-p#{RUBY_PATCHLEVEL}"
       else
-        "#{RUBY_ENGINE} #{RUBY_VERSION}"
+        if defined?(RUBY_ENGINE_VERSION)
+          "#{RUBY_ENGINE} #{RUBY_ENGINE_VERSION} - ruby #{RUBY_VERSION}"
+        else
+          "#{RUBY_ENGINE} #{RUBY_VERSION}"
+        end
       end
     end
 
@@ -84,10 +88,10 @@ module Puma
       log "* Version #{Puma::Const::PUMA_VERSION} (#{ruby_engine}), codename: #{Puma::Const::CODE_NAME}"
       log "* Min threads: #{min_t}, max threads: #{max_t}"
       log "* Environment: #{ENV['RACK_ENV']}"
+    end
 
-      if @options[:mode] == :tcp
-        log "* Mode: Lopez Express (tcp)"
-      end
+    def redirected_io?
+      @options[:redirect_stdout] || @options[:redirect_stderr]
     end
 
     def redirect_io
@@ -96,12 +100,20 @@ module Puma
       append = @options[:redirect_append]
 
       if stdout
+        unless Dir.exist?(File.dirname(stdout))
+          raise "Cannot redirect STDOUT to #{stdout}"
+        end
+
         STDOUT.reopen stdout, (append ? "a" : "w")
         STDOUT.sync = true
         STDOUT.puts "=== puma startup: #{Time.now} ==="
       end
 
       if stderr
+        unless Dir.exist?(File.dirname(stderr))
+          raise "Cannot redirect STDERR to #{stderr}"
+        end
+
         STDERR.reopen stderr, (append ? "a" : "w")
         STDERR.sync = true
         STDERR.puts "=== puma startup: #{Time.now} ==="
@@ -114,7 +126,6 @@ module Puma
         exit 1
       end
 
-      # Load the app before we daemonize.
       begin
         @app = @launcher.config.app
       rescue Exception => e
@@ -138,11 +149,11 @@ module Puma
       server.max_threads = max_t
       server.inherit_binder @launcher.binder
 
-      if @options[:mode] == :tcp
-        server.tcp_mode!
+      if @options[:early_hints]
+        server.early_hints = true
       end
 
-      unless development?
+      unless development? || test?
         server.leak_stack_on_error = false
       end
 

data/lib/puma/server.rb

@@ -1,35 +1,43 @@
+# frozen_string_literal: true
+
 require 'stringio'
 
 require 'puma/thread_pool'
 require 'puma/const'
 require 'puma/events'
 require 'puma/null_io'
-require 'puma/compat'
 require 'puma/reactor'
 require 'puma/client'
 require 'puma/binder'
-require 'puma/delegation'
 require 'puma/accept_nonblock'
 require 'puma/util'
+require 'puma/io_buffer'
 
 require 'puma/puma_http11'
 
-unless Puma.const_defined? "IOBuffer"
-  require 'puma/io_buffer'
-end
-
 require 'socket'
+require 'forwardable'
 
 module Puma
 
   # The HTTP Server itself. Serves out a single Rack app.
+  #
+  # This class is used by the `Puma::Single` and `Puma::Cluster` classes
+  # to generate one or more `Puma::Server` instances capable of handling requests.
+  # Each Puma process will contain one `Puma::Server` instance.
+  #
+  # The `Puma::Server` instance pulls requests from the socket, adds them to a
+  # `Puma::Reactor` where they get eventually passed to a `Puma::ThreadPool`.
+  #
+  # Each `Puma::Server` will have one reactor and one thread pool.
   class Server
 
     include Puma::Const
-    extend  Puma::Delegation
+    extend Forwardable
 
     attr_reader :thread
     attr_reader :events
+    attr_reader :requests_count
     attr_accessor :app
 
     attr_accessor :min_threads
@@ -51,24 +59,22 @@ module Puma
       @app = app
       @events = events
 
-      @check, @notify = Puma::Util.pipe
-
+      @check, @notify = nil
       @status = :stop
 
       @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
 
@@ -78,28 +84,26 @@ module Puma
       ENV['RACK_ENV'] ||= "development"
 
       @mode = :http
+
+      @precheck_closing = true
+
+      @requests_count = 0
     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_delegators :@binder, :add_tcp_listener, :add_ssl_listener, :add_unix_listener, :connected_ports
 
     def inherit_binder(bind)
       @binder = bind
-      @own_binder = false
-    end
-
-    def tcp_mode!
-      @mode = :tcp
     end
 
     # On Linux, use TCP_CORK to better control how the TCP stack
     # 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
@@ -107,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
 
@@ -114,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
@@ -122,6 +145,10 @@ module Puma
 
       def uncork_socket(socket)
       end
+
+      def closed_socket?(socket)
+        false
+      end
     end
 
     def backlog
@@ -132,94 +159,18 @@ module Puma
       @thread_pool and @thread_pool.spawned
     end
 
-    # Lopez Mode == raw tcp apps
 
-    def run_lopez_mode(background=true)
-      @thread_pool = ThreadPool.new(@min_threads,
-                                    @max_threads,
-                                    Hash) do |client, tl|
-
-        io = client.to_io
-        addr = io.peeraddr.last
-
-        if addr.empty?
-          # Set unix socket addrs to localhost
-          addr = "127.0.0.1:0"
-        else
-          addr = "#{addr}:#{io.peeraddr[1]}"
-        end
-
-        env = { 'thread' => tl, REMOTE_ADDR => addr }
-
-        begin
-          @app.call env, client.to_io
-        rescue Object => e
-          STDERR.puts "! Detected exception at toplevel: #{e.message} (#{e.class})"
-          STDERR.puts e.backtrace
-        end
-
-        client.close unless env['detach']
-      end
-
-      @events.fire :state, :running
-
-      if background
-        @thread = Thread.new { handle_servers_lopez_mode }
-        return @thread
-      else
-        handle_servers_lopez_mode
-      end
+    # This number represents the number of requests that
+    # the server is capable of taking right now.
+    #
+    # For example if the number is 5 then it means
+    # there are 5 threads sitting idle ready to take
+    # a request. If one request comes in, then the
+    # value would be 4 until it finishes processing.
+    def pool_capacity
+      @thread_pool and @thread_pool.pool_capacity
     end
 
-    def handle_servers_lopez_mode
-      begin
-        check = @check
-        sockets = [check] + @binder.ios
-        pool = @thread_pool
-
-        while @status == :run
-          begin
-            ios = IO.select sockets
-            ios.first.each do |sock|
-              if sock == check
-                break if handle_check
-              else
-                begin
-                  if io = sock.accept_nonblock
-                    client = Client.new io, nil
-                    pool << client
-                  end
-                rescue SystemCallError
-                  # nothing
-                rescue Errno::ECONNABORTED
-                  # client closed the socket even before accept
-                  io.close rescue nil
-                end
-              end
-            end
-          rescue Object => e
-            @events.unknown_error self, e, "Listen loop"
-          end
-        end
-
-        @events.fire :state, @status
-
-        graceful_shutdown if @status == :stop || @status == :restart
-
-      rescue Exception => e
-        STDERR.puts "Exception handling servers: #{e.message} (#{e.class})"
-        STDERR.puts e.backtrace
-      ensure
-        @check.close
-        @notify.close
-
-        if @status != :restart and @own_binder
-          @binder.close
-        end
-      end
-
-      @events.fire :state, :done
-    end
     # Runs the server.
     #
     # If +background+ is true (the default) then a thread is spun
@@ -233,22 +184,20 @@ module Puma
 
       @status = :run
 
-      if @mode == :tcp
-        return run_lopez_mode(background)
-      end
-
-      queue_requests = @queue_requests
-
       @thread_pool = ThreadPool.new(@min_threads,
                                     @max_threads,
-                                    IOBuffer) do |client, buffer|
+                                    ::Puma::IOBuffer) do |client, buffer|
+
+        # Advertise this server into the thread
+        Thread.current[ThreadLocalKey] = self
+
         process_now = false
 
         begin
-          if queue_requests
+          if @queue_requests
             process_now = client.eagerly_finish
           else
-            client.finish
+            client.finish(@first_data_timeout)
             process_now = true
           end
         rescue MiniSSL::SSLError => e
@@ -260,11 +209,11 @@ module Puma
 
           @events.ssl_error self, addr, cert, e
         rescue HttpParserError => e
-          client.write_400
+          client.write_error(400)
           client.close
 
           @events.parse_error self, client.env, e
-        rescue ConnectionError
+        rescue ConnectionError, EOFError
           client.close
         else
           if process_now
@@ -274,11 +223,14 @@ module Puma
             @reactor.add client
           end
         end
+
+        process_now
       end
 
+      @thread_pool.out_of_band_hook = @options[:out_of_band]
       @thread_pool.clean_thread_locals = @options[:clean_thread_locals]
 
-      if queue_requests
+      if @queue_requests
         @reactor = Reactor.new self, @thread_pool
         @reactor.run_in_thread
       end
@@ -294,7 +246,10 @@ module Puma
       @events.fire :state, :running
 
       if background
-        @thread = Thread.new { handle_servers }
+        @thread = Thread.new do
+          Puma.set_thread_name "server"
+          handle_servers
+        end
         return @thread
       else
         handle_servers
@@ -302,6 +257,7 @@ module Puma
     end
 
     def handle_servers
+      @check, @notify = Puma::Util.pipe unless @notify
       begin
         check = @check
         sockets = [check] + @binder.ios
@@ -326,6 +282,10 @@ module Puma
                 break if handle_check
               else
                 begin
+                  pool.wait_until_not_full
+                  pool.wait_for_less_busy_worker(
+                    @options[:wait_for_less_busy_worker].to_f)
+
                   if io = sock.accept_nonblock
                     client = Client.new io, @binder.env(sock)
                     if remote_addr_value
@@ -335,13 +295,16 @@ module Puma
                     end
 
                     pool << client
-                    pool.wait_until_not_full unless queue_requests
                   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
@@ -352,21 +315,20 @@ module Puma
 
         @events.fire :state, @status
 
-        graceful_shutdown if @status == :stop || @status == :restart
         if queue_requests
-          @reactor.clear! if @status == :restart
+          @queue_requests = false
+          @reactor.clear!
           @reactor.shutdown
         end
+        graceful_shutdown if @status == :stop || @status == :restart
       rescue Exception => e
         STDERR.puts "Exception handling servers: #{e.message} (#{e.class})"
         STDERR.puts e.backtrace
       ensure
-        @check.close
+        @check.close unless @check.closed? # Ruby 2.2 issue
         @notify.close
-
-        if @status != :restart and @own_binder
-          @binder.close
-        end
+        @notify = nil
+        @check = nil
       end
 
       @events.fire :state, :done
@@ -399,8 +361,12 @@ module Puma
     #
     def process_client(client, buffer)
       begin
+
+        clean_thread_locals = @options[:clean_thread_locals]
         close_socket = true
 
+        requests = 0
+
         while true
           case handle_request(client, buffer)
           when false
@@ -409,10 +375,24 @@ module Puma
             close_socket = false
             return
           when true
-            return unless @queue_requests
             buffer.reset
 
-            unless client.reset(@status == :run)
+            ThreadPool.clean_thread_locals if clean_thread_locals
+
+            requests += 1
+
+            check_for_more_data = @status == :run
+
+            if requests >= MAX_FAST_INLINE
+              # This will mean that reset will only try to use the data it already
+              # has buffered and won't try to read more data. What this means is that
+              # every client, independent of their request speed, gets treated like a slow
+              # one once every MAX_FAST_INLINE requests.
+              check_for_more_data = false
+            end
+
+            unless client.reset(check_for_more_data)
+              return unless @queue_requests
               close_socket = false
               client.set_timeout @persistent_timeout
               @reactor.add client
@@ -427,6 +407,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
@@ -437,13 +419,17 @@ module Puma
 
       # The client doesn't know HTTP well
       rescue HttpParserError => e
-        client.write_400
+        lowlevel_error(e, client.env)
+
+        client.write_error(400)
 
         @events.parse_error self, client.env, e
 
       # Server error
       rescue StandardError => e
-        client.write_500
+        lowlevel_error(e, client.env)
+
+        client.write_error(500)
 
         @events.unknown_error self, e, "Read"
 
@@ -453,6 +439,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"
@@ -483,6 +470,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]
@@ -513,23 +504,34 @@ module Puma
     end
 
     def default_server_port(env)
-      return PORT_443 if env[HTTPS_KEY] == 'on' || env[HTTPS_KEY] == 'https'
-      env['HTTP_X_FORWARDED_PROTO'] == 'https' ? PORT_443 : PORT_80
+      if ['on', HTTPS].include?(env[HTTPS_KEY]) || env[HTTP_X_FORWARDED_PROTO].to_s[0...5] == HTTPS || env[HTTP_X_FORWARDED_SCHEME] == HTTPS || env[HTTP_X_FORWARDED_SSL] == "on"
+        PORT_443
+      else
+        PORT_80
+      end
     end
 
-    # Given the request +env+ from +client+ and a partial request body
-    # in +body+, finish reading the body if there is one and invoke
-    # the rack app. Then construct the response and write it back to
-    # +client+
+    # Takes the request +req+, invokes the Rack application to construct
+    # the response and writes it back to +req.io+.
+    #
+    # The second parameter +lines+ is a IO-like object unique to this thread.
+    # This is normally an instance of Puma::IOBuffer.
+    #
+    # It'll return +false+ when the connection is closed, this doesn't mean
+    # that the response wasn't successful.
     #
-    # +cl+ is the previously fetched Content-Length header if there
-    # was one. This is an optimization to keep from having to look
-    # it up again.
+    # It'll return +:async+ if the connection remains open but will be handled
+    # elsewhere, i.e. the connection has been hijacked by the Rack application.
     #
+    # Finally, it'll return +true+ on keep-alive connections.
     def handle_request(req, lines)
+      @requests_count +=1
+
       env = req.env
       client = req.io
 
+      return false if closed_socket?(client)
+
       normalize_env env, req
 
       env[PUMA_SOCKET] = client
@@ -546,7 +548,30 @@ module Puma
       head = env[REQUEST_METHOD] == HEAD
 
       env[RACK_INPUT] = body
-      env[RACK_URL_SCHEME] =  env[HTTPS_KEY] ? HTTPS : HTTP
+      env[RACK_URL_SCHEME] = default_server_port(env) == PORT_443 ? HTTPS : HTTP
+
+      if @early_hints
+        env[EARLY_HINTS] = lambda { |headers|
+          begin
+            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|
+                  next if possible_header_injection?(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
+          rescue ConnectionError
+            # noop, if we lost the socket we just won't send the early hints
+          end
+        }
+      end
 
       # A rack extension. If the app writes #call'ables to this
       # array, we will invoke them when the request is done.
@@ -568,10 +593,15 @@ module Puma
 
             return :async
           end
-        rescue StandardError => e
-          @events.unknown_error self, e, "Rack app"
+        rescue ThreadPool::ForceShutdown => e
+          @events.unknown_error self, e, "Rack app", env
+          @events.log "Detected force shutdown of a thread"
+
+          status, headers, res_body = lowlevel_error(e, env, 503)
+        rescue Exception => e
+          @events.unknown_error self, e, "Rack app", env
 
-          status, headers, res_body = lowlevel_error(e)
+          status, headers, res_body = lowlevel_error(e, env, 500)
         end
 
         content_length = nil
@@ -586,10 +616,10 @@ module Puma
         line_ending = LINE_END
         colon = COLON
 
-        http_11 = if env[HTTP_VERSION] == HTTP_11
+        http_11 = env[HTTP_VERSION] == HTTP_11
+        if http_11
           allow_chunked = true
           keep_alive = env.fetch(HTTP_CONNECTION, "").downcase != CLOSE
-          include_keepalive_header = false
 
           # An optimization. The most common response is 200, so we can
           # reply with the proper 200 status without having to compute
@@ -603,11 +633,9 @@ module Puma
 
             no_body ||= status < 200 || STATUS_WITH_NO_ENTITY_BODY[status]
           end
-          true
         else
           allow_chunked = false
           keep_alive = env.fetch(HTTP_CONNECTION, "").downcase == KEEP_ALIVE
-          include_keepalive_header = keep_alive
 
           # Same optimization as above for HTTP/1.1
           #
@@ -619,14 +647,18 @@ module Puma
 
             no_body ||= status < 200 || STATUS_WITH_NO_ENTITY_BODY[status]
           end
-          false
         end
 
+        # regardless of what the client wants, we always close the connection
+        # if running without request queueing
+        keep_alive &&= @queue_requests
+
         response_hijack = nil
 
         headers.each do |k, vs|
           case k.downcase
           when CONTENT_LENGTH2
+            next if possible_header_injection?(vs)
             content_length = vs
             next
           when TRANSFER_ENCODING
@@ -637,8 +669,9 @@ 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|
+              next if possible_header_injection?(v)
               lines.append k, colon, v, line_ending
             end
           else
@@ -646,10 +679,15 @@ module Puma
           end
         end
 
-        if include_keepalive_header
-          lines << CONNECTION_KEEP_ALIVE
-        elsif http_11 && !keep_alive
-          lines << CONNECTION_CLOSE
+        # HTTP/1.1 & 1.0 assume different defaults:
+        # - HTTP 1.0 assumes the connection will be closed if not specified
+        # - HTTP 1.1 assumes the connection will be kept alive if not specified.
+        # Only set the header if we're doing something which is not the default
+        # for this protocol version
+        if http_11
+          lines << CONNECTION_CLOSE if !keep_alive
+        else
+          lines << CONNECTION_KEEP_ALIVE if keep_alive
         end
 
         if no_body
@@ -681,8 +719,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
@@ -720,7 +758,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.
     #
@@ -776,15 +814,21 @@ module Puma
 
     # A fallback rack response if +@app+ raises as exception.
     #
-    def lowlevel_error(e)
+    def lowlevel_error(e, env, status=500)
       if handler = @options[:lowlevel_error_handler]
-        return handler.call(e)
+        if handler.arity == 1
+          return handler.call(e)
+        elsif handler.arity == 2
+          return handler.call(e, env)
+        else
+          return handler.call(e, env, status)
+        end
       end
 
       if @leak_stack_on_error
-        [500, {}, ["Puma caught this error: #{e.message} (#{e.class})\n#{e.backtrace.join("\n")}"]]
+        [status, {}, ["Puma caught this error: #{e.message} (#{e.class})\n#{e.backtrace.join("\n")}"]]
       else
-        [500, {}, ["An unhandled lowlevel error occurred. The application logs may have details.\n"]]
+        [status, {}, ["An unhandled lowlevel error occurred. The application logs may have details.\n"]]
       end
     end
 
@@ -828,38 +872,53 @@ module Puma
         @events.debug "Drained #{count} additional connections."
       end
 
-      @thread_pool.shutdown if @thread_pool
+      if @status != :restart
+        @binder.close
+      end
+
+      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)
+      @check, @notify = Puma::Util.pipe unless @notify
       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
+    def begin_restart(sync=false)
+      notify_safely(RESTART_COMMAND)
+      @thread.join if @thread && sync
     end
 
     def fast_write(io, str)
@@ -882,5 +941,28 @@ 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
+
+    def possible_header_injection?(header_value)
+      HTTP_INJECTION_REGEX =~ header_value.to_s
+    end
+    private :possible_header_injection?
+
+    # List of methods invoked by #stats.
+    STAT_METHODS = [:backlog, :running, :pool_capacity, :max_threads, :requests_count].freeze
+
+    # Returns a hash of stats about the running server for reporting purposes.
+    def stats
+      STAT_METHODS.map {|name| [name, send(name) || 0]}.to_h
+    end
   end
 end