god 0.6.0 → 0.7.0

data/lib/god/timer.rb

@@ -1,87 +0,0 @@
-module God
-  
-  class TimerEvent
-    attr_accessor :condition, :at
-    
-    def initialize(condition, interval)
-      self.condition = condition
-      self.at = Time.now.to_i + interval
-    end
-  end
-  
-  class Timer
-    INTERVAL = 0.25
-    
-    attr_reader :events, :timer
-    
-    @@timer = nil
-    
-    def self.get
-      @@timer ||= Timer.new
-    end
-    
-    def self.reset
-      @@timer = nil
-    end
-    
-    # Start the scheduler loop to handle events
-    def initialize
-      @events = []
-      @mutex = Mutex.new
-      
-      @timer = Thread.new do
-        loop do
-          begin
-            # get the current time
-            t = Time.now.to_i
-          
-            # iterate over each event and trigger any that are due
-            @events.each do |event|
-              if t >= event.at
-                self.trigger(event)
-                @mutex.synchronize do
-                  @events.delete(event)
-                end
-              else
-                break
-              end
-            end
-          
-            # sleep until next check
-            sleep INTERVAL
-          rescue Exception => e
-            message = format("Unhandled exception (%s): %s\n%s",
-                             e.class, e.message, e.backtrace.join("\n"))
-            applog(nil, :fatal, message)
-            sleep INTERVAL
-          end
-        end
-      end
-    end
-    
-    # Create and register a new TimerEvent with the given parameters
-    def schedule(condition, interval = condition.interval)
-      @mutex.synchronize do
-        @events << TimerEvent.new(condition, interval)
-        @events.sort! { |x, y| x.at <=> y.at }
-      end
-    end
-    
-    # Remove any TimerEvents for the given condition
-    def unschedule(condition)
-      @mutex.synchronize do
-        @events.reject! { |x| x.condition == condition }
-      end
-    end
-    
-    def trigger(event)
-      Hub.trigger(event.condition)
-    end
-    
-    # Join the timer thread
-    def join
-      @timer.join
-    end
-  end
-  
-end

data/test/test_hub.rb

@@ -1,240 +0,0 @@
-require File.dirname(__FILE__) + '/helper'
-
-class TestHub < Test::Unit::TestCase
-  def setup
-    God::Socket.stubs(:new).returns(true)
-    God.reset
-    
-    God.watch do |w|
-      w.name = 'foo'
-      w.start = 'bar'
-      w.interval = 10
-    end
-    
-    @watch = God.watches['foo']
-  end
-  
-  # attach
-  
-  def test_attach_should_store_condition_metric_association
-    c = Conditions::FakePollCondition.new
-    m = Metric.new(@watch, :foo)
-    Hub.attach(c, m)
-    
-    assert_equal m, Hub.directory[c]
-  end
-  
-  def test_attach_should_schedule_for_poll_condition
-    c = Conditions::FakePollCondition.new
-    m = Metric.new(@watch, :foo)
-    
-    Timer.any_instance.expects(:schedule).with(c, 0)
-    
-    Hub.attach(c, m)
-  end
-  
-  def test_attach_should_regsiter_for_event_condition
-    c = Conditions::FakeEventCondition.new
-    m = Metric.new(@watch, :foo)
-    
-    c.expects(:register)
-    
-    Hub.attach(c, m)
-  end
-  
-  # detach
-  
-  def test_detach_should_remove_condition_metric_association
-    c = Conditions::FakePollCondition.new
-    m = Metric.new(@watch, :foo)
-    
-    Hub.attach(c, m)
-    Hub.detach(c)
-    
-    assert_nil Hub.directory[c]
-  end
-  
-  def test_detach_should_unschedule_poll_conditions
-    c = Conditions::FakePollCondition.new
-    m = Metric.new(@watch, :foo)
-    Hub.attach(c, m)
-    
-    Timer.any_instance.expects(:unschedule).with(c)
-    c.expects(:deregister).never
-    
-    Hub.detach(c)
-  end
-  
-  def test_detach_should_deregister_event_conditions
-    c = Conditions::FakeEventCondition.new
-    m = Metric.new(@watch, :foo)
-    Hub.attach(c, m)
-    
-    c.expects(:deregister).once
-    
-    Hub.detach(c)
-  end
-  
-  # trigger
-  
-  def test_trigger_should_handle_poll_for_poll_condition
-    c = Conditions::FakePollCondition.new
-    Hub.expects(:handle_poll).with(c)
-    
-    Hub.trigger(c)
-  end
-  
-  def test_trigger_should_handle_event_for_event_condition
-    c = Conditions::FakeEventCondition.new
-    Hub.expects(:handle_event).with(c)
-    
-    Hub.trigger(c)
-  end
-  
-  # handle_poll
-  
-  def test_handle_poll_no_change_should_reschedule
-    c = Conditions::FakePollCondition.new
-    c.interval = 10
-    
-    m = Metric.new(@watch, {true => :up})
-    Hub.attach(c, m)
-    
-    c.expects(:test).returns(false)
-    Timer.any_instance.expects(:schedule)
-    
-    no_stdout do
-      t = Hub.handle_poll(c)
-      t.join
-    end
-  end
-  
-  def test_handle_poll_change_should_move
-    c = Conditions::FakePollCondition.new
-    c.interval = 10
-    
-    m = Metric.new(@watch, {true => :up})
-    Hub.attach(c, m)
-    
-    c.expects(:test).returns(true)
-    @watch.expects(:move).with(:up)
-    
-    no_stdout do
-      t = Hub.handle_poll(c)
-      t.join
-    end
-  end
-  
-  def test_handle_poll_should_not_abort_on_exception
-    c = Conditions::FakePollCondition.new
-    c.interval = 10
-    
-    m = Metric.new(@watch, {true => :up})
-    Hub.attach(c, m)
-    
-    c.expects(:test).raises(StandardError.new)
-    
-    assert_nothing_raised do
-      no_stdout do
-        t = Hub.handle_poll(c)
-        t.join
-      end
-    end
-  end
-  
-  def test_handle_poll_should_use_overridden_transition
-    c = Conditions::Tries.new
-    c.times = 1
-    c.transition = :start
-    c.prepare
-    
-    m = Metric.new(@watch, {true => :up})
-    Hub.attach(c, m)
-    
-    @watch.expects(:move).with(:start)
-    
-    no_stdout do
-      t = Hub.handle_poll(c)
-      t.join
-    end
-  end
-  
-  def test_handle_poll_should_notify_if_triggering
-    c = Conditions::FakePollCondition.new
-    c.interval = 10
-    c.notify = 'tom'
-    
-    m = Metric.new(@watch, {true => :up})
-    Hub.attach(c, m)
-    
-    c.expects(:test).returns(true)
-    Hub.expects(:notify)
-    
-    no_stdout do
-      t = Hub.handle_poll(c)
-      t.join
-    end
-  end
-  
-  def test_handle_poll_should_not_notify_if_not_triggering
-    c = Conditions::FakePollCondition.new
-    c.interval = 10
-    c.notify = 'tom'
-    
-    m = Metric.new(@watch, {true => :up})
-    Hub.attach(c, m)
-    
-    c.expects(:test).returns(false)
-    Hub.expects(:notify).never
-    
-    no_stdout do
-      t = Hub.handle_poll(c)
-      t.join
-    end
-  end
-  
-  # handle_event
-  
-  def test_handle_event_should_move
-    c = Conditions::FakeEventCondition.new
-    
-    m = Metric.new(@watch, {true => :up})
-    Hub.attach(c, m)
-    
-    @watch.expects(:move).with(:up)
-    
-    no_stdout do
-      t = Hub.handle_event(c)
-      t.join
-    end
-  end
-  
-  def test_handle_event_should_notify_if_triggering
-    c = Conditions::FakeEventCondition.new
-    c.notify = 'tom'
-    
-    m = Metric.new(@watch, {true => :up})
-    Hub.attach(c, m)
-    
-    Hub.expects(:notify)
-    
-    no_stdout do
-      t = Hub.handle_event(c)
-      t.join
-    end
-  end
-  
-  def test_handle_event_should_not_notify_if_no_notify_set
-    c = Conditions::FakeEventCondition.new
-    
-    m = Metric.new(@watch, {true => :up})
-    Hub.attach(c, m)
-    
-    Hub.expects(:notify).never
-    
-    no_stdout do
-      t = Hub.handle_event(c)
-      t.join
-    end
-  end
-end

data/test/test_timer.rb

@@ -1,69 +0,0 @@
-require File.dirname(__FILE__) + '/helper'
-
-class TestTimer < Test::Unit::TestCase
-  def setup
-    Timer.reset
-    @t = Timer.get
-  end
-  
-  def test_new_timer_should_have_no_events
-    assert_equal 0, @t.events.size
-  end
-  
-  def test_schedule_should_queue_event
-    Time.stubs(:now).returns(0)
-    
-    w = Watch.new
-    @t.schedule(stub(:interval => 20))
-    
-    assert_equal 1, @t.events.size
-  end
-  
-  def test_timer_should_remove_expired_events
-    @t.schedule(stub(:interval => 0))
-    sleep(0.3)
-    assert_equal 0, @t.events.size
-  end
-  
-  def test_timer_should_remove_only_expired_events
-    @t.schedule(stub(:interval => 0))
-    @t.schedule(stub(:interval => 1000))
-    sleep(0.3)
-    assert_equal 1, @t.events.size
-  end
-  
-  def test_timer_should_sort_timer_events
-    @t.schedule(stub(:interval => 1000))
-    @t.schedule(stub(:interval => 800))
-    @t.schedule(stub(:interval => 900))
-    @t.schedule(stub(:interval => 100))
-    sleep(0.3)
-    assert_equal [100, 800, 900, 1000], @t.events.map { |x| x.condition.interval }
-  end
-  
-  def test_unschedule_should_remove_conditions
-    a = stub()
-    b = stub()
-    @t.schedule(a, 100)
-    @t.schedule(b, 200)
-    assert_equal 2, @t.events.size
-    @t.unschedule(a)
-    assert_equal 1, @t.events.size
-  end
-  
-  def test_time_should_recover_from_exceptions
-    @t.expects(:trigger).raises(Exception.new)
-    no_stdout do
-      @t.schedule(stub(:interval => 0))
-      sleep(0.3)
-      @t.schedule(stub(:interval => 0))
-    end
-  end
-  
-  # join
-  
-  def test_join_should_join
-    Thread.any_instance.expects(:join)
-    @t.join
-  end
-end