puma 6.0.0 → 6.1.0

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

@@ -11,7 +11,6 @@ require_relative 'reactor'
 require_relative 'client'
 require_relative 'binder'
 require_relative 'util'
-require_relative 'io_buffer'
 require_relative 'request'
 
 require 'socket'
@@ -96,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
@@ -230,7 +230,7 @@ module Puma
 
       @status = :run
 
-      @thread_pool = ThreadPool.new(thread_name, @options) { |a, b| process_client a, b }
+      @thread_pool = ThreadPool.new(thread_name, @options) { |client| process_client client }
 
       if @queue_requests
         @reactor = Reactor.new(@io_selector_backend) { |c| reactor_wakeup c }
@@ -335,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
@@ -401,7 +402,7 @@ module Puma
     # returning.
     #
     # Return true if one or more requests were processed.
-    def process_client(client, buffer)
+    def process_client(client)
       # Advertise this server into the thread
       Thread.current[ThreadLocalKey] = self
 
@@ -427,15 +428,13 @@ module Puma
 
         while true
           @requests_count += 1
-          case handle_request(client, buffer, requests + 1)
+          case handle_request(client, requests + 1)
           when false
             break
           when :async
             close_socket = false
             break
           when true
-            buffer.reset
-
             ThreadPool.clean_thread_locals if clean_thread_locals
 
             requests += 1
@@ -469,7 +468,7 @@ module Puma
         # The ensure tries to close +client+ down
         requests > 0
       ensure
-        buffer.reset
+        client.io_buffer.reset
 
         begin
           client.close if close_socket

data/lib/puma/single.rb

@@ -16,7 +16,7 @@ module Puma
     # @!attribute [r] stats
     def stats
       {
-        started_at: @started_at.utc.iso8601
+        started_at: utc_iso8601(@started_at)
       }.merge(@server.stats).merge(super)
     end
 
@@ -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/puma/thread_pool.rb

@@ -45,7 +45,6 @@ module Puma
       @min = Integer(options[:min_threads])
       @max = Integer(options[:max_threads])
       @block = block
-      @extra = [::Puma::IOBuffer]
       @out_of_band = options[:out_of_band]
       @clean_thread_locals = options[:clean_thread_locals]
       @reaping_time = options[:reaping_time]
@@ -112,8 +111,6 @@ module Puma
         not_empty = @not_empty
         not_full = @not_full
 
-        extra = @extra.map { |i| i.new }
-
         while true
           work = nil
 
@@ -147,7 +144,7 @@ module Puma
           end
 
           begin
-            @out_of_band_pending = true if block.call(work, *extra)
+            @out_of_band_pending = true if block.call(work)
           rescue Exception => e
             STDERR.puts "Error reached top of thread-pool: #{e.message} (#{e.class})"
           end

data/lib/puma.rb

@@ -3,8 +3,6 @@
 # Standard libraries
 require 'socket'
 require 'tempfile'
-require 'time'
-require 'etc'
 require 'uri'
 require 'stringio'
 
@@ -28,7 +26,7 @@ module Puma
   # not in minissl.rb
   HAS_SSL = const_defined?(:MiniSSL, false) && MiniSSL.const_defined?(:Engine, false)
 
-  HAS_UNIX_SOCKET = Object.const_defined? :UNIXSocket
+  HAS_UNIX_SOCKET = Object.const_defined?(:UNIXSocket) && !IS_WINDOWS
 
   if HAS_SSL
     require_relative 'puma/minissl'

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.0
+  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