firenxis-god 0.11.0

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,168 @@
+require 'net/http'
+
+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)
+    #
+    # 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
+                    :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
+      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
+        
+        Net::HTTP.start(self.host, self.port) 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)
+        
+        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
+          self.info = "memory within bounds #{history}"
+          return false
+        end
+      end
+    end
+    
+  end
+end

data/lib/god/conditions/process_exits.rb

@@ -0,0 +1,72 @@
+module God
+  module Conditions
+    
+    # Condition Symbol :process_exits
+    # Type: Event
+    # 
+    # Trigger when a process exits.
+    #
+    # Paramaters
+    #   Required
+    #     +pid_file+ is the pid file of the process in question. Automatically
+    #                populated for Watches.
+    #
+    # Examples
+    #
+    # Trigger if process exits (from a Watch):
+    #
+    #   on.condition(:process_exits)
+    #
+    # Trigger if process exits:
+    #
+    #   on.condition(:process_exits) do |c|
+    #     c.pid_file = "/var/run/mongrel.3000.pid"
+    #   end
+    class ProcessExits < EventCondition
+      attr_accessor :pid_file
+      
+      def initialize
+        self.info = "process exited"
+      end
+      
+      def valid?
+        true
+      end
+      
+      def pid
+        self.pid_file ? File.read(self.pid_file).strip.to_i : self.watch.pid
+      end
+      
+      def register
+        pid = self.pid
+        
+        begin
+          EventHandler.register(pid, :proc_exit) do |extra|
+            formatted_extra = extra.size > 0 ? " #{extra.inspect}" : ""
+            self.info = "process #{pid} exited#{formatted_extra}"
+            self.watch.trigger(self)
+          end
+          
+          msg = "#{self.watch.name} registered 'proc_exit' event for pid #{pid}"
+          applog(self.watch, :info, msg)
+        rescue StandardError
+          raise EventRegistrationFailedError.new
+        end
+      end
+      
+      def deregister
+        pid = self.pid
+        if pid
+          EventHandler.deregister(pid, :proc_exit)
+          
+          msg = "#{self.watch.name} deregistered 'proc_exit' event for pid #{pid}"
+          applog(self.watch, :info, msg)
+        else
+          pid_file_location = self.pid_file || self.watch.pid_file
+          applog(self.watch, :error, "#{self.watch.name} could not deregister: no cached PID or PID file #{pid_file_location} (#{self.base_name})")
+        end
+      end
+    end
+    
+  end
+end