god 0.4.3 → 0.5.0

data/lib/god/task.rb

@@ -0,0 +1,233 @@
+module God
+  
+  class Task
+    attr_accessor :name, :interval, :group, :valid_states, :initial_state
+    
+    attr_writer   :autostart
+    def autostart?; @autostart; end
+    
+    # api
+    attr_accessor :state, :behaviors, :metrics
+    
+    # internal
+    attr_accessor :mutex
+    
+    def initialize
+      @autostart ||= true
+      
+      # initial state is unmonitored
+      self.state = :unmonitored
+      
+      # the list of behaviors
+      self.behaviors = []
+      
+      # the list of conditions for each action
+      self.metrics = {nil => [], :unmonitored => []}
+      
+      # mutex
+      self.mutex = Monitor.new
+    end
+    
+    def prepare
+      self.valid_states.each do |state|
+        self.metrics[state] ||= []
+      end
+    end
+    
+    def valid?
+      valid = true
+      
+      # a name must be specified
+      if self.name.nil?
+        valid = false
+        LOG.log(self, :error, "No name was specified")
+      end
+      
+      # valid_states must be specified
+      if self.valid_states.nil?
+        valid = false
+        LOG.log(self, :error, "No valid_states array was specified")
+      end
+      
+      # valid_states must be specified
+      if self.initial_state.nil?
+        valid = false
+        LOG.log(self, :error, "No initial_state was specified")
+      end
+      
+      valid
+    end
+    
+    ###########################################################################
+    #
+    # Advanced mode
+    #
+    ###########################################################################
+    
+    def canonical_hash_form(to)
+      to.instance_of?(Symbol) ? {true => to} : to
+    end
+    
+    # Define a transition handler which consists of a set of conditions
+    def transition(start_states, end_states)
+      # convert end_states into canonical hash form
+      canonical_end_states = canonical_hash_form(end_states)
+      
+      Array(start_states).each do |start_state|
+        # validate start state
+        unless self.valid_states.include?(start_state)
+          abort "Invalid state :#{start_state}. Must be one of the symbols #{self.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)
+        
+        if block_given?
+          # let the config file define some conditions on the metric
+          yield(m)
+        else
+          # add an :always condition if no block
+          m.condition(:always) do |c|
+            c.what = true
+          end
+        end
+        
+        # record the metric
+        self.metrics[start_state] ||= []
+        self.metrics[start_state] << m
+      end
+    end
+    
+    def lifecycle
+      # create a new metric to hold the watch and conditions
+      m = Metric.new(self)
+      
+      # let the config file define some conditions on the metric
+      yield(m)
+      
+      # record the metric
+      self.metrics[nil] << m
+    end
+    
+    ###########################################################################
+    #
+    # Lifecycle
+    #
+    ###########################################################################
+        
+    # Enable monitoring
+    def monitor
+      self.move(self.initial_state)
+    end
+    
+    # Disable monitoring
+    def unmonitor
+      self.move(:unmonitored)
+    end
+    
+    # Move from one state to another
+    def move(to_state)
+      self.mutex.synchronize do
+        orig_to_state = to_state
+        from_state = self.state
+        
+        msg = "#{self.name} move '#{from_state}' to '#{to_state}'"
+        Syslog.debug(msg)
+        LOG.log(self, :info, msg)
+        
+        # cleanup from current state
+        self.metrics[from_state].each { |m| m.disable }
+        
+        if to_state == :unmonitored
+          self.metrics[nil].each { |m| m.disable }
+        end
+        
+        # perform action
+        self.action(to_state)
+        
+        # enable simple mode
+        if [:start, :restart].include?(to_state) && self.metrics[to_state].empty?
+          to_state = :up
+        end
+        
+        # move to new state
+        self.metrics[to_state].each { |m| m.enable }
+        
+        # if no from state, enable lifecycle metric
+        if from_state == :unmonitored
+          self.metrics[nil].each { |m| m.enable }
+        end
+        
+        # set state
+        self.state = to_state
+        
+        # trigger
+        Trigger.broadcast(self, :state_change, [from_state, orig_to_state])
+        
+        # return self
+        self
+      end
+    end
+    
+    ###########################################################################
+    #
+    # Actions
+    #
+    ###########################################################################
+    
+    def method_missing(sym, *args)
+      unless (sym.to_s =~ /=$/)
+        super
+      end
+      
+      base = sym.to_s.chop.intern
+      
+      unless self.valid_states.include?(base)
+        super
+      end
+      
+      self.class.send(:attr_accessor, base)
+      self.send(sym, *args)
+    end
+    
+    #   +a+ is the action Symbol
+    #   +c+ is the Condition
+    def action(a, c = nil)
+      if self.respond_to?(a)
+        command = self.send(a)
+        
+        case command
+          when String
+            msg = "#{self.name} #{a}: #{command}"
+            Syslog.debug(msg)
+            LOG.log(self, :info, msg)
+            
+            system(command)
+          when Proc
+            msg = "#{self.name} #{a}: lambda"
+            Syslog.debug(msg)
+            LOG.log(self, :info, msg)
+            
+            command.call
+          else
+            raise NotImplementedError
+        end
+      end
+    end
+    
+    ###########################################################################
+    #
+    # Registration
+    #
+    ###########################################################################
+    
+    def register!
+      # override if necessary
+    end
+    
+    def unregister!
+      # override if necessary
+    end
+  end
+  
+end

data/lib/god/trigger.rb

@@ -0,0 +1,43 @@
+module God
+  
+  class Trigger
+    
+    class << self
+      attr_accessor :triggers # {task.name => condition}
+    end
+    
+    # init
+    self.triggers = {}
+    @mutex = Mutex.new
+    
+    def self.register(condition)
+      @mutex.synchronize do
+        self.triggers[condition.watch.name] ||= []
+        self.triggers[condition.watch.name] << condition
+      end
+    end
+    
+    def self.deregister(condition)
+      @mutex.synchronize do
+        self.triggers[condition.watch.name].delete(condition)
+        self.triggers.delete(condition.watch.name) if self.triggers[condition.watch.name].empty?
+      end
+    end
+    
+    def self.broadcast(task, message, payload)
+      return unless self.triggers[task.name]
+      
+      @mutex.synchronize do
+        self.triggers[task.name].each do |t|
+          t.process(message, payload)
+        end
+      end
+    end
+    
+    def self.reset
+      self.triggers.clear
+    end
+    
+  end
+  
+end

data/lib/god/watch.rb

@@ -3,51 +3,33 @@ require 'forwardable'
 
 module God
   
-  class Watch
+  class Watch < Task
     VALID_STATES = [:init, :up, :start, :restart]
+    INITIAL_STATE = :init
     
     # config
-    attr_accessor :state, :interval, :group,
-                  :grace, :start_grace, :stop_grace, :restart_grace
-                  
-    
-    attr_writer   :autostart
-    def autostart?; @autostart; end
+    attr_accessor :grace, :start_grace, :stop_grace, :restart_grace
     
     extend Forwardable
     def_delegators :@process, :name, :uid, :gid, :start, :stop, :restart,
                               :name=, :uid=, :gid=, :start=, :stop=, :restart=,
-                              :pid_file, :pid_file=, :log, :log=, :alive?
-    
-    # api
-    attr_accessor :behaviors, :metrics
-    
-    # internal
-    attr_accessor :mutex
-    
+                              :pid_file, :pid_file=, :log, :log=, :alive?    
     # 
     def initialize
-      @autostart ||= true
+      super
+      
       @process = God::Process.new
-            
-      # no grace period by default
-      self.grace = self.start_grace = self.stop_grace = self.restart_grace = 0
       
-      # the list of behaviors
-      self.behaviors = []
+      # valid states
+      self.valid_states = VALID_STATES
+      self.initial_state = INITIAL_STATE
       
-      # the list of conditions for each action
-      self.metrics = {:init => [],
-                      :start => [],
-                      :restart => [],
-                      :up => []}
-                         
-      # mutex
-      self.mutex = Mutex.new
+      # no grace period by default
+      self.grace = self.start_grace = self.stop_grace = self.restart_grace = 0
     end
     
     def valid?
-      @process.valid?
+      super && @process.valid?
     end
     
     ###########################################################################
@@ -74,35 +56,6 @@ 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
@@ -126,7 +79,7 @@ module God
     # Lifecycle
     #
     ###########################################################################
-        
+    
     # Enable monitoring
     def monitor
       # start monitoring at the first available of the init or up states
@@ -137,56 +90,19 @@ module God
       end
     end
     
-    # Disable monitoring
-    def unmonitor
-      self.move(nil)
-    end
-    
-    # Move from one state to another
-    def move(to_state)
-      msg = "#{self.name} move '#{self.state}' to '#{to_state}'"
-      Syslog.debug(msg)
-      LOG.log(self, :info, msg)
-       
-      # cleanup from current state
-      from_state = self.state
-      if from_state
-        self.metrics[from_state].each { |m| m.disable }
-      end
-      
-      # perform action
-      self.action(to_state)
-      
-      # enable simple mode
-      if [:start, :restart].include?(to_state) && self.metrics[to_state].empty?
-        to_state = :up
-      end
-      
-      # move to new state
-      if to_state
-        self.metrics[to_state].each { |m| m.enable }
-      end
-      
-      # set state
-      self.state = to_state
-      
-      # return self
-      self
-    end
+    ###########################################################################
+    #
+    # Actions
+    #
+    ###########################################################################
     
     def action(a, c = nil)
       case a
       when :start
-        msg = "#{self.name} start: #{self.start.to_s}"
-        Syslog.debug(msg)
-        LOG.log(self, :info, msg)
         call_action(c, :start)
         sleep(self.start_grace + self.grace)
       when :restart
         if self.restart
-          msg = "#{self.name} restart: #{self.restart.to_s}"
-          Syslog.debug(msg)
-          LOG.log(self, :info, msg)
           call_action(c, :restart)
         else
           action(:stop, c)
@@ -194,33 +110,51 @@ module God
         end
         sleep(self.restart_grace + self.grace)
       when :stop
-        if self.stop
-          msg = "#{self.name} stop: #{self.stop.to_s}"
-          Syslog.debug(msg)
-          LOG.log(self, :info, msg)
-        end
         call_action(c, :stop)
         sleep(self.stop_grace + self.grace)
-      end      
+      end
     end
     
     def call_action(condition, action)
       # before
       before_items = self.behaviors
       before_items += [condition] if condition
-      before_items.each { |b| b.send("before_#{action}") }
+      before_items.each do |b|
+        info = b.send("before_#{action}")
+        if info
+          msg = "#{self.name} before_#{action}: #{info} (#{b.base_name})"
+          Syslog.debug(msg)
+          LOG.log(self, :info, msg)
+        end
+      end
+      
+      # log
+      if self.send(action)
+        msg = "#{self.name} #{action}: #{self.send(action).to_s}"
+        Syslog.debug(msg)
+        LOG.log(self, :info, msg)
+      end
       
       @process.call_action(action)
-
+      
       # after
       after_items = self.behaviors
       after_items += [condition] if condition
-      after_items.each { |b| b.send("after_#{action}") }
+      after_items.each do |b|
+        info = b.send("after_#{action}")
+        if info
+          msg = "#{self.name} after_#{action}: #{info} (#{b.base_name})"
+          Syslog.debug(msg)
+          LOG.log(self, :info, msg)
+        end
+      end
     end
     
-    def canonical_hash_form(to)
-      to.instance_of?(Symbol) ? {true => to} : to
-    end
+    ###########################################################################
+    #
+    # Registration
+    #
+    ###########################################################################
     
     def register!
       God.registry.add(@process)