god 0.6.0 → 0.7.0

data/test/test_metric.rb

@@ -69,20 +69,4 @@ class TestMetric < Test::Unit::TestCase
       @metric.condition(:invalid) { }
     end
   end
-  
-  # enable
-  
-  def test_enable_should_attach_conditions
-    @metric.condition(:fake_poll_condition)
-    Hub.expects(:attach).with(@metric.conditions.first, @metric)
-    @metric.enable
-  end
-  
-  # disable
-  
-  def test_disable_should_detach_conditions
-    @metric.condition(:fake_poll_condition)
-    Hub.expects(:detach).with(@metric.conditions.first)
-    @metric.disable
-  end
 end

data/test/test_process.rb

@@ -144,6 +144,34 @@ class TestProcessDaemon < Test::Unit::TestCase
     end
   end
   
+  # pid
+  
+  def test_pid_should_return_integer_for_valid_pid_files
+    File.stubs(:read).returns("123")
+    assert_equal 123, @p.pid
+  end
+  
+  def test_pid_should_return_nil_for_missing_files
+    @p.pid_file = ''
+    assert_equal nil, @p.pid
+  end
+  
+  def test_pid_should_return_nil_for_invalid_pid_files
+    File.stubs(:read).returns("four score and seven years ago")
+    assert_equal nil, @p.pid
+  end
+  
+  def test_pid_should_retain_last_pid_value_if_pid_file_is_removed
+    File.stubs(:read).returns("123")
+    assert_equal 123, @p.pid
+    
+    File.stubs(:read).returns("")
+    assert_equal 123, @p.pid
+    
+    File.stubs(:read).returns("246")
+    assert_equal 246, @p.pid
+  end
+  
   # defaul_pid_file
   
   def test_default_pid_file
@@ -156,7 +184,7 @@ class TestProcessDaemon < Test::Unit::TestCase
   def test_call_action_with_string_should_call_system
     @p.start = "do something"
     @p.expects(:fork)
-    Process.expects(:waitpid)
+    Process.expects(:waitpid2).returns([123, 0])
     @p.call_action(:start)
   end
   

data/test/test_task.rb

@@ -67,20 +67,196 @@ class TestTask < Test::Unit::TestCase
   
   def test_action_should_send_string_commands_to_system
     @task.foo = 'foo'
+    Thread.current.stubs(:==).returns(true)
     @task.expects(:system).with('foo')
     no_stdout { @task.action(:foo, nil) }
   end
   
-  def test_action_should_cal_lambda_commands
+  def test_action_should_call_lambda_commands
     @task.foo = lambda { }
+    Thread.current.stubs(:==).returns(true)
     @task.foo.expects(:call)
     no_stdout { @task.action(:foo, nil) }
   end
   
   def test_action_should_raise_not_implemented_on_non_string_or_lambda_action
+    Thread.current.stubs(:==).returns(true)
     assert_raise NotImplementedError do
       @task.foo = 7
       @task.action(:foo, nil)
     end
   end
+  
+  def test_action_from_outside_driver_should_send_message_to_driver
+    @task.foo = 'foo'
+    @task.driver.expects(:message).with(:action, [:foo, nil])
+    @task.action(:foo, nil)
+  end
+  
+  # attach
+  
+  def test_attach_should_schedule_for_poll_condition
+    c = Conditions::FakePollCondition.new
+    @task.driver.expects(:schedule).with(c, 0)
+    @task.attach(c)
+  end
+  
+  def test_attach_should_regsiter_for_event_condition
+    c = Conditions::FakeEventCondition.new
+    c.expects(:register)
+    @task.attach(c)
+  end
+  
+  # detach
+  
+  def test_detach_should_reset_poll_condition
+    c = Conditions::FakePollCondition.new
+    c.expects(:reset)
+    c.expects(:deregister).never
+    @task.detach(c)
+  end
+  
+  def test_detach_should_deregister_event_conditions
+    c = Conditions::FakeEventCondition.new
+    c.expects(:deregister).once
+    @task.detach(c)
+  end
+  
+  # trigger
+  
+  def test_trigger_should_send_message_to_driver
+    c = Conditions::FakePollCondition.new
+    @task.driver.expects(:message).with(:handle_event, [c])
+    @task.trigger(c)
+  end
+  
+  # handle_poll
+  
+  def test_handle_poll_no_change_should_reschedule
+    c = Conditions::FakePollCondition.new
+    c.watch = @task
+    c.interval = 10
+    
+    m = Metric.new(@task, {true => :up})
+    @task.directory[c] = m
+    
+    c.expects(:test).returns(false)
+    @task.driver.expects(:schedule)
+    
+    no_stdout do
+      @task.handle_poll(c)
+    end
+  end
+  
+  def test_handle_poll_change_should_move
+    c = Conditions::FakePollCondition.new
+    c.watch = @task
+    c.interval = 10
+    
+    m = Metric.new(@task, {true => :up})
+    @task.directory[c] = m
+    
+    c.expects(:test).returns(true)
+    @task.expects(:move).with(:up)
+    
+    no_stdout do
+      @task.handle_poll(c)
+    end
+  end
+  
+  def test_handle_poll_should_use_overridden_transition
+    c = Conditions::Tries.new
+    c.watch = @task
+    c.times = 1
+    c.transition = :start
+    c.prepare
+    
+    m = Metric.new(@task, {true => :up})
+    @task.directory[c] = m
+    
+    @task.expects(:move).with(:start)
+    
+    no_stdout do
+      @task.handle_poll(c)
+    end
+  end
+  
+  def test_handle_poll_should_notify_if_triggering
+    c = Conditions::FakePollCondition.new
+    c.watch = @task
+    c.interval = 10
+    c.notify = 'tom'
+    
+    m = Metric.new(@task, {true => :up})
+    @task.directory[c] = m
+    
+    c.expects(:test).returns(true)
+    @task.expects(:notify)
+    
+    no_stdout do
+      @task.handle_poll(c)
+    end
+  end
+  
+  def test_handle_poll_should_not_notify_if_not_triggering
+    c = Conditions::FakePollCondition.new
+    c.watch = @task
+    c.interval = 10
+    c.notify = 'tom'
+    
+    m = Metric.new(@task, {true => :up})
+    @task.directory[c] = m
+    
+    c.expects(:test).returns(false)
+    @task.expects(:notify).never
+    
+    no_stdout do
+      @task.handle_poll(c)
+    end
+  end
+  
+  # handle_event
+  
+  def test_handle_event_should_move
+    c = Conditions::FakeEventCondition.new
+    c.watch = @task
+    
+    m = Metric.new(@task, {true => :up})
+    @task.directory[c] = m
+    
+    @task.expects(:move).with(:up)
+    
+    no_stdout do
+      @task.handle_event(c)
+    end
+  end
+  
+  def test_handle_event_should_notify_if_triggering
+    c = Conditions::FakeEventCondition.new
+    c.watch = @task
+    c.notify = 'tom'
+    
+    m = Metric.new(@task, {true => :up})
+    @task.directory[c] = m
+    
+    @task.expects(:notify)
+    
+    no_stdout do
+      @task.handle_event(c)
+    end
+  end
+  
+  def test_handle_event_should_not_notify_if_no_notify_set
+    c = Conditions::FakeEventCondition.new
+    c.watch = @task
+    
+    m = Metric.new(@task, {true => :up})
+    @task.directory[c] = m
+    
+    @task.expects(:notify).never
+    
+    no_stdout do
+      @task.handle_event(c)
+    end
+  end
 end

data/test/test_timeline.rb

@@ -18,7 +18,8 @@ class TestTimeline < Test::Unit::TestCase
   end
   
   def test_clear_should_clear_array
-    @timeline.push(1)
+    @timeline << 1
+    assert_equal [1], @timeline
     assert_equal [], @timeline.clear
   end
   

data/test/test_watch.rb

@@ -37,12 +37,6 @@ class TestWatch < Test::Unit::TestCase
     assert_equal :unmonitored, @watch.state
   end
   
-  # mutex
-  
-  def test_mutex_should_return_the_same_mutex_each_time
-    assert_equal @watch.mutex, @watch.mutex
-  end
-  
   # valid?
   
   def test_valid?
@@ -132,6 +126,9 @@ class TestWatch < Test::Unit::TestCase
   # move
   
   def test_move_should_not_clean_up_if_from_state_is_nil
+    Thread.current.stubs(:==).returns(true)
+    @watch.driver.expects(:message).never
+    
     metric = nil
     
     @watch.instance_eval do
@@ -150,6 +147,9 @@ class TestWatch < Test::Unit::TestCase
   end
   
   def test_move_should_clean_up_from_state_if_not_nil
+    Thread.current.stubs(:==).returns(true)
+    @watch.driver.expects(:message).never
+    
     metric = nil
     
     @watch.instance_eval do
@@ -170,12 +170,18 @@ class TestWatch < Test::Unit::TestCase
   end
   
   def test_move_should_call_action
+    Thread.current.stubs(:==).returns(true)
+    @watch.driver.expects(:message).never
+    
     @watch.expects(:action).with(:start)
     
     no_stdout { @watch.move(:start) }
   end
   
   def test_move_should_move_to_up_state_if_no_start_or_restart_metric
+    Thread.current.stubs(:==).returns(true)
+    @watch.driver.expects(:message).never
+    
     [:start, :restart].each do |state|
       @watch.expects(:action)
       no_stdout { @watch.move(state) }
@@ -184,6 +190,9 @@ class TestWatch < Test::Unit::TestCase
   end
   
   def test_move_should_enable_destination_metric
+    Thread.current.stubs(:==).returns(true)
+    @watch.driver.expects(:message).never
+    
     metric = nil
     
     @watch.instance_eval do
@@ -204,6 +213,9 @@ class TestWatch < Test::Unit::TestCase
   # action
   
   def test_action_should_pass_start_and_stop_actions_to_call_action
+    Thread.current.stubs(:==).returns(true)
+    @watch.driver.expects(:message).never
+    
     c = Conditions::FakePollCondition.new
     [:start, :stop].each do |cmd|
       @watch.expects(:call_action).with(c, cmd)
@@ -212,6 +224,9 @@ class TestWatch < Test::Unit::TestCase
   end
   
   def test_action_should_do_stop_then_start_if_no_restart_command
+    Thread.current.stubs(:==).returns(true)
+    @watch.driver.expects(:message).never
+    
     c = Conditions::FakePollCondition.new
     @watch.expects(:call_action).with(c, :stop)
     @watch.expects(:call_action).with(c, :start)
@@ -219,6 +234,9 @@ class TestWatch < Test::Unit::TestCase
   end
   
   def test_action_should_restart_to_call_action_if_present
+    Thread.current.stubs(:==).returns(true)
+    @watch.driver.expects(:message).never
+    
     @watch.restart = lambda { }
     c = Conditions::FakePollCondition.new
     @watch.expects(:call_action).with(c, :restart)

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.2
 specification_version: 1
 name: god
 version: !ruby/object:Gem::Version 
-  version: 0.6.0
-date: 2007-12-04 00:00:00 -08:00
+  version: 0.7.0
+date: 2008-02-01 00:00:00 -08:00
 summary: Like monit, only awesome
 require_paths: 
 - lib
@@ -66,12 +66,13 @@ files:
 - lib/god/contact.rb
 - lib/god/contacts/email.rb
 - lib/god/dependency_graph.rb
+- lib/god/diagnostics.rb
+- lib/god/driver.rb
 - lib/god/errors.rb
 - lib/god/event_handler.rb
 - lib/god/event_handlers/dummy_handler.rb
 - lib/god/event_handlers/kqueue_handler.rb
 - lib/god/event_handlers/netlink_handler.rb
-- lib/god/hub.rb
 - lib/god/logger.rb
 - lib/god/metric.rb
 - lib/god/process.rb
@@ -81,7 +82,6 @@ files:
 - lib/god/system/process.rb
 - lib/god/task.rb
 - lib/god/timeline.rb
-- lib/god/timer.rb
 - lib/god/trigger.rb
 - lib/god/watch.rb
 - test/configs/child_events/child_events.god
@@ -116,10 +116,10 @@ files:
 - test/test_conditions_tries.rb
 - test/test_contact.rb
 - test/test_dependency_graph.rb
+- test/test_driver.rb
 - test/test_event_handler.rb
 - test/test_god.rb
 - test/test_handlers_kqueue_handler.rb
-- test/test_hub.rb
 - test/test_logger.rb
 - test/test_metric.rb
 - test/test_process.rb
@@ -129,7 +129,6 @@ files:
 - test/test_system_process.rb
 - test/test_task.rb
 - test/test_timeline.rb
-- test/test_timer.rb
 - test/test_trigger.rb
 - test/test_watch.rb
 test_files: 
@@ -141,10 +140,10 @@ test_files:
 - test/test_conditions_tries.rb
 - test/test_contact.rb
 - test/test_dependency_graph.rb
+- test/test_driver.rb
 - test/test_event_handler.rb
 - test/test_god.rb
 - test/test_handlers_kqueue_handler.rb
-- test/test_hub.rb
 - test/test_logger.rb
 - test/test_metric.rb
 - test/test_process.rb
@@ -154,7 +153,6 @@ test_files:
 - test/test_system_process.rb
 - test/test_task.rb
 - test/test_timeline.rb
-- test/test_timer.rb
 - test/test_trigger.rb
 - test/test_watch.rb
 rdoc_options: 

data/lib/god/hub.rb

@@ -1,222 +0,0 @@
-module God
-  
-  class Hub
-    class << self
-      # directory to hold conditions and their corresponding metric
-      # {condition => metric}
-      attr_accessor :directory
-    end
-    
-    self.directory = {}
-    
-    def self.attach(condition, metric)
-      self.directory[condition] = metric
-      condition.reset
-      
-      case condition
-        when PollCondition
-          Timer.get.schedule(condition, 0)
-        when EventCondition, TriggerCondition
-          condition.register
-      end
-    end
-    
-    def self.detach(condition)
-      self.directory.delete(condition)
-      
-      case condition
-        when PollCondition
-          Timer.get.unschedule(condition)
-        when EventCondition, TriggerCondition
-          condition.deregister
-      end
-    end
-    
-    def self.trigger(condition)
-      case condition
-        when PollCondition
-          self.handle_poll(condition)
-        when EventCondition, TriggerCondition
-          self.handle_event(condition)
-      end
-    end
-    
-    def self.handle_poll(condition)
-      Thread.new do
-        begin
-          metric = self.directory[condition]
-          
-          # it's possible that the timer will trigger an event before it can be cleared
-          # by an exiting metric, in which case it should be ignored
-          unless metric.nil?
-            watch = metric.watch
-            
-            watch.mutex.synchronize do
-              # run the test
-              result = condition.test
-              
-              # log
-              messages = self.log(watch, metric, condition, result)
-              
-              # notify
-              if condition.notify && self.trigger?(metric, result)
-                self.notify(condition, messages.last)
-              end
-              
-              # after-condition
-              condition.after
-              
-              # get the destination
-              dest = 
-              if result && condition.transition
-                # condition override
-                condition.transition
-              else
-                # regular
-                metric.destination && metric.destination[result]
-              end
-              
-              # transition or reschedule
-              if dest
-                # transition
-                begin
-                  watch.move(dest)
-                rescue EventRegistrationFailedError
-                  msg = watch.name + ' Event registration failed, moving back to previous state'
-                  applog(watch, :info, msg)
-                  
-                  dest = watch.state
-                  retry
-                end
-              else
-                # reschedule
-                Timer.get.schedule(condition)
-              end
-            end
-          end
-        rescue Exception => e
-          message = format("Unhandled exception (%s): %s\n%s",
-                           e.class, e.message, e.backtrace.join("\n"))
-          applog(nil, :fatal, message)
-        end
-      end
-    end
-    
-    def self.handle_event(condition)
-      Thread.new do
-        begin
-          metric = self.directory[condition]
-          
-          unless metric.nil?
-            watch = metric.watch
-            
-            watch.mutex.synchronize do
-              # log
-              messages = self.log(watch, metric, condition, true)
-              
-              # notify
-              if condition.notify && self.trigger?(metric, true)
-                self.notify(condition, messages.last)
-              end
-              
-              # get the destination
-              dest = 
-              if condition.transition
-                # condition override
-                condition.transition
-              else
-                # regular
-                metric.destination && metric.destination[true]
-              end
-              
-              if dest
-                watch.move(dest)
-              end
-            end
-          end
-        rescue Exception => e
-          message = format("Unhandled exception (%s): %s\n%s",
-                           e.class, e.message, e.backtrace.join("\n"))
-          applog(nil, :fatal, message)
-        end
-      end
-    end
-    
-    # helpers
-    
-    def self.trigger?(metric, result)
-      (metric.destination && metric.destination.keys.size == 2) || result == true
-    end
-    
-    def self.log(watch, metric, condition, result)
-      status = 
-      if self.trigger?(metric, result)
-        "[trigger]"
-      else
-        "[ok]"
-      end
-      
-      messages = []
-      
-      # log info if available
-      if condition.info
-        Array(condition.info).each do |condition_info|
-          messages << "#{watch.name} #{status} #{condition_info} (#{condition.base_name})"
-          applog(watch, :info, messages.last)
-        end
-      else
-        messages << "#{watch.name} #{status} (#{condition.base_name})"
-        applog(watch, :info, messages.last)
-      end
-      
-      # log
-      debug_message = watch.name + ' ' + condition.base_name + " [#{result}] " + self.dest_desc(metric, condition)
-      applog(watch, :debug, debug_message)
-      
-      messages
-    end
-    
-    def self.dest_desc(metric, condition)
-      if condition.transition
-        {true => condition.transition}.inspect
-      else
-        if metric.destination
-          metric.destination.inspect
-        else
-          'none'
-        end
-      end
-    end
-    
-    def self.notify(condition, message)
-      spec = Contact.normalize(condition.notify)
-      unmatched = []
-      
-      # resolve contacts
-      resolved_contacts =
-      spec[:contacts].inject([]) do |acc, contact_name_or_group|
-        cons = Array(God.contacts[contact_name_or_group] || God.contact_groups[contact_name_or_group])
-        unmatched << contact_name_or_group if cons.empty?
-        acc += cons
-        acc
-      end
-      
-      # warn about unmatched contacts
-      unless unmatched.empty?
-        msg = "#{condition.watch.name} no matching contacts for '#{unmatched.join(", ")}'"
-        applog(condition.watch, :warn, msg)
-      end
-      
-      # notify each contact
-      resolved_contacts.each do |c|
-        host = `hostname`.chomp rescue 'none'
-        c.notify(message, Time.now, spec[:priority], spec[:category], host)
-        
-        msg = "#{condition.watch.name} #{c.info ? c.info : "notification sent for contact: #{c.name}"} (#{c.base_name})"
-        
-        applog(condition.watch, :info, msg % [])
-      end
-    end
-  end
-  
-end