resurrected_god 0.14.0 → 1.0.0

data/lib/god/system/process.rb

@@ -1,13 +1,12 @@
 module God
   module System
-
     class Process
       def self.fetch_system_poller
         @@poller ||= if SlashProcPoller.usable?
-		       SlashProcPoller
-		     else
-		       PortablePoller
-		     end
+                       SlashProcPoller
+                     else
+                       PortablePoller
+                     end
       end
 
       def initialize(pid)
@@ -45,6 +44,5 @@ module God
         end
       end
     end
-
   end
 end

data/lib/god/system/slash_proc_poller.rb

@@ -5,27 +5,27 @@ module God
       @@hertz = 100
       @@total_mem = nil
 
-      MeminfoPath = '/proc/meminfo'
-      UptimePath = '/proc/uptime'
+      MEMINFO_PATH = '/proc/meminfo'.freeze
+      UPTIME_PATH = '/proc/uptime'.freeze
 
-      RequiredPaths = [MeminfoPath, UptimePath]
+      REQUIRED_PATHS = [MEMINFO_PATH, UPTIME_PATH].freeze
 
       # FreeBSD has /proc by default, but nothing mounted there!
       # So we should check for the actual required paths!
-      # Returns true if +RequiredPaths+ are readable.
+      # Returns true if +REQUIRED_PATHS+ are readable.
       def self.usable?
-        RequiredPaths.all? do |path|
-          test(?r, path) && readable?(path)
+        REQUIRED_PATHS.all? do |path|
+          test('r', path) && readable?(path)
         end
       end
 
       def initialize(pid)
         super(pid)
+        return if @@total_mem
 
-        unless @@total_mem # in K
-          File.open(MeminfoPath) do |f|
-            @@total_mem = f.gets.split[1]
-          end
+        # in K
+        File.open(MEMINFO_PATH) do |f|
+          @@total_mem = f.gets.split[1]
         end
       end
 
@@ -45,7 +45,7 @@ module God
       def percent_cpu
         stats = stat
         total_time = stats[:utime].to_i + stats[:stime].to_i # in jiffies
-        seconds = uptime - stats[:starttime].to_i / @@hertz
+        seconds = uptime - (stats[:starttime].to_i / @@hertz)
         if seconds == 0
           0
         else
@@ -55,21 +55,19 @@ module God
         0
       end
 
-      private
-
       # Some systems (CentOS?) have a /proc, but they can hang when trying to
       # read from them. Try to use this sparingly as it is expensive.
       def self.readable?(path)
-        begin
-          Timeout.timeout(1) { File.read(path) }
-        rescue Timeout::Error
-          false
-        end
+        Timeout.timeout(1) { File.read(path) }
+      rescue Timeout::Error
+        false
       end
 
+      private
+
       # in seconds
       def uptime
-        File.read(UptimePath).split[0].to_f
+        File.read(UPTIME_PATH).split[0].to_f
       end
 
       def stat

data/lib/god/task.rb

@@ -1,5 +1,4 @@
 module God
-
   class Task
     # Public: Gets/Sets the String name of the task.
     attr_accessor :name
@@ -33,7 +32,7 @@ module God
     attr_accessor :state, :behaviors, :metrics, :directory
 
     def initialize
-      @autostart ||= true
+      @autostart = true
 
       # initial state is unmonitored
       self.state = :unmonitored
@@ -42,7 +41,7 @@ module God
       self.behaviors = []
 
       # the list of conditions for each action
-      self.metrics = {nil => [], :unmonitored => [], :stop => []}
+      self.metrics = { nil => [], :unmonitored => [], :stop => [] }
 
       # the condition -> metric lookup
       self.directory = {}
@@ -55,8 +54,8 @@ module God
     #
     # Returns nothing.
     def prepare
-      self.valid_states.each do |state|
-        self.metrics[state] ||= []
+      valid_states.each do |state|
+        metrics[state] ||= []
       end
     end
 
@@ -67,21 +66,21 @@ module God
       valid = true
 
       # A name must be specified.
-      if self.name.nil?
+      if name.nil?
         valid = false
-        applog(self, :error, "No name String was specified.")
+        applog(self, :error, 'No name String was specified.')
       end
 
       # Valid states must be specified.
-      if self.valid_states.nil?
+      if valid_states.nil?
         valid = false
-        applog(self, :error, "No valid_states Array or Symbols was specified.")
+        applog(self, :error, 'No valid_states Array or Symbols was specified.')
       end
 
       # An initial state must be specified.
-      if self.initial_state.nil?
+      if initial_state.nil?
         valid = false
-        applog(self, :error, "No initial_state Symbol was specified.")
+        applog(self, :error, 'No initial_state Symbol was specified.')
       end
 
       valid
@@ -101,7 +100,7 @@ module God
     #
     # Returns the canonical Hash.
     def canonical_hash_form(to)
-      to.instance_of?(Symbol) ? {true => to} : to
+      to.instance_of?(Symbol) ? { true => to } : to
     end
 
     # Public: Define a transition handler which consists of a set of conditions
@@ -118,8 +117,8 @@ module God
 
       Array(start_states).each do |start_state|
         # Validate start state.
-        unless self.valid_states.include?(start_state)
-          abort "Invalid state :#{start_state}. Must be one of the symbols #{self.valid_states.map{|x| ":#{x}"}.join(', ')}"
+        unless valid_states.include?(start_state)
+          abort "Invalid state :#{start_state}. Must be one of the symbols #{valid_states.map { |x| ":#{x}" }.join(', ')}"
         end
 
         # Create a new metric to hold the task, end states, and conditions.
@@ -137,12 +136,12 @@ module God
 
         # Populate the condition -> metric directory.
         m.conditions.each do |c|
-          self.directory[c] = m
+          directory[c] = m
         end
 
         # Record the metric.
-        self.metrics[start_state] ||= []
-        self.metrics[start_state] << m
+        metrics[start_state] ||= []
+        metrics[start_state] << m
       end
     end
 
@@ -159,11 +158,11 @@ module God
 
       # Populate the condition -> metric directory.
       m.conditions.each do |c|
-        self.directory[c] = m
+        directory[c] = m
       end
 
       # Record the metric.
-      self.metrics[nil] << m
+      metrics[nil] << m
     end
 
     ###########################################################################
@@ -176,14 +175,14 @@ module God
     #
     # Returns nothing.
     def monitor
-      self.move(self.initial_state)
+      move(initial_state)
     end
 
     # Disable monitoring.
     #
     # Returns nothing.
     def unmonitor
-      self.move(:unmonitored)
+      move(:unmonitored)
     end
 
     # Move to the given state.
@@ -192,40 +191,31 @@ module God
     #
     # Returns this Task.
     def move(to_state)
-      if !self.driver.in_driver_context?
-        # Called from outside Driver. Send an async message to Driver.
-        self.driver.message(:move, [to_state])
-      else
+      if driver.in_driver_context?
         # Called from within Driver. Record original info.
         orig_to_state = to_state
-        from_state = self.state
+        from_state = state
 
         # Log.
-        msg = "#{self.name} move '#{from_state}' to '#{to_state}'"
+        msg = "#{name} move '#{from_state}' to '#{to_state}'"
         applog(self, :info, msg)
 
         # Cleanup from current state.
-        self.driver.clear_events
-        self.metrics[from_state].each { |m| m.disable }
-        if to_state == :unmonitored
-          self.metrics[nil].each { |m| m.disable }
-        end
+        driver.clear_events
+        metrics[from_state].each(&:disable)
+        metrics[nil].each(&:disable) if to_state == :unmonitored
 
         # Perform action.
-        self.action(to_state)
+        action(to_state)
 
         # Enable simple mode.
-        if [:start, :restart].include?(to_state) && self.metrics[to_state].empty?
-          to_state = :up
-        end
+        to_state = :up if [:start, :restart].include?(to_state) && metrics[to_state].empty?
 
         # Move to new state.
-        self.metrics[to_state].each { |m| m.enable }
+        metrics[to_state].each(&:enable)
 
         # If no from state, enable lifecycle metric.
-        if from_state == :unmonitored
-          self.metrics[nil].each { |m| m.enable }
-        end
+        metrics[nil].each(&:enable) if from_state == :unmonitored
 
         # Set state.
         self.state = to_state
@@ -234,8 +224,11 @@ module God
         Trigger.broadcast(self, :state_change, [from_state, orig_to_state])
 
         # Log.
-        msg = "#{self.name} moved '#{from_state}' to '#{to_state}'"
+        msg = "#{name} moved '#{from_state}' to '#{to_state}'"
         applog(self, :info, msg)
+      else
+        # Called from outside Driver. Send an async message to Driver.
+        driver.message(:move, [to_state])
       end
 
       self
@@ -247,7 +240,7 @@ module God
     #
     # Returns nothing.
     def trigger(condition)
-      self.driver.message(:handle_event, [condition])
+      driver.message(:handle_event, [condition])
     end
 
     def signal(sig)
@@ -261,49 +254,43 @@ module God
     ###########################################################################
 
     def method_missing(sym, *args)
-      unless (sym.to_s =~ /=$/)
-        super
-      end
+      super unless /=$/.match?(sym.to_s)
 
       base = sym.to_s.chop.intern
 
-      unless self.valid_states.include?(base)
-        super
-      end
+      super unless valid_states.include?(base)
 
       self.class.send(:attr_accessor, base)
-      self.send(sym, *args)
+      send(sym, *args)
     end
 
     # Perform the given action.
     #
-    # a - The Symbol action.
-    # c - The Condition.
+    # action - The Symbol action.
+    # condition - The Condition.
     #
     # Returns this Task.
-    def action(a, c = nil)
-      if !self.driver.in_driver_context?
+    def action(action, condition = nil)
+      if !driver.in_driver_context?
         # Called from outside Driver. Send an async message to Driver.
-        self.driver.message(:action, [a, c])
-      else
+        driver.message(:action, [action, condition])
+      elsif respond_to?(action)
         # Called from within Driver.
-        if self.respond_to?(a)
-          command = self.send(a)
-
-          case command
-            when String
-              msg = "#{self.name} #{a}: #{command}"
-              applog(self, :info, msg)
-
-              system(command)
-            when Proc
-              msg = "#{self.name} #{a}: lambda"
-              applog(self, :info, msg)
-
-              command.call
-            else
-              raise NotImplementedError
-          end
+        command = send(action)
+
+        case command
+        when String
+          msg = "#{name} #{action}: #{command}"
+          applog(self, :info, msg)
+
+          system(command)
+        when Proc
+          msg = "#{name} #{action}: lambda"
+          applog(self, :info, msg)
+
+          command.call
+        else
+          raise NotImplementedError
         end
       end
     end
@@ -316,19 +303,19 @@ module God
 
     def attach(condition)
       case condition
-        when PollCondition
-          self.driver.schedule(condition, 0)
-        when EventCondition, TriggerCondition
-          condition.register
+      when PollCondition
+        driver.schedule(condition, 0)
+      when EventCondition, TriggerCondition
+        condition.register
       end
     end
 
     def detach(condition)
       case condition
-        when PollCondition
-          condition.reset
-        when EventCondition, TriggerCondition
-          condition.deregister
+      when PollCondition
+        condition.reset
+      when EventCondition, TriggerCondition
+        condition.deregister
       end
     end
 
@@ -360,55 +347,53 @@ module God
     # Returns nothing.
     def handle_poll(condition)
       # Lookup metric.
-      metric = self.directory[condition]
+      metric = directory[condition]
 
       # Run the test.
       begin
         result = condition.test
       rescue Object => e
         cname = condition.class.to_s.split('::').last
-        message = format("Unhandled exception in %s condition - (%s): %s\n%s",
-                         cname, e.class, e.message, e.backtrace.join("\n"))
+        message = format("Unhandled exception in %{cname} condition - (%{class}): %{message}\n%{backtrace}",
+                         cname: cname, class: e.class, message: e.message, backtrace: e.backtrace.join("\n"))
         applog(self, :error, message)
         result = false
       end
 
       # Log.
-      messages = self.log_line(self, metric, condition, result)
+      messages = log_line(self, metric, condition, result)
 
       # Notify.
-      if result && condition.notify
-        self.notify(condition, messages.last)
-      end
+      notify(condition, messages.last) if result && condition.notify
 
       # After-condition.
       condition.after
 
       # Get the destination.
       dest =
-      if result && condition.transition
-        # Condition override.
-        condition.transition
-      else
-        # Regular.
-        metric.destination && metric.destination[result]
-      end
+        if result && condition.transition
+          # Condition override.
+          condition.transition
+        else
+          # Regular.
+          metric.destination && metric.destination[result]
+        end
 
       # Transition or reschedule.
       if dest
         # Transition.
         begin
-          self.move(dest)
+          move(dest)
         rescue EventRegistrationFailedError
-          msg = self.name + ' Event registration failed, moving back to previous state'
+          msg = "#{name} Event registration failed, moving back to previous state"
           applog(self, :info, msg)
 
-          dest = self.state
+          dest = state
           retry
         end
       else
         # Reschedule.
-        self.driver.schedule(condition)
+        driver.schedule(condition)
       end
     end
 
@@ -420,29 +405,20 @@ module God
     # Returns nothing.
     def handle_event(condition)
       # Lookup metric.
-      metric = self.directory[condition]
+      metric = directory[condition]
 
       # Log.
-      messages = self.log_line(self, metric, condition, true)
+      messages = log_line(self, metric, condition, true)
 
       # Notify.
-      if condition.notify
-        self.notify(condition, messages.last)
-      end
+      notify(condition, messages.last) if condition.notify
 
       # Get the destination.
-      dest =
-      if condition.transition
-        # Condition override.
-        condition.transition
-      else
-        # Regular.
-        metric.destination && metric.destination[true]
-      end
+      dest = condition.transition || (metric.destination && metric.destination[true])
 
-      if dest
-        self.move(dest)
-      end
+      return unless dest
+
+      move(dest)
     end
 
     # Determine whether a trigger happened.
@@ -465,11 +441,11 @@ module God
     # Returns the Array of String messages.
     def log_line(watch, metric, condition, result)
       status =
-      if self.trigger?(metric, result)
-        "[trigger]"
-      else
-        "[ok]"
-      end
+        if trigger?(metric, result)
+          '[trigger]'
+        else
+          '[ok]'
+        end
 
       messages = []
 
@@ -485,7 +461,7 @@ module God
       end
 
       # Log.
-      debug_message = watch.name + ' ' + condition.base_name + " [#{result}] " + self.dest_desc(metric, condition)
+      debug_message = "#{watch.name} #{condition.base_name} [#{result}] #{dest_desc(metric, condition)}"
       applog(watch, :debug, debug_message)
 
       messages
@@ -499,13 +475,11 @@ module God
     # Returns the formatted String.
     def dest_desc(metric, condition)
       if condition.transition
-        {true => condition.transition}.inspect
+        { true => condition.transition }.inspect
+      elsif metric.destination
+        metric.destination.inspect
       else
-        if metric.destination
-          metric.destination.inspect
-        else
-          'none'
-        end
+        'none'
       end
     end
 
@@ -521,16 +495,16 @@ module God
 
       # Resolve contacts.
       resolved_contacts =
-      spec[:contacts].inject([]) do |acc, contact_name_or_group|
-        cons = Array(God.contacts[contact_name_or_group] || God.contact_groups[contact_name_or_group])
-        unmatched << contact_name_or_group if cons.empty?
-        acc += cons
-        acc
-      end
+        spec[:contacts].inject([]) do |acc, contact_name_or_group|
+          cons = Array(God.contacts[contact_name_or_group] || God.contact_groups[contact_name_or_group])
+          unmatched << contact_name_or_group if cons.empty?
+          acc += cons
+          acc
+        end
 
       # Warn about unmatched contacts.
       unless unmatched.empty?
-        msg = "#{condition.watch.name} no matching contacts for '#{unmatched.join(", ")}'"
+        msg = "#{condition.watch.name} no matching contacts for '#{unmatched.join(', ')}'"
         applog(condition.watch, :warn, msg)
       end
 
@@ -539,12 +513,12 @@ module God
         host = `hostname`.chomp rescue 'none'
         begin
           c.notify(message, Time.now, spec[:priority], spec[:category], host)
-          msg = "#{condition.watch.name} #{c.info ? c.info : "notification sent for contact: #{c.name}"} (#{c.base_name})"
-          applog(condition.watch, :info, msg % [])
+          msg = "#{condition.watch.name} #{c.info || "notification sent for contact: #{c.name}"} (#{c.base_name})"
+          applog(condition.watch, :info, msg)
         rescue Exception => e
           applog(condition.watch, :error, "#{e.message} #{e.backtrace}")
           msg = "#{condition.watch.name} Failed to deliver notification for contact: #{c.name} (#{c.base_name})"
-          applog(condition.watch, :error, msg % [])
+          applog(condition.watch, :error, msg)
         end
       end
     end

data/lib/god/timeline.rb

@@ -1,5 +1,4 @@
 module God
-
   class Timeline < Array
     # Instantiate a new Timeline
     #   +max_size+ is the maximum size to which the timeline should grow
@@ -15,11 +14,10 @@ module God
     #
     # Returns Timeline
     def push(val)
-      self.concat([val])
+      concat([val])
       shift if size > @max_size
     end
 
-    alias_method :<<, :push
+    alias << push
   end
-
 end

data/lib/god/trigger.rb

@@ -1,7 +1,5 @@
 module God
-
   class Trigger
-
     class << self
       attr_accessor :triggers # {task.name => condition}
     end
@@ -12,32 +10,30 @@ module God
 
     def self.register(condition)
       @mutex.synchronize do
-        self.triggers[condition.watch.name] ||= []
-        self.triggers[condition.watch.name] << condition
+        triggers[condition.watch.name] ||= []
+        triggers[condition.watch.name] << condition
       end
     end
 
     def self.deregister(condition)
       @mutex.synchronize do
-        self.triggers[condition.watch.name].delete(condition)
-        self.triggers.delete(condition.watch.name) if self.triggers[condition.watch.name].empty?
+        triggers[condition.watch.name].delete(condition)
+        triggers.delete(condition.watch.name) if triggers[condition.watch.name].empty?
       end
     end
 
     def self.broadcast(task, message, payload)
-      return unless self.triggers[task.name]
+      return unless triggers[task.name]
 
       @mutex.synchronize do
-        self.triggers[task.name].each do |t|
+        triggers[task.name].each do |t|
           t.process(message, payload)
         end
       end
     end
 
     def self.reset
-      self.triggers.clear
+      triggers.clear
     end
-
   end
-
 end

data/lib/god/version.rb

@@ -1,4 +1,4 @@
 module God
   # The String version number for this package.
-  VERSION = '0.14.0'.freeze
+  VERSION = '1.0.0'.freeze
 end