resurrected_god 0.14.0 → 1.0.0

data/lib/god/conditions/flapping.rb

@@ -1,13 +1,12 @@
 module God
   module Conditions
-
     # Condition Symbol :flapping
     # Type: Trigger
     #
     # Trigger when a Task transitions to or from a state or states a given number
     # of times within a given period.
     #
-    # Paramaters
+    # Parameters
     #   Required
     #     +times+ is the number of times that the Task must transition before
     #             triggering.
@@ -17,7 +16,7 @@ module God
     #              your code (see examples).
     #     --one or both of--
     #     +from_state+ is the state (as a Symbol) from which the transition must occur.
-    #     +to_state is the state (as a Symbol) to which the transition must occur.
+    #     +to_state+ is the state (as a Symbol) to which the transition must occur.
     #
     #   Optional:
     #     +retry_in+ is the number of seconds after which to re-monitor the Task after
@@ -39,90 +38,86 @@ module God
                     :retry_within
 
       def initialize
-        self.info = "process is flapping"
+        super
+        self.info = 'process is flapping'
       end
 
       def prepare
-        @timeline = Timeline.new(self.times)
-        @retry_timeline = Timeline.new(self.retry_times)
+        @timeline = Timeline.new(times)
+        @retry_timeline = Timeline.new(retry_times)
       end
 
       def valid?
         valid = true
-        valid &= complain("Attribute 'times' must be specified", self) if self.times.nil?
-        valid &= complain("Attribute 'within' must be specified", self) if self.within.nil?
-        valid &= complain("Attributes 'from_state', 'to_state', or both must be specified", self) if self.from_state.nil? && self.to_state.nil?
+        valid &= complain("Attribute 'times' must be specified", self) if times.nil?
+        valid &= complain("Attribute 'within' must be specified", self) if within.nil?
+        valid &= complain("Attributes 'from_state', 'to_state', or both must be specified", self) if from_state.nil? && to_state.nil?
         valid
       end
 
       def process(event, payload)
-        begin
-          if event == :state_change
-            event_from_state, event_to_state = *payload
+        return if event != :state_change
+
+        event_from_state, event_to_state = *payload
 
-            from_state_match = !self.from_state || self.from_state && Array(self.from_state).include?(event_from_state)
-            to_state_match = !self.to_state || self.to_state && Array(self.to_state).include?(event_to_state)
+        from_state_match = !from_state || Array(from_state).include?(event_from_state)
+        to_state_match = !to_state || Array(to_state).include?(event_to_state)
 
-            if from_state_match && to_state_match
-              @timeline << Time.now
+        if from_state_match && to_state_match
+          @timeline << Time.now
 
-              concensus = (@timeline.size == self.times)
-              duration = (@timeline.last - @timeline.first) < self.within
+          consensus = (@timeline.size == times)
+          duration = (@timeline.last - @timeline.first) < within
 
-              if concensus && duration
-                @timeline.clear
-                trigger
-                retry_mechanism
-              end
-            end
+          if consensus && duration
+            @timeline.clear
+            trigger
+            retry_mechanism
           end
-        rescue => e
-          puts e.message
-          puts e.backtrace.join("\n")
         end
+      rescue => e
+        puts e.message
+        puts e.backtrace.join("\n")
       end
 
       private
 
       def retry_mechanism
-        if self.retry_in
-          @retry_timeline << Time.now
-
-          concensus = (@retry_timeline.size == self.retry_times)
-          duration = (@retry_timeline.last - @retry_timeline.first) < self.retry_within
-
-          if concensus && duration
-            # give up
-            Thread.new do
-              sleep 1
-
-              # log
-              msg = "#{self.watch.name} giving up"
-              applog(self.watch, :info, msg)
-            end
-          else
-            # try again later
-            Thread.new do
-              sleep 1
-
-              # log
-              msg = "#{self.watch.name} auto-reenable monitoring in #{self.retry_in} seconds"
-              applog(self.watch, :info, msg)
-
-              sleep self.retry_in
-
-              # log
-              msg = "#{self.watch.name} auto-reenabling monitoring"
-              applog(self.watch, :info, msg)
-
-              if self.watch.state == :unmonitored
-                self.watch.monitor
-              end
-            end
+        return unless retry_in
+
+        @retry_timeline << Time.now
+
+        consensus = (@retry_timeline.size == retry_times)
+        duration = (@retry_timeline.last - @retry_timeline.first) < retry_within
+
+        if consensus && duration
+          # give up
+          Thread.new do
+            sleep 1
+
+            # log
+            msg = "#{watch.name} giving up"
+            applog(watch, :info, msg)
+          end
+        else
+          # try again later
+          Thread.new do
+            sleep 1
+
+            # log
+            msg = "#{watch.name} auto-reenable monitoring in #{retry_in} seconds"
+            applog(watch, :info, msg)
+
+            sleep retry_in
+
+            # log
+            msg = "#{watch.name} auto-reenabling monitoring"
+            applog(watch, :info, msg)
+
+            watch.monitor if watch.state == :unmonitored
           end
         end
       end
     end
-
   end
 end

data/lib/god/conditions/http_response_code.rb

@@ -3,13 +3,12 @@ require 'net/https'
 
 module God
   module Conditions
-
     # Condition Symbol :http_response_code
     # Type: Poll
     #
     # Trigger based on the response from an HTTP request.
     #
-    # Paramaters
+    # Parameters
     #   Required
     #     +host+ is the hostname to connect [required]
     #     --one of code_is or code_is_not--
@@ -88,15 +87,13 @@ module God
       end
 
       def prepare
-        self.code_is = Array(self.code_is).map { |x| x.to_i } if self.code_is
-        self.code_is_not = Array(self.code_is_not).map { |x| x.to_i } if self.code_is_not
+        self.code_is = Array(code_is).map(&:to_i) if code_is
+        self.code_is_not = Array(code_is_not).map(&:to_i) if code_is_not
 
-        if self.times.kind_of?(Integer)
-          self.times = [self.times, self.times]
-        end
+        self.times = [times, times] if times.is_a?(Integer)
 
-        @timeline = Timeline.new(self.times[1])
-        @history = Timeline.new(self.times[1])
+        @timeline = Timeline.new(times[1])
+        @history = Timeline.new(times[1])
       end
 
       def reset
@@ -106,57 +103,57 @@ module God
 
       def valid?
         valid = true
-        valid &= complain("Attribute 'host' must be specified", self) if self.host.nil?
+        valid &= complain("Attribute 'host' must be specified", self) if host.nil?
         valid &= complain("One (and only one) of attributes 'code_is' and 'code_is_not' must be specified", self) if
-          (self.code_is.nil? && self.code_is_not.nil?) || (self.code_is && self.code_is_not)
+          (code_is.nil? && code_is_not.nil?) || (code_is && code_is_not)
         valid
       end
 
       def test
         response = nil
 
-        connection = Net::HTTP.new(self.host, self.port)
-        connection.use_ssl = self.port == 443 ? true : self.ssl
+        connection = Net::HTTP.new(host, port)
+        connection.use_ssl = port == 443 ? true : ssl
         connection.verify_mode = OpenSSL::SSL::VERIFY_NONE if connection.use_ssl?
 
-        if connection.use_ssl? && self.ca_file
-          pem = File.read(self.ca_file)
-          connection.ca_file = self.ca_file
+        if connection.use_ssl? && ca_file
+          File.read(ca_file) # it may raise EOFError
+          connection.ca_file = ca_file
           connection.verify_mode = OpenSSL::SSL::VERIFY_PEER
         end
 
         connection.start do |http|
-          http.read_timeout = self.timeout
-          response = http.get(self.path, self.headers)
+          http.read_timeout = timeout
+          response = http.get(path, headers)
         end
 
         actual_response_code = response.code.to_i
-        if self.code_is && self.code_is.include?(actual_response_code)
+        if code_is&.include?(actual_response_code)
           pass(actual_response_code)
-        elsif self.code_is_not && !self.code_is_not.include?(actual_response_code)
+        elsif code_is_not && !code_is_not.include?(actual_response_code)
           pass(actual_response_code)
         else
           fail(actual_response_code)
         end
       rescue Errno::ECONNREFUSED
-        self.code_is ? fail('Refused') : pass('Refused')
+        code_is ? fail('Refused') : pass('Refused')
       rescue Errno::ECONNRESET
-        self.code_is ? fail('Reset') : pass('Reset')
+        code_is ? fail('Reset') : pass('Reset')
       rescue EOFError
-        self.code_is ? fail('EOF') : pass('EOF')
+        code_is ? fail('EOF') : pass('EOF')
       rescue Timeout::Error
-        self.code_is ? fail('Timeout') : pass('Timeout')
+        code_is ? fail('Timeout') : pass('Timeout')
       rescue Errno::ETIMEDOUT
-        self.code_is ? fail('Timedout') : pass('Timedout')
-      rescue Exception => failure
-        self.code_is ? fail(failure.class.name) : pass(failure.class.name)
+        code_is ? fail('Timedout') : pass('Timedout')
+      rescue Exception => e
+        code_is ? fail(e.class.name) : pass(e.class.name)
       end
 
       private
 
       def pass(code)
         @timeline << true
-        if @timeline.select { |x| x }.size >= self.times.first
+        if @timeline.count { |x| x } >= times.first
           self.info = "http response abnormal #{history(code, true)}"
           true
         else
@@ -173,12 +170,10 @@ module God
 
       def history(code, passed)
         entry = code.to_s.dup
-        entry = '*' + entry if passed
+        entry = "*#{entry}" if passed
         @history << entry
-        '[' + @history.join(", ") + ']'
+        "[#{@history.join(', ')}]"
       end
-
     end
-
   end
 end

data/lib/god/conditions/lambda.rb

@@ -1,6 +1,5 @@
 module God
   module Conditions
-
     class Lambda < PollCondition
       attr_accessor :lambda
 
@@ -11,15 +10,14 @@ module God
       end
 
       def test
-        if self.lambda.call()
-          self.info = "lambda condition was satisfied"
+        if self.lambda.call
+          self.info = 'lambda condition was satisfied'
           true
         else
-          self.info = "lambda condition was not satisfied"
+          self.info = 'lambda condition was not satisfied'
           false
         end
       end
     end
-
   end
 end

data/lib/god/conditions/memory_usage.rb

@@ -1,12 +1,11 @@
 module God
   module Conditions
-
     # Condition Symbol :memory_usage
     # Type: Poll
     #
     # Trigger when the resident memory of a process is above a specified limit.
     #
-    # Paramaters
+    # Parameters
     #   Required
     #     +pid_file+ is the pid file of the process in question. Automatically
     #                populated for Watches.
@@ -40,11 +39,9 @@ module God
       end
 
       def prepare
-        if self.times.kind_of?(Integer)
-          self.times = [self.times, self.times]
-        end
+        self.times = [times, times] if times.is_a?(Integer)
 
-        @timeline = Timeline.new(self.times[1])
+        @timeline = Timeline.new(times[1])
       end
 
       def reset
@@ -52,31 +49,30 @@ module God
       end
 
       def pid
-        self.pid_file ? File.read(self.pid_file).strip.to_i : self.watch.pid
+        pid_file ? File.read(pid_file).strip.to_i : watch.pid
       end
 
       def valid?
         valid = true
-        valid &= complain("Attribute 'pid_file' must be specified", self) if self.pid_file.nil? && self.watch.pid_file.nil?
-        valid &= complain("Attribute 'above' must be specified", self) if self.above.nil?
+        valid &= complain("Attribute 'pid_file' must be specified", self) if pid_file.nil? && watch.pid_file.nil?
+        valid &= complain("Attribute 'above' must be specified", self) if above.nil?
         valid
       end
 
       def test
-        process = System::Process.new(self.pid)
+        process = System::Process.new(pid)
         @timeline.push(process.memory)
         self.info = []
 
-        history = "[" + @timeline.map { |x| "#{x > self.above ? '*' : ''}#{x}kb" }.join(", ") + "]"
+        history = @timeline.map { |x| "#{x > above ? '*' : ''}#{x}kb" }.join(', ')
 
-        if @timeline.select { |x| x > self.above }.size >= self.times.first
-          self.info = "memory out of bounds #{history}"
-          return true
+        if @timeline.count { |x| x > above } >= times.first
+          self.info = "memory out of bounds [#{history}]"
+          true
         else
-          return false
+          false
         end
       end
     end
-
   end
 end

data/lib/god/conditions/process_exits.rb

@@ -20,7 +20,8 @@ module God
       attr_accessor :pid_file
 
       def initialize
-        self.info = "process exited"
+        super
+        self.info = 'process exited'
       end
 
       def valid?
@@ -28,7 +29,7 @@ module God
       end
 
       def pid
-        self.pid_file ? File.read(self.pid_file).strip.to_i : self.watch.pid
+        pid_file ? File.read(pid_file).strip.to_i : watch.pid
       end
 
       def register
@@ -36,15 +37,15 @@ module God
 
         begin
           EventHandler.register(pid, :proc_exit) do |extra|
-            formatted_extra = extra.size > 0 ? " #{extra.inspect}" : ""
+            formatted_extra = extra.empty? ? '' : " #{extra.inspect}"
             self.info = "process #{pid} exited#{formatted_extra}"
-            self.watch.trigger(self)
+            watch.trigger(self)
           end
 
-          msg = "#{self.watch.name} registered 'proc_exit' event for pid #{pid}"
-          applog(self.watch, :info, msg)
+          msg = "#{watch.name} registered 'proc_exit' event for pid #{pid}"
+          applog(watch, :info, msg)
         rescue StandardError
-          raise EventRegistrationFailedError.new
+          raise EventRegistrationFailedError
         end
       end
 
@@ -53,14 +54,13 @@ module God
         if pid
           EventHandler.deregister(pid, :proc_exit)
 
-          msg = "#{self.watch.name} deregistered 'proc_exit' event for pid #{pid}"
-          applog(self.watch, :info, msg)
+          msg = "#{watch.name} deregistered 'proc_exit' event for pid #{pid}"
+          applog(watch, :info, msg)
         else
-          pid_file_location = self.pid_file || self.watch.pid_file
-          applog(self.watch, :error, "#{self.watch.name} could not deregister: no cached PID or PID file #{pid_file_location} (#{self.base_name})")
+          pid_file_location = pid_file || watch.pid_file
+          applog(watch, :error, "#{watch.name} could not deregister: no cached PID or PID file #{pid_file_location} (#{base_name})")
         end
       end
     end
-
   end
 end

data/lib/god/conditions/process_running.rb

@@ -29,13 +29,13 @@ module God
       attr_accessor :pid_file
 
       def pid
-        self.pid_file ? File.read(self.pid_file).strip.to_i : self.watch.pid
+        pid_file ? File.read(pid_file).strip.to_i : watch.pid
       end
 
       def valid?
         valid = true
-        valid &= complain("Attribute 'pid_file' must be specified", self) if self.pid_file.nil? && self.watch.pid_file.nil?
-        valid &= complain("Attribute 'running' must be specified", self) if self.running.nil?
+        valid &= complain("Attribute 'pid_file' must be specified", self) if pid_file.nil? && watch.pid_file.nil?
+        valid &= complain("Attribute 'running' must be specified", self) if running.nil?
         valid
       end
 
@@ -45,16 +45,14 @@ module God
         pid = self.pid
         active = pid && System::Process.new(pid).exists?
 
-        if (self.running && active)
-          self.info.concat(["process is running"])
+        if running && active
+          info.concat(['process is running'])
           true
-        elsif (!self.running && !active)
-          self.info.concat(["process is not running"])
+        elsif !running && !active
+          info.concat(['process is not running'])
           true
         else
-          if self.running
-            self.info.concat(["process is not running"])
-          end
+          info.concat(['process is not running']) if running
           false
         end
       end

data/lib/god/conditions/socket_responding.rb

@@ -72,12 +72,10 @@ module God
       end
 
       def prepare
-        if self.times.kind_of?(Integer)
-          self.times = [self.times, self.times]
-        end
+        self.times = [times, times] if times.is_a?(Integer)
 
-        @timeline = Timeline.new(self.times[1])
-        @history = Timeline.new(self.times[1])
+        @timeline = Timeline.new(times[1])
+        @history = Timeline.new(times[1])
       end
 
       def reset
@@ -85,15 +83,15 @@ module God
         @history.clear
       end
 
-      def socket=(s)
-        components = s.split(':')
+      def socket=(socket)
+        components = socket.split(':')
         if components.size == 3
-          @family,@addr,@port = components
+          @family, @addr, @port = components
           @port = @port.to_i
-        elsif components[0] =~ /^tcp$/
+        elsif /^tcp$/.match?(components[0])
           @family = components[0]
           @port = components[1].to_i
-        elsif components[0] =~ /^unix$/
+        elsif /^unix$/.match?(components[0])
           @family = components[0]
           @path = components[1]
         end
@@ -101,40 +99,37 @@ module God
 
       def valid?
         valid = true
-        if self.family == 'tcp' and @port == 0
-          valid &= complain("Attribute 'port' must be specified for tcp sockets", self)
-        end
-        if self.family == 'unix' and self.path.nil?
-          valid &= complain("Attribute 'path' must be specified for unix sockets", self)
-        end
-        valid = false unless %w{tcp unix}.member?(self.family)
+        valid &= complain("Attribute 'port' must be specified for tcp sockets", self) if family == 'tcp' && @port == 0
+        valid &= complain("Attribute 'path' must be specified for unix sockets", self) if family == 'unix' && path.nil?
+        valid = false unless %w[tcp unix].member?(family)
         valid
       end
 
       def test
         self.info = []
-        if self.family == 'tcp'
+        case family
+        when 'tcp'
           begin
-            s = TCPSocket.new(self.addr, self.port)
+            s = TCPSocket.new(addr, port)
           rescue SystemCallError
           end
-          status = self.responding == !s.nil?
-        elsif self.family == 'unix'
+          status = responding != s.nil?
+        when 'unix'
           begin
-            s = UNIXSocket.new(self.path)
+            s = UNIXSocket.new(path)
           rescue SystemCallError
           end
-          status = self.responding == !s.nil?
+          status = responding != s.nil?
         else
           status = false
         end
         @timeline.push(status)
-        history = "[" + @timeline.map {|t| t ? '*' : ''}.join(',') + "]"
-        if @timeline.select { |x| x }.size >= self.times.first
-          self.info = "socket out of bounds #{history}"
-          return true
+        history = @timeline.map { |t| t ? '*' : '' }.join(',')
+        if @timeline.count { |x| x } >= times.first
+          self.info = "socket out of bounds [#{history}]"
+          true
         else
-          return false
+          false
         end
       end
     end

data/lib/god/conditions/tries.rb

@@ -1,11 +1,10 @@
 module God
   module Conditions
-
     class Tries < PollCondition
       attr_accessor :times, :within
 
       def prepare
-        @timeline = Timeline.new(self.times)
+        @timeline = Timeline.new(times)
       end
 
       def reset
@@ -14,31 +13,30 @@ module God
 
       def valid?
         valid = true
-        valid &= complain("Attribute 'times' must be specified", self) if self.times.nil?
+        valid &= complain("Attribute 'times' must be specified", self) if times.nil?
         valid
       end
 
       def test
         @timeline << Time.now
 
-        concensus = (@timeline.size == self.times)
-        duration = self.within.nil? || (@timeline.last - @timeline.first) < self.within
+        consensus = (@timeline.size == times)
+        duration = within.nil? || (@timeline.last - @timeline.first) < within
 
-        if within
-          history = "[#{@timeline.size}/#{self.times} within #{(@timeline.last - @timeline.first).to_i}s]"
-        else
-          history = "[#{@timeline.size}/#{self.times}]"
-        end
+        history = if within
+                    "[#{@timeline.size}/#{times} within #{(@timeline.last - @timeline.first).to_i}s]"
+                  else
+                    "[#{@timeline.size}/#{times}]"
+                  end
 
-        if concensus && duration
+        if consensus && duration
           self.info = "tries exceeded #{history}"
-          return true
+          true
         else
           self.info = "tries within bounds #{history}"
-          return false
+          false
         end
       end
     end
-
   end
 end