mcproc 2016.2.20

data/lib/god/contacts/airbrake.rb

@@ -0,0 +1,44 @@
+# Send a notice to Airbrake (http://airbrake.io/).
+#
+# apikey - The String API key.
+
+CONTACT_DEPS[:airbrake] = ['airbrake']
+CONTACT_DEPS[:airbrake].each do |d|
+  require d
+end
+
+module God
+  module Contacts
+    class Airbrake < Contact
+
+      class << self
+        attr_accessor :apikey
+      end
+
+      def valid?
+        valid = true
+        valid &= complain("Attribute 'apikey' must be specified", self) if self.apikey.nil?
+        valid
+      end
+
+      attr_accessor :apikey
+
+      def notify(message, time, priority, category, host)
+        ::Airbrake.configure {}
+
+        message = "God: #{message.to_s} at #{host}"
+        message << " | #{[category, priority].join(" ")}" unless category.to_s.empty? or priority.to_s.empty?
+
+        if ::Airbrake.notify nil, :error_message => message, :api_key => arg(:apikey)
+          self.info = "sent airbrake notification to #{self.name}"
+        else
+          self.info = "failed to send airbrake notification to #{self.name}"
+        end
+      rescue Object => e
+        applog(nil, :info, "failed to send airbrake notification: #{e.message}")
+        applog(nil, :debug, e.backtrace.join("\n"))
+      end
+
+    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,130 @@
+# 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 Symbol authentication method. Possible values:
+#                   [ nil | :plain | :login | :cram_md5 ]
+#                   The default is nil, which means no authentication. To
+#                   enable authentication, pass the appropriate symbol and
+#                   then pass the appropriate SMTP Auth Options (below).
+#
+# === SMTP Auth Options (when server_auth != nil) ===
+# 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
+        attr_accessor :format
+      end
+
+      self.from_email = 'god@example.com'
+      self.from_name = 'God Process Monitoring'
+      self.delivery_method = :smtp
+      self.server_auth = nil
+      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
+
+      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
+
+        Net::SMTP.start(*args) do |smtp|
+          smtp.send_message(mail, arg(:from_email), arg(:to_email))
+        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

data/lib/god/contacts/hipchat.rb

@@ -0,0 +1,117 @@
+# Send a notice to a Hipchat room (http://hipchat.com).
+#
+#  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).
+#  from      - The String representing who the message should be sent as.
+
+require 'net/http'
+require 'net/https'
+
+CONTACT_DEPS[:hipchat] = ['json']
+CONTACT_DEPS[:hipchat].each do |d|
+  require d
+end
+
+module Marshmallow
+  class Connection
+    def initialize(options)
+      raise "Required option :token not set." unless options[:token]
+      @options = options
+    end
+
+    def base_url
+      scheme = @options[:ssl] ? 'https' : 'http'
+      "#{scheme}://api.hipchat.com/v1/rooms"
+    end
+
+    def find_room_id_by_name(room_name)
+      url = URI.parse("#{base_url}/list?format=json&auth_token=#{@options[:token]}")
+      http = Net::HTTP.new(url.host, url.port)
+      http.use_ssl = true if @options[:ssl]
+
+      req = Net::HTTP::Get.new(url.request_uri)
+      req.set_content_type('application/json')
+
+      res = http.request(req)
+      case res
+        when Net::HTTPSuccess
+          rooms = JSON.parse(res.body)
+          room = rooms['rooms'].select { |x| x['name'] == room_name }
+          rooms.empty? ? nil : room.first['room_id'].to_i
+        else
+          raise res.error!
+      end
+    end
+
+    def speak(room, message)
+      room_id = find_room_id_by_name(room)
+      puts "in spark: room_id = #{room_id}"
+      raise "No such room: #{room}." unless room_id
+
+      escaped_message = URI.escape(message)
+
+      url = URI.parse("#{base_url}/message?message_format=text&format=json&auth_token=#{@options[:token]}&from=#{@options[:from]}&room_id=#{room}&message=#{escaped_message}")
+      
+      http = Net::HTTP.new(url.host, url.port)
+      http.use_ssl = true if @options[:ssl]
+
+      req = Net::HTTP::Post.new(url.request_uri)
+      req.set_content_type('application/json')
+      res = http.request(req)
+      case res
+        when Net::HTTPSuccess
+          true
+        else
+          raise res.error!
+      end
+    end
+  end
+end
+
+module God
+  module Contacts
+
+    class Hipchat < Contact
+      class << self
+        attr_accessor :token, :room, :ssl, :from
+        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 :token, :room, :ssl, :from
+
+      def valid?
+        valid = true
+        valid &= complain("Attribute 'token' must be specified", self) unless arg(:token)
+        valid &= complain("Attribute 'room' must be specified", self) unless arg(:room)
+        valid &= complain("Attribute 'from' must be specified", self) unless arg(:from)
+        valid
+      end
+
+      def notify(message, time, priority, category, host)
+        body = Hipchat.format.call(message, time, priority, category, host)
+
+        conn = Marshmallow::Connection.new(
+          :token => arg(:token),
+          :ssl   => arg(:ssl),
+          :from  => arg(:from)
+        )
+
+        conn.speak(arg(:room), body)
+
+        self.info = "notified hipchat: #{arg(:room)}"
+      rescue Object => e
+        applog(nil, :info, "failed to notify hipchat: #{e.message}")
+        applog(nil, :debug, e.backtrace.join("\n"))
+      end
+    end
+
+  end
+end

data/lib/god/contacts/jabber.rb

@@ -0,0 +1,75 @@
+# Send a notice to a Jabber address.
+#
+# 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").
+
+CONTACT_DEPS[:jabber] = ['xmpp4r']
+CONTACT_DEPS[:jabber].each do |d|
+  require d
+end
+
+module God
+  module Contacts
+
+    class Jabber < Contact
+      class << self
+        attr_accessor :host, :port, :from_jid, :password, :to_jid, :subject
+        attr_accessor :format
+      end
+
+      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
+        text
+      end
+
+      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)
+        body = Jabber.format.call(message, time, priority, category, host)
+
+        message = ::Jabber::Message.new(arg(:to_jid), body)
+        message.set_type(:normal)
+        message.set_id('1')
+        message.set_subject(arg(:subject))
+
+        jabber_id = ::Jabber::JID.new("#{arg(:from_jid)}/God")
+
+        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
+  end
+end