puma 6.0.2 → 6.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 83bb232727e7777f406dcacc150db80426972c1e65635f1d81d771fee3585060
-  data.tar.gz: 16453cd88384851586d3ff6bc274393b44a6a078eaec9932cac795009fc342fb
+  metadata.gz: 1df130ccb43143b23de48c5dc2f0890165e078eba4f09432b0a73411b5b54a94
+  data.tar.gz: e562fc40625877488fd13719e9620f2401394a33a74bee46e5a4731becfab6ae
 SHA512:
-  metadata.gz: ce357b7686a54c2d0e820d70f24bb427803ba9e7aa24a8b0511624dc4ef850e937b9261575462d6a20a0c69f73d1fefa939a242d8e3e5e9577fdd4e45a862af2
-  data.tar.gz: 3d9fda444a65d5917872261ff4dff8f3e156aec8a1d06d72cc19201da8f820b0262baac73665bb062355966a8d9415ed5b92d01f4c8ad6e312737141c657e823
+  metadata.gz: e436db46a9761b73dc370a38e1e59a0e2ac1e385ecf578fc631fc4671329b9cbcfd634e9bed73e17657c13eaf53387a55726d9c986739f6f9ccdb4223fea026e
+  data.tar.gz: db4526766e567440a95129831ef30cea038a98e9d613dc76308c96d0d81913d4e15fbb9c1c8d111ce395af0d908268316cb65c04511dbfbd8361fab31a62634a

data/History.md

@@ -1,3 +1,19 @@
+## 6.1.0 / 2022-02-12
+
+* Features
+  * WebSocket support via partial hijack ([#3058], [#3007])
+  * Add built-in systemd notify support ([#3011])
+  * Periodically send status to systemd ([#3006], [#2604])
+  * Introduce the ability to return 413: payload too large for requests ([#3040])
+  * Log loaded extensions when `PUMA_DEBUG` is set ([#3036], [#3020])
+
+* Bugfixes
+  * Fix issue with rack 3 compatibility re: rackup ([#3061], [#3057])
+  * Allow setting TCP low_latency with SSL listener ([#3065])
+
+* Performance
+  * Reduce memory usage for large file uploads ([#3062])
+
 ## 6.0.2 / 2023-01-01
 
 * Refactor
@@ -1932,6 +1948,18 @@ be added back in a future date when a java Puma::MiniSSL is added.
 * Bugfixes
   * Your bugfix goes here <Most recent on the top, like GitHub> (#Github Number)
 
+[#3058]:https://github.com/puma/puma/pull/3058     "PR by @dentarg, merged 2023-01-29"
+[#3007]:https://github.com/puma/puma/issues/3007   "Issue by @MSP-Greg, closed 2023-01-29"
+[#3011]:https://github.com/puma/puma/pull/3011     "PR by @joaomarcos96, merged 2023-01-03"
+[#3006]:https://github.com/puma/puma/pull/3006     "PR by @QWYNG, merged 2023-02-09"
+[#2604]:https://github.com/puma/puma/issues/2604   "Issue by @dgoetz, closed 2023-02-09"
+[#3040]:https://github.com/puma/puma/pull/3040     "PR by @shayonj, merged 2023-01-02"
+[#3036]:https://github.com/puma/puma/pull/3036     "PR by @MSP-Greg, merged 2023-01-13"
+[#3020]:https://github.com/puma/puma/issues/3020   "Issue by @dentarg, closed 2023-01-13"
+[#3061]:https://github.com/puma/puma/pull/3061     "PR by @MSP-Greg, merged 2023-02-12"
+[#3057]:https://github.com/puma/puma/issues/3057   "Issue by @mmarvb8h, closed 2023-02-12"
+[#3065]:https://github.com/puma/puma/pull/3065     "PR by @MSP-Greg, merged 2023-02-11"
+[#3062]:https://github.com/puma/puma/pull/3062     "PR by @willkoehler, merged 2023-01-29"
 [#3035]:https://github.com/puma/puma/pull/3035     "PR by @MSP-Greg, merged 2022-12-24"
 [#3033]:https://github.com/puma/puma/issues/3033   "Issue by @jules-w2, closed 2022-12-24"
 [#3016]:https://github.com/puma/puma/pull/3016     "PR by @MSP-Greg, merged 2022-12-24"

data/README.md

@@ -365,6 +365,7 @@ Community guides:
 * [puma-metrics](https://github.com/harmjanblok/puma-metrics) — export Puma metrics to Prometheus
 * [puma-plugin-statsd](https://github.com/yob/puma-plugin-statsd) — send Puma metrics to statsd
 * [puma-plugin-systemd](https://github.com/sj26/puma-plugin-systemd) — deeper integration with systemd for notify, status and watchdog
+* [puma-plugin-telemetry](https://github.com/babbel/puma-plugin-telemetry) - telemetry plugin for Puma offering various targets to publish
 
 ### Monitoring
 

data/docs/systemd.md

@@ -24,8 +24,7 @@ After=network.target
 
 [Service]
 # Puma supports systemd's `Type=notify` and watchdog service
-# monitoring, if the [sd_notify](https://github.com/agis/ruby-sdnotify) gem is installed,
-# as of Puma 5.1 or later.
+# monitoring, as of Puma 5.1 or later.
 # On earlier versions of Puma or JRuby, change this to `Type=simple` and remove
 # the `WatchdogSec` line.
 Type=notify

data/lib/puma/binder.rb

@@ -158,10 +158,10 @@ module Puma
             ios_len = @ios.length
             params = Util.parse_query uri.query
 
-            opt = params.key?('low_latency') && params['low_latency'] != 'false'
+            low_latency = params.key?('low_latency') && params['low_latency'] != 'false'
             backlog = params.fetch('backlog', 1024).to_i
 
-            io = add_tcp_listener uri.host, uri.port, opt, backlog
+            io = add_tcp_listener uri.host, uri.port, low_latency, backlog
 
             @ios[ios_len..-1].each do |i|
               addr = loc_addr_str i
@@ -251,7 +251,8 @@ module Puma
           else
             ios_len = @ios.length
             backlog = params.fetch('backlog', 1024).to_i
-            io = add_ssl_listener uri.host, uri.port, ctx, optimize_for_latency = true, backlog
+            low_latency = params['low_latency'] != 'false'
+            io = add_ssl_listener uri.host, uri.port, ctx, low_latency, backlog
 
             @ios[ios_len..-1].each do |i|
               addr = loc_addr_str i

data/lib/puma/client.rb

@@ -86,6 +86,9 @@ module Puma
       @requests_served = 0
       @hijacked = false
 
+      @http_content_length_limit = nil
+      @http_content_length_limit_exceeded = false
+
       @peerip = nil
       @peer_family = nil
       @listener = nil
@@ -95,12 +98,14 @@ module Puma
       @body_remain = 0
 
       @in_last_chunk = false
+
+      @read_buffer = +""
     end
 
     attr_reader :env, :to_io, :body, :io, :timeout_at, :ready, :hijacked,
-                :tempfile, :io_buffer
+                :tempfile, :io_buffer, :http_content_length_limit_exceeded
 
-    attr_writer :peerip
+    attr_writer :peerip, :http_content_length_limit
 
     attr_accessor :remote_addr_header, :listener
 
@@ -151,6 +156,7 @@ module Puma
       @body_remain = 0
       @peerip = nil if @remote_addr_header
       @in_last_chunk = false
+      @http_content_length_limit_exceeded = false
 
       if @buffer
         return false unless try_to_parse_proxy_protocol
@@ -210,6 +216,17 @@ module Puma
     end
 
     def try_to_finish
+      if env[CONTENT_LENGTH] && above_http_content_limit(env[CONTENT_LENGTH].to_i)
+        @http_content_length_limit_exceeded = true
+      end
+
+      if @http_content_length_limit_exceeded
+        @buffer = nil
+        @body = EmptyBody
+        set_ready
+        return true
+      end
+
       return read_body if in_data_phase
 
       begin
@@ -239,6 +256,10 @@ module Puma
 
       @parsed_bytes = @parser.execute(@env, @buffer, @parsed_bytes)
 
+      if @parser.finished? && above_http_content_limit(@parser.body.bytesize)
+        @http_content_length_limit_exceeded = true
+      end
+
       if @parser.finished?
         return setup_body
       elsif @parsed_bytes >= MAX_HEADER
@@ -414,7 +435,7 @@ module Puma
       end
 
       begin
-        chunk = @io.read_nonblock(want)
+        chunk = @io.read_nonblock(want, @read_buffer)
       rescue IO::WaitReadable
         return false
       rescue SystemCallError, IOError
@@ -446,7 +467,7 @@ module Puma
     def read_chunked_body
       while true
         begin
-          chunk = @io.read_nonblock(4096)
+          chunk = @io.read_nonblock(4096, @read_buffer)
         rescue IO::WaitReadable
           return false
         rescue SystemCallError, IOError
@@ -594,5 +615,9 @@ module Puma
       @requests_served += 1
       @ready = true
     end
+
+    def above_http_content_limit(value)
+      @http_content_length_limit&.< value
+    end
   end
 end

data/lib/puma/cluster/worker.rb

@@ -115,6 +115,11 @@ module Puma
 
         while restart_server.pop
           server_thread = server.run
+
+          if @log_writer.debug? && index == 0
+            debug_loaded_extensions "Loaded Extensions - worker 0:"
+          end
+
           stat_thread ||= Thread.new(@worker_write) do |io|
             Puma.set_thread_name "stat pld"
             base_payload = "p#{Process.pid}"

data/lib/puma/cluster.rb

@@ -467,6 +467,7 @@ module Puma
                   @events.fire(:ping!, w)
                   if !booted && @workers.none? {|worker| worker.last_status.empty?}
                     @events.fire_on_booted!
+                    debug_loaded_extensions("Loaded Extensions - master:") if @log_writer.debug?
                     booted = true
                   end
                 end
@@ -476,6 +477,7 @@ module Puma
             end
             if in_phased_restart && workers_not_booted.zero?
               @events.fire_on_booted!
+              debug_loaded_extensions("Loaded Extensions - master:") if @log_writer.debug?
               in_phased_restart = false
             end
 

data/lib/puma/configuration.rb

@@ -167,6 +167,7 @@ module Puma
       worker_shutdown_timeout: 30,
       worker_timeout: 60,
       workers: 0,
+      http_content_length_limit: nil
     }
 
     def initialize(user_options={}, default_options = {}, &block)

data/lib/puma/const.rb

@@ -99,8 +99,8 @@ module Puma
   # too taxing on performance.
   module Const
 
-    PUMA_VERSION = VERSION = "6.0.2"
-    CODE_NAME = "Sunflower"
+    PUMA_VERSION = VERSION = "6.1.0"
+    CODE_NAME = "The Way Up"
 
     PUMA_SERVER_STRING = ["puma", PUMA_VERSION, CODE_NAME].join(" ").freeze
 

data/lib/puma/dsl.rb

@@ -65,6 +65,7 @@ module Puma
 
       ca_additions = "&ca=#{Puma::Util.escape(opts[:ca])}" if ['peer', 'force_peer'].include?(verify)
 
+      low_latency_str = opts.key?(:low_latency) ? "&low_latency=#{opts[:low_latency]}" : ''
       backlog_str = opts[:backlog] ? "&backlog=#{Integer(opts[:backlog])}" : ''
 
       if defined?(JRUBY_VERSION)
@@ -114,7 +115,7 @@ module Puma
           end
 
         "ssl://#{host}:#{port}?#{cert_flags}#{key_flags}#{ssl_cipher_filter}" \
-          "#{reuse_flag}&verify_mode=#{verify}#{tls_str}#{ca_additions}#{v_flags}#{backlog_str}"
+          "#{reuse_flag}&verify_mode=#{verify}#{tls_str}#{ca_additions}#{v_flags}#{backlog_str}#{low_latency_str}"
       end
     end
 
@@ -1022,6 +1023,19 @@ module Puma
       @options[:mutate_stdout_and_stderr_to_sync_on_write] = enabled
     end
 
+    # Specify how big the request payload should be, in bytes.
+    # This limit is compared against Content-Length HTTP header.
+    # If the payload size (CONTENT_LENGTH) is larger than http_content_length_limit,
+    # HTTP 413 status code is returned.
+    #
+    # When no Content-Length http header is present, it is compared against the
+    # size of the body of the request.
+     #
+    # The default value for http_content_length_limit is nil.
+    def http_content_length_limit(limit)
+      @options[:http_content_length_limit] = limit
+    end
+
     private
 
     # To avoid adding cert_pem and key_pem as URI params, we store them on the

data/lib/puma/launcher.rb

@@ -59,6 +59,10 @@ module Puma
 
       @environment = conf.environment
 
+      if ENV["NOTIFY_SOCKET"]
+        @config.plugins.create('systemd')
+      end
+
       if @config.options[:bind_to_activated_sockets]
         @config.options[:binds] = @binder.synthesize_binds_from_activated_fs(
           @config.options[:binds],
@@ -180,7 +184,6 @@ module Puma
 
       setup_signals
       set_process_title
-      integrate_with_systemd
 
       # This blocks until the server is stopped
       @runner.run
@@ -311,27 +314,6 @@ module Puma
       @runner.reload_worker_directory if @runner.respond_to?(:reload_worker_directory)
     end
 
-    # Puma's systemd integration allows Puma to inform systemd:
-    #  1. when it has successfully started
-    #  2. when it is starting shutdown
-    #  3. periodically for a liveness check with a watchdog thread
-    def integrate_with_systemd
-      return unless ENV["NOTIFY_SOCKET"]
-
-      begin
-        require_relative 'systemd'
-      rescue LoadError
-        log "Systemd integration failed. It looks like you're trying to use systemd notify but don't have sd_notify gem installed"
-        return
-      end
-
-      log "* Enabling systemd notification integration"
-
-      systemd = Systemd.new(@log_writer, @events)
-      systemd.hook_events
-      systemd.start_watchdog
-    end
-
     def log(str)
       @log_writer.log(str)
     end

data/lib/puma/log_writer.rb

@@ -80,6 +80,10 @@ module Puma
     end
     private :internal_write
 
+    def debug?
+      @debug
+    end
+
     def debug(str)
       log("% #{str}") if @debug
     end

data/lib/puma/plugin/systemd.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require_relative '../plugin'
+
+# Puma's systemd integration allows Puma to inform systemd:
+#  1. when it has successfully started
+#  2. when it is starting shutdown
+#  3. periodically for a liveness check with a watchdog thread
+#  4. periodically set the status
+Puma::Plugin.create do
+  def start(launcher)
+    require_relative '../sd_notify'
+
+    launcher.log_writer.log "* Enabling systemd notification integration"
+
+    # hook_events
+    launcher.events.on_booted { Puma::SdNotify.ready }
+    launcher.events.on_stopped { Puma::SdNotify.stopping }
+    launcher.events.on_restart { Puma::SdNotify.reloading }
+
+    # start watchdog
+    if Puma::SdNotify.watchdog?
+      ping_f = watchdog_sleep_time
+
+      in_background do
+        launcher.log_writer.log "Pinging systemd watchdog every #{ping_f.round(1)} sec"
+        loop do
+          sleep ping_f
+          Puma::SdNotify.watchdog
+        end
+      end
+    end
+
+    # start status loop
+    instance = self
+    sleep_time = 1.0
+    in_background do
+      launcher.log_writer.log "Sending status to systemd every #{sleep_time.round(1)} sec"
+
+      loop do
+        sleep sleep_time
+        # TODO: error handling?
+        Puma::SdNotify.status(instance.status)
+      end
+    end
+  end
+
+  def status
+    if clustered?
+      messages = stats[:worker_status].map do |worker|
+        common_message(worker[:last_status])
+      end.join(',')
+
+      "Puma #{Puma::Const::VERSION}: cluster: #{booted_workers}/#{workers}, worker_status: [#{messages}]"
+    else
+      "Puma #{Puma::Const::VERSION}: worker: #{common_message(stats)}"
+    end
+  end
+
+  private
+
+  def watchdog_sleep_time
+    usec = Integer(ENV["WATCHDOG_USEC"])
+
+    sec_f = usec / 1_000_000.0
+    # "It is recommended that a daemon sends a keep-alive notification message
+    # to the service manager every half of the time returned here."
+    sec_f / 2
+  end
+
+  def stats
+    Puma.stats_hash
+  end
+
+  def clustered?
+    stats.has_key?(:workers)
+  end
+
+  def workers
+    stats.fetch(:workers, 1)
+  end
+
+  def booted_workers
+    stats.fetch(:booted_workers, 1)
+  end
+
+  def common_message(stats)
+    "{ #{stats[:running]}/#{stats[:max_threads]} threads, #{stats[:pool_capacity]} available, #{stats[:backlog]} backlog }"
+  end
+end

data/lib/puma/rack_default.rb

@@ -2,8 +2,23 @@
 
 require_relative '../rack/handler/puma'
 
-module Rack::Handler
-  def self.default(options = {})
-    Rack::Handler::Puma
+# rackup was removed in Rack 3, it is now a separate gem
+if Object.const_defined? :Rackup
+  module Rackup
+    module Handler
+      def self.default(options = {})
+        ::Rackup::Handler::Puma
+      end
+    end
   end
+elsif Object.const_defined?(:Rack) && Rack::RELEASE < '3'
+  module Rack
+    module Handler
+      def self.default(options = {})
+        ::Rack::Handler::Puma
+      end
+    end
+  end
+else
+  raise "Rack 3 must be used with the Rackup gem"
 end

data/lib/puma/request.rb

@@ -53,8 +53,13 @@ module Puma
       socket  = client.io   # io may be a MiniSSL::Socket
       app_body = nil
 
+
       return false if closed_socket?(socket)
 
+      if client.http_content_length_limit_exceeded
+        return prepare_response(413, {}, ["Payload Too Large"], requests, client)
+      end
+
       normalize_env env, client
 
       env[PUMA_SOCKET] = socket
@@ -168,7 +173,7 @@ module Puma
       # below converts app_body into body, dependent on app_body's characteristics, and
       # resp_info[:content_length] will be set if it can be determined
       if !resp_info[:content_length] && !resp_info[:transfer_encoding] && status != 204
-        if res_body.respond_to?(:to_ary) && (array_body = res_body.to_ary)
+        if res_body.respond_to?(:to_ary) && (array_body = res_body.to_ary) && array_body.is_a?(Array)
           body = array_body
           resp_info[:content_length] = body.sum(&:bytesize)
         elsif res_body.is_a?(File) && res_body.respond_to?(:size)
@@ -215,27 +220,33 @@ module Puma
       cork_socket socket
 
       if resp_info[:no_body]
-        if content_length and status != 204
+        # 101 (Switching Protocols) doesn't return here or have content_length,
+        # it should be using `response_hijack`
+        unless status == 101
+          if content_length && status != 204
+            io_buffer.append CONTENT_LENGTH_S, content_length.to_s, line_ending
+          end
+
+          io_buffer << LINE_END
+          fast_write_str socket, io_buffer.read_and_reset
+          socket.flush
+          return keep_alive
+        end
+      else
+        if content_length
           io_buffer.append CONTENT_LENGTH_S, content_length.to_s, line_ending
+          chunked = false
+        elsif !response_hijack && resp_info[:allow_chunked]
+          io_buffer << TRANSFER_ENCODING_CHUNKED
+          chunked = true
         end
-
-        io_buffer << LINE_END
-        fast_write_str socket, io_buffer.read_and_reset
-        socket.flush
-        return keep_alive
-      end
-      if content_length
-        io_buffer.append CONTENT_LENGTH_S, content_length.to_s, line_ending
-        chunked = false
-      elsif !response_hijack and resp_info[:allow_chunked]
-        io_buffer << TRANSFER_ENCODING_CHUNKED
-        chunked = true
       end
 
       io_buffer << line_ending
 
       if response_hijack
         fast_write_str socket, io_buffer.read_and_reset
+        uncork_socket socket
         response_hijack.call socket
         return :async
       end
@@ -295,8 +306,8 @@ module Puma
     def fast_write_response(socket, body, io_buffer, chunked, content_length)
       if body.is_a?(::File) && body.respond_to?(:read)
         if chunked  # would this ever happen?
-          while part = body.read(BODY_LEN_MAX)
-            io_buffer.append part.bytesize.to_s(16), LINE_END, part, LINE_END
+          while chunk = body.read(BODY_LEN_MAX)
+            io_buffer.append chunk.bytesize.to_s(16), LINE_END, chunk, LINE_END
           end
           fast_write_str socket, CLOSE_CHUNKED
         else
@@ -476,7 +487,7 @@ module Puma
       to_add = nil
 
       env.each do |k,v|
-        if k.start_with?("HTTP_") and k.include?(",") and k != "HTTP_TRANSFER,ENCODING"
+        if k.start_with?("HTTP_") && k.include?(",") && k != "HTTP_TRANSFER,ENCODING"
           if to_delete
             to_delete << k
           else

data/lib/puma/runner.rb

@@ -198,5 +198,12 @@ module Puma
         }
       }
     end
+
+    # this method call should always be guarded by `@log_writer.debug?`
+    def debug_loaded_extensions(str)
+      @log_writer.debug "────────────────────────────────── #{str}"
+      re_ext = /\.#{RbConfig::CONFIG['DLEXT']}\z/i
+      $LOADED_FEATURES.grep(re_ext).each { |f| @log_writer.debug("    #{f}") }
+    end
   end
 end

data/lib/puma/sd_notify.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require "socket"
+
+module Puma
+  # The MIT License
+  #
+  # Copyright (c) 2017-2022 Agis Anastasopoulos
+  #
+  # Permission is hereby granted, free of charge, to any person obtaining a copy of
+  # this software and associated documentation files (the "Software"), to deal in
+  # the Software without restriction, including without limitation the rights to
+  # use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+  # the Software, and to permit persons to whom the Software is furnished to do so,
+  # subject to the following conditions:
+  #
+  # The above copyright notice and this permission notice shall be included in all
+  # copies or substantial portions of the Software.
+  #
+  # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+  # FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+  # COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+  # IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+  # CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+  #
+  # This is a copy of https://github.com/agis/ruby-sdnotify as of commit cca575c
+  # The only changes made was "rehoming" it within the Puma module to avoid
+  # namespace collisions and applying standard's code formatting style.
+  #
+  # SdNotify is a pure-Ruby implementation of sd_notify(3). It can be used to
+  # notify systemd about state changes. Methods of this package are no-op on
+  # non-systemd systems (eg. Darwin).
+  #
+  # The API maps closely to the original implementation of sd_notify(3),
+  # therefore be sure to check the official man pages prior to using SdNotify.
+  #
+  # @see https://www.freedesktop.org/software/systemd/man/sd_notify.html
+  module SdNotify
+    # Exception raised when there's an error writing to the notification socket
+    class NotifyError < RuntimeError; end
+
+    READY     = "READY=1"
+    RELOADING = "RELOADING=1"
+    STOPPING  = "STOPPING=1"
+    STATUS    = "STATUS="
+    ERRNO     = "ERRNO="
+    MAINPID   = "MAINPID="
+    WATCHDOG  = "WATCHDOG=1"
+    FDSTORE   = "FDSTORE=1"
+
+    def self.ready(unset_env=false)
+      notify(READY, unset_env)
+    end
+
+    def self.reloading(unset_env=false)
+      notify(RELOADING, unset_env)
+    end
+
+    def self.stopping(unset_env=false)
+      notify(STOPPING, unset_env)
+    end
+
+    # @param status [String] a custom status string that describes the current
+    #   state of the service
+    def self.status(status, unset_env=false)
+      notify("#{STATUS}#{status}", unset_env)
+    end
+
+    # @param errno [Integer]
+    def self.errno(errno, unset_env=false)
+      notify("#{ERRNO}#{errno}", unset_env)
+    end
+
+    # @param pid [Integer]
+    def self.mainpid(pid, unset_env=false)
+      notify("#{MAINPID}#{pid}", unset_env)
+    end
+
+    def self.watchdog(unset_env=false)
+      notify(WATCHDOG, unset_env)
+    end
+
+    def self.fdstore(unset_env=false)
+      notify(FDSTORE, unset_env)
+    end
+
+    # @param [Boolean] true if the service manager expects watchdog keep-alive
+    #   notification messages to be sent from this process.
+    #
+    # If the $WATCHDOG_USEC environment variable is set,
+    # and the $WATCHDOG_PID variable is unset or set to the PID of the current
+    # process
+    #
+    # @note Unlike sd_watchdog_enabled(3), this method does not mutate the
+    #   environment.
+    def self.watchdog?
+      wd_usec = ENV["WATCHDOG_USEC"]
+      wd_pid = ENV["WATCHDOG_PID"]
+
+      return false if !wd_usec
+
+      begin
+        wd_usec = Integer(wd_usec)
+      rescue
+        return false
+      end
+
+      return false if wd_usec <= 0
+      return true if !wd_pid || wd_pid == $$.to_s
+
+      false
+    end
+
+    # Notify systemd with the provided state, via the notification socket, if
+    # any.
+    #
+    # Generally this method will be used indirectly through the other methods
+    # of the library.
+    #
+    # @param state [String]
+    # @param unset_env [Boolean]
+    #
+    # @return [Fixnum, nil] the number of bytes written to the notification
+    #   socket or nil if there was no socket to report to (eg. the program wasn't
+    #   started by systemd)
+    #
+    # @raise [NotifyError] if there was an error communicating with the systemd
+    #   socket
+    #
+    # @see https://www.freedesktop.org/software/systemd/man/sd_notify.html
+    def self.notify(state, unset_env=false)
+      sock = ENV["NOTIFY_SOCKET"]
+
+      return nil if !sock
+
+      ENV.delete("NOTIFY_SOCKET") if unset_env
+
+      begin
+        Addrinfo.unix(sock, :DGRAM).connect do |s|
+          s.close_on_exec = true
+          s.write(state)
+        end
+      rescue StandardError => e
+        raise NotifyError, "#{e.class}: #{e.message}", e.backtrace
+      end
+    end
+  end
+end

data/lib/puma/server.rb

@@ -95,6 +95,7 @@ module Puma
       @queue_requests      = @options[:queue_requests]
       @max_fast_inline     = @options[:max_fast_inline]
       @io_selector_backend = @options[:io_selector_backend]
+      @http_content_length_limit = @options[:http_content_length_limit]
 
       temp = !!(@options[:environment] =~ /\A(development|test)\z/)
       @leak_stack_on_error = @options[:environment] ? temp : true
@@ -334,6 +335,7 @@ module Puma
                 drain += 1 if shutting_down?
                 pool << Client.new(io, @binder.env(sock)).tap { |c|
                   c.listener = sock
+                  c.http_content_length_limit = @http_content_length_limit
                   c.send(addr_send_name, addr_value) if addr_value
                 }
               end

data/lib/puma/single.rb

@@ -57,6 +57,8 @@ module Puma
 
       @events.fire_on_booted!
 
+      debug_loaded_extensions("Loaded Extensions:") if @log_writer.debug?
+
       begin
         server_thread.join
       rescue Interrupt

data/lib/rack/handler/puma.rb

@@ -1,114 +1,136 @@
 # frozen_string_literal: true
 
-require 'rack/handler'
-
-module Rack
-  module Handler
-    module Puma
-      DEFAULT_OPTIONS = {
-        :Verbose => false,
-        :Silent  => false
-      }
-
-      def self.config(app, options = {})
-        require_relative '../../puma'
-        require_relative '../../puma/configuration'
-        require_relative '../../puma/log_writer'
-        require_relative '../../puma/launcher'
-
-        default_options = DEFAULT_OPTIONS.dup
-
-        # Libraries pass in values such as :Port and there is no way to determine
-        # if it is a default provided by the library or a special value provided
-        # by the user. A special key `user_supplied_options` can be passed. This
-        # contains an array of all explicitly defined user options. We then
-        # know that all other values are defaults
-        if user_supplied_options = options.delete(:user_supplied_options)
-          (options.keys - user_supplied_options).each do |k|
-            default_options[k] = options.delete(k)
-          end
+# This module is used as an 'include' file in code at bottom of file
+module Puma
+  module RackHandler
+    DEFAULT_OPTIONS = {
+      :Verbose => false,
+      :Silent  => false
+    }
+
+    def config(app, options = {})
+      require_relative '../../puma'
+      require_relative '../../puma/configuration'
+      require_relative '../../puma/log_writer'
+      require_relative '../../puma/launcher'
+
+      default_options = DEFAULT_OPTIONS.dup
+
+      # Libraries pass in values such as :Port and there is no way to determine
+      # if it is a default provided by the library or a special value provided
+      # by the user. A special key `user_supplied_options` can be passed. This
+      # contains an array of all explicitly defined user options. We then
+      # know that all other values are defaults
+      if user_supplied_options = options.delete(:user_supplied_options)
+        (options.keys - user_supplied_options).each do |k|
+          default_options[k] = options.delete(k)
         end
+      end
 
-        conf = ::Puma::Configuration.new(options, default_options) do |user_config, file_config, default_config|
-          if options.delete(:Verbose)
-            require 'rack/common_logger'
-            app = Rack::CommonLogger.new(app, STDOUT)
-          end
-
-          if options[:environment]
-            user_config.environment options[:environment]
-          end
-
-          if options[:Threads]
-            min, max = options.delete(:Threads).split(':', 2)
-            user_config.threads min, max
-          end
-
-          if options[:Host] || options[:Port]
-            host = options[:Host] || default_options[:Host]
-            port = options[:Port] || default_options[:Port]
-            self.set_host_port_to_config(host, port, user_config)
-          end
-
-          if default_options[:Host]
-            file_config.set_default_host(default_options[:Host])
-          end
-          self.set_host_port_to_config(default_options[:Host], default_options[:Port], default_config)
-
-          user_config.app app
+      conf = ::Puma::Configuration.new(options, default_options) do |user_config, file_config, default_config|
+        if options.delete(:Verbose)
+          require 'rack/common_logger'
+          app = Rack::CommonLogger.new(app, STDOUT)
         end
-        conf
-      end
 
-      def self.run(app, **options)
-        conf   = self.config(app, options)
+        if options[:environment]
+          user_config.environment options[:environment]
+        end
 
-        log_writer = options.delete(:Silent) ? ::Puma::LogWriter.strings : ::Puma::LogWriter.stdio
+        if options[:Threads]
+          min, max = options.delete(:Threads).split(':', 2)
+          user_config.threads min, max
+        end
 
-        launcher = ::Puma::Launcher.new(conf, :log_writer => log_writer)
+        if options[:Host] || options[:Port]
+          host = options[:Host] || default_options[:Host]
+          port = options[:Port] || default_options[:Port]
+          self.set_host_port_to_config(host, port, user_config)
+        end
 
-        yield launcher if block_given?
-        begin
-          launcher.run
-        rescue Interrupt
-          puts "* Gracefully stopping, waiting for requests to finish"
-          launcher.stop
-          puts "* Goodbye!"
+        if default_options[:Host]
+          file_config.set_default_host(default_options[:Host])
         end
+        self.set_host_port_to_config(default_options[:Host], default_options[:Port], default_config)
+
+        user_config.app app
       end
+      conf
+    end
+
+    def run(app, **options)
+      conf   = self.config(app, options)
+
+      log_writer = options.delete(:Silent) ? ::Puma::LogWriter.strings : ::Puma::LogWriter.stdio
+
+      launcher = ::Puma::Launcher.new(conf, :log_writer => log_writer)
 
-      def self.valid_options
-        {
-          "Host=HOST"       => "Hostname to listen on (default: localhost)",
-          "Port=PORT"       => "Port to listen on (default: 8080)",
-          "Threads=MIN:MAX" => "min:max threads to use (default 0:16)",
-          "Verbose"         => "Don't report each request (default: false)"
-        }
+      yield launcher if block_given?
+      begin
+        launcher.run
+      rescue Interrupt
+        puts "* Gracefully stopping, waiting for requests to finish"
+        launcher.stop
+        puts "* Goodbye!"
       end
+    end
 
-      def self.set_host_port_to_config(host, port, config)
-        config.clear_binds! if host || port
-
-        if host && (host[0,1] == '.' || host[0,1] == '/')
-          config.bind "unix://#{host}"
-        elsif host && host =~ /^ssl:\/\//
-          uri = URI.parse(host)
-          uri.port ||= port || ::Puma::Configuration::DEFAULTS[:tcp_port]
-          config.bind uri.to_s
-        else
-
-          if host
-            port ||= ::Puma::Configuration::DEFAULTS[:tcp_port]
-          end
-
-          if port
-            host ||= ::Puma::Configuration::DEFAULTS[:tcp_host]
-            config.port port, host
-          end
+    def valid_options
+      {
+        "Host=HOST"       => "Hostname to listen on (default: localhost)",
+        "Port=PORT"       => "Port to listen on (default: 8080)",
+        "Threads=MIN:MAX" => "min:max threads to use (default 0:16)",
+        "Verbose"         => "Don't report each request (default: false)"
+      }
+    end
+
+    def set_host_port_to_config(host, port, config)
+      config.clear_binds! if host || port
+
+      if host && (host[0,1] == '.' || host[0,1] == '/')
+        config.bind "unix://#{host}"
+      elsif host && host =~ /^ssl:\/\//
+        uri = URI.parse(host)
+        uri.port ||= port || ::Puma::Configuration::DEFAULTS[:tcp_port]
+        config.bind uri.to_s
+      else
+
+        if host
+          port ||= ::Puma::Configuration::DEFAULTS[:tcp_port]
+        end
+
+        if port
+          host ||= ::Puma::Configuration::DEFAULTS[:tcp_host]
+          config.port port, host
         end
       end
     end
+  end
+end
 
-    register :puma, Puma
+# rackup was removed in Rack 3, it is now a separate gem
+if Object.const_defined? :Rackup
+  module Rackup
+    module Handler
+      module Puma
+        class << self
+          include ::Puma::RackHandler
+        end
+      end
+      register :puma, Puma
+    end
+  end
+elsif Object.const_defined?(:Rack) && Rack::RELEASE < '3'
+  module Rack
+    module Handler
+      module Puma
+        class << self
+          include ::Puma::RackHandler
+        end
+      end
+      register :puma, Puma
+    end
   end
+else
+  raise "You must install the rackup gem when using Rack 3"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: puma
 version: !ruby/object:Gem::Version
-  version: 6.0.2
+  version: 6.1.0
 platform: ruby
 authors:
 - Evan Phoenix
@@ -104,6 +104,7 @@ files:
 - lib/puma/minissl/context_builder.rb
 - lib/puma/null_io.rb
 - lib/puma/plugin.rb
+- lib/puma/plugin/systemd.rb
 - lib/puma/plugin/tmp_restart.rb
 - lib/puma/rack/builder.rb
 - lib/puma/rack/urlmap.rb
@@ -111,10 +112,10 @@ files:
 - lib/puma/reactor.rb
 - lib/puma/request.rb
 - lib/puma/runner.rb
+- lib/puma/sd_notify.rb
 - lib/puma/server.rb
 - lib/puma/single.rb
 - lib/puma/state_file.rb
-- lib/puma/systemd.rb
 - lib/puma/thread_pool.rb
 - lib/puma/util.rb
 - lib/rack/handler/puma.rb
@@ -144,7 +145,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.26
+rubygems_version: 3.3.20
 signing_key:
 specification_version: 4
 summary: Puma is a simple, fast, threaded, and highly parallel HTTP 1.1 server for

data/lib/puma/systemd.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-require 'sd_notify'
-
-module Puma
-  class Systemd
-    def initialize(log_writer, events)
-      @log_writer = log_writer
-      @events = events
-    end
-
-    def hook_events
-      @events.on_booted { SdNotify.ready }
-      @events.on_stopped { SdNotify.stopping }
-      @events.on_restart { SdNotify.reloading }
-    end
-
-    def start_watchdog
-      return unless SdNotify.watchdog?
-
-      ping_f = watchdog_sleep_time
-
-      log "Pinging systemd watchdog every #{ping_f.round(1)} sec"
-      Thread.new do
-        loop do
-          sleep ping_f
-          SdNotify.watchdog
-        end
-      end
-    end
-
-    private
-
-    def watchdog_sleep_time
-      usec = Integer(ENV["WATCHDOG_USEC"])
-
-      sec_f = usec / 1_000_000.0
-      # "It is recommended that a daemon sends a keep-alive notification message
-      # to the service manager every half of the time returned here."
-      sec_f / 2
-    end
-
-    def log(str)
-      @log_writer.log(str)
-    end
-  end
-end