god 0.1.0 → 0.2.0

data/lib/god/watch.rb

@@ -1,11 +1,13 @@
 module God
   
   class Watch < Base
+    VALID_STATES = [:init, :up, :start, :restart]
+    
     # config
-    attr_accessor :name, :start, :stop, :restart, :interval, :grace
+    attr_accessor :name, :state, :start, :stop, :restart, :interval, :grace
     
     # api
-    attr_accessor :behaviors, :conditions
+    attr_accessor :behaviors, :metrics
     
     # internal
     attr_accessor :mutex
@@ -13,18 +15,18 @@ module God
     # 
     def initialize(meddle)
       @meddle = meddle
-      
+            
       # no grace period by default
       self.grace = 0
       
-      # keep track of which action each condition belongs to
-      @action = nil
-      
+      # the list of behaviors
       self.behaviors = []
       
       # the list of conditions for each action
-      self.conditions = {:start => [],
-                         :restart => []}
+      self.metrics = {:init => [],
+                      :start => [],
+                      :restart => [],
+                      :up => []}
                          
       # mutex
       self.mutex = Mutex.new
@@ -48,67 +50,89 @@ module God
       self.behaviors << b
     end
     
+    ###########################################################################
+    #
+    # Advanced mode
+    #
+    ###########################################################################
+    
+    # Define a transition handler which consists of a set of conditions
+    def transition(start_states, end_states)
+      # convert to into canonical hash form
+      canonical_end_states = canonical_hash_form(end_states)
+      
+      # for each start state do
+      Array(start_states).each do |start_state|
+        # validate start state
+        unless VALID_STATES.include?(start_state)
+          abort "Invalid state :#{start_state}. Must be one of the symbols #{VALID_STATES.map{|x| ":#{x}"}.join(', ')}"
+        end
+        
+        # create a new metric to hold the watch, end states, and conditions
+        m = Metric.new(self, canonical_end_states)
+        
+        # let the config file define some conditions on the metric
+        yield(m)
+        
+        # record the metric
+        self.metrics[start_state] << m
+      end
+    end
+    
+    ###########################################################################
+    #
+    # Simple mode
+    #
+    ###########################################################################
+    
     def start_if
-      @action = :start
-      yield(self)
-      @action = nil
+      self.transition(:up, :start) do |on|
+        yield(on)
+      end
     end
     
     def restart_if
-      @action = :restart
-      yield(self)
-      @action = nil
+      self.transition(:up, :restart) do |on|
+        yield(on)
+      end
     end
     
-    # Instantiate a Condition of type +kind+ and pass it into the optional
-    # block. Attributes of the condition must be set in the config file
-    def condition(kind)
-      # must be in a _if block
-      unless @action
-        abort "Watch#condition can only be called from inside a start_if block"
+    ###########################################################################
+    #
+    # Lifecycle
+    #
+    ###########################################################################
+        
+    # Schedule all poll conditions and register all condition events
+    def monitor
+      # start monitoring at the first available of the init or up states
+      if !self.metrics[:init].empty?
+        self.move(:init)
+      else
+        self.move(:up)
       end
-      
-      # create the condition
-      begin
-        c = Condition.generate(kind)
-      rescue NoSuchConditionError => e
-        abort e.message
+    end
+    
+    # Move from one state to another
+    def move(to_state)
+      puts "move '#{self.state}' to '#{to_state}'"
+       
+      # cleanup from current state
+      if from_state = self.state
+        self.metrics[from_state].each { |m| m.disable }
       end
       
-      # send to block so config can set attributes
-      yield(c) if block_given?
-      
-      # call prepare on the condition
-      c.prepare
+      # perform action (if available)
+      self.action(to_state)
       
-      # abort if the Condition is invalid, the Condition will have printed
-      # out its own error messages by now
-      unless c.valid?
-        abort
-      end
-      
-      # inherit interval from meddle if no poll condition specific interval was set
-      if c.kind_of?(PollCondition) && !c.interval
-        if self.interval
-          c.interval = self.interval
-        else
-          abort "No interval set for Condition '#{c.class.name}' in Watch '#{self.name}', and no default Watch interval from which to inherit"
-        end
-      end
+      # move to new state
+      self.metrics[to_state].each { |m| m.enable }
       
-      self.conditions[@action] << c
-    end
-        
-    # Schedule all poll conditions and register all condition events
-    def monitor
-      [:start, :restart].each do |cmd|
-        self.conditions[cmd].each do |c|
-          @meddle.timer.register(self, c, cmd) if c.kind_of?(PollCondition)
-        end
-      end
+      # set state
+      self.state = to_state
     end
     
-    def action(a, c)
+    def action(a, c = nil)
       case a
       when :start
         puts self.start
@@ -132,7 +156,9 @@ module God
     
     def call_action(condition, action, command)
       # before
-      (self.behaviors + [condition]).each { |b| b.send("before_#{action}") }
+      before_items = self.behaviors
+      before_items += [condition] if condition
+      before_items.each { |b| b.send("before_#{action}") }
       
       # action
       if command.kind_of?(String)
@@ -144,7 +170,13 @@ module God
       end
       
       # after
-      (self.behaviors + [condition]).each { |b| b.send("after_#{action}") }
+      after_items = self.behaviors
+      after_items += [condition] if condition
+      after_items.each { |b| b.send("after_#{action}") }
+    end
+    
+    def canonical_hash_form(to)
+      to.instance_of?(Symbol) ? {true => to} : to
     end
   end
   

data/test/configs/real.rb

@@ -21,11 +21,8 @@ God.meddle do |god|
   
     # 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|
+      start.condition(:process_running) do |c|
+        c.running = false
         c.pid_file = pid_file
       end
     end

data/test/configs/test.rb

@@ -0,0 +1,75 @@
+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} -p 3001 -d"
+    w.stop = "mongrel_rails stop -P ./log/mongrel.pid -c #{RAILS_ROOT}"
+    
+    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
+    
+    # determine the state on startup
+    w.transition(:init, { true => :up, false => :start }) do |on|
+      on.condition(:process_running) do |c|
+        c.running = true
+        c.pid_file = pid_file
+      end
+    end
+    
+    # determine when process has finished starting
+    w.transition([:start, :restart], :up) do |on|
+      on.condition(:process_running) do |c|
+        c.running = true
+        c.pid_file = pid_file
+      end
+    end
+  
+    # start if process is not running
+    w.transition(:up, :start) do |on|
+      on.condition(:process_exits) do |c|
+        c.pid_file = pid_file
+      end
+    end
+    
+    # restart if memory or cpu is too high
+    w.transition(:up, :restart) do |on|
+      on.condition(:memory_usage) do |c|
+        c.interval = 20
+        c.pid_file = pid_file
+        c.above = (50 * 1024) # 50mb
+        c.times = [3, 5]
+      end
+      
+      on.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

@@ -1,3 +1,4 @@
+$:.unshift File.join(File.dirname(__FILE__), *%w[.. ext kqueue_handler])
 require File.join(File.dirname(__FILE__), *%w[.. lib god])
 
 require 'test/unit'

data/test/test_condition.rb

@@ -2,7 +2,7 @@ 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
+    assert_equal Conditions::ProcessRunning, Condition.generate(:process_running).class
   end
   
   def test_generate_should_raise_on_invalid_type

data/test/test_god.rb

@@ -2,14 +2,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)))
+    Meddle.expects(:new).with(:port => 1).returns(mock(:monitor => true))
+    Timer.expects(:get).returns(stub(:join => nil)).times(2)
     
     God.meddle(:port => 1) {}
   end
 
   def test_should_start_monitoring
     Meddle.any_instance.expects(:monitor)
-    Meddle.any_instance.expects(:timer).returns(stub(:join => nil))
+    Timer.expects(:get).returns(stub(:join => nil)).times(2)
     God.meddle {}
   end
 end

data/test/test_metric.rb

@@ -0,0 +1,60 @@
+require File.dirname(__FILE__) + '/helper'
+
+class TestMetric < Test::Unit::TestCase
+  def setup
+    @metric = Metric.new(stub(:interval => 10), nil)
+  end
+  
+  # watch
+  
+  def test_watch
+    w = stub()
+    m = Metric.new(w, nil)
+    assert_equal w, m.watch
+  end
+  
+  # destination
+  
+  def test_destination
+    d = stub()
+    m = Metric.new(nil, d)
+    assert_equal d, m.destination
+  end
+  
+  # condition
+  
+  def test_condition_should_be_block_optional
+    @metric.condition(:fake_poll_condition)
+    assert_equal 1, @metric.conditions.size
+  end
+  
+  def test_poll_condition_should_inherit_interval_from_watch_if_not_specified
+    @metric.condition(:fake_poll_condition)
+    assert_equal 10, @metric.conditions.first.interval
+  end
+  
+  def test_poll_condition_should_abort_if_no_interval_and_no_watch_interval
+    metric = Metric.new(stub(:name => 'foo', :interval => nil), nil)
+    
+    assert_raise AbortCalledError do
+      metric.condition(:fake_poll_condition)
+    end
+  end
+  
+  def test_condition_should_allow_generation_of_subclasses_of_poll_or_event
+    metric = Metric.new(stub(:name => 'foo', :interval => 10), nil)
+    
+    assert_nothing_raised do
+      metric.condition(:fake_poll_condition)
+      metric.condition(:fake_event_condition)
+    end
+  end
+  
+  def test_condition_should_abort_if_not_subclass_of_poll_or_event
+    metric = Metric.new(stub(:name => 'foo', :interval => 10), nil)
+    
+    assert_raise AbortCalledError do
+      metric.condition(:fake_condition) { |c| }
+    end
+  end
+end

data/test/test_timer.rb

@@ -2,42 +2,52 @@ require File.dirname(__FILE__) + '/helper'
 
 class TestTimer < Test::Unit::TestCase
   def setup
-    @t = Timer.new
+    Timer.reset
+    @t = Timer.get
   end
   
   def test_new_timer_should_have_no_events
     assert_equal 0, @t.events.size
   end
   
-  def test_register_should_queue_event
+  def test_schedule_should_queue_event
     Time.stubs(:now).returns(0)
     
     w = Watch.new(nil)
-    @t.register(w, stub(:interval => 20), nil)
+    @t.schedule(stub(:interval => 20))
     
     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)
+    @t.schedule(stub(:interval => 0))
     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)
+    @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.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)
+    @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
 end