mcproc 2016.2.20

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/compat19.rb

@@ -0,0 +1,33 @@
+require 'monitor'
+
+# Taken from http://redmine.ruby-lang.org/repositories/entry/ruby-19/lib/monitor.rb
+
+module MonitorMixin
+  class ConditionVariable
+    def wait(timeout = nil)
+      @monitor.__send__(:mon_check_owner)
+      count = @monitor.__send__(:mon_exit_for_cond)
+      begin
+        @cond.wait(@monitor.instance_variable_get("@mon_mutex"), timeout)
+        return true
+      ensure
+        @monitor.__send__(:mon_enter_for_cond, count)
+      end
+    end
+  end
+end
+
+# Taken from http://redmine.ruby-lang.org/repositories/entry/ruby-19/lib/thread.rb
+
+class ConditionVariable
+  def wait(mutex, timeout=nil)
+    begin
+      # TODO: mutex should not be used
+      @waiters_mutex.synchronize do
+        @waiters.push(Thread.current)
+      end
+      mutex.sleep timeout
+    end
+    self
+  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,36 @@
+module God
+  module Conditions
+    # Always trigger or never trigger.
+    #
+    # Examples
+    #
+    #   # Always trigger.
+    #   on.condition(:always) do |c|
+    #     c.what = true
+    #   end
+    #
+    #   # Never trigger.
+    #   on.condition(:always) do |c|
+    #     c.what = false
+    #   end
+    class Always < PollCondition
+      # The Boolean determining whether this condition will always trigger
+      # (true) or never trigger (false).
+      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)
+        self.info = []
+
+        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
+          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,32 @@
+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
+        self.info = []
+        usage = `df -P | grep -i " #{self.mount_point}$" | awk '{print $5}' | sed 's/%//'`
+        if usage.to_i > self.above
+          self.info = "disk space out of bounds"
+          return true
+        else
+          return false
+        end
+      end
+    end
+  end
+end