god 0.10.1 → 0.11.0

data/lib/god/contacts/jabber.rb

@@ -1,124 +1,73 @@
-# To add Jabber notifications you must have xmpp4r gem installed.
-# Configure your watches like this:
+# Send a notice to a Jabber address.
 #
-#   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
+# host     - The String hostname of the Jabber server.
+# port     - The Integer port of the Jabber server (default: 5222).
+# from_jid - The String Jabber ID of the sender.
+# password - The String password of the sender.
+# to_jid   - The String Jabber ID of the recipient.
+# subject  - The String subject of the message (default: "God Notification").
 
-module XMPP4R
-  require 'xmpp4r'
-  include Jabber
+CONTACT_DEPS[:jabber] = ['xmpp4r']
+CONTACT_DEPS[:jabber].each do |d|
+  require d
 end
 
 module God
   module Contacts
-    class Jabber < Contact      
+
+    class Jabber < Contact
       class << self
-        attr_accessor :settings, :format, :client
+        attr_accessor :host, :port, :from_jid, :password, :to_jid, :subject
+        attr_accessor :format
       end
-      
-      self.format = lambda do |message, priority, category, host|
+
+      self.port = 5222
+      self.subject = 'God Notification'
+
+      self.format = lambda do |message, time, 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
+        text
       end
-      
-      attr_accessor :jabber_id
-      
+
+      attr_accessor :host, :port, :from_jid, :password, :to_jid, :subject
+
       def valid?
         valid = true
+        valid &= complain("Attribute 'host' must be specified", self) unless arg(:host)
+        valid &= complain("Attribute 'port' must be specified", self) unless arg(:port)
+        valid &= complain("Attribute 'from_jid' must be specified", self) unless arg(:from_jid)
+        valid &= complain("Attribute 'to_jid' must be specified", self) unless arg(:to_jid)
+        valid &= complain("Attribute 'password' must be specified", self) unless arg(:password)
+        valid
       end
-      
+
       def notify(message, time, priority, category, host)
-        connect
-        
-        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'
-        
-        self.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
-      
-      def send!(msg)
-        attempts = 0
-        begin
-          attempts += 1
-          client.send(msg)
-        rescue Errno::EPIPE, IOError => e
-          sleep 1
-          disconnect!
-          reconnect!
-          retry unless attempts > 3
-          raise e
-        rescue Errno::ECONNRESET => e
-          sleep (attempts^2) * 60 + 60
-          disconnect!
-          reconnect!
-          retry unless attempts > 3
-          raise e
-        end
-      end
-      
-      def connect
-        connect! unless connected?
-      end
-      
-      def connected?
-        connected = client.respond_to?(:is_connected?) && client.is_connected?
-        return connected
-      end
-      
-      def connect!
-        disconnect! if connected?
+        body = Jabber.format.call(message, time, priority, category, host)
 
-        @connect_mutex ||= Mutex.new
-        # don't try to connect if another thread is already connecting.
-        return if @connect_mutex.locked?
-        @connect_mutex.lock
-        
-        jabber_id = XMPP4R::JID::new "#{Jabber.settings[:jabber_id]}/God"
-        jabber_client = XMPP4R::Client::new jabber_id
-        jabber_client.connect Jabber.settings[:host]
-        jabber_client.auth Jabber.settings[:password]
-        self.client = jabber_client
-        
-        @connect_mutex.unlock
-      end
-      
-      def disconnect!
-        if client.respond_to?(:is_connected?) && client.is_connected?
-          begin
-            client.close
-          rescue Errno::EPIPE, IOError => e
-            self.info "Failed to disconnect: #{e}"
-            nil
-          end
-        end
-        client = nil
-      end
+        message = ::Jabber::Message.new(arg(:to_jid), body)
+        message.set_type(:normal)
+        message.set_id('1')
+        message.set_subject(arg(:subject))
 
-      def client
-        Jabber.client
-      end
+        jabber_id = ::Jabber::JID.new("#{arg(:from_jid)}/God")
 
-      def client=(jc)
-        Jabber.client = jc
+        client = ::Jabber::Client.new(jabber_id)
+        client.connect(arg(:host), arg(:port))
+        client.auth(arg(:password))
+        client.send(message)
+        client.close
+
+        self.info = "sent jabber message to #{self.to_jid}"
+      rescue Object => e
+        if e.respond_to?(:message)
+          applog(nil, :info, "failed to send jabber message to #{arg(:to_jid)}: #{e.message}")
+        else
+          applog(nil, :info, "failed to send jabber message to #{arg(:to_jid)}: #{e.class}")
+        end
+        applog(nil, :debug, e.backtrace.join("\n"))
       end
 
     end

data/lib/god/contacts/prowl.rb

@@ -1,38 +1,19 @@
-# For Prowl notifications you need the 'prowly' gem
-#   (gem install prowly)
+# Send a notice to Prowl (http://prowl.weks.net/).
 #
-# Configure your watches like this:
-#
-#   God.contact(:prowl) do |c|
-#     c.name      = 'georgette'
-#     c.apikey    = 'ffffffffffffffffffffffffffffffffffffffff'
-#     c.group     = 'developers'
-#   end
-#
-#
-#   God.contact(:prowl) do |c|
-#     c.name      = 'johnny'
-#     c.apikey    = 'ffffffffffffffffffffffffffffffffffffffff'
-#     c.group     = 'developers'
-#   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 = 'developers'
-#     end
-#   end
+# apikey - The String API key.
 
-require 'prowly'
+CONTACT_DEPS[:prowl] = ['prowly']
+CONTACT_DEPS[:prowl].each do |d|
+  require d
+end
 
 module God
   module Contacts
     class Prowl < Contact
 
-      attr_accessor :apikey
+      class << self
+        attr_accessor :apikey
+      end
 
       def valid?
         valid = true
@@ -40,28 +21,27 @@ module God
         valid
       end
 
+      attr_accessor :apikey
+
       def notify(message, time, priority, category, host)
-        begin
-          result = Prowly.notify do |n|
-            n.apikey      = self.apikey
-            n.priority    = map_priority(priority.to_i)
-            n.application = category || "God"
-            n.event       = "on " + host.to_s
-            n.description = message.to_s + " at " + time.to_s
-          end
+        result = Prowly.notify do |n|
+          n.apikey      = arg(:apikey)
+          n.priority    = map_priority(priority.to_i)
+          n.application = category || "God"
+          n.event       = "on " + host.to_s
+          n.description = message.to_s + " at " + time.to_s
+        end
 
-          if result.succeeded?
-            self.info = "sent prowl notification to #{self.name}"
-          else
-            self.info = "failed to send prowl notification to #{self.name}: #{result.message}"
-          end
+        if result.succeeded?
+          self.info = "sent prowl notification to #{self.name}"
+        else
+          self.info = "failed to send prowl notification to #{self.name}: #{result.message}"
         end
       rescue Object => e
-        self.info = "failed to send prowl notification to #{self.name}: #{e.message}"
+        applog(nil, :info, "failed to send prowl notification to #{self.name}: #{e.message}")
+        applog(nil, :debug, e.backtrace.join("\n"))
       end
 
-      private
-
       def map_priority(priority)
         case priority
            when 1 then Prowly::Notification::Priority::EMERGENCY
@@ -74,4 +54,4 @@ module God
       end
     end
   end
-end
+end

data/lib/god/contacts/scout.rb

@@ -1,33 +1,19 @@
-# Configure your Scout client key:
+# Send a notice to Scout (http://scoutapp.com/).
 #
-#   God::Contacts::Scout.client_key = '1qpw29ie38ur37yt5
-#
-# A client key is configured per god process. Inside this God process,
-# you can create multiple Scout 'contacts' - which are actually Scout
-# plugins. This allows you to use Scout's UI to configure who gets
-# notifications for each plugin, and to disable notifications when you
-# go on vacation, etc.
-#
-#   God.contact(:scout) do |c|
-#     c.name      = 'scout_delayed_job_plugin'
-#     c.plugin_id = '12345
-#   end
-#
-#   God.contact(:scout) do |c|
-#     c.name      = 'scout_apache_plugin'
-#     c.plugin_id = '54312
-#   end
+# client_key - The String client key.
+# plugin_id  - The String plugin id.
 
 require 'net/http'
 require 'uri'
 
 module God
   module Contacts
+
     class Scout < Contact
       class << self
-        attr_accessor :client_key, :format
+        attr_accessor :client_key, :plugin_id
+        attr_accessor :format
       end
-      attr_accessor :plugin_id
 
       self.format = lambda do |message, priority, category, host|
         text  = "Message: #{message}\n"
@@ -37,28 +23,33 @@ module God
         return text
       end
 
+      attr_accessor :client_key, :plugin_id
+
       def valid?
         valid = true
+        valid &= complain("Attribute 'client_key' must be specified", self) unless arg(:client_key)
+        valid &= complain("Attribute 'plugin_id' must be specified", self) unless arg(:plugin_id)
+        valid
       end
 
       def notify(message, time, priority, category, host)
-        begin
-          data = {
-            :client_key => Scout.client_key,
-            :plugin_id => plugin_id,
-            :format => 'xml',
-            'alert[subject]' => message,
-            'alert[body]' => Scout.format.call(message, priority, category, host)
-          }
+        data = {
+          :client_key => arg(:client_key),
+          :plugin_id => arg(:plugin_id),
+          :format => 'xml',
+          'alert[subject]' => message,
+          'alert[body]' => Scout.format.call(message, priority, category, host)
+        }
 
-          uri = URI.parse('http://scoutapp.com/alerts/create')
-          Net::HTTP.post_form(uri, data)
+        uri = URI.parse('http://scoutapp.com/alerts/create')
+        Net::HTTP.post_form(uri, data)
 
-          self.info = "sent scout alert to plugin ##{plugin_id}"
-        rescue => e
-          self.info = "failed to send scout alert to plugin ##{plugin_id}: #{e.message}"
-        end
+        self.info = "sent scout alert to plugin ##{plugin_id}"
+      rescue => e
+        applog(nil, :info, "failed to send scout alert to plugin ##{plugin_id}: #{e.message}")
+        applog(nil, :debug, e.backtrace.join("\n"))
       end
     end
+
   end
 end

data/lib/god/contacts/twitter.rb

@@ -1,37 +1,50 @@
-# For Twitter updates you need the 'twitter' gem
-#   (gem install twitter)
+# Send a notice to a Twitter account (http://twitter.com/).
 #
-# 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
+# consumer_token  - The String OAuth consumer token (defaults to God's
+#                   existing consumer token).
+# consumer_secret - The String OAuth consumer secret (defaults to God's
+#                   existing consumer secret).
+# access_token    - The String OAuth access token.
+# access_secret   - The String OAuth access secret.
 
-require 'twitter'
+CONTACT_DEPS[:twitter] = ['twitter']
+CONTACT_DEPS[:twitter].each do |d|
+  require d
+end
 
 module God
   module Contacts
     class Twitter < Contact
       class << self
-        attr_accessor :settings
+        attr_accessor :consumer_token, :consumer_secret,
+                      :access_token, :access_secret
       end
 
+      self.consumer_token = 'gOhjax6s0L3mLeaTtBWPw'
+      self.consumer_secret = 'yz4gpAVXJHKxvsGK85tEyzQJ7o2FEy27H1KEWL75jfA'
+
       def valid?
         valid = true
+        valid &= complain("Attribute 'consumer_token' must be specified", self) unless arg(:consumer_token)
+        valid &= complain("Attribute 'consumer_secret' must be specified", self) unless arg(:consumer_secret)
+        valid &= complain("Attribute 'access_token' must be specified", self) unless arg(:access_token)
+        valid &= complain("Attribute 'access_secret' must be specified", self) unless arg(:access_secret)
+        valid
       end
 
+      attr_accessor :consumer_token, :consumer_secret,
+                    :access_token, :access_secret
+
       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
+        oauth = ::Twitter::OAuth.new(arg(:consumer_token), arg(:consumer_secret))
+        oauth.authorize_from_access(arg(:access_token), arg(:access_secret))
+
+        ::Twitter::Base.new(oauth).update(message)
+
+        self.info = "sent twitter update"
+      rescue => e
+        applog(nil, :info, "failed to send twitter update: #{e.message}")
+        applog(nil, :debug, e.backtrace.join("\n"))
       end
     end
   end

data/lib/god/contacts/webhook.rb

@@ -1,44 +1,70 @@
-# Configure your watches like this:
+# Send a notice to a webhook.
 #
-#   God.contact(:webhook) do |c|
-#     c.name      = 'Tester'
-#     c.hook_url  = 'http://hook/url'
-#   end
+# url    - The String webhook URL.
+# format - The Symbol format [ :form | :json ] (default: :form).
 
 require 'net/http'
 require 'uri'
 
+CONTACT_DEPS[:webhook] = ['json']
+CONTACT_DEPS[:webhook].each do |d|
+  require d
+end
+
 module God
   module Contacts
 
     class Webhook < Contact
+      class << self
+        attr_accessor :url, :format
+      end
 
-      attr_accessor :hook_url
+      self.format = :form
 
       def valid?
         valid = true
+        valid &= complain("Attribute 'url' must be specified", self) unless arg(:url)
+        valid &= complain("Attribute 'format' must be one of [ :form | :json ]", self) unless [:form, :json].include?(arg(:format))
+        valid
       end
 
+      attr_accessor :url, :format
+
       def notify(message, time, priority, category, host)
-        begin
-          data = {
-            :message => message,
-            :time => time,
-            :priority => priority,
-            :category => category,
-            :host => host
-          }
-
-          uri = URI.parse(self.hook_url)
-          Net::HTTP.post_form(uri, data)
-
-          self.info = "sent webhook to #{self.hook_url}"
-        rescue => e
-          puts e.message
-          puts e.backtrace.join("\n")
-
-          self.info = "failed to send webhook to #{self.hook_url}: #{e.message}"
+        data = {
+          :message => message,
+          :time => time,
+          :priority => priority,
+          :category => category,
+          :host => host
+        }
+
+        uri = URI.parse(arg(:url))
+        http = Net::HTTP.new(uri.host, uri.port)
+
+        req = nil
+        res = nil
+
+        case arg(:format)
+          when :form
+            req = Net::HTTP::Post.new(uri.path)
+            req.set_form_data(data)
+          when :json
+            req = Net::HTTP::Post.new(uri.path)
+            req.body = data.to_json
+        end
+
+        res = http.request(req)
+
+        case res
+          when Net::HTTPSuccess
+            self.info = "sent webhook to #{arg(:url)}"
+          else
+            self.info = "failed to send webhook to #{arg(:url)}: #{res.error!}"
         end
+      rescue Object => e
+        applog(nil, :info, "failed to send email to #{arg(:url)}: #{e.message}")
+        applog(nil, :debug, e.backtrace.join("\n"))
       end
 
     end