god 0.1.0

data/test/configs/real.rb

@@ -0,0 +1,64 @@
+if $0 == __FILE__
+  require File.join(File.dirname(__FILE__), *%w[.. .. lib god])
+end
+
+RAILS_ROOT = "/Users/tom/dev/git/helloworld"
+
+God.meddle do |god|
+  god.watch do |w|
+    w.name = "local-3000"
+    w.interval = 5 # seconds
+    w.start = "mongrel_rails start -P ./log/mongrel.pid -c #{RAILS_ROOT} -d"
+    w.stop = "mongrel_rails stop -P ./log/mongrel.pid -c #{RAILS_ROOT}"
+    w.grace = 5
+    
+    pid_file = File.join(RAILS_ROOT, "log/mongrel.pid")
+    
+    # clean pid files before start if necessary
+    w.behavior(:clean_pid_file) do |b|
+      b.pid_file = pid_file
+    end
+  
+    # start if process is not running
+    w.start_if do |start|
+      # start.condition(:process_exits) do |c|
+      #   c.pid_file = pid_file
+      # end
+      
+      start.condition(:process_not_running) do |c|
+        c.pid_file = pid_file
+      end
+    end
+    
+    # restart if memory or cpu is too high
+    w.restart_if do |restart|
+      restart.condition(:memory_usage) do |c|
+        c.interval = 20
+        c.pid_file = pid_file
+        c.above = (50 * 1024) # 50mb
+        c.times = [3, 5]
+      end
+      
+      restart.condition(:cpu_usage) do |c|
+        c.interval = 10
+        c.pid_file = pid_file
+        c.above = 10 # percent
+        c.times = [3, 5]
+      end
+    end
+  end
+  
+  # clear old session files
+  # god.watch do |w|
+  #   w.name = "local-session-cleanup"
+  #   w.start = lambda do
+  #     Dir["#{RAILS_ROOT}/tmp/sessions/ruby_sess.*"].select do |f|
+  #       File.mtime(f) < Time.now - (7 * 24 * 60 * 60)
+  #     end.each { |f| File.delete(f) }
+  #   end
+  #   
+  #   w.start_if do |start|
+  #     start.condition(:always)
+  #   end
+  # end
+end

data/test/helper.rb

@@ -0,0 +1,93 @@
+require File.join(File.dirname(__FILE__), *%w[.. lib god])
+
+require 'test/unit'
+
+begin
+  require 'mocha'
+rescue LoadError
+  unless gems ||= false
+    require 'rubygems'
+    gems = true
+    retry
+  else
+    abort "=> You need the Mocha gem to run these tests."
+  end
+end
+
+include God
+
+module God
+  class AbortCalledError < StandardError
+  end
+
+  class Base
+    def abort(msg)
+      raise AbortCalledError.new("abort called")
+    end
+    
+    def self.abort(msg)
+      raise AbortCalledError.new("abort called")
+    end
+  end
+
+  module Conditions
+    class FakeCondition < Condition
+      def test
+        true
+      end
+    end
+  
+    class FakePollCondition < PollCondition
+      def test
+        true
+      end
+    end
+  
+    class FakeEventCondition < EventCondition
+      def test
+        true
+      end
+    end
+  end
+  
+  module Behaviors
+    class FakeBehavior < Behavior
+    end
+  end
+end
+
+def silence_warnings
+  old_verbose, $VERBOSE = $VERBOSE, nil
+  yield
+ensure
+  $VERBOSE = old_verbose
+end
+
+# This allows you to be a good OOP citizen and honor encapsulation, but
+# still make calls to private methods (for testing) by doing
+#
+#   obj.bypass.private_thingie(arg1, arg2)
+#
+# Which is easier on the eye than
+#
+#   obj.send(:private_thingie, arg1, arg2)
+#
+class Object
+  class Bypass
+    instance_methods.each do |m|
+      undef_method m unless m =~ /^__/
+    end
+
+    def initialize(ref)
+      @ref = ref
+    end
+  
+    def method_missing(sym, *args)
+      @ref.__send__(sym, *args)
+    end
+  end
+
+  def bypass
+    Bypass.new(self)
+  end
+end

data/test/suite.rb

@@ -0,0 +1,6 @@
+require 'test/unit'
+
+tests = Dir["#{File.dirname(__FILE__)}/test_*.rb"]
+tests.each do |file|
+  require file
+end

data/test/test_behavior.rb

@@ -0,0 +1,13 @@
+require File.dirname(__FILE__) + '/helper'
+
+class TestBehavior < Test::Unit::TestCase
+  def test_generate_should_return_an_object_corresponding_to_the_given_type
+    assert_equal Behaviors::FakeBehavior, Behavior.generate(:fake_behavior).class
+  end
+  
+  def test_generate_should_raise_on_invalid_type
+    assert_raise NoSuchBehaviorError do
+      Behavior.generate(:foo)
+    end
+  end
+end

data/test/test_condition.rb

@@ -0,0 +1,26 @@
+require File.dirname(__FILE__) + '/helper'
+
+class TestCondition < Test::Unit::TestCase
+  def test_generate_should_return_an_object_corresponding_to_the_given_type
+    assert_equal Conditions::ProcessNotRunning, Condition.generate(:process_not_running).class
+  end
+  
+  def test_generate_should_raise_on_invalid_type
+    assert_raise NoSuchConditionError do
+      Condition.generate(:foo)
+    end
+  end
+  
+  def test_generate_should_return_a_good_error_message_for_invalid_types
+    emsg = "No Condition found with the class name God::Conditions::FooBar"
+    rmsg = nil
+    
+    begin
+      Condition.generate(:foo_bar)
+    rescue => e
+      rmsg = e.message
+    end
+    
+    assert_equal emsg, rmsg
+  end
+end

data/test/test_god.rb

@@ -0,0 +1,15 @@
+require File.dirname(__FILE__) + '/helper'
+
+class TestGod < Test::Unit::TestCase
+  def test_should_create_new_meddle
+    Meddle.expects(:new).with(:port => 1).returns(mock(:monitor => true, :timer => stub(:join => nil)))
+    
+    God.meddle(:port => 1) {}
+  end
+
+  def test_should_start_monitoring
+    Meddle.any_instance.expects(:monitor)
+    Meddle.any_instance.expects(:timer).returns(stub(:join => nil))
+    God.meddle {}
+  end
+end

data/test/test_meddle.rb

@@ -0,0 +1,46 @@
+require File.dirname(__FILE__) + '/helper'
+
+class TestMeddle < Test::Unit::TestCase
+  def setup
+    Server.stubs(:new).returns(true)
+    @meddle = Meddle.new
+  end
+  
+  def test_should_initialize_watches_to_empty_array
+    assert_equal [], @meddle.watches
+  end
+  
+  def test_watches_should_get_stored
+    watch = nil
+    @meddle.watch { |w| watch = w }
+    
+    assert_equal 1, @meddle.watches.size
+    assert_equal watch, @meddle.watches.first
+  end
+
+  def test_should_kick_off_a_server_instance
+    Server.expects(:new).returns(true)
+    Meddle.new
+  end
+
+  def test_should_take_an_options_hash
+    Server.expects(:new)
+    Meddle.new(:port => 5555)
+  end
+  
+  def test_should_allow_multiple_watches
+    @meddle.watch { |w| w.name = 'foo' }
+    
+    assert_nothing_raised do
+      @meddle.watch { |w| w.name = 'bar' }
+    end
+  end
+  
+  def test_should_disallow_duplicate_watch_names
+    @meddle.watch { |w| w.name = 'foo' }
+    
+    assert_raise AbortCalledError do
+      @meddle.watch { |w| w.name = 'foo' }
+    end
+  end
+end

data/test/test_reporter.rb

@@ -0,0 +1,18 @@
+require File.dirname(__FILE__) + '/helper'
+
+class TestReporter < Test::Unit::TestCase
+
+  def test_should_create_a_drb_object
+    DRb.expects(:start_service)
+    DRbObject.expects(:new).with(nil, "druby://host:port").returns(stub(:anything => true))
+
+    Reporter.new('host', 'port').anything
+  end
+
+  def test_should_forward_unknown_methods_to_drb_object
+    Reporter.any_instance.expects(:service).returns(mock(:something_fake => true))
+    
+    reporter = Reporter.new('host', 'port')
+    reporter.something_fake
+  end
+end

data/test/test_server.rb

@@ -0,0 +1,24 @@
+require File.dirname(__FILE__) + '/helper'
+
+class TestServer < Test::Unit::TestCase
+  def setup
+    silence_warnings do 
+      Object.const_set(:DRb, stub_everything)
+    end
+  end
+
+  def test_should_start_a_drb_server
+    DRb.expects(:start_service)
+    Server.new
+  end
+
+  def test_should_use_supplied_port_and_host
+    DRb.expects(:start_service).with { |uri, object| uri == "druby://host:port" && object.is_a?(Server) }
+    server = Server.new(nil, 'host', 'port')
+  end
+
+  def test_should_forward_foreign_method_calls_to_meddle
+    server = Server.new(mock(:something_random => true))
+    server.something_random
+  end
+end

data/test/test_system_process.rb

@@ -0,0 +1,42 @@
+require File.dirname(__FILE__) + '/helper'
+
+class TestSystemProcess < Test::Unit::TestCase
+  def setup
+    pid = Process.pid
+    @process = System::Process.new(pid)
+  end
+  
+  def test_exists_should_return_true_for_running_process
+    assert_equal true, @process.exists?
+  end
+  
+  def test_exists_should_return_false_for_non_existant_process
+    assert_equal false, System::Process.new(0).exists?
+  end
+  
+  def test_memory
+    assert_kind_of Integer, @process.memory
+    assert @process.memory > 0
+  end
+  
+  def test_percent_memory
+    assert_kind_of Float, @process.percent_memory
+  end
+  
+  def test_percent_cpu
+    assert_kind_of Float, @process.percent_cpu
+  end
+  
+  def test_cpu_time
+    assert_kind_of Integer, @process.cpu_time
+  end
+  
+  def test_time_string_to_seconds
+    assert_equal 0, @process.bypass.time_string_to_seconds('0:00:00')
+    assert_equal 0, @process.bypass.time_string_to_seconds('0:00:55')
+    assert_equal 27, @process.bypass.time_string_to_seconds('0:27:32')
+    assert_equal 75, @process.bypass.time_string_to_seconds('1:15:13')
+    assert_equal 735, @process.bypass.time_string_to_seconds('12:15:13')
+  end
+end
+

data/test/test_timeline.rb

@@ -0,0 +1,24 @@
+require File.dirname(__FILE__) + '/helper'
+
+class TestTimeline < Test::Unit::TestCase
+  def setup
+    @timeline = Conditions::Timeline.new(5)
+  end
+  
+  def test_new_should_be_empty
+    assert_equal 0, @timeline.size
+  end
+  
+  def test_should_not_grow_to_more_than_size
+    (1..10).each do |i|
+      @timeline.push(i)
+    end
+    
+    assert_equal [10, 9, 8, 7, 6], @timeline
+  end
+  
+  def test_clear_should_clear_array
+    @timeline.push(1)
+    assert_equal [], @timeline.clear
+  end
+end

data/test/test_timer.rb

@@ -0,0 +1,43 @@
+require File.dirname(__FILE__) + '/helper'
+
+class TestTimer < Test::Unit::TestCase
+  def setup
+    @t = Timer.new
+  end
+  
+  def test_new_timer_should_have_no_events
+    assert_equal 0, @t.events.size
+  end
+  
+  def test_register_should_queue_event
+    Time.stubs(:now).returns(0)
+    
+    w = Watch.new(nil)
+    @t.register(w, stub(:interval => 20), nil)
+    
+    assert_equal 1, @t.events.size
+    assert_equal w, @t.events.first.watch
+  end
+  
+  def test_timer_should_remove_expired_events
+    @t.register(nil, stub(:interval => 0), nil)
+    sleep(0.3)
+    assert_equal 0, @t.events.size
+  end
+  
+  def test_timer_should_remove_only_expired_events
+    @t.register(nil, stub(:interval => 0), nil)
+    @t.register(nil, stub(:interval => 1000), nil)
+    sleep(0.3)
+    assert_equal 1, @t.events.size
+  end
+  
+  def test_timer_should_sort_timer_events
+    @t.register(nil, stub(:interval => 1000), nil)
+    @t.register(nil, stub(:interval => 800), nil)
+    @t.register(nil, stub(:interval => 900), nil)
+    @t.register(nil, stub(:interval => 100), nil)
+    sleep(0.3)
+    assert_equal [100, 800, 900, 1000], @t.events.map { |x| x.condition.interval }
+  end
+end

data/test/test_watch.rb

@@ -0,0 +1,123 @@
+require File.dirname(__FILE__) + '/helper'
+
+class TestWatch < Test::Unit::TestCase
+  def setup
+    @watch = Watch.new(nil)
+  end
+  
+  def test_should_have_empty_start_conditions
+    assert_equal [], @watch.conditions[:start]
+  end
+  
+  def test_should_have_empty_restart_conditions
+    assert_equal [], @watch.conditions[:restart]
+  end
+  
+  def test_should_have_standard_attributes
+    assert_nothing_raised do
+      @watch.name = 'foo'
+      @watch.start = 'start'
+      @watch.stop = 'stop'
+      @watch.restart = 'restart'
+      @watch.interval = 30
+      @watch.grace = 5
+    end
+  end
+  
+  # _if methods
+  
+  def test_start_if_should_modify_action_within_scope
+    assert_equal nil, @watch.instance_variable_get(:@action)
+    @watch.start_if do |w|
+      assert_equal :start, @watch.instance_variable_get(:@action)
+    end
+    assert_equal nil, @watch.instance_variable_get(:@action)
+  end
+  
+  def test_restart_if_should_modify_action_within_scope
+    assert_equal nil, @watch.instance_variable_get(:@action)
+    @watch.restart_if do |w|
+      assert_equal :restart, @watch.instance_variable_get(:@action)
+    end
+    assert_equal nil, @watch.instance_variable_get(:@action)
+  end
+  
+  # condition
+  
+  def test_start_condition_should_record_condition_in_correct_list
+    cond = nil
+    @watch.interval = 0
+    @watch.start_if do |w|
+      w.condition(:fake_poll_condition) { |c| cond = c }
+    end
+    assert_equal 1, @watch.conditions[:start].size
+    assert_equal cond, @watch.conditions[:start].first
+  end
+  
+  def test_restart_condition_should_record_condition_in_correct_list
+    cond = nil
+    @watch.interval = 0
+    @watch.restart_if do |w|
+      w.condition(:fake_poll_condition) { |c| cond = c }
+    end
+    assert_equal 1, @watch.conditions[:restart].size
+    assert_equal cond, @watch.conditions[:restart].first
+  end
+  
+  def test_condition_called_from_outside_if_block_should_raise
+    assert_raise AbortCalledError do
+      @watch.condition(:fake_poll_condition) { |c| cond = c }
+    end
+  end
+  
+  def test_condition_should_be_block_optional
+    @watch.interval = 0
+    @watch.start_if do |w|
+      w.condition(:always)
+    end
+    assert_equal 1, @watch.conditions[:start].size
+  end
+  
+  def test_poll_condition_should_inherit_interval_from_watch_if_not_specified
+    @watch.interval = 27
+    @watch.start_if do |w|
+      w.condition(:fake_poll_condition)
+    end
+    assert_equal 27, @watch.conditions[:start].first.interval
+  end
+  
+  def test_poll_condition_should_abort_if_no_interval_and_no_watch_interval
+    assert_raise AbortCalledError do
+      @watch.start_if do |w|
+        w.condition(:fake_poll_condition)
+      end
+    end
+  end
+  
+  def test_condition_should_allow_generation_of_subclasses_of_poll_or_event
+    @watch.interval = 27
+    assert_nothing_raised do
+      @watch.start_if do |w|
+        w.condition(:fake_poll_condition)
+        w.condition(:fake_event_condition)
+      end
+    end
+  end
+  
+  def test_condition_should_abort_if_not_subclass_of_poll_or_event
+    assert_raise AbortCalledError do
+      @watch.start_if do |w|
+        w.condition(:fake_condition) { |c| }
+      end
+    end
+  end
+
+  # behavior
+  
+  def test_behavior_should_record_behavior
+    beh = nil
+    @watch.behavior(:fake_behavior) { |b| beh = b }
+    assert_equal 1, @watch.behaviors.size
+    assert_equal beh, @watch.behaviors.first
+  end
+end