god 0.4.3 → 0.5.0

data/lib/god/conditions/http_response_code.rb

@@ -0,0 +1,97 @@
+require 'net/http'
+
+module God
+  module Conditions
+    
+    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. '/'
+      
+      def initialize
+        super
+        self.times = [1, 1]
+      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("Attribute 'port' must be specified", self) if self.port.nil?
+        valid &= complain("Attribute 'path' must be specified", self) if self.path.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 &= complain("Attribute 'timeout' must be specified", self) if self.timeout.nil?
+        valid
+      end
+      
+      def test
+        response = nil
+        
+        Net::HTTP.start(self.host, self.port) do |http|
+          http.read_timeout = self.timeout
+          response = http.head(self.path)
+        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 Timeout::Error
+        self.code_is ? fail('Timeout') : pass('Timeout')
+      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

@@ -6,12 +6,18 @@ module God
 
       def valid?
         valid = true
-        valid &= complain("You must specify the 'lambda' attribute for :lambda") if self.lambda.nil?
+        valid &= complain("Attribute 'lambda' must be specified", self) if self.lambda.nil?
         valid
       end
 
       def test
-        self.lambda.call()
+        if self.lambda.call()
+          self.info = "lambda condition was satisfied"
+          true
+        else
+          self.info = "lambda condition was not satisfied"
+          false
+        end
       end
     end
 

data/lib/god/conditions/memory_usage.rb

@@ -17,24 +17,32 @@ module God
         
         @timeline = Timeline.new(self.times[1])
       end
-    
+      
+      def reset
+        @timeline.clear
+      end
+      
       def valid?
         valid = true
-        valid &= complain("You must specify the 'pid_file' attribute on the Watch for :memory_usage") if self.watch.pid_file.nil?
-        valid &= complain("You must specify the 'above' attribute for :memory_usage") if self.above.nil?
+        valid &= complain("Attribute 'pid_file' must be specified", self) if self.watch.pid_file.nil?
+        valid &= complain("Attribute 'above' must be specified", self) if self.above.nil?
         valid
       end
-    
+      
       def test
         return false unless File.exist?(self.watch.pid_file)
         
         pid = File.read(self.watch.pid_file).strip
         process = System::Process.new(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
-          @timeline.clear
+          self.info = "memory out of bounds #{history}"
           return true
         else
+          self.info = "memory within bounds #{history}"
           return false
         end
       end

data/lib/god/conditions/process_exits.rb

@@ -2,9 +2,13 @@ module God
   module Conditions
     
     class ProcessExits < EventCondition
+      def initialize
+        self.info = "process exited"
+      end
+      
       def valid?
         valid = true
-        valid &= complain("You must specify the 'pid_file' attribute on the Watch for :process_exits") if self.watch.pid_file.nil?
+        valid &= complain("Attribute 'pid_file' must be specified", self) if self.watch.pid_file.nil?
         valid
       end
     
@@ -21,8 +25,12 @@ module God
       end
       
       def deregister
-        pid = File.read(self.watch.pid_file).strip.to_i
-        EventHandler.deregister(pid, :proc_exit)
+        if File.exist?(self.watch.pid_file)
+          pid = File.read(self.watch.pid_file).strip.to_i
+          EventHandler.deregister(pid, :proc_exit)
+        else
+          LOG.log(self.watch, :error, "#{self.watch.name} could not deregister: no such PID file #{self.watch.pid_file} (#{self.base_name})")
+        end
       end
     end
     

data/lib/god/conditions/process_running.rb

@@ -6,18 +6,36 @@ module God
       
       def valid?
         valid = true
-        valid &= complain("You must specify the 'pid_file' attribute on the Watch for :process_running") if self.watch.pid_file.nil?
-        valid &= complain("You must specify the 'running' attribute for :process_running") if self.running.nil?
+        valid &= complain("Attribute 'pid_file' must be specified", self) if self.watch.pid_file.nil?
+        valid &= complain("Attribute 'running' must be specified", self) if self.running.nil?
         valid
       end
     
       def test
-        return !self.running unless File.exist?(self.watch.pid_file)
+        self.info = []
+        
+        unless File.exist?(self.watch.pid_file)
+          self.info << "#{self.watch.name} #{self.class.name}: no such pid file: #{self.watch.pid_file}"
+          return !self.running
+        end
         
         pid = File.read(self.watch.pid_file).strip
         active = System::Process.new(pid).exists?
         
-        (self.running && active) || (!self.running && !active)
+        if (self.running && active)
+          self.info << "process is running"
+          true
+        elsif (!self.running && !active)
+          self.info << "process is not running"
+          true
+        else
+          if self.running
+            self.info << "process is not running"
+          else
+            self.info << "process is running"
+          end
+          false
+        end
       end
     end
     

data/lib/god/conditions/tries.rb

@@ -7,23 +7,34 @@ module God
       def prepare
         @timeline = Timeline.new(self.times)
       end
-    
+      
+      def reset
+        @timeline.clear
+      end
+      
       def valid?
         valid = true
-        valid &= complain("You must specify the 'times' attribute for :tries") if self.times.nil?
+        valid &= complain("Attribute 'times' must be specified", self) if self.times.nil?
         valid
       end
-    
+      
       def test
         @timeline << Time.now
         
         concensus = (@timeline.size == self.times)
-        duration = within.nil? || (@timeline.last - @timeline.first) < self.within
+        duration = self.within.nil? || (@timeline.last - @timeline.first) < self.within
+        
+        if within
+          history = "[#{@timeline.size}/#{self.times} within #{(@timeline.last - @timeline.first).to_i}s]"
+        else
+          history = "[#{@timeline.size}/#{self.times}]"
+        end
         
         if concensus && duration
-          @timeline.clear if within.nil?
+          self.info = "tries exceeded #{history}"
           return true
         else
+          self.info = "tries within bounds #{history}"
           return false
         end
       end

data/lib/god/configurable.rb

@@ -0,0 +1,54 @@
+module God
+  
+  module Configurable
+    # Override this method in your Configurable (optional)
+    #
+    # Called once after the Configurable has been sent to the block and attributes have been
+    # set. Do any post-processing on attributes here
+    def prepare
+      
+    end
+    
+    def reset
+      
+    end
+    
+    # Override this method in your Configurable (optional)
+    #
+    # Called once during evaluation of the config file. Return true if valid, false otherwise
+    #
+    # A convenience method 'complain' is available that will print out a message and return false,
+    # making it easy to report multiple validation errors:
+    #
+    #   def valid?
+    #     valid = true
+    #     valid &= complain("You must specify the 'pid_file' attribute for :memory_usage") if self.pid_file.nil?
+    #     valid &= complain("You must specify the 'above' attribute for :memory_usage") if self.above.nil?
+    #     valid
+    #   end
+    def valid?
+      true
+    end
+    
+    def base_name
+      self.class.name.split('::').last
+    end
+    
+    def friendly_name
+      base_name
+    end
+    
+    def self.complain(text, c = nil)
+      msg = text
+      msg += " for #{c.friendly_name}" if c
+      Syslog.err(msg)
+      puts msg
+      false
+    end
+    
+    def complain(text, c = nil)
+      Configurable.complain(text, c)
+    end
+  end
+  
+end

data/lib/god/contact.rb

@@ -0,0 +1,106 @@
+module God
+  
+  class Contact
+    include Configurable
+    
+    attr_accessor :name, :group, :info
+    
+    def self.generate(kind)
+      sym = kind.to_s.capitalize.gsub(/_(.)/){$1.upcase}.intern
+      c = God::Contacts.const_get(sym).new
+      
+      unless c.kind_of?(Contact)
+        abort "Contact '#{c.class.name}' must subclass God::Contact" 
+      end
+      
+      c
+    rescue NameError
+      raise NoSuchContactError.new("No Contact found with the class name God::Contacts::#{sym}")
+    end
+    
+    def self.valid?(contact)
+      valid = true
+      valid &= Configurable.complain("Attribute 'name' must be specified", contact) if contact.name.nil?
+      valid
+    end
+    
+    # Normalize the given notify specification into canonical form.
+    #   +spec+ is the notify spec as a String, Array of Strings, or Hash
+    #
+    # Canonical form looks like:
+    # {:contacts => ['fred', 'john'], :priority => '1', :category => 'awesome'}
+    # Where :contacts will be present and point to an Array of Strings. Both
+    # :priority and :category may not be present but if they are, they will each
+    # contain a single String.
+    # 
+    # Returns normalized notify spec
+    # Raises ArgumentError on invalid spec (message contains details)
+    def self.normalize(spec)
+      case spec
+        when String
+          {:contacts => Array(spec)}
+        when Array
+          unless spec.select { |x| !x.instance_of?(String) }.empty?
+            raise ArgumentError.new("contains non-String elements")
+          end
+          {:contacts => spec}
+        when Hash
+          copy = spec.dup
+          
+          # check :contacts
+          if contacts = copy.delete(:contacts)
+            case contacts
+              when String
+                # valid
+              when Array
+                unless contacts.select { |x| !x.instance_of?(String) }.empty?
+                  raise ArgumentError.new("has a :contacts key containing non-String elements")
+                end
+                # valid
+              else
+                raise ArgumentError.new("must have a :contacts key pointing to a String or Array of Strings")
+            end
+          else
+            raise ArgumentError.new("must have a :contacts key")
+          end
+          
+          # remove priority and category
+          copy.delete(:priority)
+          copy.delete(:category)
+          
+          # check for invalid keys
+          unless copy.empty?
+            raise ArgumentError.new("contains extra elements: #{copy.inspect}")
+          end
+          
+          # normalize
+          spec[:contacts] &&= Array(spec[:contacts])
+          spec[:priority] &&= spec[:priority].to_s
+          spec[:category] &&= spec[:category].to_s
+          
+          spec
+        else
+          raise ArgumentError.new("must be a String (contact name), Array (of contact names), or Hash (contact specification)")
+      end
+    end
+    
+    # Abstract
+    # Send the message to the external source
+    #   +message+ is the message body returned from the condition
+    #   +time+ is the Time at which the notification was made
+    #   +priority+ is the arbitrary priority String
+    #   +category+ is the arbitrary category String
+    #   +host+ is the hostname of the server
+    def notify(message, time, priority, category, host)
+      raise AbstractMethodNotOverriddenError.new("Contact#notify must be overridden in subclasses")
+    end
+    
+    # Construct the friendly name of this Contact, looks like:
+    #
+    # Contact FooBar
+    def friendly_name
+      super + " Contact '#{self.name}'"
+    end
+  end
+  
+end

data/lib/god/contacts/email.rb

@@ -0,0 +1,73 @@
+require 'time'
+require 'net/smtp'
+
+module God
+  module Contacts
+    
+    class Email < Contact
+      class << self
+        attr_accessor :message_settings, :delivery_method, :server_settings, :format
+      end
+      
+      self.message_settings = {:from => 'god@example.com'}
+      
+      self.delivery_method = :smtp
+      
+      self.server_settings = {:address => 'localhost',
+                              :port => 25}
+                            # :domain
+                            # :user_name
+                            # :password
+                            # :authentication
+      
+      self.format = lambda do |name, email, message, time, priority, category, host|
+        <<-EOF
+From: god <#{self.message_settings[:from]}>
+To: #{name} <#{email}>
+Subject: [god] #{message}
+Date: #{Time.now.httpdate}
+Message-Id: <unique.message.id.string@example.com>
+
+Message: #{message}
+Host: #{host}
+Priority: #{priority}
+Category: #{category}
+        EOF
+      end
+      
+      attr_accessor :email
+      
+      def valid?
+        valid = true
+        valid &= complain("Attribute 'email' must be specified", self) if self.email.nil?
+        valid
+      end
+      
+      def notify(message, time, priority, category, host)
+        begin
+          body = Email.format.call(self.name, self.email, message, time, priority, category, host)
+          
+          args = [Email.server_settings[:address], Email.server_settings[:port]]
+          if Email.server_settings[:authentication]
+            args << Email.server_settings[:domain]
+            args << Email.server_settings[:user_name]
+            args << Email.server_settings[:password]
+            args << Email.server_settings[:authentication] 
+          end
+            
+          Net::SMTP.start(*args) do |smtp|
+            smtp.send_message body, Email.message_settings[:from], self.email
+          end
+          
+          self.info = "sent email to #{self.email}"
+        rescue => e
+          puts e.message
+          puts e.backtrace.join("\n")
+          
+          self.info = "failed to send email to #{self.email}: #{e.message}"
+        end
+      end
+    end
+    
+  end
+end

data/lib/god/errors.rb

@@ -12,6 +12,9 @@ module God
   class NoSuchBehaviorError < StandardError
   end
   
+  class NoSuchContactError < StandardError
+  end
+  
   class InvalidCommandError < StandardError
   end