resurrected_god 0.14.0

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

data/lib/god/conditions/file_mtime.rb

@@ -0,0 +1,28 @@
+module God
+  module Conditions
+
+    class FileMtime < PollCondition
+      attr_accessor :path, :max_age
+
+      def initialize
+        super
+        self.path = nil
+        self.max_age = nil
+      end
+
+      def valid?
+        valid = true
+        valid &= complain("Attribute 'path' must be specified", self) if self.path.nil?
+        valid &= complain("Attribute 'max_age' must be specified", self) if self.max_age.nil?
+        valid
+      end
+
+      def test
+        (Time.now - File.mtime(self.path)) > self.max_age
+      end
+    end
+
+  end
+end
+
+

data/lib/god/conditions/file_touched.rb

@@ -0,0 +1,44 @@
+module God
+  module Conditions
+  
+    # Condition Symbol :file_touched
+    # Type: Poll
+    #
+    # Trigger when a specified file is touched.
+    #
+    # Paramaters
+    #   Required
+    #     +path+ is the path to the file to watch.
+    #
+    # Examples
+    #
+    # Trigger if 'tmp/restart.txt' file is touched (from a Watch):
+    #
+    #   on.condition(:file_touched) do |c|
+    #     c.path = 'tmp/restart.txt'
+    #   end
+    #
+    class FileTouched < PollCondition
+      attr_accessor :path
+
+      def initialize
+        super
+        self.path = nil
+      end
+
+      def valid?
+        valid = true
+        valid &= complain("Attribute 'path' must be specified", self) if self.path.nil?
+        valid
+      end
+
+      def test
+        if File.exists?(self.path)
+          (Time.now - File.mtime(self.path)) <= self.interval
+        else
+          false
+        end
+      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

data/lib/god/conditions/http_response_code.rb

@@ -0,0 +1,184 @@
+require 'net/http'
+require 'net/https'
+
+module God
+  module Conditions
+
+    # Condition Symbol :http_response_code
+    # Type: Poll
+    #
+    # Trigger based on the response from an HTTP request.
+    #
+    # Paramaters
+    #   Required
+    #     +host+ is the hostname to connect [required]
+    #     --one of code_is or code_is_not--
+    #     +code_is+ trigger if the response code IS one of these
+    #               e.g. 500 or '500' or [404, 500] or %w{404 500}
+    #     +code_is_not+ trigger if the response code IS NOT one of these
+    #                   e.g. 200 or '200' or [200, 302] or %w{200 302}
+    #  Optional
+    #     +port+ is the port to connect (default 80)
+    #     +path+ is the path to connect (default '/')
+    #     +headers+ is the hash of HTTP headers to send (default none)
+    #     +times+ is the number of times after which to trigger (default 1)
+    #             e.g. 3 (times in a row) or [3, 5] (three out of fives times)
+    #     +timeout+ is the time to wait for a connection (default 60.seconds)
+    #     +ssl+ should the connection use ssl (default false)
+    #
+    # Examples
+    #
+    # Trigger if the response code from www.example.com/foo/bar
+    # is not a 200 (or if the connection is refused or times out:
+    #
+    #   on.condition(:http_response_code) do |c|
+    #     c.host = 'www.example.com'
+    #     c.path = '/foo/bar'
+    #     c.code_is_not = 200
+    #   end
+    #
+    # Trigger if the response code is a 404 or a 500 (will not
+    # be triggered by a connection refusal or timeout):
+    #
+    #   on.condition(:http_response_code) do |c|
+    #     c.host = 'www.example.com'
+    #     c.path = '/foo/bar'
+    #     c.code_is = [404, 500]
+    #   end
+    #
+    # Trigger if the response code is not a 200 five times in a row:
+    #
+    #   on.condition(:http_response_code) do |c|
+    #     c.host = 'www.example.com'
+    #     c.path = '/foo/bar'
+    #     c.code_is_not = 200
+    #     c.times = 5
+    #   end
+    #
+    # Trigger if the response code is not a 200 or does not respond
+    # within 10 seconds:
+    #
+    #   on.condition(:http_response_code) do |c|
+    #     c.host = 'www.example.com'
+    #     c.path = '/foo/bar'
+    #     c.code_is_not = 200
+    #     c.timeout = 10
+    #   end
+    class HttpResponseCode < PollCondition
+      attr_accessor :code_is,      # e.g. 500 or '500' or [404, 500] or %w{404 500}
+                    :code_is_not,  # e.g. 200 or '200' or [200, 302] or %w{200 302}
+                    :times,        # e.g. 3 or [3, 5]
+                    :host,         # e.g. www.example.com
+                    :port,         # e.g. 8080
+                    :ssl,          # e.g. true or false
+                    :ca_file,      # e.g /path/to/pem_file for ssl verification (checkout http://curl.haxx.se/ca/cacert.pem)
+                    :timeout,      # e.g. 60.seconds
+                    :path,         # e.g. '/'
+                    :headers       # e.g. {'Host' => 'myvirtual.mydomain.com'}
+
+      def initialize
+        super
+        self.port = 80
+        self.path = '/'
+        self.headers = {}
+        self.times = [1, 1]
+        self.timeout = 60.seconds
+        self.ssl = false
+        self.ca_file = nil
+      end
+
+      def prepare
+        self.code_is = Array(self.code_is).map { |x| x.to_i } if self.code_is
+        self.code_is_not = Array(self.code_is_not).map { |x| x.to_i } if self.code_is_not
+
+        if self.times.kind_of?(Integer)
+          self.times = [self.times, self.times]
+        end
+
+        @timeline = Timeline.new(self.times[1])
+        @history = Timeline.new(self.times[1])
+      end
+
+      def reset
+        @timeline.clear
+        @history.clear
+      end
+
+      def valid?
+        valid = true
+        valid &= complain("Attribute 'host' must be specified", self) if self.host.nil?
+        valid &= complain("One (and only one) of attributes 'code_is' and 'code_is_not' must be specified", self) if
+          (self.code_is.nil? && self.code_is_not.nil?) || (self.code_is && self.code_is_not)
+        valid
+      end
+
+      def test
+        response = nil
+
+        connection = Net::HTTP.new(self.host, self.port)
+        connection.use_ssl = self.port == 443 ? true : self.ssl
+        connection.verify_mode = OpenSSL::SSL::VERIFY_NONE if connection.use_ssl?
+
+        if connection.use_ssl? && self.ca_file
+          pem = File.read(self.ca_file)
+          connection.ca_file = self.ca_file
+          connection.verify_mode = OpenSSL::SSL::VERIFY_PEER
+        end
+
+        connection.start do |http|
+          http.read_timeout = self.timeout
+          response = http.get(self.path, self.headers)
+        end
+
+        actual_response_code = response.code.to_i
+        if self.code_is && self.code_is.include?(actual_response_code)
+          pass(actual_response_code)
+        elsif self.code_is_not && !self.code_is_not.include?(actual_response_code)
+          pass(actual_response_code)
+        else
+          fail(actual_response_code)
+        end
+      rescue Errno::ECONNREFUSED
+        self.code_is ? fail('Refused') : pass('Refused')
+      rescue Errno::ECONNRESET
+        self.code_is ? fail('Reset') : pass('Reset')
+      rescue EOFError
+        self.code_is ? fail('EOF') : pass('EOF')
+      rescue Timeout::Error
+        self.code_is ? fail('Timeout') : pass('Timeout')
+      rescue Errno::ETIMEDOUT
+        self.code_is ? fail('Timedout') : pass('Timedout')
+      rescue Exception => failure
+        self.code_is ? fail(failure.class.name) : pass(failure.class.name)
+      end
+
+      private
+
+      def pass(code)
+        @timeline << true
+        if @timeline.select { |x| x }.size >= self.times.first
+          self.info = "http response abnormal #{history(code, true)}"
+          true
+        else
+          self.info = "http response nominal #{history(code, true)}"
+          false
+        end
+      end
+
+      def fail(code)
+        @timeline << false
+        self.info = "http response nominal #{history(code, false)}"
+        false
+      end
+
+      def history(code, passed)
+        entry = code.to_s.dup
+        entry = '*' + entry if passed
+        @history << entry
+        '[' + @history.join(", ") + ']'
+      end
+
+    end
+
+  end
+end

data/lib/god/conditions/lambda.rb

@@ -0,0 +1,25 @@
+module God
+  module Conditions
+
+    class Lambda < PollCondition
+      attr_accessor :lambda
+
+      def valid?
+        valid = true
+        valid &= complain("Attribute 'lambda' must be specified", self) if self.lambda.nil?
+        valid
+      end
+
+      def test
+        if self.lambda.call()
+          self.info = "lambda condition was satisfied"
+          true
+        else
+          self.info = "lambda condition was not satisfied"
+          false
+        end
+      end
+    end
+
+  end
+end

data/lib/god/conditions/memory_usage.rb

@@ -0,0 +1,82 @@
+module God
+  module Conditions
+
+    # Condition Symbol :memory_usage
+    # Type: Poll
+    #
+    # Trigger when the resident memory of a process is above a specified limit.
+    #
+    # Paramaters
+    #   Required
+    #     +pid_file+ is the pid file of the process in question. Automatically
+    #                populated for Watches.
+    #     +above+ is the amount of resident memory (in kilobytes) above which
+    #             the condition should trigger. You can also use the sugar
+    #             methods #kilobytes, #megabytes, and #gigabytes to clarify
+    #             this amount (see examples).
+    #
+    # Examples
+    #
+    # Trigger if the process is using more than 100 megabytes of resident
+    # memory (from a Watch):
+    #
+    #   on.condition(:memory_usage) do |c|
+    #     c.above = 100.megabytes
+    #   end
+    #
+    # Non-Watch Tasks must specify a PID file:
+    #
+    #   on.condition(:memory_usage) do |c|
+    #     c.above = 100.megabytes
+    #     c.pid_file = "/var/run/mongrel.3000.pid"
+    #   end
+    class MemoryUsage < 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.memory)
+        self.info = []
+
+        history = "[" + @timeline.map { |x| "#{x > self.above ? '*' : ''}#{x}kb" }.join(", ") + "]"
+
+        if @timeline.select { |x| x > self.above }.size >= self.times.first
+          self.info = "memory out of bounds #{history}"
+          return true
+        else
+          return false
+        end
+      end
+    end
+
+  end
+end