puma 5.5.2 → 6.3.0

data/lib/puma/launcher.rb

@@ -1,11 +1,12 @@
 # frozen_string_literal: true
 
-require 'puma/events'
-require 'puma/detect'
-require 'puma/cluster'
-require 'puma/single'
-require 'puma/const'
-require 'puma/binder'
+require_relative 'log_writer'
+require_relative 'events'
+require_relative 'detect'
+require_relative 'cluster'
+require_relative 'single'
+require_relative 'const'
+require_relative 'binder'
 
 module Puma
   # Puma::Launcher is the single entry point for starting a Puma server based on user
@@ -15,17 +16,14 @@ module Puma
   # It is responsible for either launching a cluster of Puma workers or a single
   # puma server.
   class Launcher
-    KEYS_NOT_TO_PERSIST_IN_STATE = [
-       :logger, :lowlevel_error_handler,
-       :before_worker_shutdown, :before_worker_boot, :before_worker_fork,
-       :after_worker_boot, :before_fork, :on_restart
-     ]
+    autoload :BundlePruner, 'puma/launcher/bundle_pruner'
+
     # Returns an instance of Launcher
     #
     # +conf+ A Puma::Configuration object indicating how to run the server.
     #
     # +launcher_args+ A Hash that currently has one required key `:events`,
-    # this is expected to hold an object similar to an `Puma::Events.stdio`,
+    # this is expected to hold an object similar to an `Puma::LogWriter.stdio`,
     # this object will be responsible for broadcasting Puma's internal state
     # to a logging destination. An optional key `:argv` can be supplied,
     # this should be an array of strings, these arguments are re-used when
@@ -39,25 +37,35 @@ module Puma
     #       [200, {}, ["hello world"]]
     #     end
     #   end
-    #   Puma::Launcher.new(conf, events: Puma::Events.stdio).run
+    #   Puma::Launcher.new(conf, log_writer: Puma::LogWriter.stdio).run
     def initialize(conf, launcher_args={})
       @runner        = nil
-      @events        = launcher_args[:events] || Events::DEFAULT
+      @log_writer    = launcher_args[:log_writer] || LogWriter::DEFAULT
+      @events        = launcher_args[:events] || Events.new
       @argv          = launcher_args[:argv] || []
       @original_argv = @argv.dup
       @config        = conf
 
-      @binder        = Binder.new(@events, conf)
-      @binder.create_inherited_fds(ENV).each { |k| ENV.delete k }
-      @binder.create_activated_fds(ENV).each { |k| ENV.delete k }
-
-      @environment = conf.environment
+      @config.options[:log_writer] = @log_writer
 
       # Advertise the Configuration
       Puma.cli_config = @config if defined?(Puma.cli_config)
 
       @config.load
 
+      @binder        = Binder.new(@log_writer, conf)
+      @binder.create_inherited_fds(ENV).each { |k| ENV.delete k }
+      @binder.create_activated_fds(ENV).each { |k| ENV.delete k }
+
+      @environment = conf.environment
+
+      # Load the systemd integration if we detect systemd's NOTIFY_SOCKET.
+      # Skip this on JRuby though, because it is incompatible with the systemd
+      # integration due to https://github.com/jruby/jruby/issues/6504
+      if ENV["NOTIFY_SOCKET"] && !Puma.jruby?
+        @config.plugins.create('systemd')
+      end
+
       if @config.options[:bind_to_activated_sockets]
         @config.options[:binds] = @binder.synthesize_binds_from_activated_fs(
           @config.options[:binds],
@@ -68,28 +76,30 @@ module Puma
       @options = @config.options
       @config.clamp
 
-      @events.formatter = Events::PidFormatter.new if clustered?
-      @events.formatter = options[:log_formatter] if @options[:log_formatter]
+      @log_writer.formatter = LogWriter::PidFormatter.new if clustered?
+      @log_writer.formatter = options[:log_formatter] if @options[:log_formatter]
+
+      @log_writer.custom_logger = options[:custom_logger] if @options[:custom_logger]
 
       generate_restart_data
 
-      if clustered? && !Process.respond_to?(:fork)
+      if clustered? && !Puma.forkable?
         unsupported "worker mode not supported on #{RUBY_ENGINE} on this platform"
       end
 
       Dir.chdir(@restart_dir)
 
-      prune_bundler if prune_bundler?
+      prune_bundler!
 
       @environment = @options[:environment] if @options[:environment]
       set_rack_environment
 
       if clustered?
-        @options[:logger] = @events
+        @options[:logger] = @log_writer
 
-        @runner = Cluster.new(self, @events)
+        @runner = Cluster.new(self)
       else
-        @runner = Single.new(self, @events)
+        @runner = Single.new(self)
       end
       Puma.stats_object = @runner
 
@@ -98,7 +108,7 @@ module Puma
       log_config if ENV['PUMA_LOG_CONFIG']
     end
 
-    attr_reader :binder, :events, :config, :options, :restart_dir
+    attr_reader :binder, :log_writer, :events, :config, :options, :restart_dir
 
     # Return stats about the server
     def stats
@@ -114,7 +124,7 @@ module Puma
       permission = @options[:state_permission]
       return unless path
 
-      require 'puma/state_file'
+      require_relative 'state_file'
 
       sf = StateFile.new
       sf.pid = Process.pid
@@ -158,18 +168,20 @@ module Puma
       true
     end
 
+    # Begin a refork if supported
+    def refork
+      if clustered? && @runner.respond_to?(:fork_worker!) && @options[:fork_worker]
+        @runner.fork_worker!
+        true
+      else
+        log "* refork called but not available."
+        false
+      end
+    end
+
     # Run the server. This blocks until the server is stopped
     def run
-      previous_env =
-        if defined?(Bundler)
-          env = Bundler::ORIGINAL_ENV.dup
-          # add -rbundler/setup so we load from Gemfile when restarting
-          bundle = "-rbundler/setup"
-          env["RUBYOPT"] = [env["RUBYOPT"], bundle].join(" ").lstrip unless env["RUBYOPT"].to_s.include?(bundle)
-          env
-        else
-          ENV.to_h
-        end
+      previous_env = get_env
 
       @config.clamp
 
@@ -177,24 +189,11 @@ module Puma
 
       setup_signals
       set_process_title
-      integrate_with_systemd
+
+      # This blocks until the server is stopped
       @runner.run
 
-      case @status
-      when :halt
-        log "* Stopping immediately!"
-        @runner.stop_control
-      when :run, :stop
-        graceful_stop
-      when :restart
-        log "* Restarting..."
-        ENV.replace(previous_env)
-        @runner.stop_control
-        restart!
-      when :exit
-        # nothing
-      end
-      close_binder_listeners unless @status == :restart
+      do_run_finished(previous_env)
     end
 
     # Return all tcp ports the launcher may be using, TCP or SSL
@@ -238,30 +237,56 @@ module Puma
 
     private
 
-    # If configured, write the pid of the current process out
-    # to a file.
-    def write_pid
-      path = @options[:pidfile]
-      return unless path
-      cur_pid = Process.pid
-      File.write path, cur_pid, mode: 'wb:UTF-8'
-      at_exit do
-        delete_pidfile if cur_pid == Process.pid
+    def get_env
+      if defined?(Bundler)
+        env = Bundler::ORIGINAL_ENV.dup
+        # add -rbundler/setup so we load from Gemfile when restarting
+        bundle = "-rbundler/setup"
+        env["RUBYOPT"] = [env["RUBYOPT"], bundle].join(" ").lstrip unless env["RUBYOPT"].to_s.include?(bundle)
+        env
+      else
+        ENV.to_h
       end
     end
 
-    def reload_worker_directory
-      @runner.reload_worker_directory if @runner.respond_to?(:reload_worker_directory)
+    def do_run_finished(previous_env)
+      case @status
+      when :halt
+        do_forceful_stop
+      when :run, :stop
+        do_graceful_stop
+      when :restart
+        do_restart(previous_env)
+      end
+
+      close_binder_listeners unless @status == :restart
+    end
+
+    def do_forceful_stop
+      log "* Stopping immediately!"
+      @runner.stop_control
+    end
+
+    def do_graceful_stop
+      @events.fire_on_stopped!
+      @runner.stop_blocked
+    end
+
+    def do_restart(previous_env)
+      log "* Restarting..."
+      ENV.replace(previous_env)
+      @runner.stop_control
+      restart!
     end
 
     def restart!
       @events.fire_on_restart!
-      @config.run_hooks :on_restart, self, @events
+      @config.run_hooks :on_restart, self, @log_writer
 
       if Puma.jruby?
         close_binder_listeners
 
-        require 'puma/jruby_restart'
+        require_relative 'jruby_restart'
         JRubyRestart.chdir_exec(@restart_dir, restart_args)
       elsif Puma.windows?
         close_binder_listeners
@@ -278,94 +303,24 @@ module Puma
       end
     end
 
-    # @!attribute [r] files_to_require_after_prune
-    def files_to_require_after_prune
-      puma = spec_for_gem("puma")
-
-      require_paths_for_gem(puma) + extra_runtime_deps_directories
-    end
-
-    # @!attribute [r] extra_runtime_deps_directories
-    def extra_runtime_deps_directories
-      Array(@options[:extra_runtime_dependencies]).map do |d_name|
-        if (spec = spec_for_gem(d_name))
-          require_paths_for_gem(spec)
-        else
-          log "* Could not load extra dependency: #{d_name}"
-          nil
-        end
-      end.flatten.compact
-    end
-
-    # @!attribute [r] puma_wild_location
-    def puma_wild_location
-      puma = spec_for_gem("puma")
-      dirs = require_paths_for_gem(puma)
-      puma_lib_dir = dirs.detect { |x| File.exist? File.join(x, '../bin/puma-wild') }
-      File.expand_path(File.join(puma_lib_dir, "../bin/puma-wild"))
-    end
-
-    def prune_bundler
-      return if ENV['PUMA_BUNDLER_PRUNED']
-      return unless defined?(Bundler)
-      require_rubygems_min_version!(Gem::Version.new("2.2"), "prune_bundler")
-      unless puma_wild_location
-        log "! Unable to prune Bundler environment, continuing"
-        return
-      end
-
-      dirs = files_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_location, '-I', dirs.join(':')] + @original_argv
-        # Ruby 2.0+ defaults to true which breaks socket activation
-        args += [{:close_others => false}]
-        Kernel.exec(*args)
-      end
-    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 'puma/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
+    # If configured, write the pid of the current process out
+    # to a file.
+    def write_pid
+      path = @options[:pidfile]
+      return unless path
+      cur_pid = Process.pid
+      File.write path, cur_pid, mode: 'wb:UTF-8'
+      at_exit do
+        delete_pidfile if cur_pid == Process.pid
       end
-
-      log "* Enabling systemd notification integration"
-
-      systemd = Systemd.new(@events)
-      systemd.hook_events
-      systemd.start_watchdog
     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
+    def reload_worker_directory
+      @runner.reload_worker_directory if @runner.respond_to?(:reload_worker_directory)
     end
 
     def log(str)
-      @events.log str
+      @log_writer.log(str)
     end
 
     def clustered?
@@ -373,15 +328,10 @@ module Puma
     end
 
     def unsupported(str)
-      @events.error(str)
+      @log_writer.error(str)
       raise UnsupportedOption
     end
 
-    def graceful_stop
-      @events.fire_on_stopped!
-      @runner.stop_blocked
-    end
-
     def set_process_title
       Process.respond_to?(:setproctitle) ? Process.setproctitle(title) : $0 = title
     end
@@ -407,6 +357,11 @@ module Puma
       @options[:prune_bundler] && clustered? && !@options[:preload_app]
     end
 
+    def prune_bundler!
+      return unless prune_bundler?
+      BundlePruner.new(@original_argv, @options[:extra_runtime_dependencies], @log_writer).prune
+    end
+
     def generate_restart_data
       if dir = @options[:directory]
         @restart_dir = dir
@@ -473,7 +428,8 @@ module Puma
 
       begin
         Signal.trap "SIGTERM" do
-          graceful_stop
+          # Shortcut the control flow in case raise_exception_on_sigterm is true
+          do_graceful_stop
 
           raise(SignalException, "SIGTERM") if @options[:raise_exception_on_sigterm]
         end
@@ -505,8 +461,8 @@ module Puma
         unless Puma.jruby? # INFO in use by JVM already
           Signal.trap "SIGINFO" do
             thread_status do |name, backtrace|
-              @events.log name
-              @events.log backtrace.map { |bt| "  #{bt}" }
+              @log_writer.log(name)
+              @log_writer.log(backtrace.map { |bt| "  #{bt}" })
             end
           end
         end
@@ -516,23 +472,6 @@ module Puma
       end
     end
 
-    def require_rubygems_min_version!(min_version, feature)
-      return if min_version <= Gem::Version.new(Gem::VERSION)
-
-      raise "#{feature} is not supported on your version of RubyGems. " \
-              "You must have RubyGems #{min_version}+ to use this feature."
-    end
-
-    # @version 5.0.0
-    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 log_config
       log "Configuration:"
 

data/lib/puma/log_writer.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+require_relative 'null_io'
+require_relative 'error_logger'
+require 'stringio'
+require 'io/wait' unless Puma::HAS_NATIVE_IO_WAIT
+
+module Puma
+
+  # Handles logging concerns for both standard messages
+  # (+stdout+) and errors (+stderr+).
+  class LogWriter
+
+    class DefaultFormatter
+      def call(str)
+        str
+      end
+    end
+
+    class PidFormatter
+      def call(str)
+        "[#{$$}] #{str}"
+      end
+    end
+
+    LOG_QUEUE = Queue.new
+
+    attr_reader :stdout,
+                :stderr
+
+    attr_accessor :formatter, :custom_logger
+
+    # Create a LogWriter that prints to +stdout+ and +stderr+.
+    def initialize(stdout, stderr)
+      @formatter = DefaultFormatter.new
+      @custom_logger = nil
+      @stdout = stdout
+      @stderr = stderr
+
+      @debug = ENV.key?('PUMA_DEBUG')
+      @error_logger = ErrorLogger.new(@stderr)
+    end
+
+    DEFAULT = new(STDOUT, STDERR)
+
+    # Returns an LogWriter object which writes its status to
+    # two StringIO objects.
+    def self.strings
+      LogWriter.new(StringIO.new, StringIO.new)
+    end
+
+    def self.stdio
+      LogWriter.new($stdout, $stderr)
+    end
+
+    def self.null
+      n = NullIO.new
+      LogWriter.new(n, n)
+    end
+
+    # Write +str+ to +@stdout+
+    def log(str)
+      if @custom_logger&.respond_to?(:write)
+        @custom_logger.write(format(str))
+      else
+        internal_write "#{@formatter.call str}\n"
+      end
+    end
+
+    def write(str)
+      internal_write @formatter.call(str)
+    end
+
+    def internal_write(str)
+      LOG_QUEUE << str
+      while (w_str = LOG_QUEUE.pop(true)) do
+        begin
+          @stdout.is_a?(IO) and @stdout.wait_writable(1)
+          @stdout.write w_str
+          @stdout.flush unless @stdout.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
+
+    def debug?
+      @debug
+    end
+
+    def debug(str)
+      log("% #{str}") if @debug
+    end
+
+    # Write +str+ to +@stderr+
+    def error(str)
+      @error_logger.info(text: @formatter.call("ERROR: #{str}"))
+      exit 1
+    end
+
+    def format(str)
+      formatter.call(str)
+    end
+
+    # An HTTP connection error has occurred.
+    # +error+ a connection exception, +req+ the request,
+    # and +text+ additional info
+    # @version 5.0.0
+    def connection_error(error, req, text="HTTP connection error")
+      @error_logger.info(error: error, req: req, text: text)
+    end
+
+    # An HTTP parse error has occurred.
+    # +error+ a parsing exception,
+    # and +req+ the request.
+    def parse_error(error, req)
+      @error_logger.info(error: error, req: req, text: 'HTTP parse error, malformed request')
+    end
+
+    # An SSL error has occurred.
+    # @param error <Puma::MiniSSL::SSLError>
+    # @param ssl_socket <Puma::MiniSSL::Socket>
+    def ssl_error(error, ssl_socket)
+      peeraddr = ssl_socket.peeraddr.last rescue "<unknown>"
+      peercert = ssl_socket.peercert
+      subject = peercert&.subject
+      @error_logger.info(error: error, text: "SSL error, peer: #{peeraddr}, peer cert: #{subject}")
+    end
+
+    # An unknown error has occurred.
+    # +error+ an exception object, +req+ the request,
+    # and +text+ additional info
+    def unknown_error(error, req=nil, text="Unknown error")
+      @error_logger.info(error: error, req: req, text: text)
+    end
+
+    # Log occurred error debug dump.
+    # +error+ an exception object, +req+ the request,
+    # and +text+ additional info
+    # @version 5.0.0
+    def debug_error(error, req=nil, text="")
+      @error_logger.debug(error: error, req: req, text: text)
+    end
+  end
+end

data/lib/puma/minissl/context_builder.rb

@@ -1,9 +1,9 @@
 module Puma
   module MiniSSL
     class ContextBuilder
-      def initialize(params, events)
+      def initialize(params, log_writer)
         @params = params
-        @events = events
+        @log_writer = log_writer
       end
 
       def context
@@ -11,42 +11,56 @@ module Puma
 
         if defined?(JRUBY_VERSION)
           unless params['keystore']
-            events.error "Please specify the Java keystore via 'keystore='"
+            log_writer.error "Please specify the Java keystore via 'keystore='"
           end
 
           ctx.keystore = params['keystore']
 
           unless params['keystore-pass']
-            events.error "Please specify the Java keystore password  via 'keystore-pass='"
+            log_writer.error "Please specify the Java keystore password  via 'keystore-pass='"
           end
 
           ctx.keystore_pass = params['keystore-pass']
-          ctx.ssl_cipher_list = params['ssl_cipher_list'] if params['ssl_cipher_list']
+          ctx.keystore_type = params['keystore-type']
+
+          if truststore = params['truststore']
+            ctx.truststore = truststore.eql?('default') ? :default : truststore
+            ctx.truststore_pass = params['truststore-pass']
+            ctx.truststore_type = params['truststore-type']
+          end
+
+          ctx.cipher_suites = params['cipher_suites'] || params['ssl_cipher_list']
+          ctx.protocols = params['protocols'] if params['protocols']
         else
-          unless params['key']
-            events.error "Please specify the SSL key via 'key='"
+          if params['key'].nil? && params['key_pem'].nil?
+            log_writer.error "Please specify the SSL key via 'key=' or 'key_pem='"
           end
 
-          ctx.key = params['key']
+          ctx.key = params['key'] if params['key']
+          ctx.key_pem = params['key_pem'] if params['key_pem']
+          ctx.key_password_command = params['key_password_command'] if params['key_password_command']
 
-          unless params['cert']
-            events.error "Please specify the SSL cert via 'cert='"
+          if params['cert'].nil? && params['cert_pem'].nil?
+            log_writer.error "Please specify the SSL cert via 'cert=' or 'cert_pem='"
           end
 
-          ctx.cert = params['cert']
+          ctx.cert = params['cert'] if params['cert']
+          ctx.cert_pem = params['cert_pem'] if params['cert_pem']
 
           if ['peer', 'force_peer'].include?(params['verify_mode'])
             unless params['ca']
-              events.error "Please specify the SSL ca via 'ca='"
+              log_writer.error "Please specify the SSL ca via 'ca='"
             end
           end
 
           ctx.ca = params['ca'] if params['ca']
           ctx.ssl_cipher_filter = params['ssl_cipher_filter'] if params['ssl_cipher_filter']
+
+          ctx.reuse = params['reuse'] if params['reuse']
         end
 
-        ctx.no_tlsv1 = true if params['no_tlsv1'] == 'true'
-        ctx.no_tlsv1_1 = true if params['no_tlsv1_1'] == 'true'
+        ctx.no_tlsv1   = params['no_tlsv1'] == 'true'
+        ctx.no_tlsv1_1 = params['no_tlsv1_1'] == 'true'
 
         if params['verify_mode']
           ctx.verify_mode = case params['verify_mode']
@@ -57,7 +71,7 @@ module Puma
                             when "none"
                               MiniSSL::VERIFY_NONE
                             else
-                              events.error "Please specify a valid verify_mode="
+                              log_writer.error "Please specify a valid verify_mode="
                               MiniSSL::VERIFY_NONE
                             end
         end
@@ -73,7 +87,7 @@ module Puma
 
       private
 
-      attr_reader :params, :events
+      attr_reader :params, :log_writer
     end
   end
 end