puma 2.2.0 → 8.0.2

data/lib/puma/error_logger.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require_relative 'const'
+
+module Puma
+  # The implementation of a detailed error logging.
+  # @version 5.0.0
+  #
+  class ErrorLogger
+    include Const
+
+    attr_reader :ioerr
+
+    REQUEST_FORMAT = %{"%s %s%s" - (%s)}
+
+    LOG_QUEUE = Queue.new
+
+    def initialize(ioerr, env: ENV)
+      @ioerr = ioerr
+
+      @debug = env.key?('PUMA_DEBUG')
+    end
+
+    def self.stdio(env: ENV)
+      new($stderr, env: env)
+    end
+
+    # Print occurred error details.
+    # +options+ hash with additional options:
+    # - +error+ is an exception object
+    # - +req+ the http request
+    # - +text+ (default nil) custom string to print in title
+    #   and before all remaining info.
+    #
+    def info(options={})
+      internal_write title(options)
+    end
+
+    # Print occurred error details only if
+    # environment variable PUMA_DEBUG is defined.
+    # +options+ hash with additional options:
+    # - +error+ is an exception object
+    # - +req+ the http request
+    # - +text+ (default nil) custom string to print in title
+    #   and before all remaining info.
+    #
+    def debug(options={})
+      return unless @debug
+
+      error = options[:error]
+      req = options[:req]
+
+      string_block = []
+      string_block << title(options)
+      string_block << request_dump(req) if request_parsed?(req)
+      string_block << error.backtrace if error
+
+      internal_write string_block.join("\n")
+    end
+
+    def title(options={})
+      text = options[:text]
+      req = options[:req]
+      error = options[:error]
+
+      string_block = ["#{Time.now}"]
+      string_block << " #{text}" if text
+      string_block << " (#{request_title(req)})" if request_parsed?(req)
+      string_block << ": #{error.inspect}" if error
+      string_block.join('')
+    end
+
+    def request_dump(req)
+      "Headers: #{request_headers(req)}\n" \
+      "Body: #{req.body}"
+    end
+
+    def request_title(req)
+      env = req.env
+
+      query_string = env[QUERY_STRING]
+
+      REQUEST_FORMAT % [
+        env[REQUEST_METHOD],
+        env[REQUEST_PATH] || env[PATH_INFO],
+        query_string.nil? || query_string.empty? ? "" : "?#{query_string}",
+        env[HTTP_X_FORWARDED_FOR] || env[REMOTE_ADDR] || "-"
+      ]
+    end
+
+    def request_headers(req)
+      headers = req.env.select { |key, _| key.start_with?('HTTP_') }
+      headers.map { |key, value| [key[5..-1], value] }.to_h.inspect
+    end
+
+    def request_parsed?(req)
+      req && req.env[REQUEST_METHOD]
+    end
+
+    def internal_write(str)
+      LOG_QUEUE << str
+      while (w_str = LOG_QUEUE.pop(true)) do
+        begin
+          @ioerr.is_a?(IO) and @ioerr.wait_writable(1)
+          @ioerr.write "#{w_str}\n"
+          @ioerr.flush unless @ioerr.sync
+        rescue Errno::EPIPE, Errno::EBADF, IOError, Errno::EINVAL
+        # 'Invalid argument' (Errno::EINVAL) may be raised by flush
+        end
+      end
+    rescue ThreadError
+    end
+    private :internal_write
+  end
+end

data/lib/puma/events.rb

@@ -1,88 +1,72 @@
-require 'puma/const'
-require 'stringio'
+# frozen_string_literal: true
 
 module Puma
-  # The default implement of an event sink object used by Server
-  # for when certain kinds of events occur in the life of the server.
-  #
-  # The methods available are the events that the Server fires.
-  #
-  class Events
 
-    include Const
+  # This is an event sink used by `Puma::Server` to handle
+  # lifecycle events such as :after_booted, :before_restart, and :after_stopped.
+  # Using `Puma::DSL` it is possible to register callback hooks
+  # for each event type.
+  class Events
 
-    # Create an Events object that prints to +stdout+ and +stderr+.
-    #
-    def initialize(stdout, stderr)
-      @stdout = stdout
-      @stderr = stderr
+    def initialize
+      @hooks = Hash.new { |h,k| h[k] = [] }
+    end
 
-      @stdout.sync = true
-      @stderr.sync = true
+    # Fire callbacks for the named hook
+    def fire(hook, *args)
+      @hooks[hook].each { |t| t.call(*args) }
     end
 
-    attr_reader :stdout, :stderr
+    # Register a callback for a given hook
+    def register(hook, obj=nil, &blk)
+      if obj and blk
+        raise "Specify either an object or a block, not both"
+      end
+
+      h = obj || blk
 
-    # Write +str+ to +@stdout+
-    #
-    def log(str)
-      @stdout.puts str
+      @hooks[hook] << h
+
+      h
     end
 
-    def write(str)
-      @stdout.write str
+    def after_booted(&block)
+      register(:after_booted, &block)
     end
 
-    # Write +str+ to +@stderr+
-    #
-    def error(str)
-      @stderr.puts "ERROR: #{str}"
-      exit 1
+    def before_restart(&block)
+      register(:before_restart, &block)
     end
 
-    # An HTTP parse error has occured.
-    # +server+ is the Server object, +env+ the request, and +error+ a
-    # parsing exception.
-    #
-    def parse_error(server, env, error)
-      @stderr.puts "#{Time.now}: HTTP parse error, malformed request (#{env[HTTP_X_FORWARDED_FOR] || env[REMOTE_ADDR]}): #{error.inspect}"
-      @stderr.puts "#{Time.now}: ENV: #{env.inspect}\n---\n"
+    def after_stopped(&block)
+      register(:after_stopped, &block)
     end
 
-    # An unknown error has occured.
-    # +server+ is the Server object, +env+ the request, +error+ an exception
-    # object, and +kind+ some additional info.
-    #
-    def unknown_error(server, error, kind="Unknown")
-      if error.respond_to? :render
-        error.render "#{Time.now}: #{kind} error", @stderr
-      else
-        @stderr.puts "#{Time.now}: #{kind} error: #{error.inspect}"
-        @stderr.puts error.backtrace.join("\n")
-      end
+    def on_booted(&block)
+      Puma.deprecate_method_change :on_booted, __callee__, :after_booted
+      after_booted(&block)
     end
 
-    DEFAULT = new(STDOUT, STDERR)
+    def on_restart(&block)
+      Puma.deprecate_method_change :on_restart, __callee__, :before_restart
+      before_restart(&block)
+    end
 
-    # Returns an Events object which writes it's status to 2 StringIO
-    # objects.
-    #
-    def self.strings
-      Events.new StringIO.new, StringIO.new
+    def on_stopped(&block)
+      Puma.deprecate_method_change :on_stopped, __callee__, :after_stopped
+      after_stopped(&block)
     end
-  end
 
-  class PidEvents < Events
-    def log(str)
-      super "[#{$$}] #{str}"
+    def fire_after_booted!
+      fire(:after_booted)
     end
 
-    def write(str)
-      super "[#{$$}] #{str}"
+    def fire_before_restart!
+      fire(:before_restart)
     end
 
-    def error(str)
-      super "[#{$$}] #{str}"
+    def fire_after_stopped!
+      fire(:after_stopped)
     end
   end
 end

data/lib/puma/io_buffer.rb

@@ -1,7 +1,50 @@
-require 'puma/detect'
+# frozen_string_literal: true
 
-if Puma::IS_JRUBY
-  require 'puma/java_io_buffer'
-else
-  require 'puma/puma_http11'
+require 'stringio'
+
+module Puma
+  class IOBuffer < StringIO
+    def initialize
+      super.binmode
+    end
+
+    def empty?
+      length.zero?
+    end
+
+    def reset
+      truncate 0
+      rewind
+    end
+
+    def to_s
+      rewind
+      read
+    end
+
+    # Read & Reset - returns contents and resets
+    # @return [String] StringIO contents
+    def read_and_reset
+      rewind
+      str = read
+      truncate 0
+      rewind
+      str
+    end
+
+    alias_method :clear, :reset
+
+    # Create an `IoBuffer#append` method that accepts multiple strings and writes them
+    if RUBY_ENGINE == 'truffleruby'
+      # truffleruby (24.2.1, like ruby 3.3.7)
+      #   StringIO.new.write("a", "b") # => `write': wrong number of arguments (given 2, expected 1) (ArgumentError)
+      def append(*strs)
+        strs.each { |str| write str }
+      end
+    else
+      # Ruby 3+
+      #   StringIO.new.write("a", "b") # => 2
+      alias_method :append, :write
+    end
+  end
 end

data/lib/puma/jruby_restart.rb

@@ -1,60 +1,11 @@
+# frozen_string_literal: true
+
 require 'ffi'
 
 module Puma
   module JRubyRestart
     extend FFI::Library
     ffi_lib 'c'
-
-    attach_function :execlp, [:string, :varargs], :int
     attach_function :chdir, [:string], :int
-    attach_function :fork, [], :int
-    attach_function :exit, [:int], :void
-    attach_function :setsid, [], :int
-
-    def self.chdir_exec(dir, argv)
-      chdir(dir)
-      cmd = argv.first
-      argv = ([:string] * argv.size).zip(argv).flatten
-      argv << :string
-      argv << nil
-      execlp(cmd, *argv)
-      raise SystemCallError.new(FFI.errno)
-    end
-
-    def self.daemon?
-      ENV.key? 'PUMA_DAEMON_RESTART'
-    end
-
-    def self.daemon_init
-      return false unless ENV.key? 'PUMA_DAEMON_RESTART'
-
-      master = ENV['PUMA_DAEMON_RESTART']
-      Process.kill "SIGUSR2", master.to_i
-
-      setsid
-
-      null = File.open "/dev/null", "w+"
-      STDIN.reopen null
-      STDOUT.reopen null
-      STDERR.reopen null
-
-      true
-    end
-
-    def self.daemon_start(dir, argv)
-      ENV['PUMA_DAEMON_RESTART'] = Process.pid.to_s
-
-      cmd = argv.first
-      argv = ([:string] * argv.size).zip(argv).flatten
-      argv << :string
-      argv << nil
-
-      chdir(dir)
-      ret = fork
-      return ret if ret != 0
-      execlp(cmd, *argv)
-      raise SystemCallError.new(FFI.errno)
-    end
   end
 end
-

data/lib/puma/json_serialization.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+require 'stringio'
+
+module Puma
+
+  # Puma deliberately avoids the use of the json gem and instead performs JSON
+  # serialization without any external dependencies. In a puma cluster, loading
+  # any gem into the puma master process means that operators cannot use a
+  # phased restart to upgrade their application if the new version of that
+  # application uses a different version of that gem. The json gem in
+  # particular is additionally problematic because it leverages native
+  # extensions. If the puma master process relies on a gem with native
+  # extensions and operators remove gems from disk related to old releases,
+  # subsequent phased restarts can fail.
+  #
+  # The implementation of JSON serialization in this module is not designed to
+  # be particularly full-featured or fast. It just has to handle the few places
+  # where Puma relies on JSON serialization internally.
+
+  module JSONSerialization
+    QUOTE = /"/
+    BACKSLASH = /\\/
+    CONTROL_CHAR_TO_ESCAPE = /[\x00-\x1F]/ # As required by ECMA-404
+    CHAR_TO_ESCAPE = Regexp.union QUOTE, BACKSLASH, CONTROL_CHAR_TO_ESCAPE
+
+    class SerializationError < StandardError; end
+
+    class << self
+      def generate(value)
+        StringIO.open do |io|
+          serialize_value io, value
+          io.string
+        end
+      end
+
+      private
+
+      def serialize_value(output, value)
+        case value
+        when Hash
+          output << '{'
+          value.each_with_index do |(k, v), index|
+            output << ',' if index != 0
+            serialize_object_key output, k
+            output << ':'
+            serialize_value output, v
+          end
+          output << '}'
+        when Array
+          output << '['
+          value.each_with_index do |member, index|
+            output << ',' if index != 0
+            serialize_value output, member
+          end
+          output << ']'
+        when Integer, Float
+          output << value.to_s
+        when String
+          serialize_string output, value
+        when true
+          output << 'true'
+        when false
+          output << 'false'
+        when nil
+          output << 'null'
+        else
+          raise SerializationError, "Unexpected value of type #{value.class}"
+        end
+      end
+
+      def serialize_string(output, value)
+        output << '"'
+        output << value.gsub(CHAR_TO_ESCAPE) do |character|
+          case character
+          when BACKSLASH
+            '\\\\'
+          when QUOTE
+            '\\"'
+          when CONTROL_CHAR_TO_ESCAPE
+            '\u%.4X' % character.ord
+          end
+        end
+        output << '"'
+      end
+
+      def serialize_object_key(output, value)
+        case value
+        when Symbol, String
+          serialize_string output, value.to_s
+        else
+          raise SerializationError, "Could not serialize object of type #{value.class} as object key"
+        end
+      end
+    end
+  end
+end

data/lib/puma/launcher/bundle_pruner.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Puma
+  class Launcher
+
+    # This class is used to pickup Gemfile changes during
+    # application restarts.
+    class BundlePruner
+
+      def initialize(original_argv, extra_runtime_dependencies, log_writer)
+        @original_argv = Array(original_argv)
+        @extra_runtime_dependencies = Array(extra_runtime_dependencies)
+        @log_writer = log_writer
+      end
+
+      def prune
+        return if ENV['PUMA_BUNDLER_PRUNED']
+        return unless defined?(Bundler)
+
+        require_rubygems_min_version!
+
+        unless puma_wild_path
+          log "! Unable to prune Bundler environment, continuing"
+          return
+        end
+
+        dirs = paths_to_require_after_prune
+
+        log '* Pruning Bundler environment'
+        home = ENV['GEM_HOME']
+        original_bundle_env = Bundler.original_env.select { |k, v| k.start_with?('BUNDLE_') && v }
+
+        with_unbundled_env do
+          ENV['GEM_HOME'] = home
+          ENV['PUMA_BUNDLER_PRUNED'] = '1'
+          original_bundle_env.each { |k, v| ENV[k] = v }
+          args = [Gem.ruby, puma_wild_path, '-I', dirs.join(':')] + @original_argv
+          # Defaults to true which breaks socket activation
+          args += [{:close_others => false}]
+          Kernel.exec(*args)
+        end
+      end
+
+      private
+
+      def require_rubygems_min_version!
+        min_version = Gem::Version.new('2.2')
+
+        return if min_version <= Gem::Version.new(Gem::VERSION)
+
+        raise "prune_bundler is not supported on your version of RubyGems. " \
+              "You must have RubyGems #{min_version}+ to use this feature."
+      end
+
+      def puma_wild_path
+        puma_lib_dir = puma_require_paths.detect { |x| File.exist? File.join(x, '../bin/puma-wild') }
+        File.expand_path(File.join(puma_lib_dir, '../bin/puma-wild'))
+      end
+
+      def with_unbundled_env
+        bundler_ver = Gem::Version.new(Bundler::VERSION)
+        if bundler_ver < Gem::Version.new('2.1.0')
+          Bundler.with_clean_env { yield }
+        else
+          Bundler.with_unbundled_env { yield }
+        end
+      end
+
+      def paths_to_require_after_prune
+        puma_require_paths + extra_runtime_deps_paths
+      end
+
+      def extra_runtime_deps_paths
+        t = @extra_runtime_dependencies.map do |dep_name|
+          if (spec = spec_for_gem(dep_name))
+            require_paths_for_gem(spec)
+          else
+            log "* Could not load extra dependency: #{dep_name}"
+            nil
+          end
+        end
+        t.flatten!; t.compact!; t
+      end
+
+      def puma_require_paths
+        require_paths_for_gem(spec_for_gem('puma'))
+      end
+
+      def spec_for_gem(gem_name)
+        Bundler.rubygems.loaded_specs(gem_name)
+      end
+
+      def require_paths_for_gem(gem_spec)
+        gem_spec.full_require_paths
+      end
+
+      def log(str)
+        @log_writer.log(str)
+      end
+    end
+  end
+end