firenxis-god 0.11.0

data/lib/god/conditions/process_running.rb

@@ -0,0 +1,74 @@
+module God
+  module Conditions
+    
+    # Condition Symbol :process_running
+    # Type: Poll
+    # 
+    # Trigger when a process is running or not running depending on attributes.
+    #
+    # Paramaters
+    #   Required
+    #     +pid_file+ is the pid file of the process in question. Automatically
+    #                populated for Watches.
+    #     +running" specifies whether you want to trigger if the process is 
+    #               running (true) or whether it is not running (false)
+    #
+    # Examples
+    #
+    # Trigger if process IS NOT running (from a Watch):
+    #
+    #   on.condition(:process_running) do |c|
+    #     c.running = false
+    #   end
+    #
+    # Trigger if process IS running (from a Watch):
+    #
+    #   on.condition(:process_running) do |c|
+    #     c.running = true
+    #   end
+    #
+    # Non-Watch Tasks must specify a PID file:
+    #
+    #   on.condition(:process_running) do |c|
+    #     c.running = false
+    #     c.pid_file = "/var/run/mongrel.3000.pid"
+    #   end
+    class ProcessRunning < PollCondition
+      attr_accessor :running, :pid_file
+      
+      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 'running' must be specified", self) if self.running.nil?
+        valid
+      end
+      
+      def test
+        self.info = []
+        
+        pid = self.pid
+        active = pid && System::Process.new(pid).exists?
+        
+        if (self.running && active)
+          self.info.concat(["process is running"])
+          true
+        elsif (!self.running && !active)
+          self.info.concat(["process is not running"])
+          true
+        else
+          if self.running
+            self.info.concat(["process is not running"])
+          else
+            self.info.concat(["process is running"])
+          end
+          false
+        end
+      end
+    end
+    
+  end
+end

data/lib/god/conditions/tries.rb

@@ -0,0 +1,44 @@
+module God
+  module Conditions
+    
+    class Tries < PollCondition
+      attr_accessor :times, :within
+      
+      def prepare
+        @timeline = Timeline.new(self.times)
+      end
+      
+      def reset
+        @timeline.clear
+      end
+      
+      def valid?
+        valid = true
+        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 = 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
+          self.info = "tries exceeded #{history}"
+          return true
+        else
+          self.info = "tries within bounds #{history}"
+          return false
+        end
+      end
+    end
+    
+  end
+end

data/lib/god/configurable.rb

@@ -0,0 +1,57 @@
+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
+      x = 1 # fix for MRI's local scope optimization bug DO NOT REMOVE!
+      @base_name ||= self.class.name.split('::').last
+    end
+    
+    def friendly_name
+      base_name
+    end
+    
+    def self.complain(text, c = nil)
+      watch = c.watch rescue nil
+      msg = ""
+      msg += "#{watch.name}: " if watch
+      msg += text
+      msg += " for #{c.friendly_name}" if c
+      applog(watch, :error, msg)
+      false
+    end
+    
+    def complain(text, c = nil)
+      Configurable.complain(text, c)
+    end
+  end
+  
+end

data/lib/god/contact.rb

@@ -0,0 +1,114 @@
+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
+    
+    def self.defaults
+      yield self
+    end
+    
+    def arg(name)
+      self.instance_variable_get("@#{name}") || self.class.instance_variable_get("@#{name}")
+    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/campfire.rb

@@ -0,0 +1,121 @@
+# Send a notice to a Campfire room (http://campfirenow.com).
+#
+#  subdomain - The String subdomain of the Campfire account. If your URL is
+#              "foo.campfirenow.com" then your subdomain is "foo".
+#  token     - The String token used for authentication.
+#  room      - The String room name to which the message should be sent.
+#  ssl       - A Boolean determining whether or not to use SSL
+#              (default: false).
+
+require 'net/http'
+require 'net/https'
+
+CONTACT_DEPS[:campfire] = ['json']
+CONTACT_DEPS[:campfire].each do |d|
+  require d
+end
+
+module Marshmallow
+  class Connection
+    def initialize(options)
+      raise "Required option :subdomain not set." unless options[:subdomain]
+      raise "Required option :token not set." unless options[:token]
+      @options = options
+    end
+
+    def base_url
+      scheme = @options[:ssl] ? 'https' : 'http'
+      subdomain = @options[:subdomain]
+      "#{scheme}://#{subdomain}.campfirenow.com"
+    end
+
+    def find_room_id_by_name(room)
+      url = URI.parse("#{base_url}/rooms.json")
+
+      http = Net::HTTP.new(url.host, url.port)
+      http.use_ssl = true if @options[:ssl]
+
+      req = Net::HTTP::Get.new(url.path)
+      req.basic_auth(@options[:token], 'X')
+
+      res = http.request(req)
+      case res
+        when Net::HTTPSuccess
+          rooms = JSON.parse(res.body)
+          room = rooms['rooms'].select { |x| x['name'] == room }
+          rooms.empty? ? nil : room.first['id']
+        else
+          raise res.error!
+      end
+    end
+
+    def speak(room, message)
+      room_id = find_room_id_by_name(room)
+      raise "No such room: #{room}." unless room_id
+
+      url = URI.parse("#{base_url}/room/#{room_id}/speak.json")
+
+      http = Net::HTTP.new(url.host, url.port)
+      http.use_ssl = true if @options[:ssl]
+
+      req = Net::HTTP::Post.new(url.path)
+      req.basic_auth(@options[:token], 'X')
+      req.set_content_type('application/json')
+      req.body = { 'message' => { 'body' => message } }.to_json
+
+      res = http.request(req)
+      case res
+        when Net::HTTPSuccess
+          true
+        else
+          raise res.error!
+      end
+    end
+  end
+end
+
+module God
+  module Contacts
+
+    class Campfire < Contact
+      class << self
+        attr_accessor :subdomain, :token, :room, :ssl
+        attr_accessor :format
+      end
+
+      self.ssl = false
+
+      self.format = lambda do |message, time, priority, category, host|
+        "[#{time.strftime('%H:%M:%S')}] #{host} - #{message}"
+      end
+
+      attr_accessor :subdomain, :token, :room, :ssl
+
+      def valid?
+        valid = true
+        valid &= complain("Attribute 'subdomain' must be specified", self) unless arg(:subdomain)
+        valid &= complain("Attribute 'token' must be specified", self) unless arg(:token)
+        valid &= complain("Attribute 'room' must be specified", self) unless arg(:room)
+        valid
+      end
+
+      def notify(message, time, priority, category, host)
+        body = Campfire.format.call(message, time, priority, category, host)
+
+        conn = Marshmallow::Connection.new(
+          :subdomain => arg(:subdomain),
+          :token => arg(:token),
+          :ssl => arg(:ssl)
+        )
+
+        conn.speak(arg(:room), body)
+
+        self.info = "notified campfire: #{arg(:subdomain)}"
+      rescue Object => e
+        applog(nil, :info, "failed to notify campfire: #{e.message}")
+        applog(nil, :debug, e.backtrace.join("\n"))
+      end
+    end
+
+  end
+end

data/lib/god/contacts/email.rb

@@ -0,0 +1,136 @@
+# Send a notice to an email address.
+#
+# to_email        - The String email address to which the email will be sent.
+# to_name         - The String name corresponding to the recipient.
+# from_email      - The String email address from which the email will be sent.
+# from_name       - The String name corresponding to the sender.
+# delivery_method - The Symbol delivery method. [ :smtp | :sendmail ]
+#                   (default: :smtp).
+#
+# === SMTP Options (when delivery_method = :smtp) ===
+# server_host     - The String hostname of the SMTP server (default: localhost).
+# server_port     - The Integer port of the SMTP server (default: 25).
+# server_auth     - The Boolean of whether or not to use authentication
+#                   (default: false).
+#
+# === SMTP Auth Options (when server_auth = true) ===
+# server_domain   - The String domain.
+# server_user     - The String username.
+# server_password - The String password.
+#
+# === Sendmail Options (when delivery_method = :sendmail) ===
+# sendmail_path   - The String path to the sendmail executable
+#                   (default: "/usr/sbin/sendmail").
+# sendmail_args   - The String args to send to sendmail (default "-i -t").
+
+require 'time'
+require 'net/smtp'
+
+module God
+  module Contacts
+
+    class Email < Contact
+      class << self
+        attr_accessor :to_email, :to_name, :from_email, :from_name,
+                      :delivery_method, :server_host, :server_port,
+                      :server_auth, :server_domain, :server_user,
+                      :server_password, :sendmail_path, :sendmail_args, :enable_starttls
+        attr_accessor :format
+      end
+
+      self.from_email = 'god@example.com'
+      self.from_name = 'God Process Monitoring'
+      self.delivery_method = :smtp
+      self.server_auth = false
+      self.server_host = 'localhost'
+      self.server_port = 25
+      self.sendmail_path = '/usr/sbin/sendmail'
+      self.sendmail_args = '-i -t'
+
+      self.format = lambda do |name, from_email, from_name, to_email, to_name, message, time, priority, category, host|
+        <<-EOF
+From: #{from_name} <#{from_email}>
+To: #{to_name || name} <#{to_email}>
+Subject: [god] #{message}
+Date: #{time.httpdate}
+Message-Id: <#{rand(1000000000).to_s(36)}.#{$$}.#{from_email}>
+
+Message: #{message}
+Host: #{host}
+Priority: #{priority}
+Category: #{category}
+        EOF
+      end
+
+      attr_accessor :to_email, :to_name, :from_email, :from_name,
+                    :delivery_method, :server_host, :server_port,
+                    :server_auth, :server_domain, :server_user,
+                    :server_password, :sendmail_path, :sendmail_args, :enable_starttls
+
+      def valid?
+        valid = true
+        valid &= complain("Attribute 'to_email' must be specified", self) unless arg(:to_email)
+        valid &= complain("Attribute 'delivery_method' must be one of [ :smtp | :sendmail ]", self) unless [:smtp, :sendmail].include?(arg(:delivery_method))
+        if arg(:delivery_method) == :smtp
+          valid &= complain("Attribute 'server_host' must be specified", self) unless arg(:server_host)
+          valid &= complain("Attribute 'server_port' must be specified", self) unless arg(:server_port)
+          if arg(:server_auth)
+            valid &= complain("Attribute 'server_domain' must be specified", self) unless arg(:server_domain)
+            valid &= complain("Attribute 'server_user' must be specified", self) unless arg(:server_user)
+            valid &= complain("Attribute 'server_password' must be specified", self) unless arg(:server_password)
+          end
+        end
+        valid
+      end
+
+      def notify(message, time, priority, category, host)
+        body = Email.format.call(self.name, arg(:from_email), arg(:from_name),
+                                 arg(:to_email), arg(:to_name), message, time,
+                                 priority, category, host)
+
+        case arg(:delivery_method)
+          when :smtp
+            notify_smtp(body)
+          when :sendmail
+            notify_sendmail(body)
+        end
+
+        self.info = "sent email to #{arg(:to_email)} via #{arg(:delivery_method).to_s}"
+      rescue Object => e
+        applog(nil, :info, "failed to send email to #{arg(:to_email)} via #{arg(:delivery_method).to_s}: #{e.message}")
+        applog(nil, :debug, e.backtrace.join("\n"))
+      end
+
+      def notify_smtp(mail)
+        args = [arg(:server_host), arg(:server_port)]
+        if arg(:server_auth)
+          args << arg(:server_domain)
+          args << arg(:server_user)
+          args << arg(:server_password)
+          args << arg(:server_auth)
+        end
+
+        if arg(:enable_starttls)
+          smtp = Net::SMTP.new(arg(:server_host),arg(:server_port))
+          smtp.enable_starttls
+        
+          smtp.start(arg(:server_host), arg(:server_user),arg(:server_password), arg(:server_auth)) do |smtp|
+            smtp.send_message(mail,arg(:from_email), arg(:to_email) )
+          end
+        else
+          Net::SMTP.start(*args) do |smtp|
+            smtp.send_message(mail, arg(:from_email), arg(:to_email))
+          end
+        end
+      end
+
+      def notify_sendmail(mail)
+        IO.popen("#{arg(:sendmail_path)} #{arg(:sendmail_args)}","w+") do |sm|
+          sm.print(mail.gsub(/\r/, ''))
+          sm.flush
+        end
+      end
+    end
+
+  end
+end