samhendley-god 0.7.13

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!
+      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,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/campfire.rb

@@ -0,0 +1,82 @@
+# notify campfire using tinder http://tinder.rubyforge.org
+#
+#  Example: set up a new campfire notifier
+#
+#  Credentials
+#
+#  God::Contacts::Campfire.server_settings = {
+#     :subdomain => "yoursubdomain",
+#     :user_name => "youruser",
+#     :room => "yourroom",
+#     :password => "yourpassword"
+#  }
+#
+#  Register a new notifier
+#
+#  God.contact(:campfire) do |c|
+#     c.name = 'campfire'
+#  end
+# 
+#  Define a transition for the process running event
+#
+#   w.transition(:up, :start) do |on|
+#     on.condition(:process_running) do |c|
+#        c.running = true
+#        c.notify = 'campfire'
+#     end
+#   end
+
+require 'tinder'
+
+module God
+  module Contacts
+
+    class Campfire < Contact
+      class << self
+        attr_accessor :server_settings, :format
+      end
+
+      self.server_settings = {:subdomain => '',
+                              :user_name => '',
+                              :password => '',
+                              :room => ''}
+
+      self.format = lambda do |message, host|
+        <<-EOF
+        #{host} - #{message}
+        EOF
+      end
+
+      def initialize
+        @room = nil
+      end
+
+      def notify(message, time, priority, category, host)
+        begin
+          body = Campfire.format.call(message,host)
+
+          room.speak body
+
+          self.info = "notified campfire: #{Campfire.server_settings[:subdomain]}"
+        rescue => e
+          applog(nil, :info, "failed to notify campfire: #{e.message}")
+          applog(nil, :debug, e.backtrace.join("\n"))
+        end
+      end
+
+      private
+
+      def room
+        unless @room
+          applog(nil,:debug, "initializing campfire connection using credentials: #{Campfire.server_settings.inspect}")
+
+          campfire = Tinder::Campfire.new Campfire.server_settings[:subdomain] 
+          campfire.login Campfire.server_settings[:user_name], Campfire.server_settings[:password]
+          @room = campfire.find_room_by_name(Campfire.server_settings[:room])
+        end
+        @room
+      end
+    end
+
+  end
+end

data/lib/god/contacts/email.rb

@@ -0,0 +1,95 @@
+require 'time'
+require 'net/smtp'
+
+module God
+  module Contacts
+    
+    class Email < Contact
+      class << self
+        attr_accessor :message_settings, :delivery_method, :server_settings, :sendmail_settings, :format
+      end
+      
+      self.message_settings = {:from => 'god@example.com'}
+      
+      self.delivery_method = :smtp # or :sendmail
+      
+      self.server_settings = {:address => 'localhost',
+                              :port => 25}
+                            # :domain
+                            # :user_name
+                            # :password
+                            # :authentication
+
+      self.sendmail_settings = {:location  => '/usr/sbin/sendmail',
+                                :arguments => '-i -t'
+      }
+      
+      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)
+
+          case Email.delivery_method
+          when :smtp
+            notify_smtp(body)
+          when :sendmail
+            notify_sendmail(body)
+          else
+            raise "unknown delivery method: #{Email.delivery_method}"
+          end
+          
+          self.info = "sent email to #{self.email}"
+        rescue => e
+          applog(nil, :info, "failed to send email to #{self.email}: #{e.message}")
+          applog(nil, :debug, e.backtrace.join("\n"))
+        end
+      end
+
+      # private
+
+      def notify_smtp(mail)
+        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 mail, Email.message_settings[:from], self.email
+        end
+      end
+
+      def notify_sendmail(mail)
+        IO.popen("#{Email.sendmail_settings[:location]} #{Email.sendmail_settings[:arguments]}","w+") do |sm|
+          sm.print(mail.gsub(/\r/, ''))
+          sm.flush
+        end
+      end
+    end
+
+  end
+end

data/lib/god/contacts/jabber.rb

@@ -0,0 +1,65 @@
+# To add Jabber notifications you must have xmpp4r gem installed.
+# Configure your watches like this:
+#
+#   God::Contacts::Jabber.settings = { :jabber_id => 'sender@example.com',
+#                                      :password  => 'secret' }
+#   God.contact(:jabber) do |c|
+#     c.name      = 'Tester'
+#     c.jabber_id = 'receiver@example.com'
+#     c.group     = 'developers'
+#   end
+
+module XMPP4R
+  require 'rubygems'
+  require 'xmpp4r'
+  include Jabber
+end
+
+module God
+  module Contacts
+    class Jabber < Contact      
+      class << self
+        attr_accessor :settings, :format
+      end
+      
+      self.format = lambda do |message, priority, category, host|
+        text  = "Message: #{message}\n"
+        text += "Host: #{host}\n"         if host
+        text += "Priority: #{priority}\n" if priority
+        text += "Category: #{category}\n" if category
+        return text
+      end
+      
+      attr_accessor :jabber_id
+      
+      def valid?
+        valid = true
+      end
+      
+      def notify(message, time, priority, category, host)
+        begin
+          jabber_id = XMPP4R::JID::new "#{Jabber.settings[:jabber_id]}/God"
+          jabber_client = XMPP4R::Client::new jabber_id
+          jabber_client.connect
+          jabber_client.auth Jabber.settings[:password]
+
+          body = Jabber.format.call message, priority, category, host
+          
+          message = XMPP4R::Message::new self.jabber_id, body
+          message.set_type :normal
+          message.set_id '1'
+          message.set_subject 'God'
+          jabber_client.send message
+
+          self.info = "sent jabber message to #{self.jabber_id}"
+        rescue => e
+          puts e.message
+          puts e.backtrace.join("\n")
+          
+          self.info = "failed to send jabber message to #{self.jabber_id}: #{e.message}"
+        end
+      end
+    end
+    
+  end
+end

data/lib/god/contacts/twitter.rb

@@ -0,0 +1,39 @@
+# For Twitter updates you need the 'twitter' gem
+#   (gem install twitter)
+#
+# Configure your watches like this:
+#
+#   God::Contacts::Twitter.settings = { :username => 'sender@example.com',
+#                                       :password  => 'secret' }
+#   God.contact(:twitter) do |c|
+#     c.name      = 'Tester'
+#     c.group     = 'developers'
+#   end
+
+require 'rubygems'
+require 'twitter'
+
+module God
+  module Contacts
+    class Twitter < Contact
+      class << self
+        attr_accessor :settings
+      end
+
+      def valid?
+        valid = true
+      end
+
+      def notify(message, time, priority, category, host)
+        begin
+          ::Twitter::Base.new(Twitter.settings[:username], 
+                              Twitter.settings[:password]).update(message)
+
+          self.info = "sent twitter update as #{Twitter.settings[:username]}"
+        rescue => e
+          self.info = "failed to send twitter update from #{self.twitter_id}: #{e.message}"
+        end
+      end
+    end
+  end
+end