trident 0.1.0

data/test/unit/trident/pool_test.rb

@@ -0,0 +1,233 @@
+require_relative '../../test_helper'
+
+class Trident::PoolTest < MiniTest::Should::TestCase
+
+  setup do
+    SignalHandler.stubs(:reset_for_fork)
+
+    PoolHandler.constants(false).each do |c|
+      PoolHandler.send(:remove_const, c) if c =~ /^Test/
+    end
+    env = <<-EOS
+      class TestPoolWorker
+        def initialize(o)
+          @o = o
+        end
+        def start
+          sleep(@o['sleep']) if @o['sleep']
+        end
+      end
+    EOS
+    signal_mappings = {'stop_forcefully' => 'KILL', 'stop_gracefully' => 'TERM'}
+    @handler = PoolHandler.new("foo", "TestPoolWorker", env, signal_mappings, {})
+  end
+
+  context "#spawn_worker" do
+
+    should "fork a worker" do
+      pool = Pool.new("foo", @handler, 1, 'sleep' => 0.1)
+      assert_empty pool.workers
+      pool.send(:spawn_worker)
+      assert_equal 1, pool.workers.size
+      Process.waitpid(pool.workers.first)
+      assert $?.success?
+    end
+
+  end
+
+  context "#kill_worker" do
+
+    should "kill a worker" do
+      pool = Pool.new("foo", @handler, 1, 'sleep' => 1)
+      pool.send(:spawn_worker)
+      pid = pool.workers.first
+
+      pool.send(:kill_worker, pid, 'stop_forcefully')
+      Process.waitpid(pid)
+      assert ! $?.success?
+      assert_empty pool.workers
+    end
+
+    should "kill a worker with specific signal" do
+      pool = Pool.new("foo", @handler, 1, 'sleep' => 1)
+      pool.send(:spawn_worker)
+      pid = pool.workers.first
+
+      Process.expects(:kill).with("TERM", pid)
+      pool.send(:kill_worker, pid, 'stop_gracefully')
+    end
+
+  end
+
+  context "#spawn_workers" do
+
+    should "start multiple workers" do
+      pool = Pool.new("foo", @handler, 4, 'sleep' => 1)
+      pool.send(:spawn_workers, 4)
+      assert_equal 4, pool.workers.size
+    end
+
+  end
+
+  context "#kill_workers" do
+
+    should "kill multiple workers, most recent first" do
+      pool = Pool.new("foo", @handler, 4, 'sleep' => 1)
+      pool.send(:spawn_workers, 4)
+      orig_workers = pool.workers.dup
+      assert_equal 4, orig_workers.size
+
+      pool.send(:kill_workers, 3, 'stop_forcefully')
+      assert_equal 1, pool.workers.size
+      assert_equal orig_workers.first, pool.workers.first
+    end
+
+  end
+
+  context "#cleanup_dead_workers" do
+
+    should "stop tracking workers that have died" do
+      pool = Pool.new("foo", @handler, 4, 'sleep' => 0)
+      pool.send(:spawn_workers, 4)
+
+      sleep 0.1
+      assert_equal 4, pool.workers.size
+      pool.send(:cleanup_dead_workers)
+      assert_equal 0, pool.workers.size
+    end
+
+    should "block waiting for workers that have died when blocking" do
+      pool = Pool.new("foo", @handler, 1, 'sleep' => 0.2)
+      pool.send(:spawn_workers, 1)
+      assert_equal 1, pool.workers.size
+
+      thread = Thread.new { pool.send(:cleanup_dead_workers, true) }
+      sleep(0.1)
+      assert_equal 1, pool.workers.size
+      thread.join
+      assert_equal 0, pool.workers.size
+    end
+
+    should "not block waiting for workers that have died when not-blocking" do
+      pool = Pool.new("foo", @handler, 1, 'sleep' => 0.1)
+      pool.send(:spawn_workers, 1)
+      assert_equal 1, pool.workers.size
+
+      pool.send(:cleanup_dead_workers, false)
+      assert_equal 1, pool.workers.size
+    end
+
+    should "cleanup workers that have died even if already waited on" do
+      pool = Pool.new("foo", @handler, 4, 'sleep' => 0)
+      pool.send(:spawn_workers, 4)
+
+      # Calling process.wait on a pid that was already waited on throws a ECHLD
+      Process.waitall
+      assert_equal 4, pool.workers.size
+      pool.send(:cleanup_dead_workers, false)
+
+      assert_equal 0, pool.workers.size
+    end
+
+
+  end
+
+  context "#maintain_worker_count" do
+
+    should "spawn workers when count is low" do
+      pool = Pool.new("foo", @handler, 2, 'sleep' => 0.1)
+      assert_empty pool.workers
+
+      pool.send(:maintain_worker_count, 'stop_gracefully')
+      assert_equal 2, pool.workers.size
+    end
+
+    should "kill workers when count is high" do
+      pool = Pool.new("foo", @handler, 2, 'sleep' => 0.1)
+      pool.send(:spawn_workers, 4)
+      assert_equal 4, pool.workers.size
+
+      pool.send(:maintain_worker_count, 'stop_gracefully')
+      assert_equal 2, pool.workers.size
+    end
+
+    should "kill workers with given action when count is high" do
+      pool = Pool.new("foo", @handler, 2, 'sleep' => 0.1)
+      pool.send(:spawn_workers, 4)
+      assert_equal 4, pool.workers.size
+
+      Process.expects(:kill).with("KILL", pool.workers.to_a[-1])
+      Process.expects(:kill).with("KILL", pool.workers.to_a[-2])
+      pool.send(:maintain_worker_count, 'stop_forcefully')
+
+      pool.send(:spawn_workers, 2)
+      Process.expects(:kill).with("TERM", pool.workers.to_a[-1])
+      Process.expects(:kill).with("TERM", pool.workers.to_a[-2])
+      pool.send(:maintain_worker_count, 'stop_gracefully')
+    end
+
+    should "do nothing when count is correct" do
+      Process.expects(:kill).never
+      pool = Pool.new("foo", @handler, 2, 'sleep' => 0.1)
+      pool.send(:spawn_workers, 2)
+      orig_workers = pool.workers.dup
+      assert_equal 2, orig_workers.size
+
+      pool.send(:maintain_worker_count, 'stop_gracefully')
+      assert_equal 2, pool.workers.size
+      assert_equal orig_workers, pool.workers
+    end
+
+  end
+
+  context "#start" do
+
+    should "start up the workers" do
+      pool = Pool.new("foo", @handler, 2, 'sleep' => 0.1)
+      pool.start
+      assert_equal 2, pool.workers.size
+    end
+
+  end
+
+  context "#stop" do
+
+    should "stop the workers" do
+      pool = Pool.new("foo", @handler, 2, 'sleep' => 0.1)
+      pool.start
+      assert_equal 2, pool.workers.size
+      pool.stop
+      assert_empty pool.workers
+    end
+
+  end
+
+  context "#wait" do
+
+    should "block till all workers complete" do
+      pool = Pool.new("foo", @handler, 2, 'sleep' => 0.1)
+      pool.start
+      assert_equal 2, pool.workers.size
+      pool.wait
+      assert_empty pool.workers
+    end
+
+  end
+
+  context "#update" do
+
+    should "update monitored workers" do
+      pool = Pool.new("foo", @handler, 2, 'sleep' => 0.2)
+      pool.start
+      orig_workers = pool.workers.dup
+      assert_equal 2, orig_workers.size
+      Process.kill("KILL", orig_workers.first)
+      sleep(0.1)
+      assert_equal orig_workers, pool.workers
+      pool.update
+      refute_equal orig_workers, pool.workers
+    end
+
+  end
+
+end

data/test/unit/trident/signal_handler_test.rb

@@ -0,0 +1,262 @@
+require_relative '../../test_helper'
+
+class Trident::SignalHandlerTest < MiniTest::Should::TestCase
+
+  class Target
+    attr_accessor :received
+
+    def initialize
+      @received = []
+    end
+
+    def method_missing(method, *args, &block)
+      @received << [method, args, block]
+      method =~ /action_(.*)/ ? $1.to_sym : :noaction
+    end
+
+    def respond_to_missing?(name, include_private = false)
+      name !~ /nomethod/
+    end
+  end
+
+  def do_in_child
+    read_from_child, write_from_child = IO.pipe
+
+    pid = fork do
+      read_from_child.close
+      result = yield
+      Marshal.dump(result, write_from_child)
+      exit!(0) # skips exit handlers.
+    end
+
+    [pid, read_from_child]
+    write_from_child.close
+    result = read_from_child.read
+    Process.wait(pid)
+    raise "child failed" if result.empty?
+    Marshal.load(result)
+  end
+
+  context "#initialize" do
+
+    should "add in CHLD handler" do
+      handler = SignalHandler.new({}, Target.new)
+      assert_equal({"SIGCHLD" => ["update"]}, handler.signal_mappings)
+    end
+
+    should "allow CHLD handler replacement" do
+      handler = SignalHandler.new({"CHLD" => "foo"}, Target.new)
+      assert_equal({"SIGCHLD" => ["foo"]}, handler.signal_mappings)
+    end
+
+  end
+
+  context "#signal_mappings==" do
+
+    should "normalize signal names" do
+      handler = SignalHandler.new({}, Target.new)
+      handler.send :signal_mappings=,
+                   {"int" => "foo", "sigterm" => "bar",
+                    "USR1" => "baz", "SIGUSR2" => ["bum", "hum"]}
+
+      assert_equal({"SIGCHLD" => ["update"], "SIGINT" => ["foo"],
+                    "SIGTERM" => ["bar"], "SIGUSR1" => ["baz"],
+                    "SIGUSR2" => ["bum", "hum"]}, handler.signal_mappings)
+    end
+
+    should "fail for duplicate signals" do
+      handler = SignalHandler.new({}, Target.new)
+      signals = {"int" => "foo", "sigint" => "bar"}
+      assert_raises(ArgumentError) { handler.send :signal_mappings=, signals }
+    end
+
+  end
+
+  context "#setup_self_pipe" do
+
+    should "create new pipes" do
+      handler = SignalHandler.new({}, Target.new)
+      assert_equal 0, handler.send(:self_pipe).size
+      handler.send :setup_self_pipe
+      assert_equal 2, handler.send(:self_pipe).size
+    end
+
+    should "replace pipes with new ones" do
+      handler = SignalHandler.new({}, Target.new)
+      handler.send :setup_self_pipe
+      old = handler.send(:self_pipe).dup
+      assert_equal 2, old.size
+      handler.send :setup_self_pipe
+      new = handler.send(:self_pipe).dup
+      assert_equal 2, new.size
+      refute_equal old, new
+    end
+
+  end
+
+  context "#setup_signal_handlers" do
+
+    should "trap given signals" do
+      signals = {"int" => "foo", "term" => "bar"}
+      handler = SignalHandler.new(signals, Target.new)
+
+      handler.expects(:trap_deferred).with("SIGINT")
+      handler.expects(:trap_deferred).with("SIGTERM")
+      handler.expects(:trap_deferred).with("SIGCHLD")
+      handler.send(:setup_signal_handlers)
+    end
+
+    should "save original signals" do
+      signals = {"int" => "foo", "term" => "bar"}
+      handler = SignalHandler.new(signals, Target.new)
+
+      handler.stubs(:trap_deferred)
+      handler.send(:setup_signal_handlers)
+      assert_equal({"SIGCHLD" => nil, "SIGINT" => nil, "SIGTERM" => nil},
+                   handler.original_signal_handlers)
+    end
+
+    should "fail for unhandled methods" do
+      signals = {"term" => "nomethod"}
+      handler = SignalHandler.new(signals, Target.new)
+
+      handler.stubs(:trap_deferred)
+      assert_raises(ArgumentError) { handler.send(:setup_signal_handlers) }
+    end
+
+  end
+
+  context "#reset_signal_handlers" do
+
+    should "reset signals" do
+      signals = {"int" => "foo", "term" => "bar"}
+      handler = SignalHandler.new(signals, Target.new)
+
+      handler.stubs(:trap_deferred)
+      handler.send(:setup_signal_handlers)
+
+      handler.expects(:trap).with("SIGINT", nil)
+      handler.expects(:trap).with("SIGTERM", nil)
+      handler.expects(:trap).with("SIGCHLD", nil)
+      handler.send(:reset_signal_handlers)
+      assert_empty handler.original_signal_handlers
+    end
+
+  end
+
+  context "#handle_signal_queue" do
+
+    setup do
+      signals = {"int" => "foo", "term" => "bar"}
+      @target = Target.new
+      @handler = SignalHandler.new(signals, @target)
+    end
+
+    should "do nothing when queue empty" do
+      assert_empty @handler.signal_queue
+      assert_nil @handler.send(:handle_signal_queue)
+      assert_empty @target.received
+    end
+
+    should "do nothing if signal unknown" do
+      @handler.signal_queue << "SIGUSR1"
+      assert_nil @handler.send(:handle_signal_queue)
+      assert_empty @target.received
+    end
+
+    should "call target for known signal" do
+      @handler.signal_queue << "SIGINT"
+      assert_equal :noaction, @handler.send(:handle_signal_queue)
+      assert_equal [[:foo, [], nil]], @target.received
+    end
+
+  end
+
+  context "#snooze/wakeup" do
+
+    should "block until woken" do
+      handler = SignalHandler.new({}, Target.new)
+      handler.send(:setup_self_pipe)
+      thread = Thread.new { handler.snooze }
+      sleep 0.1
+      assert thread.alive?
+      handler.wakeup
+      sleep 0.1
+      refute thread.alive?
+      assert_equal ".", thread.value
+    end
+
+  end
+
+  context "#start/stop" do
+
+    should "block until woken" do
+      handler = SignalHandler.new({}, Target.new)
+      handler.stubs(:trap)
+      thread = Thread.new { handler.start }
+      sleep 0.1
+      assert thread.alive?
+      handler.stop
+      sleep 0.1
+      refute thread.alive?
+    end
+
+  end
+
+  context ".start" do
+
+    should "fail if already instantiated" do
+      SignalHandler.instance = SignalHandler.new({}, Target.new)
+      assert_raises(RuntimeError) { SignalHandler.start({}, Target.new) }
+    end
+
+  end
+
+  context ".stop" do
+
+    should "fail if not instantiated" do
+      SignalHandler.instance = nil
+      assert_raises(RuntimeError) { SignalHandler.stop }
+    end
+
+  end
+
+  context "api" do
+
+    should "react to signals" do
+      fc = ForkChild.new do
+        target = Target.new
+        SignalHandler.start({"int" => "foo", "term" => "bar", "usr1" => "action_break"}, target)
+        target.received
+      end
+
+      sleep 0.1
+      Process.kill("TERM", fc.pid)
+      sleep 0.1
+      Process.kill("INT", fc.pid)
+      sleep 0.1
+      Process.kill("USR1", fc.pid)
+
+      received = fc.wait
+      assert_equal [[:bar, [], nil], [:foo, [], nil], [:action_break, [], nil]], received
+    end
+
+    should "honor signal queue limit" do
+      fc = ForkChild.new do
+        $stderr.reopen("/dev/null")
+        target = Target.new
+        SignalHandler.start({"int" => "foo", "term" => "bar", "usr1" => "action_break"}, target)
+        target.received
+      end
+      sleep 0.1
+
+      50.times { Process.kill("TERM", fc.pid) }
+      sleep 0.2
+      Process.kill("USR1", fc.pid)
+      received = fc.wait
+      assert received.size > 0
+      assert received.size < 50
+    end
+
+  end
+end