furnish 0.0.1

data/test/mt_cases.rb

@@ -0,0 +1,267 @@
+require 'furnish/provisioners/dummy'
+
+Dummy = Furnish::Provisioner::Dummy unless defined? Dummy
+
+class StartFailDummy < Dummy
+  def startup(*args)
+    super
+    false
+  end
+end
+
+class StopFailDummy < Dummy
+  def shutdown
+    super
+    false
+  end
+end
+
+class StartExceptionDummy < Dummy
+  def startup(*args)
+    super
+    raise "ermagherd startup"
+  end
+end
+
+class StopExceptionDummy < Dummy
+  def shutdown(*args)
+    super
+    raise "ermagherd shutdown"
+  end
+end
+
+module Furnish
+  class TestCase < MiniTest::Unit::TestCase
+    def setup
+      @tempfiles ||= []
+      file = Tempfile.new('furnish_db')
+      @tempfiles.push(file)
+      logfile = Tempfile.new('furnish_log')
+      @tempfiles.push(logfile)
+      Furnish.logger = Furnish::Logger.new(logfile, 3)
+      Furnish.init(file.path)
+      return file
+    end
+
+    def teardown
+      Furnish.logger.close
+      Furnish.shutdown
+      @tempfiles.each do |file|
+        file.unlink
+      end
+    end
+  end
+
+  class SchedulerTestCase < TestCase
+    attr_reader :sched
+
+    def setup
+      super
+      @sched = Furnish::Scheduler.new
+      @monitor = Thread.new { loop { @sched.running?; sleep 1 } }
+      @monitor.abort_on_exception = true
+    end
+
+    def teardown
+      @monitor.kill rescue nil
+      super
+    end
+  end
+
+  class RunningSchedulerTestCase < SchedulerTestCase
+    def teardown
+      sched.stop
+      super
+    end
+
+    def assert_started(name)
+      assert_includes(sched.vm.solved, name, 'scheduler thinks it solved it')
+      assert(sched.vm.groups[name].first.store[ [name, "startup"].join("-") ], "dummy provisioner for #{name} recorded the startup run")
+      refute(sched.vm.groups[name].first.store[ [name, "shutdown"].join("-") ], "dummy provisioner for #{name} has not recorded the shutdown run")
+    end
+
+    def assert_shutdown(name, provisioner)
+      refute_includes(sched.vm.solved, name, 'scheduler thinks it solved it')
+      assert(provisioner.store[ [name, "shutdown"].join("-") ], "dummy provisioner for #{name} recorded the shutdown run")
+    end
+
+    def test_provision_cycle
+      machine_names = %w[blarg blarg2 blarg3]
+
+      machine_names.each do |name|
+        assert(sched.schedule_provision(name, Dummy.new))
+      end
+
+      sched.run
+      sched.wait_for(*machine_names)
+
+      machine_names.each do |name|
+        assert_started(name)
+      end
+
+      machine_provs = machine_names.map { |n| sched.vm.groups[n].first }
+
+      sched.teardown
+
+      machine_names.each_with_index do |name, i|
+        assert_shutdown(name, machine_provs[i])
+      end
+    end
+
+    def test_dependent_provision
+      # since we can't reliably predict linear order, we just paritition it by
+      # how the dependency resolver should sort things out. This isn't perfect by
+      # any means, but allows us to check the dependency resolver.
+      machine_order = {
+        "blarg1" => %w[blarg2 blarg3],
+        "blarg2" => %w[blarg4],
+        "blarg3" => %w[blarg4],
+        "blarg4" => [],
+        "blarg5" => []
+      }
+
+      assert(sched.schedule_provision('blarg1', Dummy.new))
+      assert(sched.schedule_provision('blarg2', Dummy.new, %w[blarg1]))
+      assert(sched.schedule_provision('blarg3', Dummy.new, %w[blarg1]))
+      assert(sched.schedule_provision('blarg4', Dummy.new, %w[blarg2 blarg3]))
+      assert(sched.schedule_provision('blarg5', Dummy.new))
+
+      sched.run
+      sched.wait_for(*machine_order.keys)
+
+      1.upto(5) { |x| assert_started("blarg#{x}") }
+
+      order = Dummy.new.order
+      possible_next = Set[*%w[blarg1 blarg5]]
+
+      while machine = order.shift
+        assert_includes(possible_next, machine, "machine was matched in possible nexts")
+        machine_order[machine].each do |nexts|
+          possible_next.add(nexts)
+        end
+
+        possible_next.delete(machine)
+      end
+
+      machine_provs = (1..5).map { |n| sched.vm.groups["blarg#{n}"].first }
+
+      sched.teardown
+
+      1.upto(5) { |x| assert_shutdown("blarg#{x}", machine_provs[x-1]) }
+    end
+
+    def test_multiprovision_order
+      dummies = [Dummy.new, Dummy.new]
+      dummies.each_with_index { |x,i| x.id = i }
+      assert(sched.schedule_provision('blarg', dummies))
+      sched.run
+      sched.wait_for('blarg')
+      assert_equal(dummies.map(&:id), dummies.first.call_order.to_a)
+      dummies.first.call_order.clear
+      assert_empty(dummies.first.call_order.to_a)
+      sched.teardown
+      assert_equal(dummies.reverse.map(&:id), dummies.first.call_order.to_a)
+    end
+
+    def test_single_deprovision
+      assert(sched.schedule_provision('blarg', Dummy.new))
+      assert(sched.schedule_provision('blarg2', Dummy.new))
+      assert(sched.schedule_provision('blarg3', Dummy.new, %w[blarg2]))
+
+      sched.run
+      sched.wait_for('blarg', 'blarg2', 'blarg3')
+
+      %w[blarg blarg2 blarg3].each do |name|
+        assert_includes(sched.vm.solved, name, "#{name} is in the solved list")
+      end
+
+      sched.teardown_group("blarg")
+
+      [sched.vm.solved, sched.vm.groups.keys].each do |coll|
+        assert_includes(coll, "blarg2", "blarg2 is still available")
+        assert_includes(coll, "blarg3", "blarg3 is still available")
+        refute_includes(coll, "blarg", "blarg is not still available")
+      end
+
+      #
+      # vm.dependencies doesn't track empty references, so deprovisions that have
+      # dependencies need some extra checks to ensure their behavior. Basically
+      # this just means they can't be tested generically.
+      #
+      assert_includes(sched.vm.dependencies.keys, "blarg3", "blarg3 still has dependencies")
+      sched.teardown_group("blarg3")
+      refute_includes(sched.vm.dependencies.keys, "blarg3", "blarg3 still has dependencies")
+    end
+
+    def test_run_arguments
+      tempfiles = []
+
+      signals = %w[INFO USR2]
+
+      signals.each do |signal|
+        if Signal.list[signal] # not everyone has INFO
+          Signal.trap(signal) { nil } if Signal.list[signal]
+
+          tf = Tempfile.new('furnish_signal_handlers')
+          tempfiles.push(tf)
+          Furnish.logger = Furnish::Logger.new(tf)
+
+          sched.run(false)
+          Process.kill(signal, Process.pid)
+
+          sched.stop
+          sleep 0.1 # wait for any writes to complete
+
+          %w[solved working waiting].each do |section|
+            refute_match(/#{section}/, File.read(tf.path), "#{signal} yielded no output with the #{section} set")
+          end
+
+          sched.run(true)
+          Process.kill(signal, Process.pid)
+
+          sched.stop
+          sleep 0.1 # wait for any writes to complete
+
+          %w[solved working waiting].each do |section|
+            assert_match(/#{section}/, File.read(tf.path), "#{signal} yielded output with the #{section} set")
+          end
+        end
+      end
+    ensure
+      tempfiles.each { |f| f.unlink }
+    end
+
+    def test_provision_failures
+      dummy = StartFailDummy.new
+      assert(sched.schedule_provision('blarg', dummy))
+      assert_raises(RuntimeError, "Could not provision blarg with provisioner StartFailDummy") do
+        sched.run
+        sched.wait_for('blarg')
+      end
+      sched.stop
+      sched.deprovision_group('blarg')
+
+      # tests scheduler crashes not keeping the scheduler from being restarted
+      assert(sched.schedule_provision('blarg', Dummy.new))
+      sched.run
+      sched.wait_for('blarg')
+      sched.stop
+      assert_includes(sched.vm.solved, "blarg")
+      sched.teardown
+      refute_includes(sched.vm.solved, "blarg")
+
+      dummy = StopFailDummy.new
+      assert(sched.schedule_provision('blarg', StopFailDummy.new))
+      sched.run
+      sched.wait_for('blarg')
+      sched.stop
+      assert_includes(sched.vm.solved, "blarg")
+      assert_raises(RuntimeError) { sched.teardown }
+      assert_includes(sched.vm.solved, "blarg")
+      sched.force_deprovision = true
+      sched.teardown
+      refute_includes(sched.vm.solved, "blarg")
+    end
+  end
+end
+

data/test/test_dummy.rb

@@ -0,0 +1,95 @@
+#
+# Just some small tests for the dummy provisioner to ensure it's sane. Since
+# it's used heavily in the scheduler tests, it's important to ensure it itself
+# works.
+#
+# That said, the dummy provisioner should not be used for anything "real" and
+# this test is largely an exercise in ensuring the rest of the test suite is
+# not lying to it. Nothing here gets tested that should be used outside of the
+# test suite.
+#
+
+require 'helper'
+
+class TestDummy < Furnish::TestCase
+  def test_defaults
+    dummy = Dummy.new
+    dummy.name = 'dummy_test'
+    assert(dummy.startup, 'startup returns true by default')
+    assert(dummy.shutdown, 'shutdown returns true by default')
+    assert_equal(['dummy_test'], dummy.report, 'report returns boxed name by default')
+
+    obj = Palsy::Object.new('dummy')
+    %w[startup shutdown report].each do |meth|
+      assert(obj["dummy_test-#{meth}"], "#{meth} persists a breadcrumb when run")
+    end
+  end
+
+  def test_order_check
+    machine_names = %w[one two three]
+    machine_names.each do |name|
+      dummy = Dummy.new
+      dummy.name = name
+      assert(dummy.startup)
+    end
+
+    dummy = Dummy.new
+    assert_kind_of(Furnish::Provisioner::Dummy, dummy)
+    assert_equal(machine_names, dummy.order.to_a, 'order was respected')
+
+    assert(dummy.order.clear)
+    assert_empty(dummy.order.to_a)
+
+    machine_names.each do |name|
+      dummy = Dummy.new
+      dummy.name = name
+      assert(dummy.shutdown)
+    end
+
+    dummy = Dummy.new
+    assert_kind_of(Furnish::Provisioner::Dummy, dummy)
+    assert_equal(machine_names, dummy.order.to_a, 'order was respected')
+  end
+
+  def test_call_order
+    dummies = Dummy.new, Dummy.new
+    dummies.each_with_index do |x, i|
+      x.name = "foo"
+      x.id = "foo#{i}"
+      assert(x.startup)
+    end
+
+    assert_equal(dummies.map(&:id), dummies.first.call_order.to_a)
+
+    dummies.first.call_order.clear
+
+    dummies.reverse.each do |x|
+      assert(x.startup)
+    end
+
+    assert_equal(dummies.reverse.map(&:id), dummies.first.call_order.to_a)
+  end
+
+  def test_marshal
+    dummy = Dummy.new
+    dummy.name = "dummy_marshal_test"
+    assert(dummy.startup)
+    assert(dummy.shutdown)
+    assert_equal([dummy.name], dummy.report)
+
+    obj = Palsy::Object.new('dummy')
+    %w[startup shutdown report].each do |meth|
+      assert(obj["dummy_marshal_test-#{meth}"], "#{meth} persists a breadcrumb when run")
+    end
+
+    str = Marshal.dump(dummy)
+    refute_empty(str, "dummy was dumped successfully")
+
+    newobj = Marshal.load(str)
+    assert_kind_of(Furnish::Provisioner::Dummy, newobj)
+    refute_equal(dummy.object_id, newobj.object_id)
+
+    assert_equal(obj, dummy.store, "palsy object persists")
+    assert_equal(obj, newobj.store, "palsy object persists")
+  end
+end

data/test/test_logger.rb

@@ -0,0 +1,68 @@
+require 'helper'
+require 'tempfile'
+
+class TestLogger < Furnish::TestCase
+  def setup
+    super
+    @logger_file = Tempfile.new('furnish_log')
+    @logger = Furnish::Logger.new(@logger_file)
+  end
+
+  def read_logfile
+    File.read(@logger_file.path)
+  end
+
+  def test_defaults
+    logger = Furnish::Logger.new
+    assert_equal($stderr, logger.io, "logger io obj is stderr by default")
+    assert_equal(0, logger.debug_level, "logger debug level is 0 by default")
+  end
+
+  def test_logger_behaves_like_io
+    @logger.puts "ohai"
+    assert_equal("ohai\n", read_logfile)
+  end
+
+  def test_if_debug
+    assert_equal(0, @logger.debug_level, "debug level is 0")
+    @logger.if_debug do
+      puts "foo"
+    end
+
+    assert_empty(read_logfile, "debug level is zero and if_debug defaults at 1")
+
+    @logger.debug_level = 1
+    @logger.if_debug do
+      puts "foo"
+    end
+
+    assert_equal("foo\n", read_logfile, "debug level is 1")
+
+    @logger.if_debug(2) do
+      puts "bar"
+    end
+
+    assert_equal("foo\n", read_logfile, "debug level is 1 and if_debug is 2")
+
+    else_block = proc { puts "quux" }
+
+    @logger.if_debug(2, else_block) do
+      puts "should_not_get_here"
+    end
+
+    assert_equal("foo\nquux\n", read_logfile, "debug level is 1 and else block triggered")
+
+    @logger.debug_level = 2
+    @logger.if_debug(1) do
+      puts "level2"
+    end
+
+    assert_equal("foo\nquux\nlevel2\n", read_logfile, "debug level is 2 and if_debug checking for 1")
+  end
+
+  def teardown
+    @logger.close
+    @logger_file.unlink
+    super
+  end
+end

data/test/test_provisioner_group.rb

@@ -0,0 +1,51 @@
+require 'helper'
+
+class TestProvisionerGroup < Furnish::TestCase
+  def test_constructor
+    dummy = Dummy.new
+    pg = Furnish::ProvisionerGroup.new(dummy, 'blarg')
+    assert_includes(pg, dummy)
+    assert_equal('blarg', pg.name)
+    assert_kind_of(Set, pg.dependencies)
+    assert_empty(pg.dependencies)
+    assert_equal('blarg', dummy.name)
+
+    dummy = Dummy.new
+    pg = Furnish::ProvisionerGroup.new([dummy], 'blarg2', %w[blarg])
+    assert_includes(pg, dummy)
+    assert_equal('blarg2', pg.name)
+    assert_equal(Set['blarg'], pg.dependencies)
+    assert_equal('blarg2', dummy.name)
+  end
+
+  def test_up_down
+    store = Palsy::Object.new('dummy')
+    dummy = Dummy.new
+    pg = Furnish::ProvisionerGroup.new(dummy, 'blarg')
+
+    assert(pg.startup, 'started')
+    assert(store[ [pg.name, 'startup'].join("-") ], 'startup ran')
+    assert(pg.shutdown, 'stopped')
+    assert(store[ [pg.name, 'startup'].join("-") ], 'shutdown ran')
+
+    dummy = StartFailDummy.new
+    pg = Furnish::ProvisionerGroup.new(dummy, 'blarg2')
+    assert_raises(RuntimeError, "Could not provision #{pg.name} with provisioner #{dummy.class.name}") { pg.startup }
+
+    dummy = StopFailDummy.new
+    pg = Furnish::ProvisionerGroup.new(dummy, 'blarg3')
+    assert_raises(RuntimeError, "Could not deprovision #{pg.name}/#{dummy.class.name}") { pg.shutdown }
+    pg.shutdown(true)
+
+    dummy = StartExceptionDummy.new
+    pg = Furnish::ProvisionerGroup.new(dummy, 'blarg4')
+    assert_raises(RuntimeError, "Could not provision #{pg.name} with provisioner #{dummy.class.name}") { pg.startup }
+
+    dummy = StopExceptionDummy.new
+    pg = Furnish::ProvisionerGroup.new(dummy, 'blarg4')
+    assert_raises(RuntimeError, "Could not deprovision #{pg.name}/#{dummy.class.name}") { pg.shutdown }
+    pg.shutdown(true)
+    sleep 0.1 # wait for flush
+    assert_match(%r!Deprovision #{dummy.class.name}/#{pg.name} had errors:!, File.binread(Furnish.logger.path))
+  end
+end

data/test/test_scheduler_basic.rb

@@ -0,0 +1,33 @@
+require 'helper'
+
+class TestSchedulerBasic < Furnish::SchedulerTestCase
+  def test_schedule_provision
+    sched = Furnish::Scheduler.new
+
+    assert(sched.schedule_provision('blarg', [Dummy.new]), 'we can schedule')
+    assert_includes(sched.vm.waiters.keys, 'blarg', 'exists in the waiters')
+    assert_includes(sched.vm.groups.keys, 'blarg', 'exists in the vm group set')
+    assert_equal(1, sched.vm.groups['blarg'].count, 'one item array')
+    assert_kind_of(Furnish::Provisioner::Dummy, sched.vm.groups['blarg'].first, 'first object is our dummy object')
+    assert_equal('blarg', sched.vm.groups['blarg'].first.name, 'name is set properly')
+    assert_nil(sched.schedule_provision('blarg', [Dummy.new]), 'does not schedule twice')
+
+    assert(sched.schedule_provision('blarg2', Dummy.new), 'scheduling does not need an array')
+    assert_includes(sched.vm.waiters.keys, 'blarg2', 'exists in the waiters')
+    assert_includes(sched.vm.groups.keys, 'blarg2', 'exists in the vm group set')
+    assert_kind_of(Furnish::ProvisionerGroup, sched.vm.groups['blarg2'], 'boxes our single item')
+    assert_kind_of(Furnish::Provisioner::Dummy, sched.vm.groups['blarg2'].first, 'first object is our dummy object')
+    assert_equal('blarg2', sched.vm.groups['blarg2'].first.name, 'name is set properly')
+
+    assert_raises(
+      RuntimeError,
+      "One of your dependencies for blarg3 has not been pre-declared. Cannot continue"
+    ) do
+      sched.schedule_provision('blarg3', Dummy.new, %w[frobnik])
+    end
+
+    assert(sched.schedule_provision('blarg4', Dummy.new, %w[blarg2]), 'scheduled with a dependency')
+    assert_includes(sched.vm.waiters.keys, 'blarg4', 'included in waiters list')
+    assert_includes(sched.vm.dependencies['blarg4'], 'blarg2', 'dependencies are tracked for provision')
+  end
+end

data/test/test_scheduler_serial.rb

@@ -0,0 +1,16 @@
+require 'helper'
+
+class TestSchedulerSerial < Furnish::RunningSchedulerTestCase
+  def setup
+    super
+    sched.serial = true
+  end
+
+  def test_threading_constructs
+    assert(sched.schedule_provision('blarg', Dummy.new))
+    sched.run
+    refute(sched.running?)
+    assert_nil(sched.wait_for('blarg'))
+    sched.stop # does not explode
+  end
+end

data/test/test_scheduler_threaded.rb

@@ -0,0 +1,44 @@
+require 'helper'
+
+class SleepyDummy < Dummy
+  def startup(*args)
+    sleep 1
+    super
+  end
+end
+
+class SleepyFailingDummy < SleepyDummy
+  def startup(*args)
+    super
+    return false
+  end
+end
+
+class TestSchedulerThreaded < Furnish::RunningSchedulerTestCase
+  def setup
+    super
+    sched.serial = false
+  end
+
+  def test_running
+    assert(sched.schedule_provision('blarg', SleepyDummy.new))
+    sched.run
+    assert(sched.running?, 'running after provision')
+    sched.teardown
+    refute(sched.running?, 'not running after teardown')
+
+    # we have a monitor that's waiting for timeouts in the test suite to abort
+    # it if the scheduler crashes.
+    #
+    # this actually tests that functionality, so kill the monitor prematurely.
+    #
+    @monitor.kill rescue nil
+    assert(sched.schedule_provision('blarg', SleepyFailingDummy.new))
+    sched.run
+    assert(sched.running?, 'running after provision')
+    sleep 3
+    assert_raises(RuntimeError, "Could not provision blarg with provisioner SleepyFailingDummy") { sched.running? }
+    sched.teardown
+    refute(sched.running?, 'not running after teardown')
+  end
+end

data/test/test_vm.rb

@@ -0,0 +1,18 @@
+require 'helper'
+
+class TestVM < Furnish::TestCase
+  def test_initialize
+    vm = Furnish::VM.new
+    kinds = {
+      :groups       => Palsy::Map,
+      :dependencies => Palsy::Map,
+      :solved       => Palsy::Set,
+      :working      => Palsy::Set,
+      :waiters      => Palsy::Set,
+    }
+
+    kinds.each do |key, klass|
+      assert_kind_of(klass, vm.send(key))
+    end
+  end
+end