resurrected_god 0.14.0 → 1.0.0

data/lib/god/watch.rb

@@ -6,9 +6,9 @@ module God
   # workflows. It has four states: init, up, start, and restart.
   class Watch < Task
     # The Array of Symbol valid task states.
-    VALID_STATES = [:init, :up, :start, :restart]
+    VALID_STATES = [:init, :up, :start, :restart].freeze
 
-    # The Sybmol initial state.
+    # The Symbol initial state.
     INITIAL_STATE = :init
 
     # Public: The grace period for this process (seconds).
@@ -26,13 +26,13 @@ module God
     # Public: God::Process delegators. See lib/god/process.rb for docs.
     extend Forwardable
     def_delegators :@process, :name, :uid, :gid, :start, :stop, :restart, :dir,
-                              :name=, :uid=, :gid=, :start=, :stop=, :restart=,
-                              :dir=, :pid_file, :pid_file=, :log, :log=,
-                              :log_cmd, :log_cmd=, :err_log, :err_log=,
-                              :err_log_cmd, :err_log_cmd=, :alive?, :pid,
-                              :unix_socket, :unix_socket=, :chroot, :chroot=,
-                              :env, :env=, :signal, :stop_timeout=,
-                              :stop_signal=, :umask, :umask=
+                   :name=, :uid=, :gid=, :start=, :stop=, :restart=,
+                   :dir=, :pid_file, :pid_file=, :log, :log=,
+                   :log_cmd, :log_cmd=, :err_log, :err_log=,
+                   :err_log_cmd, :err_log_cmd=, :alive?, :pid,
+                   :unix_socket, :unix_socket=, :chroot, :chroot=,
+                   :env, :env=, :signal, :stop_timeout=,
+                   :stop_signal=, :umask, :umask=
 
     # Initialize a new Watch instance.
     def initialize
@@ -84,7 +84,7 @@ module God
       # out its own error messages by now.
       abort unless b.valid?
 
-      self.behaviors << b
+      behaviors << b
     end
 
     ###########################################################################
@@ -93,16 +93,16 @@ module God
     #
     ###########################################################################
 
-    # Default Integer interval at which keepalive will runn poll checks.
+    # Default Integer interval at which keepalive will run poll checks.
     DEFAULT_KEEPALIVE_INTERVAL = 5.seconds
 
     # Default Integer or Array of Integers specification of how many times the
     # memory condition must fail before triggering.
-    DEFAULT_KEEPALIVE_MEMORY_TIMES = [3, 5]
+    DEFAULT_KEEPALIVE_MEMORY_TIMES = [3, 5].freeze
 
     # Default Integer or Array of Integers specification of how many times the
     # CPU condition must fail before triggering.
-    DEFAULT_KEEPALIVE_CPU_TIMES = [3, 5]
+    DEFAULT_KEEPALIVE_CPU_TIMES = [3, 5].freeze
 
     # Public: A set of conditions for easily getting started with simple watch
     # scenarios. Keepalive is intended for use by beginners or on processes
@@ -127,7 +127,7 @@ module God
     #                           3 (three times), [3, 5] (three out of any five
     #                           checks). Default: [3, 5].
     #           :cpu_max      - The Integer CPU percentage max. Range is
-    #                           0 to 100. You may use the Numberic#percent
+    #                           0 to 100. You may use the Numeric#percent
     #                           sugar to clarify e.g. 50.percent.
     #           :cpu_times    - If :cpu_max is set, :cpu_times can be
     #                           set to either an Integer or a 2 element
@@ -137,25 +137,25 @@ module God
     #                           checks). Default: [3, 5].
     def keepalive(options = {})
       if God::EventHandler.loaded?
-        self.transition(:init, { true => :up, false => :start }) do |on|
+        transition(:init, { true => :up, false => :start }) do |on|
           on.condition(:process_running) do |c|
             c.interval = options[:interval] || DEFAULT_KEEPALIVE_INTERVAL
             c.running = true
           end
         end
 
-        self.transition([:start, :restart], :up) do |on|
+        transition([:start, :restart], :up) do |on|
           on.condition(:process_running) do |c|
             c.interval = options[:interval] || DEFAULT_KEEPALIVE_INTERVAL
             c.running = true
           end
         end
 
-        self.transition(:up, :start) do |on|
+        transition(:up, :start) do |on|
           on.condition(:process_exits)
         end
       else
-        self.start_if do |start|
+        start_if do |start|
           start.condition(:process_running) do |c|
             c.interval = options[:interval] || DEFAULT_KEEPALIVE_INTERVAL
             c.running = false
@@ -163,7 +163,7 @@ module God
         end
       end
 
-      self.restart_if do |restart|
+      restart_if do |restart|
         if options[:memory_max]
           restart.condition(:memory_usage) do |c|
             c.interval = options[:interval] || DEFAULT_KEEPALIVE_INTERVAL
@@ -193,10 +193,8 @@ module God
     # Yields the Metric upon which conditions can be added.
     #
     # Returns nothing.
-    def start_if
-      self.transition(:up, :start) do |on|
-        yield(on)
-      end
+    def start_if(&block)
+      transition(:up, :start, &block)
     end
 
     # Public: Restart the process if any of the given conditions are triggered.
@@ -204,10 +202,8 @@ module God
     # Yields the Metric upon which conditions can be added.
     #
     # Returns nothing.
-    def restart_if
-      self.transition(:up, :restart) do |on|
-        yield(on)
-      end
+    def restart_if(&block)
+      transition(:up, :restart, &block)
     end
 
     # Public: Stop the process if any of the given conditions are triggered.
@@ -215,10 +211,8 @@ module God
     # Yields the Metric upon which conditions can be added.
     #
     # Returns nothing.
-    def stop_if
-      self.transition(:up, :stop) do |on|
-        yield(on)
-      end
+    def stop_if(&block)
+      transition(:up, :stop, &block)
     end
 
     ###########################################################################
@@ -231,10 +225,10 @@ module God
     #
     # Returns nothing.
     def monitor
-      if !self.metrics[:init].empty?
-        self.move(:init)
+      if metrics[:init].empty?
+        move(:up)
       else
-        self.move(:up)
+        move(:init)
       end
     end
 
@@ -246,32 +240,32 @@ module God
 
     # Perform an action.
     #
-    # a - The Symbol action to perform. One of :start, :restart, :stop.
-    # c - The Condition.
+    # action - The Symbol action to perform. One of :start, :restart, :stop.
+    # condition - The Condition.
     #
     # Returns this Watch.
-    def action(a, c = nil)
-      if !self.driver.in_driver_context?
-        # Called from outside Driver. Send an async message to Driver.
-        self.driver.message(:action, [a, c])
-      else
+    def action(action, condition = nil)
+      if driver.in_driver_context?
         # Called from within Driver.
-        case a
+        case action
         when :start
-          call_action(c, :start)
-          sleep(self.start_grace + self.grace)
+          call_action(condition, :start)
+          sleep(start_grace + grace)
         when :restart
-          if self.restart
-            call_action(c, :restart)
+          if restart
+            call_action(condition, :restart)
           else
-            action(:stop, c)
-            action(:start, c)
+            action(:stop, condition)
+            action(:start, condition)
           end
-          sleep(self.restart_grace + self.grace)
+          sleep(restart_grace + grace)
         when :stop
-          call_action(c, :stop)
-          sleep(self.stop_grace + self.grace)
+          call_action(condition, :stop)
+          sleep(stop_grace + grace)
         end
+      else
+        # Called from outside Driver. Send an async message to Driver.
+        driver.message(:action, [action, condition])
       end
 
       self
@@ -285,19 +279,19 @@ module God
     # Returns nothing.
     def call_action(condition, action)
       # Before.
-      before_items = self.behaviors
+      before_items = behaviors
       before_items += [condition] if condition
       before_items.each do |b|
         info = b.send("before_#{action}")
         if info
-          msg = "#{self.name} before_#{action}: #{info} (#{b.base_name})"
+          msg = "#{name} before_#{action}: #{info} (#{b.base_name})"
           applog(self, :info, msg)
         end
       end
 
       # Log.
-      if self.send(action)
-        msg = "#{self.name} #{action}: #{self.send(action).to_s}"
+      if send(action)
+        msg = "#{name} #{action}: #{send(action)}"
         applog(self, :info, msg)
       end
 
@@ -305,12 +299,12 @@ module God
       @process.call_action(action)
 
       # After.
-      after_items = self.behaviors
+      after_items = behaviors
       after_items += [condition] if condition
       after_items.each do |b|
         info = b.send("after_#{action}")
         if info
-          msg = "#{self.name} after_#{action}: #{info} (#{b.base_name})"
+          msg = "#{name} after_#{action}: #{info} (#{b.base_name})"
           applog(self, :info, msg)
         end
       end