passenger 6.2.0 → 6.2.1

data/src/ruby_supportlib/phusion_passenger/vendor/daemon_controller.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 # daemon_controller, library for robust daemon management
-# Copyright (c) 2010-2025 Asynchronous B.V.
+# Copyright (c) 2010-2026 Asynchronous B.V.
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -19,16 +21,14 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-require 'tempfile'
-require 'fcntl'
-require 'socket'
-require 'pathname'
-require 'timeout'
-if Process.respond_to?(:spawn)
-  require 'rbconfig'
-end
+require "tempfile"
+require "fcntl"
+require "socket"
+require "pathname"
+require "timeout"
+require "rbconfig"
 
-PhusionPassenger.require_passenger_lib 'vendor/daemon_controller/lock_file'
+require_relative "daemon_controller/lock_file"
 
 module PhusionPassenger
 
@@ -38,184 +38,66 @@ class DaemonController
     Errno::ETIMEDOUT, Errno::ECONNRESET, Errno::EINVAL,
     Errno::EADDRNOTAVAIL ]
 
-  SPAWNER_FILE = File.expand_path(File.join(File.dirname(__FILE__),
+  SPAWNER_FILE = File.absolute_path(File.join(File.dirname(__FILE__),
     "daemon_controller", "spawn.rb"))
 
   class Error < StandardError
   end
+
   class TimeoutError < Error
   end
+
   class AlreadyStarted < Error
   end
+
   class StartError < Error
   end
+
   class StartTimeout < TimeoutError
   end
+
   class StopError < Error
   end
+
   class StopTimeout < TimeoutError
   end
+
   class ConnectError < Error
   end
-  class DaemonizationTimeout < TimeoutError
-  end
+
+  InternalCommandOkResult = Struct.new(:pid, :output)
+  InternalCommandErrorResult = Struct.new(:pid, :output, :exit_status)
+  InternalCommandTimeoutResult = Struct.new(:pid, :output)
 
   # Create a new DaemonController object.
   #
-  # === Mandatory options
-  #
-  # [:identifier]
-  #  A human-readable, unique name for this daemon, e.g. "Sphinx search server".
-  #  This identifier will be used in some error messages. On some platforms, it will
-  #  be used for concurrency control: on such platforms, no two DaemonController
-  #  objects will operate on the same identifier on the same time.
-  #
-  # [:start_command]
-  #  The command to start the daemon. This must be a a String, e.g.
-  #  "mongrel_rails start -e production", or a Proc which returns a String.
-  #
-  #  If the value is a Proc, and the +before_start+ option is given too, then
-  #  the +start_command+ Proc is guaranteed to be called after the +before_start+
-  #  Proc is called.
-  #
-  # [:ping_command]
-  #  The ping command is used to check whether the daemon can be connected to.
-  #  It is also used to ensure that #start only returns when the daemon can be
-  #  connected to.
-  #
-  #  The value may be a command string. This command must exit with an exit code of
-  #  0 if the daemon can be successfully connected to, or exit with a non-0 exit
-  #  code on failure.
-  #
-  #  The value may also be an Array which specifies the socket address of the daemon.
-  #  It must be in one of the following forms:
-  #  - [:tcp, host_name, port]
-  #  - [:unix, filename]
-  #
-  #  The value may also be a Proc, which returns an expression that evaluates to
-  #  true (indicating that the daemon can be connected to) or false (failure).
-  #  If the Proc raises Errno::ECONNREFUSED, Errno::ENETUNREACH, Errno::ETIMEDOUT
-  #  Errno::ECONNRESET, Errno::EINVAL or Errno::EADDRNOTAVAIL then that also
-  #  means that the daemon cannot be connected to.
-  #  <b>NOTE:</b> if the ping command returns an object which responds to
-  #  <tt>#close</tt>, then that method will be called on it.
-  #  This makes it possible to specify a ping command such as
-  #  <tt>lambda { TCPSocket.new('localhost', 1234) }</tt>, without having to worry
-  #  about closing it afterwards.
-  #  Any exceptions raised by #close are ignored.
-  #
-  # [:pid_file]
-  #  The PID file that the daemon will write to. Used to check whether the daemon
-  #  is running.
-  #
-  # [:lock_file]
-  #  The lock file to use for serializing concurrent daemon management operations.
-  #  Defaults to "(filename of PID file).lock".
-  #
-  # [:log_file]
-  #  The log file that the daemon will write to. It will be consulted to see
-  #  whether the daemon has printed any error messages during startup.
-  #
-  # === Optional options
-  # [:stop_command]
-  #  A command to stop the daemon with, e.g. "/etc/rc.d/nginx stop". If no stop
-  #  command is given (i.e. +nil+), then DaemonController will stop the daemon
-  #  by killing the PID written in the PID file.
-  #
-  #  The default value is +nil+.
-  #
-  # [:restart_command]
-  #  A command to restart the daemon with, e.g. "/etc/rc.d/nginx restart". If
-  #  no restart command is given (i.e. +nil+), then DaemonController will
-  #  restart the daemon by calling #stop and #start.
-  #
-  #  The default value is +nil+.
-  #
-  # [:before_start]
-  #  This may be a Proc. It will be called just before running the start command.
-  #  The before_start proc is not subject to the start timeout.
-  #
-  # [:start_timeout]
-  #  The maximum amount of time, in seconds, that #start may take to start
-  #  the daemon. Since #start also waits until the daemon can be connected to,
-  #  that wait time is counted as well. If the daemon does not start in time,
-  #  then #start will raise an exception.
-  #
-  #  The default value is 15.
-  #
-  # [:stop_timeout]
-  #  The maximum amount of time, in seconds, that #stop may take to stop
-  #  the daemon. Since #stop also waits until the daemon is no longer running,
-  #  that wait time is counted as well. If the daemon does not stop in time,
-  #  then #stop will raise an exception.
-  #
-  #  The default value is 15.
-  #
-  # [:log_file_activity_timeout]
-  #  Once a daemon has gone into the background, it will become difficult to
-  #  know for certain whether it is still initializing or whether it has
-  #  failed and exited, until it has written its PID file. Suppose that it
-  #  failed with an error after daemonizing but before it has written its PID file;
-  #  not many system administrators want to wait 15 seconds (the default start
-  #  timeout) to be notified of whether the daemon has terminated with an error.
-  #
-  #  An alternative way to check whether the daemon has terminated with an error,
-  #  is by checking whether its log file has been recently updated. If, after the
-  #  daemon has started, the log file hasn't been updated for the amount of seconds
-  #  given by the :log_file_activity_timeout option, then the daemon is assumed to
-  #  have terminated with an error.
-  #
-  #  The default value is 7.
-  #
-  # [:dont_stop_if_pid_file_invalid]
-  #  If the :stop_command option is given, then normally daemon_controller will
-  #  always execute this command upon calling #stop. But if :dont_stop_if_pid_file_invalid
-  #  is given, then daemon_controller will not do that if the PID file does not contain
-  #  a valid number.
-  #
-  #  The default is false.
-  #
-  # [:daemonize_for_me]
-  #  Normally daemon_controller will wait until the daemon has daemonized into the
-  #  background, in order to capture any errors that it may print on stdout or
-  #  stderr before daemonizing. However, if the daemon doesn't support daemonization
-  #  for some reason, then setting this option to true will cause daemon_controller
-  #  to do the daemonization for the daemon.
-  #
-  #  The default is false.
-  #
-  # [:keep_ios]
-  #  Upon spawning the daemon, daemon_controller will normally close all file
-  #  descriptors except stdin, stdout and stderr. However if there are any file
-  #  descriptors you want to keep open, specify the IO objects here. This must be
-  #  an array of IO objects.
-  #
-  # [:env]
-  #  This must be a Hash.  The hash will contain the environment variables available
-  #  to be made available to the daemon. Hash keys must be strings, not symbols.
-  def initialize(options)
-    [ :identifier, :start_command, :ping_command, :pid_file, :log_file ].each do |option|
-      if !options.has_key?(option)
-        raise ArgumentError, "The ':#{option}' option is mandatory."
-      end
-    end
-    @identifier = options[:identifier]
-    @start_command = options[:start_command]
-    @stop_command = options[:stop_command]
-    @ping_command = options[:ping_command]
-    @restart_command = options[:restart_command]
-    @ping_interval = options[:ping_interval] || 0.1
-    @pid_file = options[:pid_file]
-    @log_file = options[:log_file]
-    @before_start = options[:before_start]
-    @start_timeout = options[:start_timeout] || 15
-    @stop_timeout = options[:stop_timeout] || 15
-    @log_file_activity_timeout = options[:log_file_activity_timeout] || 7
-    @dont_stop_if_pid_file_invalid = options[:dont_stop_if_pid_file_invalid]
-    @daemonize_for_me = options[:daemonize_for_me]
-    @keep_ios = options[:keep_ios] || []
-    @lock_file = determine_lock_file(options, @identifier, @pid_file)
-    @env = options[:env] || {}
+  # See doc/OPTIONS.md for options docs.
+  def initialize(identifier:, start_command:, ping_command:, pid_file:, log_file:,
+    lock_file: nil, stop_command: nil, restart_command: nil, before_start: nil,
+    start_timeout: 30, start_abort_timeout: 10, stop_timeout: 30,
+    log_file_activity_timeout: 10, ping_interval: 0.1, stop_graceful_signal: "TERM", dont_stop_if_pid_file_invalid: false,
+    daemonize_for_me: false, keep_ios: nil, env: {}, logger: nil)
+    @identifier = identifier
+    @start_command = start_command
+    @ping_command = ping_command
+    @pid_file = pid_file
+    @log_file = log_file
+
+    @lock_file = determine_lock_file(lock_file, identifier, pid_file)
+    @stop_command = stop_command
+    @restart_command = restart_command
+    @before_start = before_start
+    @start_timeout = start_timeout
+    @start_abort_timeout = start_abort_timeout
+    @stop_timeout = stop_timeout
+    @log_file_activity_timeout = log_file_activity_timeout
+    @ping_interval = ping_interval
+    @stop_graceful_signal = stop_graceful_signal
+    @dont_stop_if_pid_file_invalid = dont_stop_if_pid_file_invalid
+    @daemonize_for_me = daemonize_for_me
+    @keep_ios = keep_ios
+    @env = env
+    @logger = logger
   end
 
   # Start the daemon and wait until it can be pinged.
@@ -254,15 +136,13 @@ class DaemonController
   def connect
     connection = nil
     @lock_file.shared_lock do
-      begin
-        connection = yield
-      rescue *ALLOWED_CONNECT_EXCEPTIONS
-        connection = nil
-      end
+      connection = yield
+    rescue *ALLOWED_CONNECT_EXCEPTIONS
+      connection = nil
     end
     if connection.nil?
       @lock_file.exclusive_lock do
-        if !daemon_is_running?
+        unless daemon_is_running?
           start_without_locking
         end
         connect_exception = nil
@@ -299,17 +179,17 @@ class DaemonController
   # - StopTimeout - the daemon didn't stop in time.
   def stop
     @lock_file.exclusive_lock do
-      begin
-        Timeout.timeout(@stop_timeout, Timeout::Error) do
-          kill_daemon if daemon_is_running?
-          wait_until do
-            !daemon_is_running?
-          end
+      timeoutable(@stop_timeout) do
+        allow_timeout do
+          kill_daemon
+          wait_until { !daemon_is_running? }
         end
-      rescue Timeout::Error
-        raise StopTimeout, "Daemon '#{@identifier}' did not exit in time"
       end
     end
+  rescue Timeout::Error
+    kill_daemon_with_signal(force: true)
+    wait_until { !daemon_is_running? }
+    raise StopTimeout, "Daemon '#{@identifier}' did not exit in time (force killed)"
   end
 
   # Restarts the daemon. Uses the restart_command if provided, otherwise
@@ -355,71 +235,89 @@ class DaemonController
     RUBY_PLATFORM != "java"
   end
 
-private
+  private
+
   def start_without_locking
-    if daemon_is_running?
-      raise AlreadyStarted, "Daemon '#{@identifier}' is already started"
-    end
+    raise AlreadyStarted, "Daemon '#{@identifier}' is already started" if daemon_is_running?
+
     save_log_file_information
     delete_pid_file
+    spawn_result = nil
+
     begin
-      started = false
-      before_start
-      Timeout.timeout(@start_timeout, Timeout::Error) do
-        done = false
-        spawn_daemon
+      _, remaining_time = timeoutable(@start_timeout) do
+        allow_timeout { before_start }
+        spawn_result = allow_timeout { spawn_daemon }
+        daemon_spawned
         record_activity
 
-        # We wait until the PID file is available and until
-        # the daemon responds to pings, but we wait no longer
-        # than @start_timeout seconds in total (including daemon
-        # spawn time).
-        # Furthermore, if the log file hasn't changed for
-        # @log_file_activity_timeout seconds, and the PID file
-        # still isn't available or the daemon still doesn't
-        # respond to pings, then assume that the daemon has
-        # terminated with an error.
-        wait_until do
-          if log_file_has_changed?
-            record_activity
-          elsif no_activity?(@log_file_activity_timeout)
-            raise Timeout::Error, "Daemon seems to have exited"
-          end
-          pid_file_available?
-        end
-        wait_until(@ping_interval) do
-          if log_file_has_changed?
-            record_activity
-          elsif no_activity?(@log_file_activity_timeout)
-            raise Timeout::Error, "Daemon seems to have exited"
+        if spawn_result.is_a?(InternalCommandOkResult)
+          allow_timeout do
+            # We wait until the PID file is available and until
+            # the daemon responds to pings, but we wait no longer
+            # than @start_timeout seconds in total (including daemon
+            # spawn time).
+            # Furthermore, if the log file hasn't changed for
+            # @log_file_activity_timeout seconds, and the PID file
+            # still isn't available or the daemon still doesn't
+            # respond to pings, then assume that the daemon has
+            # terminated with an error.
+            wait_until do
+              if log_file_has_changed?
+                record_activity
+              elsif no_activity?(@log_file_activity_timeout)
+                raise Timeout::Error, "Log file inactivity"
+              end
+              pid_file_available?
+            end
+            wait_until(sleep_interval: @ping_interval) do
+              if log_file_has_changed?
+                record_activity
+              elsif no_activity?(@log_file_activity_timeout)
+                raise Timeout::Error, "Log file inactivity"
+              end
+              run_ping_command || !daemon_is_running?
+            end
           end
-          run_ping_command || !daemon_is_running?
         end
-        started = run_ping_command
-      end
-      result = started
-    rescue DaemonizationTimeout, Timeout::Error => e
-      start_timed_out
-      if pid_file_available?
-        kill_daemon_with_signal(true)
-      end
-      if e.is_a?(DaemonizationTimeout)
-        result = :daemonization_timeout
+
+        spawn_result
+      end
+    rescue Timeout::Error
+      # If we got here then it means either the #before_start timed out (= no PID),
+      # or the code after #spawn_daemon timed out (already daemonized, so use PID file).
+      # #spawn_daemon itself won't trigger Timeout:Error because that's handled as
+      # InternalCommandTimeoutResult.
+      pid = spawn_result ? read_pid_file : nil
+      start_timed_out(pid)
+      debug "Timeout waiting for daemon to be ready, PID #{pid.inspect}"
+      abort_start(pid: pid, is_direct_child: false) if pid
+      raise StartTimeout, concat_spawn_output_and_logs(spawn_result ? spawn_result.output : nil,
+        differences_in_log_file, nil, "timed out")
+    end
+
+    case spawn_result
+    when InternalCommandOkResult
+      success, _ = timeoutable(remaining_time) { allow_timeout { run_ping_command } }
+      if success
+        true
       else
-        result = :start_timeout
+        raise StartError, concat_spawn_output_and_logs(spawn_result.output, differences_in_log_file)
       end
-    end
-    if !result
-      raise(StartError, differences_in_log_file ||
-        "Daemon '#{@identifier}' failed to start.")
-    elsif result == :daemonization_timeout
-      raise(StartTimeout, differences_in_log_file ||
-        "Daemon '#{@identifier}' didn't daemonize in time.")
-    elsif result == :start_timeout
-      raise(StartTimeout, differences_in_log_file ||
-        "Daemon '#{@identifier}' failed to start in time.")
+
+    when InternalCommandErrorResult
+      raise StartError, concat_spawn_output_and_logs(spawn_result.output,
+        differences_in_log_file, spawn_result.exit_status)
+
+    when InternalCommandTimeoutResult
+      daemonization_timed_out(spawn_result.pid)
+      abort_start(pid: spawn_result.pid, is_direct_child: true)
+      debug "Timeout waiting for daemon to fork, PID #{spawn_result.pid}"
+      raise StartTimeout, concat_spawn_output_and_logs(spawn_result.output,
+        differences_in_log_file, nil, "timed out")
+
     else
-      true
+      raise "Bug: unexpected result from #spawn_daemon: #{spawn_result.inspect}"
     end
   end
 
@@ -439,42 +337,39 @@ private
 
   def kill_daemon
     if @stop_command
-      if @dont_stop_if_pid_file_invalid && read_pid_file.nil?
-        return
-      end
-      begin
-        run_command(@stop_command)
-      rescue StartError => e
-        raise StopError, e.message
+      return if @dont_stop_if_pid_file_invalid && read_pid_file.nil?
+
+      result = run_command(@stop_command)
+      case result
+      when InternalCommandOkResult
+        # Success
+      when InternalCommandErrorResult
+        raise StopError, concat_spawn_output_and_logs(result.output, nil, result.exit_status)
+      when InternalCommandTimeoutResult
+        raise StopError, concat_spawn_output_and_logs(result.output, nil, nil, "timed out")
+      else
+        raise "Bug: unexpected result from #run_command: #{result.inspect}"
       end
     else
       kill_daemon_with_signal
     end
   end
 
-  def kill_daemon_with_signal(force = false)
-    pid = read_pid_file
-    if pid
+  def kill_daemon_with_signal(force: false)
+    if (pid = read_pid_file)
       if force
-        Process.kill('SIGKILL', pid)
+        Process.kill("SIGKILL", pid)
       else
-        Process.kill('SIGTERM', pid)
+        Process.kill(normalize_signal_name(@stop_graceful_signal), pid)
       end
     end
   rescue Errno::ESRCH, Errno::ENOENT
   end
 
   def daemon_is_running?
-    begin
-      pid = read_pid_file
-    rescue Errno::ENOENT
-      # The PID file may not exist, or another thread/process
-      # executing #running? may have just deleted the PID file.
-      # So we catch this error.
-      pid = nil
-    end
+    pid = read_pid_file
     if pid.nil?
-      false
+      nil
     elsif check_pid(pid)
       true
     else
@@ -484,16 +379,11 @@ private
   end
 
   def read_pid_file
-    begin
-      pid = File.read(@pid_file).strip
-    rescue Errno::ENOENT
-      return nil
-    end
-    if pid =~ /\A\d+\Z/
+    pid = File.read(@pid_file).strip
+    if /\A\d+\Z/.match?(pid)
       pid.to_i
-    else
-      nil
     end
+  rescue Errno::ENOENT
   end
 
   def delete_pid_file
@@ -514,21 +404,21 @@ private
     true
   end
 
-  def wait_until(sleep_interval = 0.1)
-    while !yield
+  def wait_until(sleep_interval: 0.1)
+    until yield
       sleep(sleep_interval)
     end
   end
 
   def wait_until_pid_file_is_available_or_log_file_has_changed
-    while !(pid_file_available? || log_file_has_changed?)
+    until pid_file_available? || log_file_has_changed?
       sleep 0.1
     end
     pid_file_is_available?
   end
 
   def wait_until_daemon_responds_to_ping_or_has_exited_or_log_file_has_changed
-    while !(run_ping_command || !daemon_is_running? || log_file_has_changed?)
+    until run_ping_command || !daemon_is_running? || log_file_has_changed?
       sleep(@ping_interval)
     end
     run_ping_command
@@ -544,28 +434,90 @@ private
   end
 
   def pid_file_available?
-    File.exist?(@pid_file) && File.stat(@pid_file).size != 0
+    File.exist?(@pid_file) && !File.zero?(@pid_file)
   end
 
   # This method does nothing and only serves as a hook for the unit test.
-  def start_timed_out
+  def daemon_spawned
   end
 
   # This method does nothing and only serves as a hook for the unit test.
-  def daemonization_timed_out
+  def start_timed_out(pid)
+  end
+
+  # This method does nothing and only serves as a hook for the unit test.
+  def daemonization_timed_out(pid)
+  end
+
+  # Aborts a daemon that we tried to start, but timed out.
+  def abort_start(pid:, is_direct_child:)
+    begin
+      debug "Killing process #{pid}"
+      Process.kill("SIGTERM", pid)
+    rescue SystemCallError
+    end
+
+    begin
+      timeoutable(@start_abort_timeout) do
+        allow_timeout do
+          wait_for_aborted_process(pid: pid, is_direct_child: is_direct_child)
+        end
+      end
+    rescue Timeout::Error
+      begin
+        Process.kill("SIGKILL", pid)
+      rescue SystemCallError
+      end
+
+      allow_timeout do
+        wait_for_aborted_process(pid: pid, is_direct_child: is_direct_child)
+      end
+    end
+  end
+
+  def wait_for_aborted_process(pid:, is_direct_child:)
+    if is_direct_child
+      begin
+        debug "Waiting directly for process #{pid}"
+        Process.waitpid(pid)
+      rescue SystemCallError
+      end
+
+      # The daemon may have:
+      # 1. Written a PID file before forking. We delete this PID file.
+      #    -OR-
+      # 2. It might have forked (and written a PID file) right before
+      #    we terminated it. We'll want the fork to stay alive rather
+      #    than going through the (complicated) trouble of killing it.
+      #    Don't touch the PID file.
+      pid2 = read_pid_file
+      debug "PID file contains #{pid2.inspect}"
+      delete_pid_file if pid == pid2
+    else
+      debug "Waiting until daemon is no longer running"
+      wait_until { !daemon_is_running? }
+    end
   end
 
   def save_log_file_information
-    @original_log_file_stat = File.stat(@log_file) rescue nil
+    @original_log_file_stat = begin
+      File.stat(@log_file)
+    rescue
+      nil
+    end
     @current_log_file_stat = @original_log_file_stat
   end
 
   def log_file_has_changed?
     if @current_log_file_stat
-      stat = File.stat(@log_file) rescue nil
+      stat = begin
+        File.stat(@log_file)
+      rescue
+        nil
+      end
       if stat
         result = @current_log_file_stat.mtime != stat.mtime ||
-                 @current_log_file_stat.size  != stat.size
+          @current_log_file_stat.size != stat.size
         @current_log_file_stat = stat
         result
       else
@@ -578,45 +530,88 @@ private
 
   def differences_in_log_file
     if @original_log_file_stat && @original_log_file_stat.file?
-      File.open(@log_file, 'r') do |f|
+      File.open(@log_file, "r") do |f|
         f.seek(@original_log_file_stat.size, IO::SEEK_SET)
-        diff = f.read.strip
-        if diff.empty?
-          nil
-        else
-          diff
-        end
+        f.read.strip
       end
-    else
-      nil
     end
   rescue Errno::ENOENT, Errno::ESPIPE
     # ESPIPE means the log file is a pipe.
     nil
   end
 
-  def determine_lock_file(options, identifier, pid_file)
-    if options[:lock_file]
-      LockFile.new(File.expand_path(options[:lock_file]))
+  def determine_lock_file(given_lock_file, identifier, pid_file)
+    if given_lock_file
+      LockFile.new(File.absolute_path(given_lock_file))
     else
-      LockFile.new(File.expand_path(pid_file + ".lock"))
+      LockFile.new(File.absolute_path(pid_file + ".lock"))
     end
   end
 
-  def self.fork_supported?
-    RUBY_PLATFORM != "java" && RUBY_PLATFORM !~ /win32/
-  end
-
-  def self.spawn_supported?
-    # Process.spawn doesn't work very well in JRuby.
-    Process.respond_to?(:spawn) && RUBY_PLATFORM != "java"
-  end
-
   def run_command(command)
     if should_capture_output_while_running_command?
-      run_command_while_capturing_output(command)
+      # Create tempfile for storing the command's output.
+      tempfile = Tempfile.new("daemon-output")
+      tempfile.chmod(0o666)
+      tempfile_path = tempfile.path
+      tempfile.close
+
+      spawn_options = {
+        in: "/dev/null",
+        out: tempfile_path,
+        err: tempfile_path,
+        close_others: true,
+      }
+    else
+      spawn_options = {
+        in: "/dev/null",
+        out: :out,
+        err: :err,
+        close_others: true,
+      }
+    end
+
+    if @keep_ios
+      @keep_ios.each do |io|
+        spawn_options[io] = io
+      end
+    end
+
+    pid = if @daemonize_for_me
+      Process.spawn(@env, ruby_interpreter, SPAWNER_FILE,
+        command, spawn_options)
+    else
+      Process.spawn(@env, command, spawn_options)
+    end
+
+    # run_command might be running in a timeout block (like
+    # in #start_without_locking).
+    begin
+      Process.waitpid(pid)
+    rescue Errno::ECHILD
+      # Maybe a background thread or whatever waitpid()'ed
+      # this child process before we had the chance. There's
+      # no way to obtain the exit status now. Assume that
+      # it started successfully; if it didn't we'll know
+      # that later by checking the PID file and by pinging
+      # it.
+      return InternalCommandOkResult.new(pid, tempfile_path && File.read(tempfile_path).strip)
+    rescue Timeout::Error
+      return InternalCommandTimeoutResult.new(pid, tempfile_path && File.read(tempfile_path).strip)
+    end
+
+    child_status = $?
+    output = File.read(tempfile_path).strip if tempfile_path
+    if child_status.success?
+      InternalCommandOkResult.new(pid, output)
     else
-      run_command_without_capturing_output(command)
+      InternalCommandErrorResult.new(pid, output, child_status)
+    end
+  ensure
+    begin
+      tempfile.unlink if tempfile
+    rescue SystemCallError
+      nil
     end
   end
 
@@ -645,192 +640,16 @@ private
       path =~ %r{\A/proc/([0-9]+|self)/fd/[12]\Z}
   end
 
-  def run_command_while_capturing_output(command)
-    # Create tempfile for storing the command's output.
-    tempfile = Tempfile.new('daemon-output')
-    tempfile.chmod(0666)
-    tempfile_path = tempfile.path
-    tempfile.close
-
-    if self.class.fork_supported? || self.class.spawn_supported?
-      if Process.respond_to?(:spawn)
-        options = {
-          in: "/dev/null",
-          out: tempfile_path,
-          err: tempfile_path,
-          close_others: true,
-        }
-        @keep_ios.each do |io|
-          options[io] = io
-        end
-        if @daemonize_for_me
-          pid = Process.spawn(@env, ruby_interpreter, SPAWNER_FILE,
-            command, options)
-        else
-          pid = Process.spawn(@env, command, options)
-        end
-      else
-        pid = safe_fork(@daemonize_for_me) do
-          ObjectSpace.each_object(IO) do |obj|
-            if !@keep_ios.include?(obj)
-              obj.close rescue nil
-            end
-          end
-          STDIN.reopen("/dev/null", "r")
-          STDOUT.reopen(tempfile_path, "w")
-          STDERR.reopen(tempfile_path, "w")
-          ENV.update(@env)
-          exec(command)
-        end
-      end
-
-      # run_command might be running in a timeout block (like
-      # in #start_without_locking).
-      begin
-        interruptable_waitpid(pid)
-      rescue Errno::ECHILD
-        # Maybe a background thread or whatever waitpid()'ed
-        # this child process before we had the chance. There's
-        # no way to obtain the exit status now. Assume that
-        # it started successfully; if it didn't we'll know
-        # that later by checking the PID file and by pinging
-        # it.
-        return
-      rescue Timeout::Error
-        daemonization_timed_out
-
-        # If the daemon doesn't fork into the background
-        # in time, then kill it.
-        begin
-          Process.kill('SIGTERM', pid)
-        rescue SystemCallError
-        end
-        begin
-          Timeout.timeout(5, Timeout::Error) do
-            begin
-              interruptable_waitpid(pid)
-            rescue SystemCallError
-            end
-          end
-        rescue Timeout::Error
-          begin
-            Process.kill('SIGKILL', pid)
-            interruptable_waitpid(pid)
-          rescue SystemCallError
-          end
-        end
-        raise DaemonizationTimeout
-      end
-      if $?.exitstatus != 0
-        raise StartError, File.read(tempfile_path).strip
-      end
-    else
-      if @env && !@env.empty?
-        raise "Setting the :env option is not supported on this Ruby implementation."
-      elsif @daemonize_for_me
-        raise "Setting the :daemonize_for_me option is not supported on this Ruby implementation."
-      end
-
-      cmd = "#{command} >\"#{tempfile_path}\""
-      cmd << " 2>\"#{tempfile_path}\"" unless PLATFORM =~ /mswin/
-      if !system(cmd)
-        raise StartError, File.read(tempfile_path).strip
-      end
-    end
-  ensure
-    File.unlink(tempfile_path) rescue nil
-  end
-
-  def run_command_without_capturing_output(command)
-    if self.class.fork_supported? || self.class.spawn_supported?
-      if Process.respond_to?(:spawn)
-        options = {
-          in: "/dev/null",
-          out: :out,
-          err: :err,
-          close_others: true,
-        }
-        @keep_ios.each do |io|
-          options[io] = io
-        end
-        if @daemonize_for_me
-          pid = Process.spawn(@env, ruby_interpreter, SPAWNER_FILE,
-            command, options)
-        else
-          pid = Process.spawn(@env, command, options)
-        end
-      else
-        pid = safe_fork(@daemonize_for_me) do
-          ObjectSpace.each_object(IO) do |obj|
-            if !@keep_ios.include?(obj)
-              obj.close rescue nil
-            end
-          end
-          STDIN.reopen("/dev/null", "r")
-          ENV.update(@env)
-          exec(command)
-        end
-      end
-
-      # run_command might be running in a timeout block (like
-      # in #start_without_locking).
-      begin
-        interruptable_waitpid(pid)
-      rescue Errno::ECHILD
-        # Maybe a background thread or whatever waitpid()'ed
-        # this child process before we had the chance. There's
-        # no way to obtain the exit status now. Assume that
-        # it started successfully; if it didn't we'll know
-        # that later by checking the PID file and by pinging
-        # it.
-        return
-      rescue Timeout::Error
-        daemonization_timed_out
-
-        # If the daemon doesn't fork into the background
-        # in time, then kill it.
-        begin
-          Process.kill('SIGTERM', pid)
-        rescue SystemCallError
-        end
-        begin
-          Timeout.timeout(5, Timeout::Error) do
-            begin
-              interruptable_waitpid(pid)
-            rescue SystemCallError
-            end
-          end
-        rescue Timeout::Error
-          begin
-            Process.kill('SIGKILL', pid)
-            interruptable_waitpid(pid)
-          rescue SystemCallError
-          end
-        end
-        raise DaemonizationTimeout
-      end
-      if $?.exitstatus != 0
-        raise StartError, "Daemon '#{@identifier}' failed to start."
-      end
-    else
-      if @env && !@env.empty?
-        raise "Setting the :env option is not supported on this Ruby implementation."
-      elsif @daemonize_for_me
-        raise "Setting the :daemonize_for_me option is not supported on this Ruby implementation."
-      end
-
-      if !system(command)
-        raise StartError, "Daemon '#{@identifier}' failed to start."
-      end
-    end
-  end
-
   def run_ping_command
     if @ping_command.respond_to?(:call)
       begin
         value = @ping_command.call
         if value.respond_to?(:close)
-          value.close rescue nil
+          begin
+            value.close
+          rescue
+            nil
+          end
         end
         value
       rescue *ALLOWED_CONNECT_EXCEPTIONS
@@ -867,27 +686,55 @@ private
     end
   end
 
-  if !can_ping_unix_sockets?
-    require 'java'
+  if can_ping_unix_sockets?
+    def ping_socket(socket_domain, sockaddr)
+      socket = Socket.new(socket_domain, Socket::Constants::SOCK_STREAM, 0)
+      begin
+        socket.connect_nonblock(sockaddr)
+      rescue Errno::ENOENT, Errno::EINPROGRESS, Errno::EAGAIN, Errno::EWOULDBLOCK
+        if select(nil, [ socket ], nil, 0.1)
+          begin
+            socket.connect_nonblock(sockaddr)
+          rescue Errno::EISCONN
+          rescue Errno::EINVAL
+            if RUBY_PLATFORM.match?(/freebsd/i)
+              raise Errno::ECONNREFUSED
+            else
+              raise
+            end
+          end
+        else
+          raise Errno::ECONNREFUSED
+        end
+      end
+      true
+    rescue Errno::ECONNREFUSED, Errno::ENOENT
+      false
+    ensure
+      socket.close if socket
+    end
+
+    def ping_tcp_socket(sockaddr)
+      ping_socket(Socket::Constants::AF_INET, sockaddr)
+    rescue Errno::EAFNOSUPPORT
+      ping_socket(Socket::Constants::AF_INET6, sockaddr)
+    end
+  else
+    require "java"
 
     def ping_socket(host_name, port)
       channel = java.nio.channels.SocketChannel.open
       begin
         address = java.net.InetSocketAddress.new(host_name, port)
         channel.configure_blocking(false)
-        if channel.connect(address)
-          return true
-        end
+        return true if channel.connect(address)
 
         deadline = Time.now.to_f + 0.1
-        done = false
-        while true
+        loop do
           begin
-            if channel.finish_connect
-              return true
-            end
+            return true if channel.finish_connect
           rescue java.net.ConnectException => e
-            if e.message =~ /Connection refused/i
+            if /Connection refused/i.match?(e.message)
               return false
             else
               throw e
@@ -896,116 +743,85 @@ private
 
           # Not done connecting and no error.
           sleep 0.01
-          if Time.now.to_f >= deadline
-            return false
-          end
+          return false if Time.now.to_f >= deadline
         end
       ensure
         channel.close
       end
     end
-  else
-    def ping_socket(socket_domain, sockaddr)
-      begin
-        socket = Socket.new(socket_domain, Socket::Constants::SOCK_STREAM, 0)
-        begin
-          socket.connect_nonblock(sockaddr)
-        rescue Errno::ENOENT, Errno::EINPROGRESS, Errno::EAGAIN, Errno::EWOULDBLOCK
-          if select(nil, [ socket ], nil, 0.1)
-            begin
-              socket.connect_nonblock(sockaddr)
-            rescue Errno::EISCONN
-            rescue Errno::EINVAL
-              if RUBY_PLATFORM =~ /freebsd/i
-                raise Errno::ECONNREFUSED
-              else
-                raise
-              end
-            end
-          else
-            raise Errno::ECONNREFUSED
-          end
-        end
-        true
-      rescue Errno::ECONNREFUSED, Errno::ENOENT
-        false
-      ensure
-        socket.close if socket
-      end
-    end
+  end
 
-    def ping_tcp_socket(sockaddr)
-      begin
-        ping_socket(Socket::Constants::AF_INET, sockaddr)
-      rescue Errno::EAFNOSUPPORT
-        ping_socket(Socket::Constants::AF_INET6, sockaddr)
-      end
+  def ruby_interpreter
+    File.join(
+      RbConfig::CONFIG["bindir"],
+      RbConfig::CONFIG.values_at("RUBY_INSTALL_NAME", "EXEEXT").join
+    )
+  end
+
+  def timeoutable(amount, &block)
+    Thread.handle_interrupt(Timeout::Error => :never) do
+      start_time = monotonic_time
+      result = Timeout.timeout(amount, Timeout::Error, &block)
+      [ result, [ monotonic_time - start_time, 0 ].max ]
     end
   end
 
-  def ruby_interpreter
-    if defined?(RbConfig)
-      rb_config = RbConfig::CONFIG
+  def allow_timeout(&block)
+    Thread.handle_interrupt(Timeout::Error => :on_blocking, &block)
+  end
+
+  def monotonic_time
+    Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  end
+
+  def signal_termination_message(process_status)
+    if process_status.signaled?
+      "terminated with signal #{signal_name_for(process_status.termsig)}"
     else
-      rb_config = Config::CONFIG
+      "exited with status #{process_status.exitstatus}"
     end
-    File.join(
-      rb_config['bindir'],
-      rb_config['RUBY_INSTALL_NAME']
-    ) + rb_config['EXEEXT']
   end
 
-  def safe_fork(double_fork)
-    pid = fork
-    if pid.nil?
-      begin
-        if double_fork
-          pid2 = fork
-          if pid2.nil?
-            Process.setsid
-            yield
-          end
-        else
-          yield
-        end
-      rescue Exception => e
-        message = "*** Exception #{e.class} " <<
-          "(#{e}) (process #{$$}):\n" <<
-          "\tfrom " << e.backtrace.join("\n\tfrom ")
-        STDERR.write(e)
-        STDERR.flush
-        exit!
-      ensure
-        exit!(0)
-      end
+  def normalize_signal_name(name)
+    name.start_with?("SIG") ? name : "SIG#{name}"
+  end
+
+  def signal_name_for(num)
+    if (name = Signal.list.key(num))
+      "SIG#{name}"
     else
-      if double_fork
-        Process.waitpid(pid) rescue nil
-        pid
-      else
-        pid
-      end
+      num.to_s
     end
   end
 
-  if RUBY_VERSION < "1.9"
-    def interruptable_waitpid(pid)
-      Process.waitpid(pid)
+  def concat_spawn_output_and_logs(output, logs, exit_status = nil, suffix_message = nil)
+    format_full_suffix_message = lambda do |main_message = nil|
+      [
+        main_message,
+        exit_status ? signal_termination_message(exit_status) : nil,
+        suffix_message,
+      ].compact.join("; ")
     end
-  else
-    # On Ruby 1.9, Thread#kill (which is called by timeout.rb) may
-    # not be able to interrupt Process.waitpid. So here we use a
-    # special version that's a bit less efficient but is at least
-    # interruptable.
-    def interruptable_waitpid(pid)
-      result = nil
-      while !result
-        result = Process.waitpid(pid, Process::WNOHANG)
-        sleep 0.01 if !result
+
+    if output.nil? && logs.nil?
+      "(#{format_full_suffix_message.call("logs not available")})"
+    elsif (output && output.empty? && logs && logs.empty?) || (output && output.empty? && logs.nil?) || (output.nil? && logs && logs.empty?)
+      "(#{format_full_suffix_message.call("logs empty")})"
+    else
+      full_suffix_message = format_full_suffix_message.call
+      if full_suffix_message.empty?
+        "#{output}\n#{logs}".strip
+      elsif logs && logs.empty?
+        "#{output}\n(#{full_suffix_message})".strip
+      else
+        "#{output}\n#{logs}\n(#{full_suffix_message})".strip
       end
-      result
     end
   end
+
+  def debug(message)
+    @logger.debug(message) if @logger
+  end
 end
 
 end # module PhusionPassenger