eye 0.7 → 0.8.celluloid15

data/lib/eye/process/trigger.rb

@@ -1,11 +1,7 @@
 module Eye::Process::Trigger
 
   def add_triggers
-    if self[:triggers]
-      self[:triggers].each do |type, cfg|
-        add_trigger(cfg)
-      end
-    end
+    (self[:triggers] || {}).each { |_type, cfg| add_trigger(cfg) }
   end
 
   def remove_triggers

data/lib/eye/process/watchers.rb

@@ -11,6 +11,12 @@ module Eye::Process::Watchers
         check_alive
       end
 
+      if self[:check_identity]
+        add_watcher(:check_identity, self[:check_identity_period]) do
+          check_identity
+        end
+      end
+
       # monitor children pids
       if self[:monitor_children]
         add_watcher(:check_children, self[:children_update_period]) do
@@ -26,7 +32,7 @@ module Eye::Process::Watchers
   end
 
   def remove_watchers
-    @watchers.each{|_, h| h[:timer].cancel }
+    @watchers.each { |_, h| h[:timer].cancel }
     @watchers = {}
   end
 
@@ -42,25 +48,22 @@ private
       block.call(subject)
     end
 
-    @watchers[type] ||= {:timer => timer, :subject => subject}
+    @watchers[type] ||= { timer: timer, subject: subject }
   end
 
   def start_checkers
-    self[:checks].each{|name, cfg| start_checker(name, cfg) }
+    self[:checks].each { |name, cfg| start_checker(name, cfg) }
   end
 
   def start_checker(name, cfg)
+    # cfg: {:type => :memory, :every => 5.seconds, :below => 100.megabytes, :times => [3, 5]}
     subject = Eye::Checker.create(pid, cfg, current_actor)
-
-    # ex: {:type => :memory, :every => 5.seconds, :below => 100.megabytes, :times => [3,5]}
     add_watcher("check_#{name}".to_sym, subject.every, subject, &method(:watcher_tick).to_proc) if subject
   end
 
   def watcher_tick(subject)
-    unless subject.check
-      return unless up?
-      subject.fire
-    end
+    # double up? test needed because state can changed while subject.check
+    subject.fire if up? && !subject.check && up?
   end
 
 end

data/lib/eye/reason.rb

@@ -13,11 +13,14 @@ class Eye::Reason
   end
 
   class User < Eye::Reason
+
     def to_s
       "#{super} by user"
     end
+
   end
 
   class Flapping < Eye::Reason; end
   class StartingGuard < Eye::Reason; end
-end
+
+end

data/lib/eye/server.rb

@@ -1,7 +1,8 @@
-require 'celluloid/io'
 require 'celluloid/autostart'
+require 'celluloid/io'
 
 class Eye::Server
+
   include Celluloid::IO
 
   attr_reader :socket_path, :server
@@ -57,4 +58,4 @@ class Eye::Server
     unlink_socket_file
   end
 
-end
+end

data/lib/eye/system.rb

@@ -3,7 +3,9 @@ require 'etc'
 require 'timeout'
 
 module Eye::System
+
   class << self
+
     # Check that pid really exits
     # very fast
     # return result hash
@@ -14,17 +16,21 @@ module Eye::System
         false
       end
 
-      {:result => res}
+      { result: res }
     rescue => ex
-      {:error => ex}
+      { error: ex }
     end
 
     # Check that pid really exits
     # very fast
     # return true/false
     def pid_alive?(pid)
-      res = check_pid_alive(pid)
-      !!res[:result]
+      if pid
+        ::Process.kill(0, pid)
+        true
+      end
+    rescue
+      false
     end
 
     # Send signal to process (uses for kill)
@@ -39,13 +45,13 @@ module Eye::System
 
       if pid
         ::Process.kill(code, pid)
-        {:result => :ok}
+        { result: :ok }
       else
-        {:error => Exception.new('no_pid')}
+        { error: Exception.new('no_pid') }
       end
 
     rescue => ex
-      {:error => ex}
+      { error: ex }
     end
 
     # Daemonize cmd, and detach
@@ -55,12 +61,12 @@ module Eye::System
     #   :environment
     #   :stdin, :stdout, :stderr
     def daemonize(cmd, cfg = {})
-      pid = ::Process::spawn(prepare_env(cfg), *Shellwords.shellwords(cmd), spawn_options(cfg))
+      pid = ::Process.spawn(prepare_env(cfg), *Shellwords.shellwords(cmd), spawn_options(cfg))
 
-      {:pid => pid, :exitstatus => 0}
+      { pid: pid, exitstatus: 0 }
 
     rescue Errno::ENOENT, Errno::EACCES => ex
-      {:error => ex}
+      { error: ex }
 
     ensure
       Process.detach(pid) if pid
@@ -72,7 +78,7 @@ module Eye::System
     #   :environment
     #   :stdin, :stdout, :stderr
     def execute(cmd, cfg = {})
-      pid = ::Process::spawn(prepare_env(cfg), *Shellwords.shellwords(cmd), spawn_options(cfg))
+      pid = ::Process.spawn(prepare_env(cfg), *Shellwords.shellwords(cmd), spawn_options(cfg))
 
       timeout = cfg[:timeout] || 1.second
       status = 0
@@ -82,17 +88,17 @@ module Eye::System
         status = st.exitstatus || st.termsig
       end
 
-      {:pid => pid, :exitstatus => status}
+      { pid: pid, exitstatus: status }
 
     rescue Timeout::Error => ex
       if pid
         warn "[#{cfg[:name]}] sending :KILL signal to <#{pid}> due to timeout (#{timeout}s)"
         send_signal(pid, 9)
       end
-      {:error => ex}
+      { error: ex }
 
     rescue Errno::ENOENT, Errno::EACCES => ex
-      {:error => ex}
+      { error: ex }
 
     ensure
       Process.detach(pid) if pid
@@ -127,12 +133,13 @@ module Eye::System
     def prepare_env(config = {})
       env = {}
 
-      (config[:environment] || {}).each do |k,v|
+      (config[:environment] || {}).each do |k, v|
         env[k.to_s] = v && v.to_s
       end
 
       env
     end
+
   end
 
 end

data/lib/eye/system_resources.rb

@@ -45,7 +45,7 @@ class Eye::SystemResources
     end
 
     def deep_children(pid)
-      Array(pid_or_children(pid)).flatten.sort_by { |pid| -pid }
+      Array(pid_or_children(pid)).flatten.sort_by(&:-@)
     end
 
     def pid_or_children(pid)
@@ -57,20 +57,25 @@ class Eye::SystemResources
       end
     end
 
+    def args(pid)
+      Eye::Sigar.proc_args(pid).join(' ').strip rescue '-'
+    end
+
     def resources(pid)
-      { :memory => memory(pid),
-        :cpu => cpu(pid),
-        :start_time => start_time(pid),
-        :pid => pid
-      }
+      { memory: memory(pid),
+        cpu: cpu(pid),
+        start_time: start_time(pid),
+        pid: pid }
     end
 
     def cache
       Celluloid::Actor[:system_resources_cache]
     end
+
   end
 
   class Cache
+
     include Celluloid
 
     attr_reader :expire
@@ -95,13 +100,15 @@ class Eye::SystemResources
     def proc_mem(pid)
       @memory[pid] ||= Eye::Sigar.proc_mem(pid) if pid
 
-    rescue ArgumentError # when incorrect PID
+    rescue ArgumentError
+      # when incorrect PID, just skip
     end
 
     def proc_cpu(pid)
       @cpu[pid] ||= Eye::Sigar.proc_cpu(pid) if pid
 
-    rescue ArgumentError # when incorrect PID
+    rescue ArgumentError
+      # when incorrect PID, just skip
     end
 
     def children(pid)
@@ -111,8 +118,10 @@ class Eye::SystemResources
         []
       end
     end
+
   end
 
   # Setup global sigar singleton here
   Cache.supervise_as(:system_resources_cache)
+
 end

data/lib/eye/trigger.rb

@@ -1,4 +1,5 @@
 class Eye::Trigger
+
   include Eye::Dsl::Validation
 
   autoload :Flapping,   'eye/trigger/flapping'
@@ -8,19 +9,18 @@ class Eye::Trigger
   autoload :CheckDependency, 'eye/trigger/check_dependency'
   autoload :StartingGuard, 'eye/trigger/starting_guard'
 
-  TYPES = {:flapping => 'Flapping', :transition => 'Transition', :stop_children => 'StopChildren',
-    :wait_dependency => 'WaitDependency', :check_dependency => 'CheckDependency', :starting_guard => 'StartingGuard'
-  }
+  TYPES = { flapping: 'Flapping', transition: 'Transition', stop_children: 'StopChildren',
+            wait_dependency: 'WaitDependency', check_dependency: 'CheckDependency', starting_guard: 'StartingGuard' }
 
   attr_reader :message, :options, :process
 
   def self.name_and_class(type)
     type = type.to_sym
-    return {:name => type, :type => type} if TYPES[type]
+    return { name: type, type: type } if TYPES[type]
 
-    if type =~ /\A(.*?)_?[0-9]+\z/
-      ctype = $1.to_sym
-      return {:name => type, :type => ctype} if TYPES[ctype]
+    if type =~ %r[\A(.*?)_?[0-9]+\z]
+      ctype = Regexp.last_match(1).to_sym
+      return { name: type, type: ctype } if TYPES[ctype]
     end
   end
 
@@ -36,7 +36,7 @@ class Eye::Trigger
   def self.create(process, options = {})
     get_class(options[:type]).new(process, options)
 
-  rescue Exception, Timeout::Error => ex
+  rescue Object => ex
     log_ex(ex)
     nil
   end
@@ -72,7 +72,7 @@ class Eye::Trigger
 
     check(transition) if filter_transition(transition)
 
-  rescue Exception, Timeout::Error => ex
+  rescue Object => ex
     if ex.class == Eye::Process::StateError
       raise ex
     else
@@ -92,7 +92,7 @@ class Eye::Trigger
       compare_state(trans.event, event)
   end
 
-  def check(transition)
+  def check(_transition)
     raise NotImplementedError
   end
 
@@ -126,22 +126,24 @@ class Eye::Trigger
   end
 
   class Custom < Eye::Trigger
+
     def self.inherited(base)
       super
       register(base)
     end
+
   end
 
 private
 
   def compare_state(state_name, condition)
     case condition
-    when Symbol
-      state_name == condition
-    when Array
-      condition.include?(state_name)
-    else
-      true
+      when Symbol
+        state_name == condition
+      when Array
+        condition.include?(state_name)
+      else
+        true
     end
   end
 

data/lib/eye/trigger/check_dependency.rb

@@ -1,4 +1,5 @@
 class Eye::Trigger::CheckDependency < Eye::Trigger
+
   param :names, [Array], true, 5
 
   def check(transition)
@@ -10,14 +11,16 @@ private
   def check_dependency(to)
     processes = names.map do |name|
       Eye::Control.find_nearest_process(name, process.group_name_pure, process.app_name)
-    end.compact.select { |p| p.state_name != :unmonitored }
+    end
+
+    processes = processes.compact.select { |p| p.state_name != :unmonitored }
     return if processes.empty?
     processes = Eye::Utils::AliveArray.new(processes)
 
     act = case to
-      when :down, :restarting; :restart
-      when :stopping; :stop
-      when :unmonitored; :unmonitor
+      when :down, :restarting then :restart
+      when :stopping then :stop
+      when :unmonitored then :unmonitor
     end
 
     if act

data/lib/eye/trigger/flapping.rb

@@ -7,10 +7,12 @@ class Eye::Trigger::Flapping < Eye::Trigger
   param :within, [Float, Fixnum], true
   param :retry_in, [Float, Fixnum]
   param :retry_times, [Fixnum]
+  param :reretry_in, [Float, Fixnum]
+  param :reretry_times, [Fixnum]
 
   def initialize(*args)
     super
-    @flapping_times = 0
+    clear_counters
   end
 
   def check(transition)
@@ -19,9 +21,16 @@ class Eye::Trigger::Flapping < Eye::Trigger
 
 private
 
+  def clear_counters
+    @retry_times = 0
+    @reretry_times = 0
+  end
+
   def good?
-    states = process.states_history.states_for_period( within, @last_at )
-    down_count = states.count{|st| st == :down }
+    down_count = 0
+    process.states_history.states_for_period(within, @last_at) do |s|
+      down_count += 1 if s[:state] == :down
+    end
 
     if down_count >= times
       @last_at = process.states_history.last_state_changed_at
@@ -38,10 +47,18 @@ private
     process.schedule :unmonitor, Eye::Reason::Flapping.new(:flapping)
 
     return unless retry_in
-    return if retry_times && @flapping_times >= retry_times
-
-    @flapping_times += 1
-    process.schedule_in(retry_in.to_f, :conditional_start, Eye::Reason::Flapping.new('retry start after flapping'))
+    if !retry_times || (retry_times && @retry_times < retry_times)
+      @retry_times += 1
+      process.schedule_in(retry_in.to_f, :conditional_start, Eye::Reason::Flapping.new('retry start after flapping'))
+    else
+      if reretry_in
+        if !reretry_times || (reretry_times && @reretry_times < reretry_times)
+          @retry_times = 0
+          @reretry_times += 1
+          process.schedule_in(reretry_in.to_f, :conditional_start, Eye::Reason::Flapping.new('reretry start after flapping'))
+        end
+      end
+    end
   end
 
 end