puma 3.12.6 → 6.2.2

data/lib/puma/launcher.rb

@@ -1,14 +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
@@ -18,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
@@ -42,58 +37,78 @@ 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)
-      @binder.import_from_env
-
-      @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],
+          @config.options[:bind_to_activated_sockets] == 'only'
+        )
+      end
+
       @options = @config.options
       @config.clamp
 
+      @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
 
-      if @options[:daemon] && Puma.windows?
-        unsupported 'daemon mode not supported on Windows'
-      end
-
       Dir.chdir(@restart_dir)
 
-      prune_bundler if prune_bundler?
+      prune_bundler!
 
       @environment = @options[:environment] if @options[:environment]
       set_rack_environment
 
       if clustered?
-        @events.formatter = Events::PidFormatter.new
-        @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
 
       @status = :run
+
+      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
@@ -106,16 +121,18 @@ module Puma
       write_pid
 
       path = @options[:state]
+      permission = @options[:state_permission]
       return unless path
 
-      require 'puma/state_file'
+      require_relative 'state_file'
 
       sf = StateFile.new
       sf.pid = Process.pid
       sf.control_url = @options[:control_url]
       sf.control_auth_token = @options[:control_auth_token]
+      sf.running_from = File.expand_path('.')
 
-      sf.save path
+      sf.save path, permission
     end
 
     # Delete the configured pidfile
@@ -124,19 +141,6 @@ module Puma
       File.unlink(path) if path && File.exist?(path)
     end
 
-    # If configured, write the pid of the current process out
-    # to a file.
-    def write_pid
-      path = @options[:pidfile]
-      return unless path
-
-      File.open(path, 'w') { |f| f.puts Process.pid }
-      cur = Process.pid
-      at_exit do
-        delete_pidfile if cur == Process.pid
-      end
-    end
-
     # Begin async shutdown of the server
     def halt
       @status = :halt
@@ -164,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
 
@@ -183,28 +189,21 @@ module Puma
 
       setup_signals
       set_process_title
+
+      # This blocks until the server is stopped
       @runner.run
 
-      case @status
-      when :halt
-        log "* Stopping immediately!"
-      when :run, :stop
-        graceful_stop
-      when :restart
-        log "* Restarting..."
-        ENV.replace(previous_env)
-        @runner.before_restart
-        restart!
-      when :exit
-        # nothing
-      end
+      do_run_finished(previous_env)
     end
 
-    # Return which tcp port the launcher is using, if it's using TCP
-    def connected_port
-      @binder.connected_port
+    # Return all tcp ports the launcher may be using, TCP or SSL
+    # @!attribute [r] connected_ports
+    # @version 5.0.0
+    def connected_ports
+      @binder.connected_ports
     end
 
+    # @!attribute [r] restart_args
     def restart_args
       cmd = @options[:restart_cmd]
       if cmd
@@ -214,19 +213,80 @@ module Puma
       end
     end
 
+    def close_binder_listeners
+      @runner.close_control_listeners
+      @binder.close_listeners
+      unless @status == :restart
+        log "=== puma shutdown: #{Time.now} ==="
+        log "- Goodbye!"
+      end
+    end
+
+    # @!attribute [r] thread_status
+    # @version 5.0.0
+    def thread_status
+      Thread.list.each do |thread|
+        name = "Thread: TID-#{thread.object_id.to_s(36)}"
+        name += " #{thread['label']}" if thread['label']
+        name += " #{thread.name}" if thread.respond_to?(:name) && thread.name
+        backtrace = thread.backtrace || ["<no backtrace available>"]
+
+        yield name, backtrace
+      end
+    end
+
     private
 
-    def reload_worker_directory
-      @runner.reload_worker_directory if @runner.respond_to?(:reload_worker_directory)
+    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 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!
-      @config.run_hooks :on_restart, self
+      @events.fire_on_restart!
+      @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
@@ -235,50 +295,32 @@ module Puma
         Dir.chdir(@restart_dir)
         Kernel.exec(*argv)
       else
-        redirects = {:close_others => true}
-        @binder.listeners.each_with_index do |(l, io), i|
-          ENV["PUMA_INHERIT_#{i}"] = "#{io.to_i}:#{l}"
-          redirects[io.to_i] = io.to_i
-        end
-
         argv = restart_args
         Dir.chdir(@restart_dir)
-        argv += [redirects] if RUBY_VERSION >= '1.9'
+        ENV.update(@binder.redirects_for_restart_env)
+        argv += [@binder.redirects_for_restart]
         Kernel.exec(*argv)
       end
     end
 
-    def prune_bundler
-      return unless defined?(Bundler)
-      puma = Bundler.rubygems.loaded_specs("puma")
-      dirs = puma.require_paths.map { |x| File.join(puma.full_gem_path, x) }
-      puma_lib_dir = dirs.detect { |x| File.exist? File.join(x, '../bin/puma-wild') }
-
-      unless puma_lib_dir
-        log "! Unable to prune Bundler environment, continuing"
-        return
-      end
-
-      deps = puma.runtime_dependencies.map do |d|
-        spec = Bundler.rubygems.loaded_specs(d.name)
-        "#{d.name}:#{spec.version.to_s}"
+    # 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
+    end
 
-      log '* Pruning Bundler environment'
-      home = ENV['GEM_HOME']
-      Bundler.with_clean_env do
-        ENV['GEM_HOME'] = home
-        ENV['PUMA_BUNDLER_PRUNED'] = '1'
-        wild = File.expand_path(File.join(puma_lib_dir, "../bin/puma-wild"))
-        args = [Gem.ruby, wild, '-I', dirs.join(':'), deps.join(',')] + @original_argv
-        # Ruby 2.0+ defaults to true which breaks socket activation
-        args += [{:close_others => false}] if RUBY_VERSION >= '2.0'
-        Kernel.exec(*args)
-      end
+    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?
@@ -286,20 +328,15 @@ module Puma
     end
 
     def unsupported(str)
-      @events.error(str)
+      @log_writer.error(str)
       raise UnsupportedOption
     end
 
-    def graceful_stop
-      @runner.stop_blocked
-      log "=== puma shutdown: #{Time.now} ==="
-      log "- Goodbye!"
-    end
-
     def set_process_title
       Process.respond_to?(:setproctitle) ? Process.setproctitle(title) : $0 = title
     end
 
+    # @!attribute [r] title
     def title
       buffer  = "puma #{Puma::Const::VERSION} (#{@options[:binds].join(',')})"
       buffer += " [#{@options[:tag]}]" if @options[:tag] && !@options[:tag].empty?
@@ -311,6 +348,7 @@ module Puma
       ENV['RACK_ENV'] = environment
     end
 
+    # @!attribute [r] environment
     def environment
       @environment
     end
@@ -319,16 +357,11 @@ module Puma
       @options[:prune_bundler] && clustered? && !@options[:preload_app]
     end
 
-    def close_binder_listeners
-      @binder.listeners.each do |l, io|
-        io.close
-        uri = URI.parse(l)
-        next unless uri.scheme == 'unix'
-        File.unlink("#{uri.host}#{uri.path}")
-      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
@@ -395,9 +428,10 @@ 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"
+          raise(SignalException, "SIGTERM") if @options[:raise_exception_on_sigterm]
         end
       rescue Exception
         log "*** SIGTERM not implemented, signal based gracefully stopping unavailable!"
@@ -405,12 +439,6 @@ module Puma
 
       begin
         Signal.trap "SIGINT" do
-          if Puma.jruby?
-            @status = :exit
-            graceful_stop
-            exit
-          end
-
           stop
         end
       rescue Exception
@@ -428,6 +456,29 @@ module Puma
       rescue Exception
         log "*** SIGHUP not implemented, signal based logs reopening unavailable!"
       end
+
+      begin
+        unless Puma.jruby? # INFO in use by JVM already
+          Signal.trap "SIGINFO" do
+            thread_status do |name, backtrace|
+              @log_writer.log(name)
+              @log_writer.log(backtrace.map { |bt| "  #{bt}" })
+            end
+          end
+        end
+      rescue Exception
+        # Not going to log this one, as SIGINFO is *BSD only and would be pretty annoying
+        # to see this constantly on Linux.
+      end
+    end
+
+    def log_config
+      log "Configuration:"
+
+      @config.final_options
+        .each { |config_key, value| log "- #{config_key}: #{value}" }
+
+      log "\n"
     end
   end
 end

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 ? peercert.subject : nil
+      @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