mojombo-god 0.7.7

data/lib/god/cli/version.rb

@@ -0,0 +1,23 @@
+module God
+  module CLI
+    
+    class Version
+      def self.version
+        require 'god'
+    
+        # print version
+        puts "Version #{God::VERSION}"
+        exit
+      end
+      
+      def self.version_extended
+        puts "Version: #{God::VERSION}"
+        puts "Polls: enabled"
+        puts "Events: " + God::EventHandler.event_system
+    
+        exit
+      end
+    end
+    
+  end
+end

data/lib/god/condition.rb

@@ -0,0 +1,96 @@
+module God
+  
+  class Condition < Behavior
+    attr_accessor :transition, :notify, :info, :phase
+    
+    # Generate a Condition of the given kind. The proper class if found by camel casing the
+    # kind (which is given as an underscored symbol).
+    #   +kind+ is the underscored symbol representing the class (e.g. :foo_bar for God::Conditions::FooBar)
+    def self.generate(kind, watch)
+      sym = kind.to_s.capitalize.gsub(/_(.)/){$1.upcase}.intern
+      c = God::Conditions.const_get(sym).new
+      
+      unless c.kind_of?(PollCondition) || c.kind_of?(EventCondition) || c.kind_of?(TriggerCondition)
+        abort "Condition '#{c.class.name}' must subclass God::PollCondition, God::EventCondition, or God::TriggerCondition" 
+      end
+      
+      if !EventHandler.loaded? && c.kind_of?(EventCondition)
+        abort "Condition '#{c.class.name}' requires an event system but none has been loaded"
+      end
+      
+      c.watch = watch
+      c
+    rescue NameError
+      raise NoSuchConditionError.new("No Condition found with the class name God::Conditions::#{sym}")
+    end
+    
+    def self.valid?(condition)
+      valid = true
+      if condition.notify
+        begin
+          Contact.normalize(condition.notify)
+        rescue ArgumentError => e
+          valid &= Configurable.complain("Attribute 'notify' " + e.message, condition)
+        end
+      end
+      valid
+    end
+    
+    # Construct the friendly name of this Condition, looks like:
+    #
+    # Condition FooBar on Watch 'baz'
+    def friendly_name
+      "Condition #{self.class.name.split('::').last} on Watch '#{self.watch.name}'"
+    end
+  end
+  
+  class PollCondition < Condition
+    # all poll conditions can specify a poll interval 
+    attr_accessor :interval
+    
+    # Override this method in your Conditions (optional)
+    def before
+    end
+    
+    # Override this method in your Conditions (mandatory)
+    #
+    # Return true if the test passes (everything is ok)
+    # Return false otherwise
+    def test
+      raise AbstractMethodNotOverriddenError.new("PollCondition#test must be overridden in subclasses")
+    end
+    
+    # Override this method in your Conditions (optional)
+    def after
+    end
+  end
+  
+  class EventCondition < Condition
+    def register
+      raise AbstractMethodNotOverriddenError.new("EventCondition#register must be overridden in subclasses")
+    end
+    
+    def deregister
+      raise AbstractMethodNotOverriddenError.new("EventCondition#deregister must be overridden in subclasses")
+    end
+  end
+  
+  class TriggerCondition < Condition
+    def process(event, payload)
+      raise AbstractMethodNotOverriddenError.new("TriggerCondition#process must be overridden in subclasses")
+    end
+    
+    def trigger
+      self.watch.trigger(self)
+    end
+    
+    def register
+      Trigger.register(self)
+    end
+    
+    def deregister
+      Trigger.deregister(self)
+    end
+  end
+  
+end

data/lib/god/conditions/always.rb

@@ -0,0 +1,23 @@
+module God
+  module Conditions
+
+    class Always < PollCondition
+      attr_accessor :what
+      
+      def initialize
+        self.info = "always"
+      end
+      
+      def valid?
+        valid = true
+        valid &= complain("Attribute 'what' must be specified", self) if self.what.nil?
+        valid
+      end
+      
+      def test
+        @what
+      end
+    end
+  
+  end
+end

data/lib/god/conditions/complex.rb

@@ -0,0 +1,86 @@
+module God
+  module Conditions
+    
+    class Complex < PollCondition
+      AND = 0x1 
+      OR  = 0x2
+      NOT = 0x4
+        
+      def initialize()
+        super
+        
+        @oper_stack = []
+        @op_stack = []
+        
+        @this = nil
+      end
+      
+      def valid?
+        @oper_stack.inject(true) { |acc, oper| acc & oper.valid? }
+      end
+      
+      def prepare
+        @oper_stack.each { |oper| oper.prepare }
+      end
+      
+      def new_oper(kind, op)
+        oper = Condition.generate(kind, self.watch)
+        @oper_stack.push(oper)
+        @op_stack.push(op)
+        oper
+      end
+      
+      def this(kind)
+        @this = Condition.generate(kind, self.watch)
+        yield @this if block_given?
+      end
+      
+      def and(kind)
+        oper = new_oper(kind, 0x1)
+        yield oper if block_given?
+      end
+      
+      def and_not(kind)
+        oper = new_oper(kind, 0x5)
+        yield oper if block_given?
+      end
+      
+      def or(kind)
+        oper = new_oper(kind, 0x2)
+        yield oper if block_given?
+      end
+      
+      def or_not(kind)
+        oper = new_oper(kind, 0x6)
+        yield oper if block_given?
+      end
+      
+      def test
+        if @this.nil?
+          # Although this() makes sense semantically and therefore
+          # encourages easy-to-read conditions, being able to omit it
+          # allows for more DRY code in some cases, so we deal with a
+          # nil @this here by initially setting res to true or false,
+          # depending on whether the first operator used is AND or OR
+          # respectively.
+          if 0 < @op_stack[0] & AND
+            res = true
+          else
+            res = false
+          end
+        else
+          res = @this.test
+        end
+        
+        @op_stack.each do |op|
+          cond = @oper_stack.shift
+          eval "res " + ((0 < op & AND) ? "&&" : "||") + "= " + ((0 < op & NOT) ? "!" : "") + "cond.test"
+          @oper_stack.push cond
+        end
+        
+        res
+      end
+    end
+    
+  end
+end

data/lib/god/conditions/cpu_usage.rb

@@ -0,0 +1,80 @@
+module God
+  module Conditions
+    
+    # Condition Symbol :cpu_usage
+    # Type: Poll
+    # 
+    # Trigger when the percent of CPU use of a process is above a specified limit.
+    # On multi-core systems, this number could conceivably be above 100.
+    #
+    # Paramaters
+    #   Required
+    #     +pid_file+ is the pid file of the process in question. Automatically
+    #                populated for Watches.
+    #     +above+ is the percent CPU above which to trigger the condition. You 
+    #             may use #percent to clarify this amount (see examples).
+    #
+    # Examples
+    #
+    # Trigger if the process is using more than 25 percent of the cpu (from a Watch):
+    #
+    #   on.condition(:cpu_usage) do |c|
+    #     c.above = 25.percent
+    #   end
+    #
+    # Non-Watch Tasks must specify a PID file:
+    #
+    #   on.condition(:cpu_usage) do |c|
+    #     c.above = 25.percent
+    #     c.pid_file = "/var/run/mongrel.3000.pid"
+    #   end
+    class CpuUsage < PollCondition
+      attr_accessor :above, :times, :pid_file
+    
+      def initialize
+        super
+        self.above = nil
+        self.times = [1, 1]
+      end
+      
+      def prepare
+        if self.times.kind_of?(Integer)
+          self.times = [self.times, self.times]
+        end
+        
+        @timeline = Timeline.new(self.times[1])
+      end
+      
+      def reset
+        @timeline.clear
+      end
+      
+      def pid
+        self.pid_file ? File.read(self.pid_file).strip.to_i : self.watch.pid
+      end
+      
+      def valid?
+        valid = true
+        valid &= complain("Attribute 'pid_file' must be specified", self) if self.pid_file.nil? && self.watch.pid_file.nil?
+        valid &= complain("Attribute 'above' must be specified", self) if self.above.nil?
+        valid
+      end
+      
+      def test
+        process = System::Process.new(self.pid)
+        @timeline.push(process.percent_cpu)
+        
+        history = "[" + @timeline.map { |x| "#{x > self.above ? '*' : ''}#{x}%%" }.join(", ") + "]"
+        
+        if @timeline.select { |x| x > self.above }.size >= self.times.first
+          self.info = "cpu out of bounds #{history}"
+          return true
+        else
+          self.info = "cpu within bounds #{history}"
+          return false
+        end
+      end
+    end
+    
+  end
+end

data/lib/god/conditions/degrading_lambda.rb

@@ -0,0 +1,52 @@
+module God
+  module Conditions
+    
+    # This condition degrades its interval by a factor of two for 3 tries before failing
+    class DegradingLambda < PollCondition
+      attr_accessor :lambda
+      
+      def initialize
+        super
+        @tries = 0
+      end
+      
+      def valid?
+        valid = true
+        valid &= complain("Attribute 'lambda' must be specified", self) if self.lambda.nil?
+        valid
+      end
+      
+      def test
+        puts "Calling test. Interval at #{self.interval}"
+        @original_interval ||= self.interval
+        unless pass?
+          if @tries == 2
+            self.info = "lambda condition was satisfied"
+            return true
+          end
+          self.interval = self.interval / 2.0
+          @tries += 1
+        else
+          @tries = 0
+          self.interval = @original_interval
+        end
+        
+        self.info = "lambda condition was not satisfied"
+        false
+      end
+      
+      private
+        
+        def pass?
+          begin
+            Timeout::timeout(@interval) {
+              self.lambda.call()
+            }
+          rescue Timeout::Error
+            false
+          end
+        end
+    end
+
+  end
+end

data/lib/god/conditions/disk_usage.rb

@@ -0,0 +1,27 @@
+module God
+  module Conditions
+    
+    class DiskUsage < PollCondition
+      attr_accessor :above, :mount_point
+      
+      def initialize
+        super
+        self.above = nil
+        self.mount_point = nil
+      end
+      
+      def valid?
+        valid = true
+        valid &= complain("Attribute 'mount_point' must be specified", self) if self.mount_point.nil?
+        valid &= complain("Attribute 'above' must be specified", self) if self.above.nil?
+        valid
+      end
+      
+      def test
+        usage = `df | grep -i " #{self.mount_point}$" | awk '{print $5}' | sed 's/%//'`
+        usage.to_i > self.above
+      end
+    end
+    
+  end
+end

data/lib/god/conditions/flapping.rb

@@ -0,0 +1,128 @@
+module God
+  module Conditions
+    
+    # Condition Symbol :flapping
+    # Type: Trigger
+    # 
+    # Trigger when a Task transitions to or from a state or states a given number
+    # of times within a given period. 
+    #
+    # Paramaters
+    #   Required
+    #     +times+ is the number of times that the Task must transition before
+    #             triggering.
+    #     +within+ is the number of seconds within which the Task must transition
+    #              the specified number of times before triggering. You may use
+    #              the sugar methods #seconds, #minutes, #hours, #days to clarify
+    #              your code (see examples).
+    #     --one or both of--
+    #     +from_state+ is the state (as a Symbol) from which the transition must occur.
+    #     +to_state is the state (as a Symbol) to which the transition must occur.
+    #
+    #   Optional:
+    #     +retry_in+ is the number of seconds after which to re-monitor the Task after
+    #                it has been disabled by the condition.
+    #     +retry_times+ is the number of times after which to permanently unmonitor
+    #                   the Task.
+    #     +retry_within+ is the number of seconds within which 
+    #
+    # Examples
+    #
+    # Trigger if
+    class Flapping < TriggerCondition
+      attr_accessor :times,
+                    :within,
+                    :from_state,
+                    :to_state,
+                    :retry_in,
+                    :retry_times,
+                    :retry_within
+      
+      def initialize
+        self.info = "process is flapping"
+      end
+      
+      def prepare
+        @timeline = Timeline.new(self.times)
+        @retry_timeline = Timeline.new(self.retry_times)
+      end
+      
+      def valid?
+        valid = true
+        valid &= complain("Attribute 'times' must be specified", self) if self.times.nil?
+        valid &= complain("Attribute 'within' must be specified", self) if self.within.nil?
+        valid &= complain("Attributes 'from_state', 'to_state', or both must be specified", self) if self.from_state.nil? && self.to_state.nil?
+        valid
+      end
+      
+      def process(event, payload)
+        begin
+          if event == :state_change
+            event_from_state, event_to_state = *payload
+            
+            from_state_match = !self.from_state || self.from_state && Array(self.from_state).include?(event_from_state)
+            to_state_match = !self.to_state || self.to_state && Array(self.to_state).include?(event_to_state)
+            
+            if from_state_match && to_state_match
+              @timeline << Time.now
+              
+              concensus = (@timeline.size == self.times)
+              duration = (@timeline.last - @timeline.first) < self.within
+              
+              if concensus && duration
+                @timeline.clear
+                trigger
+                retry_mechanism
+              end
+            end
+          end
+        rescue => e
+          puts e.message
+          puts e.backtrace.join("\n")
+        end
+      end
+      
+      private
+      
+      def retry_mechanism
+        if self.retry_in
+          @retry_timeline << Time.now
+          
+          concensus = (@retry_timeline.size == self.retry_times)
+          duration = (@retry_timeline.last - @retry_timeline.first) < self.retry_within
+          
+          if concensus && duration
+            # give up
+            Thread.new do
+              sleep 1
+              
+              # log
+              msg = "#{self.watch.name} giving up"
+              applog(self.watch, :info, msg)
+            end
+          else
+            # try again later
+            Thread.new do
+              sleep 1
+              
+              # log
+              msg = "#{self.watch.name} auto-reenable monitoring in #{self.retry_in} seconds"
+              applog(self.watch, :info, msg)
+              
+              sleep self.retry_in
+              
+              # log
+              msg = "#{self.watch.name} auto-reenabling monitoring"
+              applog(self.watch, :info, msg)
+              
+              if self.watch.state == :unmonitored
+                self.watch.monitor
+              end
+            end
+          end
+        end
+      end
+    end
+    
+  end
+end