resurrected_god 0.14.0 → 1.0.0

data/lib/god/configurable.rb

@@ -1,16 +1,13 @@
 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)
@@ -39,19 +36,19 @@ module God
       base_name
     end
 
-    def self.complain(text, c = nil)
-      watch = c.watch rescue nil
-      msg = ""
+    # configurable - Should respond to :watch and :friendly_name
+    def self.complain(text, configurable = nil)
+      watch = configurable.watch rescue nil
+      msg = ''
       msg += "#{watch.name}: " if watch
       msg += text
-      msg += " for #{c.friendly_name}" if c
+      msg += " for #{configurable.friendly_name}" if configurable
       applog(watch, :error, msg)
       false
     end
 
-    def complain(text, c = nil)
-      Configurable.complain(text, c)
+    def complain(text, configurable = nil)
+      Configurable.complain(text, configurable)
     end
   end
-
 end

data/lib/god/contact.rb

@@ -1,21 +1,18 @@
 module God
-
   class Contact
     include Configurable
 
     attr_accessor :name, :group, :info
 
     def self.generate(kind)
-      sym = kind.to_s.capitalize.gsub(/_(.)/){$1.upcase}.intern
+      sym = kind.to_s.capitalize.gsub(/_(.)/) { Regexp.last_match(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
+      abort "Contact '#{c.class.name}' must subclass God::Contact" unless c.is_a?(Contact)
 
       c
     rescue NameError
-      raise NoSuchContactError.new("No Contact found with the class name God::Contacts::#{sym}")
+      raise NoSuchContactError, "No Contact found with the class name God::Contacts::#{sym}"
     end
 
     def self.valid?(contact)
@@ -29,7 +26,7 @@ module God
     end
 
     def arg(name)
-      self.instance_variable_get("@#{name}") || self.class.instance_variable_get("@#{name}")
+      instance_variable_get("@#{name}") || self.class.instance_variable_get("@#{name}")
     end
 
     # Normalize the given notify specification into canonical form.
@@ -45,50 +42,43 @@ module God
     # Raises ArgumentError on invalid spec (message contains details)
     def self.normalize(spec)
       case spec
+      when String
+        { contacts: Array(spec) }
+      when Array
+        raise ArgumentError, 'contains non-String elements' unless spec.all? { |x| x.instance_of?(String) }
+
+        { contacts: spec }
+      when Hash
+        copy = spec.dup
+
+        # check :contacts
+        raise ArgumentError, 'must have a :contacts key' unless (contacts = copy.delete(:contacts))
+
+        case contacts
         when String
-          {:contacts => Array(spec)}
+        # valid
         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
+          raise ArgumentError, 'has a :contacts key containing non-String elements' unless contacts.all? { |x| x.instance_of?(String) }
+        # valid
         else
-          raise ArgumentError.new("must be a String (contact name), Array (of contact names), or Hash (contact specification)")
+          raise ArgumentError, 'must have a :contacts key pointing to a String or Array of Strings'
+        end
+
+        # remove priority and category
+        copy.delete(:priority)
+        copy.delete(:category)
+
+        # check for invalid keys
+        raise ArgumentError, "contains extra elements: #{copy.inspect}" unless copy.empty?
+
+        # normalize
+        spec[:contacts] &&= Array(spec[:contacts])
+        spec[:priority] &&= spec[:priority].to_s
+        spec[:category] &&= spec[:category].to_s
+
+        spec
+      else
+        raise ArgumentError, 'must be a String (contact name), Array (of contact names), or Hash (contact specification)'
       end
     end
 
@@ -99,16 +89,15 @@ module God
     #   +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")
+    def notify(message, time, priority, category, host) # rubocop:disable Lint/UnusedMethodArgument
+      raise AbstractMethodNotOverriddenError, '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}'"
+      super + " Contact '#{name}'"
     end
   end
-
 end

data/lib/god/contacts/airbrake.rb

@@ -10,35 +10,33 @@ 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 &= complain("Attribute 'apikey' must be specified", self) if apikey.nil?
         valid
       end
 
       attr_accessor :apikey
 
-      def notify(message, time, priority, category, host)
-        ::Airbrake.configure {}
+      def notify(message, _time, priority, category, host)
+        ::Airbrake.configure {} # block must be passed
 
-        message = "God: #{message.to_s} at #{host}"
-        message << " | #{[category, priority].join(" ")}" unless category.to_s.empty? or priority.to_s.empty?
+        message = +"God: #{message} at #{host}"
+        message << " | #{[category, priority].join(' ')}" unless category.to_s.empty? || 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
+        self.info = if ::Airbrake.notify nil, error_message: message, api_key: arg(:apikey)
+                      "sent airbrake notification to #{name}"
+                    else
+                      "failed to send airbrake notification to #{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

@@ -18,8 +18,9 @@ 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]
+      raise 'Required option :subdomain not set.' unless options[:subdomain]
+      raise 'Required option :token not set.' unless options[:token]
+
       @options = options
     end
 
@@ -40,12 +41,12 @@ module Marshmallow
 
       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!
+      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
 
@@ -65,10 +66,10 @@ module Marshmallow
 
       res = http.request(req)
       case res
-        when Net::HTTPSuccess
-          true
-        else
-          raise res.error!
+      when Net::HTTPSuccess
+        true
+      else
+        raise res.error!
       end
     end
   end
@@ -76,16 +77,14 @@ end
 
 module God
   module Contacts
-
     class Campfire < Contact
       class << self
-        attr_accessor :subdomain, :token, :room, :ssl
-        attr_accessor :format
+        attr_accessor :subdomain, :token, :room, :ssl, :format
       end
 
       self.ssl = false
 
-      self.format = lambda do |message, time, priority, category, host|
+      self.format = lambda do |message, time, _priority, _category, host|
         "[#{time.strftime('%H:%M:%S')}] #{host} - #{message}"
       end
 
@@ -103,9 +102,9 @@ module God
         body = Campfire.format.call(message, time, priority, category, host)
 
         conn = Marshmallow::Connection.new(
-          :subdomain => arg(:subdomain),
-          :token => arg(:token),
-          :ssl => arg(:ssl)
+          subdomain: arg(:subdomain),
+          token: arg(:token),
+          ssl: arg(:ssl)
         )
 
         conn.speak(arg(:room), body)
@@ -116,6 +115,5 @@ module God
         applog(nil, :debug, e.backtrace.join("\n"))
       end
     end
-
   end
 end

data/lib/god/contacts/email.rb

@@ -26,19 +26,17 @@
 #                   (default: "/usr/sbin/sendmail").
 # sendmail_args   - The String args to send to sendmail (default "-i -t").
 
+require 'English'
 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
+        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,
+                      :format
       end
 
       self.from_email = 'god@example.com'
@@ -51,18 +49,18 @@ module God
       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}>
+        <<~FORMAT
+          From: #{from_name} <#{from_email}>
+          To: #{to_name || name} <#{to_email}>
+          Subject: [god] #{message}
+          Date: #{time.httpdate}
+          Message-Id: <#{rand(1000000000).to_s(36)}.#{$PROCESS_ID}.#{from_email}>
 
-Message: #{message}
-Host: #{host}
-Priority: #{priority}
-Category: #{category}
-        EOF
+          Message: #{message}
+          Host: #{host}
+          Priority: #{priority}
+          Category: #{category}
+        FORMAT
       end
 
       attr_accessor :to_email, :to_name, :from_email, :from_name,
@@ -73,7 +71,9 @@ Category: #{category}
       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))
+        unless [:smtp, :sendmail].include?(arg(:delivery_method))
+          valid &= complain("Attribute 'delivery_method' must be one of [ :smtp | :sendmail ]", self)
+        end
         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)
@@ -87,20 +87,20 @@ Category: #{category}
       end
 
       def notify(message, time, priority, category, host)
-        body = Email.format.call(self.name, arg(:from_email), arg(:from_name),
+        body = Email.format.call(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)
+        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}"
+        self.info = "sent email to #{arg(:to_email)} via #{arg(:delivery_method)}"
       rescue Object => e
-        applog(nil, :info, "failed to send email to #{arg(:to_email)} via #{arg(:delivery_method).to_s}: #{e.message}")
+        applog(nil, :info, "failed to send email to #{arg(:to_email)} via #{arg(:delivery_method)}: #{e.message}")
         applog(nil, :debug, e.backtrace.join("\n"))
       end
 
@@ -119,12 +119,11 @@ Category: #{category}
       end
 
       def notify_sendmail(mail)
-        IO.popen("#{arg(:sendmail_path)} #{arg(:sendmail_args)}","w+") do |sm|
-          sm.print(mail.gsub(/\r/, ''))
+        IO.popen("#{arg(:sendmail_path)} #{arg(:sendmail_args)}", 'w+') do |sm|
+          sm.print(mail.delete("\r"))
           sm.flush
         end
       end
     end
-
   end
 end

data/lib/god/contacts/prowl.rb

@@ -10,14 +10,13 @@ end
 module God
   module Contacts
     class Prowl < Contact
-
       class << self
         attr_accessor :apikey
       end
 
       def valid?
         valid = true
-        valid &= complain("Attribute 'apikey' must be specified", self) if self.apikey.nil?
+        valid &= complain("Attribute 'apikey' must be specified", self) if apikey.nil?
         valid
       end
 
@@ -27,29 +26,29 @@ module God
         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
+          n.application = category || 'God'
+          n.event       = "on #{host}"
+          n.description = "#{message} at #{time}"
         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
+        self.info = if result.succeeded?
+                      "sent prowl notification to #{name}"
+                    else
+                      "failed to send prowl notification to #{name}: #{result.message}"
+                    end
       rescue Object => e
-        applog(nil, :info, "failed to send prowl notification to #{self.name}: #{e.message}")
+        applog(nil, :info, "failed to send prowl notification to #{name}: #{e.message}")
         applog(nil, :debug, e.backtrace.join("\n"))
       end
 
       def map_priority(priority)
         case priority
-           when 1 then Prowly::Notification::Priority::EMERGENCY
-           when 2 then Prowly::Notification::Priority::HIGH
-           when 3 then Prowly::Notification::Priority::NORMAL
-           when 4 then Prowly::Notification::Priority::MODERATE
-           when 5 then Prowly::Notification::Priority::VERY_LOW
-           else Prowly::Notification::Priority::NORMAL
+        when 1 then Prowly::Notification::Priority::EMERGENCY
+        when 2 then Prowly::Notification::Priority::HIGH
+        when 3 then Prowly::Notification::Priority::NORMAL
+        when 4 then Prowly::Notification::Priority::MODERATE
+        when 5 then Prowly::Notification::Priority::VERY_LOW
+        else Prowly::Notification::Priority::NORMAL
         end
       end
     end

data/lib/god/contacts/scout.rb

@@ -8,11 +8,9 @@ require 'uri'
 
 module God
   module Contacts
-
     class Scout < Contact
       class << self
-        attr_accessor :client_key, :plugin_id
-        attr_accessor :format
+        attr_accessor :client_key, :plugin_id, :format
       end
 
       self.format = lambda do |message, priority, category, host|
@@ -32,7 +30,7 @@ module God
         valid
       end
 
-      def notify(message, time, priority, category, host)
+      def notify(message, _time, priority, category, host)
         data = {
           :client_key => arg(:client_key),
           :plugin_id => arg(:plugin_id),
@@ -50,6 +48,5 @@ module God
         applog(nil, :debug, e.backtrace.join("\n"))
       end
     end
-
   end
 end

data/lib/god/contacts/sensu.rb

@@ -1,6 +1,6 @@
-# ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+# +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 # Send a notice to a SENSU client socket, port 3030 on 'localhost' only.
-# ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+# +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 # [mandatory]
 # check_name    - a unique check name
 #
@@ -16,7 +16,6 @@ end
 
 module God
   module Contacts
-
     class Sensu < Contact
       class << self
         attr_accessor :check_name, :status_code, :handler, :host, :port
@@ -37,23 +36,28 @@ module God
 
       def sensu_client_socket(msg)
         u = UDPSocket.new
-        u.send(msg + "\n", 0, arg(:host).nil? ? self.host : arg(:host), arg(:port).nil? ? self.port : arg(:port))
+        u.send("#{msg}\n", 0, arg(:host).nil? ? host : arg(:host), arg(:port).nil? ? port : arg(:port))
         u.close
       end
 
       def notify(message, time, priority, category, host)
         data = {
-          :category => category,
-          :message => message,
-          :priority => priority,
-          :host => host,
-          :time => time,
+          category: category,
+          message: message,
+          priority: priority,
+          host: host,
+          time: time
+        }
+        parcel = {
+          'name' => arg(:check_name),
+          'status' => arg(:status_code).nil? ? status_code : arg(:status_code),
+          'output' => data.to_json,
+          'handler' => arg(:handler).empty? ? handler : arg(:handler),
+          'executed' => Time.now.to_i
         }
-        parcel = { 'name' => arg(:check_name), 'status' => arg(:status_code).nil? ? self.status_code : arg(:status_code), 'output' => data.to_json, 'handler' => arg(:handler).empty? ? self.handler : arg(:handler), 'executed' => Time.now.to_i }
         sensu_client_socket parcel.to_json
         self.info = "notified sensu: #{arg(:check_name)}"
       end
     end
   end
 end
-

data/lib/god/contacts/slack.rb

@@ -16,15 +16,14 @@ end
 
 module God
   module Contacts
-
     class Slack < Contact
       class << self
         attr_accessor :url, :channel, :notify_channel, :format, :username, :emoji
       end
 
-      self.channel        = "#general"
+      self.channel        = '#general'
       self.notify_channel = false
-      self.format         = "%{priority} alert on %{host}: %{message} (%{category}, %{time})"
+      self.format         = '%{priority} alert on %{host}: %{message} (%{category}, %{time})'
 
       def valid?
         valid = true
@@ -35,28 +34,21 @@ module God
       attr_accessor :url, :channel, :notify_channel, :format, :username, :emoji
 
       def text(data)
-        text = ""
-        text << "<!channel> " if arg(:notify_channel)
-
-        if RUBY_VERSION =~ /^1\.8/
-          text << arg(:format).gsub(/%\{(\w+)\}/) do |match|
-            data[$1.to_sym]
-          end
-        else
-          text << arg(:format) % data
-        end
+        text = +''
+        text << '<!channel> ' if arg(:notify_channel)
+        text << (arg(:format) % data)
 
         text
       end
 
       def notify(message, time, priority, category, host)
         text = text({
-          :message => message,
-          :time => time,
-          :priority => priority,
-          :category => category,
-          :host => host
-        })
+                      message: message,
+                      time: time,
+                      priority: priority,
+                      category: category,
+                      host: host
+                    })
 
         request(text)
       end
@@ -71,28 +63,26 @@ module God
 
         req = Net::HTTP::Post.new(api_url.request_uri)
         req.body = {
-          :link_names => 1,
-          :text => text,
-          :channel => arg(:channel)
-        }.tap { |payload|
+          link_names: 1,
+          text: text,
+          channel: arg(:channel)
+        }.tap do |payload|
           payload[:username] = arg(:username) if arg(:username)
           payload[:icon_emoji] = arg(:emoji) if arg(:emoji)
-        }.to_json
+        end.to_json
 
         res = http.request(req)
 
-        case res
-          when Net::HTTPSuccess
-            self.info = "successfully notified slack on channel #{arg(:channel)}"
-          else
-            self.info = "failed to send webhook to #{arg(:url)}: #{res.error!}"
-        end
+        self.info = case res
+                    when Net::HTTPSuccess
+                      "successfully notified slack on channel #{arg(:channel)}"
+                    else
+                      "failed to send webhook to #{arg(:url)}: #{res.error!}"
+                    end
       rescue Object => e
         applog(nil, :info, "failed to send webhook to #{arg(:url)}: #{e.message}")
         applog(nil, :debug, e.backtrace.join("\n"))
       end
-
     end
-
   end
-end
+end