puma 3.12.6 → 6.2.2

data/lib/puma/error_logger.rb

@@ -0,0 +1,113 @@
+# 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)
+      @ioerr = ioerr
+
+      @debug = ENV.key? 'PUMA_DEBUG'
+    end
+
+    def self.stdio
+      new $stderr
+    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
+
+      REQUEST_FORMAT % [
+        env[REQUEST_METHOD],
+        env[REQUEST_PATH] || env[PATH_INFO],
+        env[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,56 +1,23 @@
 # frozen_string_literal: true
 
-require 'puma/const'
-require "puma/null_io"
-require 'stringio'
-
 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
-    class DefaultFormatter
-      def call(str)
-        str
-      end
-    end
-
-    class PidFormatter
-      def call(str)
-        "[#{$$}] #{str}"
-      end
-    end
-
-    include Const
 
-    # Create an Events object that prints to +stdout+ and +stderr+.
-    #
-    def initialize(stdout, stderr)
-      @formatter = DefaultFormatter.new
-      @stdout = stdout
-      @stderr = stderr
-
-      @stdout.sync = true
-      @stderr.sync = true
-
-      @debug = ENV.key? 'PUMA_DEBUG'
+  # This is an event sink used by `Puma::Server` to handle
+  # lifecycle events such as :on_booted, :on_restart, and :on_stopped.
+  # Using `Puma::DSL` it is possible to register callback hooks
+  # for each event type.
+  class Events
 
+    def initialize
       @hooks = Hash.new { |h,k| h[k] = [] }
     end
 
-    attr_reader :stdout, :stderr
-    attr_accessor :formatter
-
     # Fire callbacks for the named hook
-    #
     def fire(hook, *args)
       @hooks[hook].each { |t| t.call(*args) }
     end
 
     # 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"
@@ -63,91 +30,28 @@ module Puma
       h
     end
 
-    # Write +str+ to +@stdout+
-    #
-    def log(str)
-      @stdout.puts format(str)
-    end
-
-    def write(str)
-      @stdout.write format(str)
-    end
-
-    def debug(str)
-      log("% #{str}") if @debug
-    end
-
-    # Write +str+ to +@stderr+
-    #
-    def error(str)
-      @stderr.puts format("ERROR: #{str}")
-      exit 1
-    end
-
-    def format(str)
-      formatter.call(str)
-    end
-
-    # An HTTP parse error has occurred.
-    # +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}\n---\n"
-    end
-
-    # An SSL error has occurred.
-    # +server+ is the Server object, +peeraddr+ peer address, +peercert+
-    # any peer certificate (if present), and +error+ an exception object.
-    #
-    def ssl_error(server, peeraddr, peercert, error)
-      subject = peercert ? peercert.subject : nil
-      @stderr.puts "#{Time.now}: SSL error, peer: #{peeraddr}, peer cert: #{subject}, #{error.inspect}"
+    def on_booted(&block)
+      register(:on_booted, &block)
     end
 
-    # An unknown error has occurred.
-    # +server+ is the Server object, +error+ an exception object,
-    # +kind+ some additional info, and +env+ the request.
-    #
-    def unknown_error(server, error, kind="Unknown", env=nil)
-      if error.respond_to? :render
-        error.render "#{Time.now}: #{kind} error", @stderr
-      else
-        if env
-          string_block = [ "#{Time.now}: #{kind} error handling request { #{env['REQUEST_METHOD']} #{env['PATH_INFO']} }" ]
-          string_block << error.inspect
-        else
-          string_block = [ "#{Time.now}: #{kind} error: #{error.inspect}" ]
-        end
-        string_block << error.backtrace
-        @stderr.puts string_block.join("\n")
-      end
+    def on_restart(&block)
+      register(:on_restart, &block)
     end
 
-    def on_booted(&block)
-      register(:on_booted, &block)
+    def on_stopped(&block)
+      register(:on_stopped, &block)
     end
 
     def fire_on_booted!
       fire(:on_booted)
     end
 
-    DEFAULT = new(STDOUT, STDERR)
-
-    # Returns an Events object which writes its status to 2 StringIO
-    # objects.
-    #
-    def self.strings
-      Events.new StringIO.new, StringIO.new
-    end
-
-    def self.stdio
-      Events.new $stdout, $stderr
+    def fire_on_restart!
+      fire(:on_restart)
     end
 
-    def self.null
-      n = NullIO.new
-      Events.new n, n
+    def fire_on_stopped!
+      fire(:on_stopped)
     end
   end
 end

data/lib/puma/io_buffer.rb

@@ -1,9 +1,46 @@
 # frozen_string_literal: true
 
-require 'puma/detect'
+require 'stringio'
 
-if Puma.jruby?
-  require 'puma/java_io_buffer'
-else
-  require 'puma/puma_http11'
+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
+
+    # before Ruby 2.5, `write` would only take one argument
+    if RUBY_VERSION >= '2.5' && RUBY_ENGINE != 'truffleruby'
+      alias_method :append, :write
+    else
+      def append(*strs)
+        strs.each { |str| write str }
+      end
+    end
+  end
 end

data/lib/puma/jruby_restart.rb

@@ -16,69 +16,12 @@ module Puma
     def self.chdir_exec(dir, argv)
       chdir(dir)
       cmd = argv.first
-      argv = ([:string] * argv.size).zip(argv).flatten
+      argv = ([:string] * argv.size).zip(argv)
+      argv.flatten!
       argv << :string
       argv << nil
       execlp(cmd, *argv)
       raise SystemCallError.new(FFI.errno)
     end
-
-    PermKey = 'PUMA_DAEMON_PERM'
-    RestartKey = 'PUMA_DAEMON_RESTART'
-
-    # Called to tell things "Your now always in daemon mode,
-    # don't try to reenter it."
-    #
-    def self.perm_daemonize
-      ENV[PermKey] = "1"
-    end
-
-    def self.daemon?
-      ENV.key?(PermKey) || ENV.key?(RestartKey)
-    end
-
-    def self.daemon_init
-      return true if ENV.key?(PermKey)
-
-      return false unless ENV.key? RestartKey
-
-      master = ENV[RestartKey]
-
-      # In case the master disappears early
-      begin
-        Process.kill "SIGUSR2", master.to_i
-      rescue SystemCallError => e
-      end
-
-      ENV[RestartKey] = ""
-
-      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[RestartKey] = Process.pid.to_s
-
-      if k = ENV['PUMA_JRUBY_DAEMON_OPTS']
-        ENV['JRUBY_OPTS'] = k
-      end
-
-      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,104 @@
+# 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']
+        bundle_gemfile = Bundler.original_env['BUNDLE_GEMFILE']
+        bundle_app_config = Bundler.original_env['BUNDLE_APP_CONFIG']
+
+        with_unbundled_env do
+          ENV['GEM_HOME'] = home
+          ENV['BUNDLE_GEMFILE'] = bundle_gemfile
+          ENV['PUMA_BUNDLER_PRUNED'] = '1'
+          ENV["BUNDLE_APP_CONFIG"] = bundle_app_config
+          args = [Gem.ruby, puma_wild_path, '-I', dirs.join(':')] + @original_argv
+          # Ruby 2.0+ 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