daemon_controller 2.0.0 → 3.0.0

data/spec/daemon_controller_spec.rb

@@ -6,12 +6,16 @@ require "benchmark"
 require "socket"
 require "tmpdir"
 require "shellwords"
+require "stringio"
+require "logger"
 
 describe DaemonController, "#start" do
   include TestHelper
 
-  after :each do
+  around :each do |example|
+    error = example.run
     @controller.stop if @controller
+    print_logs(example) if error
   end
 
   it "works" do
@@ -34,7 +38,7 @@ describe DaemonController, "#start" do
     write_file("spec/echo_server.pid", "1234")
     new_controller
     expect(@controller).to receive(:daemon_is_running?).and_return(false)
-    expect(@controller).to receive(:spawn_daemon)
+    expect(@controller).to receive(:spawn_daemon).and_return(DaemonController::InternalCommandOkResult.new(1, ""))
     expect(@controller).to receive(:pid_file_available?).and_return(true)
     expect(@controller).to receive(:run_ping_command).at_least(:once).and_return(true)
     @controller.start
@@ -50,7 +54,10 @@ describe DaemonController, "#start" do
     end
     new_controller
     expect(@controller).to receive(:daemon_is_running?) { false }
-    expect(@controller).to receive(:spawn_daemon) { thread.go! }
+    expect(@controller).to receive(:spawn_daemon) {
+      thread.go!
+      DaemonController::InternalCommandOkResult.new(1, "")
+    }
     expect(@controller).to receive(:run_ping_command).at_least(:once).and_return(true)
     begin
       result = Benchmark.measure do
@@ -76,6 +83,7 @@ describe DaemonController, "#start" do
     expect(@controller).to receive(:spawn_daemon) {
       thread.go!
       running = true
+      DaemonController::InternalCommandOkResult.new(1, "")
     }
     expect(@controller).to receive(:pid_file_available?).and_return(true)
     expect(@controller).to receive(:run_ping_command).at_least(:once) { ping_ok }
@@ -97,239 +105,316 @@ describe DaemonController, "#start" do
     expect(ping_echo_server).to be(true)
   end
 
-  context "if the daemon doesn't start in time" do
-    let(:start_timeout) { exec_is_slow? ? 4 : 0.5 }
-    let(:min_start_timeout) { 0.5 }
-    let(:max_start_timeout) { exec_is_slow? ? 6 : 1 }
+  context "if the daemon exits with an error" do
+    context "before forking" do
+      it "raises StartError" do
+        new_controller(start_command: "false")
+        expect { @controller.start }.to raise_error(DaemonController::StartError)
+      end
 
-    it "raises StartTimeout" do
-      new_controller(start_command: "sleep 2", start_timeout: start_timeout)
-      start_time = Time.now
-      end_time = nil
-      expect(@controller).to receive(:start_timed_out) { end_time = Time.now }
-      expect { @controller.start }.to raise_error(DaemonController::StartTimeout)
-      expect(end_time - start_time).to be_between(min_start_timeout, max_start_timeout)
-    end
+      it "makes outputs available in the exception" do
+        new_controller(start_command: "(echo hello world; false)")
+        expect { @controller.start }.to raise_error(DaemonController::StartError, /hello world/)
+      end
 
-    it "reports logs written to stderr if the timeout happened before forking" do
-      new_controller(start_command: "echo hello world; sleep 10", start_timeout: start_timeout)
-      expect(@controller).to receive(:daemonization_timed_out)
-      begin
-        @controller.start
-        fail
-      rescue DaemonController::StartTimeout => e
-        expect(e.message).to include("hello world")
+      it "doesn't make outputs available if the log file is not a regular file" do
+        new_controller(start_command: "false", log_file: "/dev/stderr")
+        expect { @controller.start }.to raise_error(DaemonController::StartError, /logs not available/)
       end
-    end
 
-    it "reports logs written to the log file if the timeout happened before forking" do
-      new_controller(log_message2: "hello world",
-        wait2: 10,
-        start_timeout: start_timeout,
-        no_daemonize: true)
-      expect(@controller).to receive(:daemonization_timed_out)
-      begin
-        @controller.start
-        fail
-      rescue DaemonController::StartTimeout => e
-        expect(e.message).to include("hello world")
+      it "makes file logs available in the exception" do
+        new_controller(start_command: "(echo hello world; false)")
+        begin
+          @controller.start
+        rescue DaemonController::StartError => e
+          expect(e.message).to eq("hello world\n(exited with status 1)")
+        end
       end
-    end
 
-    it "reports logs if the timeout happened after forking" do
-      new_controller(log_message2: "hello world",
-        wait2: 10,
-        start_timeout: start_timeout)
-      expect(@controller).not_to receive(:daemonization_timed_out)
-      begin
-        @controller.start
-        fail
-      rescue DaemonController::StartTimeout => e
-        expect(e.message).to include("hello world")
+      specify "if file logs are available but empty, then the exception says so" do
+        new_controller(start_command: "exit 1")
+        begin
+          @controller.start
+          fail
+        rescue DaemonController::StartError => e
+          expect(e.message).to eq("(logs empty; exited with status 1)")
+        end
       end
-    end
 
-    specify "if there are no logs, then the error says so" do
-      new_controller(start_command: "sleep 10", start_timeout: start_timeout)
-      expect(@controller).to receive(:daemonization_timed_out)
-      begin
-        @controller.start
-        fail
-      rescue DaemonController::StartTimeout => e
-        expect(e.message).to eq("(logs empty; timed out)")
+      it "makes the exit signal available in the exception if the log file is a regular file" do
+        new_controller(crash_before_bind: true, crash_signal: "SIGXCPU", no_daemonize: true)
+        begin
+          @controller.start
+          fail
+        rescue DaemonController::StartError => e
+          expect(e.message).to include("crashing, as instructed")
+          expect(e.message).to include("SIGXCPU")
+        end
       end
-    end
 
-    specify "if logs cannot be captured, then the error says so" do
-      new_controller(start_command: "sleep 10", start_timeout: start_timeout, log_file: "/dev/stderr")
-      expect(@controller).to receive(:daemonization_timed_out)
-      begin
-        @controller.start
-        fail
-      rescue DaemonController::StartTimeout => e
-        expect(e.message).to eq("(logs not available; timed out)")
+      it "makes the exit signal available in the exception if the log file is not a regular file" do
+        new_controller(crash_before_bind: true,
+          crash_signal: "SIGXCPU",
+          no_daemonize: true,
+          log_file: "/dev/stderr")
+        begin
+          @controller.start
+          fail
+        rescue DaemonController::StartError => e
+          expect(e.message).to include("logs not available")
+          expect(e.message).to include("SIGXCPU")
+        end
       end
     end
-  end
 
-  it "kills the daemon forcefully if the daemon has forked but doesn't " \
-    "become pingable in time, and there's a PID file" do
-    new_controller(wait2: 3, start_timeout: 1)
-    pid = nil
-    expect(@controller).to receive(:start_timed_out) {
-      @controller.send(:wait_until) do
-        @controller.send(:pid_file_available?)
+    context "after forking" do
+      it "raises StartError" do
+        new_controller(crash_before_bind: true)
+        expect { @controller.start }.to raise_error(DaemonController::StartError)
       end
-      pid = @controller.send(:read_pid_file)
-    }
-    begin
-      block = lambda { @controller.start }
-      expect(&block).to raise_error(DaemonController::StartTimeout)
-      eventually(1) do
-        !process_is_alive?(pid)
+
+      it "makes outputs available in the exception" do
+        new_controller(log_message1: "hello world", crash_before_bind: true)
+        expect { @controller.start }.to raise_error(DaemonController::StartError, /hello world/)
       end
 
-      # The daemon should not be able to clean up its PID file since
-      # it's killed with SIGKILL.
-      expect(File.exist?("spec/echo_server.pid")).to be true
-    ensure
-      begin
-        File.unlink("spec/echo_server.pid")
-      rescue
-        nil
+      it "doesn't make outputs available if the log file is not a regular file" do
+        new_controller(crash_before_bind: true, log_file: "/dev/stderr")
+        expect { @controller.start }.to raise_error(DaemonController::StartError, "(logs not available)")
       end
-    end
-  end
 
-  it "kills the daemon if it doesn't start in time and hasn't forked yet" do
-    new_controller(start_command: "./spec/unresponsive_daemon.rb",
-      start_timeout: 0.2)
-    pid = nil
-    expect(@controller).to receive(:daemonization_timed_out) {
-      @controller.send(:wait_until) do
-        @controller.send(:pid_file_available?)
+      it "makes file logs available in the exception" do
+        new_controller(crash_before_bind: true)
+        expect { @controller.start }.to raise_error(DaemonController::StartError, /crashing, as instructed/)
+      end
+
+      specify "if the daemon didn't write a PID file, then the error is detected through log file inactivity" do
+        new_controller(log_message1: "hello",
+          log_message2: "world",
+          no_write_pid_file: true,
+          log_file_activity_timeout: 0.5)
+        begin
+          @controller.start
+          fail
+        rescue DaemonController::StartTimeout => e
+          expect(e.message).to include("hello")
+          expect(e.message).to include("world")
+          expect(e.message).to include("(timed out)")
+        ensure
+          # Kill echo_server without PID file
+          kill_and_wait_echo_server
+        end
       end
-      pid = @controller.send(:read_pid_file)
-    }
-    block = lambda { @controller.start }
-    expect(&block).to raise_error(DaemonController::StartTimeout, /logs empty/)
-    eventually(1) do
-      !process_is_alive?(pid)
-    end
-  ensure
-    begin
-      File.unlink("spec/echo_server.pid")
-    rescue
-      nil
     end
   end
 
-  it "raises an error if the daemon exits with an error before forking" do
-    new_controller(start_command: "false")
-    expect { @controller.start }.to raise_error(DaemonController::StartError)
-  end
+  context "if the daemon doesn't start in time" do
+    it "raises StartTimeout" do
+      start_timeout = exec_is_slow? ? 4 : 0.5
+      min_start_timeout = 0.5
+      max_start_timeout = exec_is_slow? ? 6 : 1
 
-  it "raises an error if the daemon exits with an error after forking" do
-    new_controller(crash_before_bind: true)
-    expect { @controller.start }.to raise_error(DaemonController::StartError)
-  end
+      new_controller(start_command: "sleep 10", start_timeout: start_timeout)
+      start_time = monotonic_time
+      end_time = nil
+      expect(@controller).to receive(:daemonization_timed_out) { end_time = monotonic_time }
+      expect { @controller.start }.to raise_error(DaemonController::StartTimeout)
+      expect(end_time - start_time).to be_between(min_start_timeout, max_start_timeout)
+    end
 
-  specify "if the daemon exits after forking without writing a PID file, then this is detected through log file inactivity" do
-    new_controller(log_message1: "hello",
-      log_message2: "world",
-      no_write_pid_file: true,
-      log_file_activity_timeout: 0.5)
-    begin
-      @controller.start
-      fail
-    rescue DaemonController::StartTimeout => e
-      expect(e.message).to include("hello")
-      expect(e.message).to include("world")
-      expect(e.message).to include("(timed out)")
-    ensure
-      # Kill echo_server without PID file
-      kill_and_wait_echo_server
+    it "doesn't terminate the fork if the daemon forked right before we perform termination" do
+      new_controller(log_message2: "hello world",
+        wait1: 0.5,
+        start_timeout: 0.1)
+      expect(@controller).to receive(:daemonization_timed_out) { |p|
+        wait_until_pid_file_available
+      }
+      expect { @controller.start }.to raise_error(DaemonController::StartTimeout)
+      expect(@controller).to be_running
     end
-  end
 
-  def find_echo_server_pid
-    process_line = `ps aux`.lines.grep(/echo_server\.rb/).first
-    process_line.split[1].to_i if process_line
-  end
+    context "if the daemon hasn't forked yet" do
+      it "terminates the daemon gracefully" do
+        new_controller(start_command: "./spec/run_in_mri_ruby unresponsive_daemon.rb",
+          start_timeout: 0.1)
 
-  def kill_and_wait_echo_server
-    pid = find_echo_server_pid
-    if pid
-      Process.kill("SIGTERM", pid)
-      Timeout.timeout(5) do
-        while find_echo_server_pid
-          sleep(0.1)
-        end
+        pid = nil
+        expect(@controller).to receive(:daemonization_timed_out) { |p|
+          pid = p
+          wait_until_pid_file_available
+        }
+
+        allow(Process).to receive(:kill).and_call_original
+        expect { @controller.start }.to raise_error(DaemonController::StartTimeout, /logs empty/)
+        expect(Process).to have_received(:kill).with("SIGTERM", pid).once
+        expect(Process).not_to have_received(:kill).with("SIGKILL", pid)
+      ensure
+        @controller = nil
       end
-    end
-  end
 
-  specify "the daemon's logs before forking is made available in the exception" do
-    new_controller(start_command: "(echo hello world; false)")
-    begin
-      @controller.start
-    rescue DaemonController::StartError => e
-      expect(e.message).to eq("hello world\n(exited with status 1)")
-    end
-  end
+      it "terminates the daemon forcefully if it doesn't gracefully terminate in time" do
+        new_controller(
+          wait2: 10,
+          start_timeout: 0.1,
+          start_abort_timeout: 0.1,
+          ignore_sigterm: true,
+          no_daemonize: true
+        )
+
+        pid = nil
+        expect(@controller).to receive(:daemonization_timed_out) { |p|
+          pid = p
+          wait_until_pid_file_available
+        }
+
+        allow(Process).to receive(:kill).and_call_original
+        expect { @controller.start }.to raise_error(DaemonController::StartTimeout)
+        expect(Process).to have_received(:kill).with("SIGTERM", pid).once
+        expect(Process).to have_received(:kill).with("SIGKILL", pid).once
+      end
 
-  specify "the daemon's logs after forking is made available in the exception" do
-    new_controller(crash_before_bind: true)
-    begin
-      @controller.start
-      fail
-    rescue DaemonController::StartError => e
-      expect(e.message).to include("crashing, as instructed")
-    end
-  end
+      it "deletes the PID file" do
+        new_controller(wait2: 10,
+          start_timeout: 0.1,
+          no_daemonize: true)
+        expect(@controller).to receive(:daemonization_timed_out) {
+          wait_until_pid_file_available
+        }
+        expect { @controller.start }.to raise_error(DaemonController::StartTimeout)
+        expect(File.exist?("spec/echo_server.pid")).to be(false)
+      end
 
-  specify "the daemon's exit signal is made available in the exception if the log file is a regular file" do
-    new_controller(crash_before_bind: true, crash_signal: "SIGXCPU", no_daemonize: true)
-    begin
-      @controller.start
-      fail
-    rescue DaemonController::StartError => e
-      expect(e.message).to include("crashing, as instructed")
-      expect(e.message).to include("SIGXCPU")
-    end
-  end
+      it "reports logs written to standard I/O channels" do
+        new_controller(log_message2: "hello world",
+          wait2: 10,
+          start_timeout: 0.1,
+          no_daemonize: true)
+        expect(@controller).to receive(:daemonization_timed_out) { |p|
+          wait_until_pid_file_available
+        }
+        expect { @controller.start }.to raise_error(DaemonController::StartTimeout, /hello world/)
+      end
 
-  specify "the daemon's exit signal is made available in the exception if the log file is not a regular file" do
-    new_controller(crash_before_bind: true,
-      crash_signal: "SIGXCPU",
-      no_daemonize: true,
-      log_file: "/dev/stderr")
-    begin
-      @controller.start
-      fail
-    rescue DaemonController::StartError => e
-      expect(e.message).to include("logs not available")
-      expect(e.message).to include("SIGXCPU")
-    end
-  end
+      it "reports logs written to the log file" do
+        new_controller(log_message2: "hello world",
+          wait2: 10,
+          start_timeout: 0.1,
+          no_daemonize: true)
+        expect(@controller).to receive(:daemonization_timed_out) {
+          wait_until_pid_file_available
+        }
+        expect { @controller.start }.to raise_error(DaemonController::StartTimeout, /hello world/)
+      end
 
-  specify "the daemon's logs are not available if the log file is not a regular file" do
-    new_controller(crash_before_bind: true, log_file: "/dev/stderr")
-    begin
-      @controller.start
-      fail
-    rescue DaemonController::StartError => e
-      expect(e.message).to eq("(logs not available)")
+      specify "if there are no logs, then the error says so" do
+        new_controller(wait2: 10,
+          start_timeout: 0.1,
+          no_daemonize: true)
+        expect(@controller).to receive(:daemonization_timed_out) {
+          wait_until_pid_file_available
+        }
+        expect { @controller.start }.to raise_error(DaemonController::StartTimeout, /\(logs empty; timed out\)/)
+      end
+
+      specify "if logs cannot be captured, then the error says so" do
+        new_controller(wait2: 10,
+          start_timeout: 0.1,
+          log_file: "/dev/stderr",
+          no_daemonize: true)
+        expect(@controller).to receive(:daemonization_timed_out) {
+          wait_until_pid_file_available
+        }
+        expect { @controller.start }.to raise_error(DaemonController::StartTimeout, /\(logs not available; timed out\)/)
+      end
     end
-  end
 
-  specify "if the logs are available but empty, then the error exception says so" do
-    new_controller(start_command: "exit 1")
-    begin
-      @controller.start
-      fail
-    rescue DaemonController::StartError => e
-      expect(e.message).to eq("(logs empty; exited with status 1)")
+    context "if the daemon already forked" do
+      it "terminates the daemon gracefully" do
+        new_controller(wait2: 10)
+
+        expect(@controller).to receive(:daemon_spawned) {
+          wait_until_pid_file_available
+          raise Timeout::Error
+        }
+
+        pid = nil
+        expect(@controller).to receive(:start_timed_out) { |p| pid = p }
+
+        allow(Process).to receive(:kill).and_call_original
+        expect { @controller.start }.to raise_error(DaemonController::StartTimeout)
+        expect(Process).to have_received(:kill).with("SIGTERM", pid).once
+        expect(Process).not_to have_received(:kill).with("SIGKILL", pid)
+      end
+
+      it "terminates the daemon forcefully if it doesn't gracefully terminate in time" do
+        new_controller(wait2: 10,
+          start_abort_timeout: 0.5,
+          ignore_sigterm: true)
+
+        expect(@controller).to receive(:daemon_spawned) {
+          wait_until_pid_file_available
+          raise Timeout::Error
+        }
+
+        pid = nil
+        expect(@controller).to receive(:start_timed_out) { |p| pid = p }
+
+        allow(Process).to receive(:kill).and_call_original
+        expect { @controller.start }.to raise_error(DaemonController::StartTimeout)
+        expect(Process).to have_received(:kill).with("SIGTERM", pid).once
+        expect(Process).to have_received(:kill).with("SIGKILL", pid).once
+      end
+
+      it "deletes the PID file" do
+        new_controller(wait2: 10)
+        expect(@controller).to receive(:daemon_spawned) {
+          wait_until_pid_file_available
+          raise Timeout::Error
+        }
+        expect(@controller).to receive(:start_timed_out)
+        expect { @controller.start }.to raise_error(DaemonController::StartTimeout)
+        expect(File.exist?("spec/echo_server.pid")).to be(false)
+      end
+
+      it "reports logs written to standard I/O channels" do
+        new_controller(log_message1: "hello world", wait2: 10)
+        expect(@controller).to receive(:daemon_spawned) {
+          wait_until_pid_file_available
+          raise Timeout::Error
+        }
+        expect(@controller).to receive(:start_timed_out)
+        expect { @controller.start }.to raise_error(DaemonController::StartTimeout, /hello world/)
+      end
+
+      it "reports logs written to the log file" do
+        new_controller(log_message2: "hello world", wait2: 10)
+        expect(@controller).to receive(:daemon_spawned) {
+          wait_until_pid_file_available
+          raise Timeout::Error
+        }
+        expect(@controller).to receive(:start_timed_out)
+        expect { @controller.start }.to raise_error(DaemonController::StartTimeout, /hello world/)
+      end
+
+      specify "if there are no logs, then the error says so" do
+        new_controller(wait2: 10)
+        expect(@controller).to receive(:daemon_spawned) {
+          wait_until_pid_file_available
+          raise Timeout::Error
+        }
+        expect(@controller).to receive(:start_timed_out)
+        expect { @controller.start }.to raise_error(DaemonController::StartTimeout, /\(logs empty; timed out\)/)
+      end
+
+      specify "if logs cannot be captured, then the error says so" do
+        new_controller(log_message2: "hello world", wait2: 10, log_file: "/dev/stderr")
+        expect(@controller).to receive(:daemon_spawned) {
+          wait_until_pid_file_available
+          raise Timeout::Error
+        }
+        expect(@controller).to receive(:start_timed_out)
+        expect { @controller.start }.to raise_error(DaemonController::StartTimeout, /\(logs not available; timed out\)/)
+      end
     end
   end
 
@@ -375,7 +460,7 @@ describe DaemonController, "#start" do
     expect(ping_echo_server).to be true
   end
 
-  it "receives environment variables" do
+  it "passes environment variables" do
     new_controller(env: {"ENV_FILE" => "spec/env_file.tmp"})
     File.unlink("spec/env_file.tmp") if File.exist?("spec/env_file.tmp")
     @controller.start
@@ -390,10 +475,6 @@ describe DaemonController, "#stop" do
     new_controller
   end
 
-  after :each do
-    @controller.stop if @controller
-  end
-
   it "raises no exception if the daemon is not running" do
     @controller.stop
   end
@@ -401,50 +482,83 @@ describe DaemonController, "#stop" do
   it "waits until the daemon is no longer running" do
     new_controller(stop_time: 0.3)
     @controller.start
-    result = Benchmark.measure do
-      @controller.stop
+    begin
+      result = Benchmark.measure do
+        @controller.stop
+      end
+      expect(@controller).not_to be_running
+      expect(result.real).to be_between(0.3, 3)
+    ensure
+      new_controller.stop
     end
-    expect(@controller).not_to be_running
-    expect(result.real).to be_between(0.3, 0.6)
   end
 
-  it "raises StopTimeout if the daemon does not stop in time" do
-    new_controller(stop_time: 0.3, stop_timeout: 0.1)
-    @controller.start
-    begin
-      expect { @controller.stop }.to raise_error(DaemonController::StopTimeout)
-    ensure
+  context "if the daemon does not stop in time" do
+    before :each do
+      new_controller(stop_time: 0.3, stop_timeout: 0.1)
+      @controller.start
+    end
+
+    after :each do
       new_controller.stop
     end
+
+    it "raises StopTimeout" do
+      expect { @controller.stop }.to raise_error(DaemonController::StopTimeout)
+    end
+
+    it "forcefully terminates the daemon and raises StopTimeout" do
+      pid = @controller.pid
+      allow(Process).to receive(:kill).and_call_original
+      expect { @controller.stop }.to raise_error(DaemonController::StopTimeout)
+      expect(Process).to have_received(:kill).with("SIGKILL", pid).once
+      expect(File.exist?("spec/echo_server.pid")).to be(false)
+    end
+
+    it "deletes the PID file" do
+      expect { @controller.stop }.to raise_error(DaemonController::StopTimeout)
+      expect(File.exist?("spec/echo_server.pid")).to be(false)
+    end
   end
 
   describe "if stop command was given" do
     it "raises StopError if the stop command exits with an error" do
       new_controller(stop_command: "(echo hello world; false)")
+      @controller.start
       begin
-        begin
-          @controller.stop
-          fail
-        rescue DaemonController::StopError => e
-          expect(e.message).to eq("hello world\n(exited with status 1)")
-        end
+        expect { @controller.stop }.to raise_error(DaemonController::StopError)
       ensure
         new_controller.stop
       end
     end
 
     it "makes the stop command's error message available in the exception" do
+      new_controller(stop_command: "(echo hello world; false)")
+      begin
+        @controller.start
+        @controller.stop
+        fail
+      rescue DaemonController::StopError => e
+        expect(e.message).to include("hello world")
+        expect(e.message).to include("(exited with status 1)")
+      ensure
+        new_controller.stop
+      end
     end
 
     it "calls the stop command if the PID file is invalid and :dont_stop_if_pid_file_invalid is not set" do
       Dir.mktmpdir do |tmpdir|
-        File.open("spec/echo_server.pid", "w").close
         new_controller(stop_command: "touch #{Shellwords.escape tmpdir}/stopped")
-        @controller.stop
-        expect(File.exist?("#{tmpdir}/stopped")).to be_truthy
+        @controller.start
+        begin
+          File.open("spec/echo_server.pid", "w").close
+          @controller.stop
+          expect(File.exist?("#{tmpdir}/stopped")).to be_truthy
+        ensure
+          # Kill echo_server without PID file
+          kill_and_wait_echo_server
+        end
       end
-    ensure
-      @controller = nil
     end
 
     it "does not call the stop command if the PID file is invalid and :dont_stop_if_pid_file_invalid is set" do