god 0.10.1 → 0.11.0

data/History.txt

@@ -1,4 +1,12 @@
-==
+== 0.11.0 / 2010-07-01
+  * Major Changes
+    * Rewrite notification system to be more consistent and flexible.
+
+== 0.10.1 / 2010-05-17
+  * Bug Fixes
+    * Fix date in gemspec
+
+== 0.10.0 / 2010-05-17
   * Minor Enhancements
     * Add stop_timeout and stop_signal options to Watch
   * Bug Fixes

data/god.gemspec

@@ -3,8 +3,8 @@ Gem::Specification.new do |s|
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
 
   s.name = 'god'
-  s.version = '0.10.1'
-  s.date = '2010-05-17'
+  s.version = '0.11.0'
+  s.date = '2010-07-01'
 
   s.summary = "Process monitoring framework."
   s.description = "An easy to configure, easy to extend monitoring framework written in Ruby."
@@ -26,7 +26,6 @@ Gem::Specification.new do |s|
 
   s.add_development_dependency('twitter', [">= 0.3.7"])
   s.add_development_dependency('prowly', [">= 0.2.1"])
-  s.add_development_dependency('tinder', [">= 1.3.1", "< 2.0.0"])
   s.add_development_dependency('xmpp4r', [">= 0.4.0"])
   s.add_development_dependency('dike', [">= 0.0.3"])
   s.add_development_dependency('snapshot', [">= 1.0.0", "< 2.0.0"])

data/lib/god.rb

@@ -48,27 +48,6 @@ require 'god/conditions/disk_usage'
 require 'god/conditions/complex'
 require 'god/conditions/file_mtime'
 
-require 'god/contact'
-require 'god/contacts/email'
-require 'god/contacts/webhook'
-begin
-  require 'god/contacts/twitter'
-rescue LoadError
-end
-begin
-  require 'god/contacts/jabber'
-rescue LoadError
-end
-begin
-  require 'god/contacts/campfire'
-rescue LoadError
-end
-begin
-  require 'god/contacts/prowl'
-rescue LoadError
-end
-
-
 require 'god/socket'
 require 'god/driver'
 
@@ -87,6 +66,25 @@ require 'god/cli/command'
 
 require 'god/diagnostics'
 
+CONTACT_DEPS = { }
+CONTACT_LOAD_SUCCESS = { }
+
+def load_contact(name)
+  require "god/contacts/#{name}"
+  CONTACT_LOAD_SUCCESS[name] = true
+rescue LoadError
+  CONTACT_LOAD_SUCCESS[name] = false
+end
+
+require 'god/contact'
+load_contact(:campfire)
+load_contact(:email)
+load_contact(:jabber)
+load_contact(:prowl)
+load_contact(:scout)
+load_contact(:twitter)
+load_contact(:webhook)
+
 $:.unshift File.join(File.dirname(__FILE__), *%w[.. ext god])
 
 # App wide logging system
@@ -150,7 +148,7 @@ class Module
 end
 
 module God
-  VERSION = '0.10.1'
+  VERSION = '0.11.0'
   LOG_BUFFER_SIZE_DEFAULT = 100
   PID_FILE_DIRECTORY_DEFAULTS = ['/var/run/god', '~/.god/pids']
   DRB_PORT_DEFAULT = 17165
@@ -352,6 +350,16 @@ module God
   def self.contact(kind)
     self.internal_init
     
+    # verify contact has been loaded
+    if CONTACT_LOAD_SUCCESS[kind] == false
+      applog(nil, :error, "A required dependency for the #{kind} contact is unavailable.")
+      applog(nil, :error, "Run the following commands to install the dependencies:")
+      CONTACT_DEPS[kind].each do |d|
+        applog(nil, :error, "  [sudo] gem install #{d}")
+      end
+      abort
+    end
+    
     # create the contact
     begin
       c = Contact.generate(kind)

data/lib/god/contact.rb

@@ -24,6 +24,14 @@ module God
       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
     #

data/lib/god/contacts/campfire.rb

@@ -1,81 +1,119 @@
-# notify campfire using tinder http://tinder.rubyforge.org
+# Send a notice to a Campfire room (http://campfirenow.com).
 #
-#  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
+#  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')
 
-require 'tinder'
+      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 :server_settings, :format
+        attr_accessor :subdomain, :token, :room, :ssl
+        attr_accessor :format
       end
 
-      self.server_settings = {:subdomain => '',
-                              :user_name => '',
-                              :password => '',
-                              :room => '',
-                              :ssl => false}
+      self.ssl = false
 
-      self.format = lambda do |message, host|
-        <<-EOF
-        #{host} - #{message}
-        EOF
+      self.format = lambda do |message, time, priority, category, host|
+        "[#{time.strftime('%H:%M:%S')}] #{host} - #{message}"
       end
 
-      def initialize
-        @room = nil
+      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)
-        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
+        body = Campfire.format.call(message, time, priority, category, host)
 
-      private
+        conn = Marshmallow::Connection.new(
+          :subdomain => arg(:subdomain),
+          :token => arg(:token),
+          :ssl => arg(:ssl)
+        )
 
-      def room
-        unless @room
-          applog(nil,:debug, "initializing campfire connection using credentials: #{Campfire.server_settings.inspect}")
+        conn.speak(arg(:room), body)
 
-          campfire = Tinder::Campfire.new Campfire.server_settings[:subdomain], :ssl => Campfire.server_settings[:ssl]
-          campfire.login Campfire.server_settings[:user_name], Campfire.server_settings[:password]
-          @room = campfire.find_room_by_name(Campfire.server_settings[:room])
-        end
-        @room
+        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
 

data/lib/god/contacts/email.rb

@@ -1,36 +1,59 @@
+# 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 :message_settings, :delivery_method, :server_settings, :sendmail_settings, :format
+        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
+        attr_accessor :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|
+      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: god <#{self.message_settings[:from]}>
-To: #{name} <#{email}>
+From: #{from_name} <#{from_email}>
+To: #{to_name || name} <#{to_email}>
 Subject: [god] #{message}
-Date: #{Time.now.httpdate}
-Message-Id: <#{rand(1000000000).to_s(36)}.#{$$}.#{self.message_settings[:from]}>
+Date: #{time.httpdate}
+Message-Id: <#{rand(1000000000).to_s(36)}.#{$$}.#{from_email}>
 
 Message: #{message}
 Host: #{host}
@@ -38,53 +61,62 @@ Priority: #{priority}
 Category: #{category}
         EOF
       end
-      
-      attr_accessor :email
-      
+
+      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
+
       def valid?
         valid = true
-        valid &= complain("Attribute 'email' must be specified", self) if self.email.nil?
+        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)
-        begin
-          body = Email.format.call(self.name, self.email, 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 Email.delivery_method
+        case arg(: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
+        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 = [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] 
+        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
 
         Net::SMTP.start(*args) do |smtp|
-          smtp.send_message mail, Email.message_settings[:from], self.email
+          smtp.send_message(mail, arg(:from_email), arg(:to_email))
         end
       end
 
       def notify_sendmail(mail)
-        IO.popen("#{Email.sendmail_settings[:location]} #{Email.sendmail_settings[:arguments]}","w+") do |sm|
+        IO.popen("#{arg(:sendmail_path)} #{arg(:sendmail_args)}","w+") do |sm|
           sm.print(mail.gsub(/\r/, ''))
           sm.flush
         end