daemon_controller 2.0.0 → 3.0.0

data/lib/daemon_controller.rb

@@ -63,172 +63,39 @@ class DaemonController
   class ConnectError < Error
   end
 
-  # Internal, not publicly thrown.
-  class DaemonizationTimeout < TimeoutError
-    attr_reader :output
-
-    def initialize(output)
-      super()
-      @output = output
-    end
-  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: nil, 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.
@@ -310,15 +177,17 @@ class DaemonController
   # - StopTimeout - the daemon didn't stop in time.
   def stop
     @lock_file.exclusive_lock do
-      Timeout.timeout(@stop_timeout, Timeout::Error) do
-        kill_daemon
-        wait_until do
-          !daemon_is_running?
+      timeoutable(@stop_timeout) do
+        allow_timeout do
+          kill_daemon
+          wait_until { !daemon_is_running? }
         end
       end
-    rescue Timeout::Error
-      raise StopTimeout, "Daemon '#{@identifier}' did not exit in time"
     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
@@ -367,66 +236,86 @@ class DaemonController
   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
-        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, "Log file inactivity"
-          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, "Log file inactivity"
+        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)
+
+        spawn_result
       end
-      result = if e.is_a?(DaemonizationTimeout)
-        :daemonization_timeout
+    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
-        :start_timeout
+        raise StartError, concat_spawn_output_and_logs(spawn_result.output, differences_in_log_file)
       end
-    end
 
-    if !result
-      raise StartError, concat_spawn_output_and_logs(@spawn_output, differences_in_log_file)
-    elsif result == :daemonization_timeout
-      raise StartTimeout, concat_spawn_output_and_logs(@spawn_output, differences_in_log_file, nil, "timed out")
-    elsif result == :start_timeout
-      raise StartTimeout, concat_spawn_output_and_logs(@spawn_output, differences_in_log_file, nil, "timed out")
+    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
 
@@ -437,14 +326,11 @@ class DaemonController
   end
 
   def spawn_daemon
-    @spawn_output = if @start_command.respond_to?(:call)
+    if @start_command.respond_to?(:call)
       run_command(@start_command.call)
     else
       run_command(@start_command)
     end
-  rescue DaemonizationTimeout => e
-    @spawn_output = e.output
-    raise e
   end
 
   def kill_daemon
@@ -452,39 +338,39 @@ class DaemonController
       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
+
+      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)
+  def kill_daemon_with_signal(force: false)
     pid = read_pid_file
     if pid
       if force
         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
@@ -522,7 +408,7 @@ class DaemonController
     true
   end
 
-  def wait_until(sleep_interval = 0.1)
+  def wait_until(sleep_interval: 0.1)
     until yield
       sleep(sleep_interval)
     end
@@ -556,11 +442,81 @@ class DaemonController
   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
+          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
+      end
+    rescue Timeout::Error
+      begin
+        Process.kill("SIGKILL", pid)
+      rescue SystemCallError
+      end
+
+      allow_timeout do
+        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
+    end
   end
 
   def save_log_file_information
@@ -604,9 +560,9 @@ class DaemonController
     nil
   end
 
-  def determine_lock_file(options, identifier, pid_file)
-    if options[:lock_file]
-      LockFile.new(File.absolute_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.absolute_path(pid_file + ".lock"))
     end
@@ -614,64 +570,44 @@ class DaemonController
 
   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
-      run_command_without_capturing_output(command)
+      spawn_options = {
+        in: "/dev/null",
+        out: :out,
+        err: :err,
+        close_others: true
+      }
     end
-  end
 
-  def should_capture_output_while_running_command?
-    if is_std_channel_chardev?(@log_file)
-      false
-    else
-      begin
-        real_log_file = Pathname.new(@log_file).realpath.to_s
-      rescue SystemCallError
-        real_log_file = nil
-      end
-      if real_log_file
-        !is_std_channel_chardev?(real_log_file)
-      else
-        true
+    if @keep_ios
+      @keep_ios.each do |io|
+        spawn_options[io] = io
       end
     end
-  end
-
-  def is_std_channel_chardev?(path)
-    path == "/dev/stdout" ||
-      path == "/dev/stderr" ||
-      path == "/dev/fd/1" ||
-      path == "/dev/fd/2" ||
-      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(0o666)
-    tempfile_path = tempfile.path
-    tempfile.close
 
-    options = {
-      in: "/dev/null",
-      out: tempfile_path,
-      err: tempfile_path,
-      close_others: true
-    }
-    @keep_ios.each do |io|
-      options[io] = io
-    end
     pid = if @daemonize_for_me
-      Process.spawn(@env, ruby_interpreter, SPAWNER_FILE,
-        command, options)
+      Process.spawn(@env || {}, ruby_interpreter, SPAWNER_FILE,
+        command, spawn_options)
     else
-      Process.spawn(@env, command, options)
+      Process.spawn(@env || {}, command, spawn_options)
     end
 
     # run_command might be running in a timeout block (like
     # in #start_without_locking).
     begin
-      interruptable_waitpid(pid)
+      Process.waitpid(pid)
     rescue Errno::ECHILD
       # Maybe a background thread or whatever waitpid()'ed
       # this child process before we had the chance. There's
@@ -679,102 +615,51 @@ class DaemonController
       # it started successfully; if it didn't we'll know
       # that later by checking the PID file and by pinging
       # it.
-      return
+      return InternalCommandOkResult.new(pid, tempfile_path ? File.read(tempfile_path).strip : nil)
     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
-          interruptable_waitpid(pid)
-        rescue SystemCallError
-        end
-      rescue Timeout::Error
-        begin
-          Process.kill("SIGKILL", pid)
-          interruptable_waitpid(pid)
-        rescue SystemCallError
-        end
-      end
-      raise DaemonizationTimeout, File.read(tempfile_path).strip
+      return InternalCommandTimeoutResult.new(pid, tempfile_path ? File.read(tempfile_path).strip : nil)
     end
 
-    output = File.read(tempfile_path).strip
-    if $?.exitstatus != 0
-      raise StartError, concat_spawn_output_and_logs(output, differences_in_log_file, $?)
+    child_status = $?
+    output = File.read(tempfile_path).strip if tempfile_path
+    if child_status.success?
+      InternalCommandOkResult.new(pid, output)
     else
-      output
+      InternalCommandErrorResult.new(pid, output, child_status)
     end
   ensure
     begin
-      File.unlink(tempfile_path)
-    rescue
+      File.unlink(tempfile_path) if tempfile_path
+    rescue SystemCallError
       nil
     end
   end
 
-  def run_command_without_capturing_output(command)
-    options = {
-      in: "/dev/null",
-      out: :out,
-      err: :err,
-      close_others: true
-    }
-    @keep_ios.each do |io|
-      options[io] = io
-    end
-    pid = if @daemonize_for_me
-      Process.spawn(@env, ruby_interpreter, SPAWNER_FILE,
-        command, options)
+  def should_capture_output_while_running_command?
+    if is_std_channel_chardev?(@log_file)
+      false
     else
-      Process.spawn(@env, command, options)
-    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)
+        real_log_file = Pathname.new(@log_file).realpath.to_s
       rescue SystemCallError
+        real_log_file = nil
       end
-      begin
-        Timeout.timeout(5, Timeout::Error) do
-          interruptable_waitpid(pid)
-        rescue SystemCallError
-        end
-      rescue Timeout::Error
-        begin
-          Process.kill("SIGKILL", pid)
-          interruptable_waitpid(pid)
-        rescue SystemCallError
-        end
+      if real_log_file
+        !is_std_channel_chardev?(real_log_file)
+      else
+        true
       end
-      raise DaemonizationTimeout, nil
-    end
-    if $?.exitstatus != 0
-      raise StartError, concat_spawn_output_and_logs(nil, differences_in_log_file, $?)
     end
   end
 
+  def is_std_channel_chardev?(path)
+    path == "/dev/stdout" ||
+      path == "/dev/stderr" ||
+      path == "/dev/fd/1" ||
+      path == "/dev/fd/2" ||
+      path =~ %r{\A/proc/([0-9]+|self)/fd/[12]\Z}
+  end
+
   def run_ping_command
     if @ping_command.respond_to?(:call)
       begin
@@ -904,17 +789,20 @@ class DaemonController
     ) + rb_config["EXEEXT"]
   end
 
-  # 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
-    until result
-      result = Process.waitpid(pid, Process::WNOHANG)
-      sleep 0.01 if !result
+  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
-    result
+  end
+
+  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)
@@ -925,6 +813,10 @@ class DaemonController
     end
   end
 
+  def normalize_signal_name(name)
+    name.start_with?("SIG") ? name : "SIG#{name}"
+  end
+
   def signal_name_for(num)
     if (name = Signal.list.find { |name, n| n == num }[0])
       "SIG#{name}"
@@ -960,4 +852,8 @@ class DaemonController
       result
     end
   end
+
+  def debug(message)
+    @logger.debug(message) if @logger
+  end
 end