trident 0.1.0

data/test/unit/trident/cli_test.rb

@@ -0,0 +1,253 @@
+require_relative '../../test_helper'
+
+class Trident::CLITest < MiniTest::Should::TestCase
+
+  class Handler
+    def initialize(options={})
+    end
+    def start
+    end
+  end
+
+  setup do
+    @project_root = File.expand_path('../../../..', __FILE__)
+    @cli = "#{@project_root}/bin/trident"
+  end
+
+  context "#help" do
+
+    should "generate readable usage" do
+      out = `#{@cli} --help`
+      assert $? == 0
+      assert out.lines.all? {|l| l.size <= 81 }
+    end
+
+  end
+
+  context "#project_root" do
+
+    should "use bundler env for root" do
+      cli = Trident::CLI.new([])
+      assert_equal @project_root, File.dirname(ENV['BUNDLE_GEMFILE'])
+      assert_equal @project_root, cli.send(:project_root)
+    end
+
+    should "use cwd for root when no bundler" do
+      cli = Trident::CLI.new([])
+      Bundler.with_clean_env do
+        assert_nil ENV['BUNDLE_GEMFILE']
+        assert_equal '.', cli.send(:project_root)
+      end
+    end
+
+  end
+
+  context "#expand_path" do
+
+    should "expand path relative to project_root" do
+      cli = Trident::CLI.new([])
+      assert_equal "#{@project_root}/bin", cli.send(:expand_path, "bin")
+    end
+
+    should "not expand path if absolute" do
+      cli = Trident::CLI.new([])
+      assert_equal "/bin", cli.send(:expand_path, "/bin")
+    end
+
+    should "handle nil path" do
+      cli = Trident::CLI.new([])
+      assert_nil cli.send(:expand_path, nil)
+    end
+
+  end
+
+  context "#load_config" do
+
+    should "load yml from file" do
+      data = <<-ENDDATA
+        foo: bar
+        baz: [1, 2, 3]
+      ENDDATA
+      IO.expects(:read).with("/foo").returns(data)
+      cli = Trident::CLI.new([])
+      config = cli.send(:load_config, "/foo")
+      assert_equal "bar", config['foo']
+      assert_equal [1, 2, 3], config['baz']
+    end
+
+    should "expand erb" do
+      data = <<-ENDDATA
+        foo: <%= 1 +1 %>
+      ENDDATA
+      IO.expects(:read).with("/foo").returns(data)
+      cli = Trident::CLI.new([])
+      config = cli.send(:load_config, "/foo")
+      assert_equal 2, config['foo']
+    end
+
+    should "use nested environments" do
+      begin
+        class ::Rails; def self.env; "test"; end; end
+        data = <<-ENDDATA
+          foo: bar
+          test:
+            foo: baz
+        ENDDATA
+        IO.expects(:read).with("/foo").returns(data)
+        cli = Trident::CLI.new([])
+        config = cli.send(:load_config, "/foo")
+        assert_equal "baz", config['foo']
+      ensure
+        Object.send(:remove_const, :Rails)
+      end
+    end
+
+  end
+
+  context "#create_handlers" do
+
+    should "create handlers from config" do
+      cli = Trident::CLI.new([])
+      handlers_config = {
+        "handler1" => {
+            "environment" => "require 'something'",
+            "class" => "Trident::CLITest::Handler",
+            "options" => {"foo" => "bar"},
+            "signals" => {"stop_forcefully" => "TERM", "stop_gracefully" => "TERM"}
+        },
+        "handler2" => {
+            "environment" => "require 'something'",
+            "class" => "Trident::CLITest::Handler",
+            "options" => {"foo" => "bar"},
+            "signals" => {"stop_forcefully" => "TERM", "stop_gracefully" => "TERM"}
+        }
+      }
+      handlers = cli.send(:create_handlers, handlers_config)
+      assert_equal 2, handlers.size
+      assert_equal 'handler1', handlers['handler1'].name
+      assert_equal "require 'something'", handlers['handler1'].environment
+      assert_equal 'Trident::CLITest::Handler', handlers['handler1'].worker_class_name
+      assert_equal({"stop_forcefully" => "TERM", "stop_gracefully" => "TERM"}, handlers['handler2'].signal_mappings)
+      assert_equal({"foo" => "bar"}, handlers['handler1'].options)
+      assert_equal 'handler2', handlers['handler2'].name
+    end
+
+  end
+
+  context "#create_pools" do
+
+    setup do
+      @handlers = {
+          "handler1" => Trident::PoolHandler.new("handler1", nil, nil, nil),
+          "handler2" => Trident::PoolHandler.new("handler2", nil, nil, nil)
+      }
+      @pools_config = {
+          "pool1" => {
+              "size" => 5,
+              "options" => {"foo" => "bar"},
+              "handler" => "handler1"
+          },
+          "pool2" => {
+              "size" => 3,
+              "options" => {"baz" => "bum"},
+              "handler" => "handler2"
+          }
+      }
+    end
+
+    should "create handlers from config" do
+      cli = Trident::CLI.new([])
+      pools = cli.send(:create_pools, @pools_config, @handlers)
+      assert_equal 2, pools.size
+      assert_equal 'pool1', pools['pool1'].name
+      assert_equal 'pool2', pools['pool2'].name
+
+      assert_equal 5, pools['pool1'].size
+      assert_equal @handlers['handler1'], pools['pool1'].handler
+      assert_equal({"foo" => "bar"}, pools['pool1'].options)
+    end
+
+    should "filter pools if given" do
+      cli = Trident::CLI.new([])
+      pools = cli.send(:create_pools, @pools_config, @handlers, ['pool1'])
+      assert_equal 1, pools.size
+      assert_equal 'pool1', pools.values.first.name
+    end
+
+  end
+
+  context "#execute" do
+
+    setup do
+      data = <<-ENDDATA
+        application: test
+        handlers:
+          handler1:
+            environment: ""
+            class: Worker
+            options:
+            signals:
+              default: TERM
+              stop_forcefully: INT
+              stop_gracefully: TERM
+              reload: HUP
+        pools:
+          qless:
+            size: 5
+            handler: handler1
+            options:
+      ENDDATA
+      IO.stubs(:read).with("/foo").returns(data)
+    end
+
+    should "fail if no logfile and pidfile when daemonizing" do
+
+      Trident::SignalHandler.expects(:start).never
+      Trident::Pool.any_instance.expects(:fork).never
+      Trident::CLI.any_instance.expects(:daemonize).never
+
+      ex = assert_raises(Clamp::UsageError) do
+        Trident::CLI.new("").run(["--config",
+                                    "/foo",
+                                    "--daemon"])
+      end
+      assert_match "--logfile and --pidfile are required", ex.message
+
+      ex = assert_raises(Clamp::UsageError) do
+        Trident::CLI.new("").run(["--config",
+                                    "/foo",
+                                    "--daemon",
+                                    "--pidfile",
+                                    Tempfile.new('pid').path])
+      end
+      assert_match "--logfile and --pidfile are required", ex.message
+
+      ex = assert_raises(Clamp::UsageError) do
+        Trident::CLI.new("").run(["--config",
+                                    "/foo",
+                                    "--daemon",
+                                    "--logfile",
+                                    Tempfile.new('log').path])
+      end
+      assert_match "--logfile and --pidfile are required", ex.message
+    end
+
+    should "run if given logfile and pidfile when daemonizing" do
+
+      Trident::SignalHandler.expects(:start).once
+      Trident::Pool.any_instance.stubs(:fork)
+      Trident::CLI.any_instance.expects(:daemonize).once
+
+      Trident::CLI.new("").run(["--config",
+                                  "/foo",
+                                  "--daemon",
+                                  "--logfile",
+                                  Tempfile.new('log').path,
+                                  "--pidfile",
+                                  Tempfile.new('pid').path])
+
+    end
+
+  end
+
+end

data/test/unit/trident/pool_handler_test.rb

@@ -0,0 +1,70 @@
+require_relative '../../test_helper'
+
+class Trident::PoolHandlerTest < MiniTest::Should::TestCase
+
+  setup do
+    PoolHandler.constants(false).each do |c|
+      PoolHandler.send(:remove_const, c) if c =~ /^Test/
+    end
+  end
+
+  context "#load" do
+
+    should "eval the environment" do
+      env = <<-EOS
+        class TestPoolWorker; def start; end; end
+      EOS
+      assert_raises(NameError) { PoolHandler.const_get("TestPoolWorker") }
+      handler = PoolHandler.new("foo", "TestPoolWorker", env, {})
+      handler.load
+      assert PoolHandler.const_get("TestPoolWorker")
+    end
+
+  end
+
+  context "#worker_class" do
+
+    should "find the worker class" do
+      env = <<-EOS
+        class TestPoolWorker; def start; end; end
+      EOS
+      handler = PoolHandler.new("foo", "TestPoolWorker", env, {})
+      handler.load
+      assert_match "TestPoolWorker", handler.worker_class.name
+    end
+
+  end
+
+  context "#start" do
+
+    should "initialize the handler class with options and call start" do
+      env = <<-EOS
+        class TestPoolWorker; def initialize(o); @o = o; end; def start; @o.merge("x" => "y"); end; end
+      EOS
+      handler = PoolHandler.new("foo", "TestPoolWorker", env, {}, {"a" => "b", "c" => "d"})
+      handler.load
+      assert_equal({"a"=>"z", "c"=>"d", "e"=>"f", "x"=>"y"}, handler.start("e" => "f", "a" => "z"))
+    end
+
+  end
+
+  context "#signal_for" do
+
+    should "return the signal for a given action" do
+      handler = PoolHandler.new("foo", "TestPoolWorker", nil, {"stop_forcefully" => "KILL"})
+      assert_equal "KILL", handler.signal_for("stop_forcefully")
+    end
+
+    should "use the default signal if present" do
+      handler = PoolHandler.new("foo", "TestPoolWorker", nil, {"default" => "INT", "stop_forcefully" => "KILL"})
+      assert_equal "INT", handler.signal_for("stop_gracefully")
+    end
+
+    should "default the signal to TERM if no default" do
+      handler = PoolHandler.new("foo", "TestPoolWorker", nil, {"stop_forcefully" => "KILL"})
+      assert_equal "SIGTERM", handler.signal_for("stop_gracefully")
+    end
+
+  end
+
+end

data/test/unit/trident/pool_manager_test.rb

@@ -0,0 +1,131 @@
+require_relative '../../test_helper'
+
+class Trident::PoolManagerTest < 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
+
+    $counter = FileCounter.new
+
+    env = <<-EOS
+      $counter.increment
+
+      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'}
+    @handler1 = PoolHandler.new("foo", "TestPoolWorker", env, signal_mappings, {})
+    @handler2 = PoolHandler.new("bar", "TestPoolWorker", env, signal_mappings, {})
+    @pool1 = Pool.new("foo", @handler1, 2, 'sleep' => 0.1)
+    @pool2 = Pool.new("bar", @handler2, 3, 'sleep' => 0.1)
+  end
+
+  context "#start" do
+
+    should "start workers for each pool" do
+      manager = PoolManager.new("mymanager", [@pool1, @pool2], false)
+      manager.expects(:load_handlers).never
+      manager.start
+      assert_equal 2, @pool1.workers.size
+      assert_equal 3, @pool2.workers.size
+      Process.waitall
+      # once for each worker
+      assert_equal 5, $counter.read
+    end
+
+    should "preload env for all handlers if prefork" do
+      manager = PoolManager.new("mymanager", [@pool1, @pool2], true)
+      manager.start
+      assert_equal 2, @pool1.workers.size
+      assert_equal 3, @pool2.workers.size
+      Process.waitall
+      # once for each worker plus once for each handler
+      assert_equal 7, $counter.read
+    end
+
+  end
+
+  context "#stop" do
+
+    should "stop workers for each pool" do
+      manager = PoolManager.new("mymanager", [@pool1, @pool2], false)
+      manager.start
+      assert_equal 2, @pool1.workers.size
+      assert_equal 3, @pool2.workers.size
+
+      manager.send(:stop, "stop_forcefully")
+      Process.waitall
+
+      assert_empty @pool1.workers
+      assert_empty @pool2.workers
+    end
+
+    should "send stop_forcefully" do
+      manager = PoolManager.new("mymanager", [@pool1, @pool2], false)
+      manager.start
+
+      manager.expects(:stop).with("stop_forcefully")
+      manager.stop_forcefully
+    end
+
+    should "send stop_gracefully" do
+      manager = PoolManager.new("mymanager", [@pool1, @pool2], false)
+      manager.start
+
+      manager.expects(:stop).with("stop_gracefully")
+      manager.stop_gracefully
+    end
+
+  end
+
+  context "#wait" do
+
+    should "wait for processes to exit" do
+      manager = PoolManager.new("mymanager", [@pool1, @pool2], false)
+      manager.start
+      assert_equal 2, @pool1.workers.size
+      assert_equal 3, @pool2.workers.size
+
+      thread = Thread.new { manager.wait }
+      sleep 0.01
+      assert_equal 2, @pool1.workers.size
+      assert_equal 3, @pool2.workers.size
+
+      thread.join
+      assert_empty @pool1.workers
+      assert_empty @pool2.workers
+    end
+
+  end
+
+  context "#update" do
+
+    should "update status of all pools" do
+      manager = PoolManager.new("mymanager", [@pool1, @pool2], false)
+      manager.start
+      orig_pool1 = @pool1.workers.dup
+      orig_pool2 = @pool2.workers.dup
+
+      assert_equal orig_pool1, @pool1.workers
+      assert_equal orig_pool2, @pool2.workers
+      sleep 0.3
+
+      manager.update
+      refute_equal orig_pool1, @pool1.workers
+      refute_equal orig_pool2, @pool2.workers
+    end
+
+  end
+
+end