eye 0.8.celluloid15 → 0.8.pre

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(&:-@)
+      Array(pid_or_children(pid)).flatten.sort_by { |pid| -pid }
     end
 
     def pid_or_children(pid)
@@ -57,25 +57,20 @@ 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
@@ -100,15 +95,13 @@ class Eye::SystemResources
     def proc_mem(pid)
       @memory[pid] ||= Eye::Sigar.proc_mem(pid) if pid
 
-    rescue ArgumentError
-      # when incorrect PID, just skip
+    rescue ArgumentError # when incorrect PID
     end
 
     def proc_cpu(pid)
       @cpu[pid] ||= Eye::Sigar.proc_cpu(pid) if pid
 
-    rescue ArgumentError
-      # when incorrect PID, just skip
+    rescue ArgumentError # when incorrect PID
     end
 
     def children(pid)
@@ -118,10 +111,8 @@ class Eye::SystemResources
         []
       end
     end
-
   end
 
   # Setup global sigar singleton here
-  Cache.supervise_as(:system_resources_cache)
-
+  Cache.supervise(as: :system_resources_cache)
 end

data/lib/eye/trigger.rb

@@ -1,5 +1,4 @@
 class Eye::Trigger
-
   include Eye::Dsl::Validation
 
   autoload :Flapping,   'eye/trigger/flapping'
@@ -9,18 +8,19 @@ 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 =~ %r[\A(.*?)_?[0-9]+\z]
-      ctype = Regexp.last_match(1).to_sym
-      return { name: type, type: ctype } if TYPES[ctype]
+    if type =~ /\A(.*?)_?[0-9]+\z/
+      ctype = $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 Object => ex
+  rescue Exception, Timeout::Error => ex
     log_ex(ex)
     nil
   end
@@ -72,7 +72,7 @@ class Eye::Trigger
 
     check(transition) if filter_transition(transition)
 
-  rescue Object => ex
+  rescue Exception, Timeout::Error => 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,24 +126,22 @@ 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,5 +1,4 @@
 class Eye::Trigger::CheckDependency < Eye::Trigger
-
   param :names, [Array], true, 5
 
   def check(transition)
@@ -11,16 +10,14 @@ private
   def check_dependency(to)
     processes = names.map do |name|
       Eye::Control.find_nearest_process(name, process.group_name_pure, process.app_name)
-    end
-
-    processes = processes.compact.select { |p| p.state_name != :unmonitored }
+    end.compact.select { |p| p.state_name != :unmonitored }
     return if processes.empty?
     processes = Eye::Utils::AliveArray.new(processes)
 
     act = case to
-      when :down, :restarting then :restart
-      when :stopping then :stop
-      when :unmonitored then :unmonitor
+      when :down, :restarting; :restart
+      when :stopping; :stop
+      when :unmonitored; :unmonitor
     end
 
     if act

data/lib/eye/trigger/flapping.rb

@@ -7,12 +7,10 @@ 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
-    clear_counters
+    @flapping_times = 0
   end
 
   def check(transition)
@@ -21,16 +19,9 @@ class Eye::Trigger::Flapping < Eye::Trigger
 
 private
 
-  def clear_counters
-    @retry_times = 0
-    @reretry_times = 0
-  end
-
   def good?
-    down_count = 0
-    process.states_history.states_for_period(within, @last_at) do |s|
-      down_count += 1 if s[:state] == :down
-    end
+    states = process.states_history.states_for_period( within, @last_at )
+    down_count = states.count{|st| st == :down }
 
     if down_count >= times
       @last_at = process.states_history.last_state_changed_at
@@ -47,18 +38,10 @@ private
     process.schedule :unmonitor, Eye::Reason::Flapping.new(:flapping)
 
     return unless retry_in
-    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
+    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'))
   end
 
 end

data/lib/eye/trigger/starting_guard.rb

@@ -33,33 +33,32 @@ class Eye::Trigger::StartingGuard < Eye::Trigger
       @reretry_count = 0
       return
     else
-      info 'false executed condition'
+      info "false executed condition"
     end
 
     new_time = nil
     if every
       if times
-        if @retry_count < times
+        if (@retry_count < times)
           new_time = Time.now + every
-          process.schedule_in every, :conditional_start, Eye::Reason::StartingGuard.new('starting_guard, retry start')
+          process.schedule_in every, :conditional_start, Eye::Reason::StartingGuard.new("starting_guard, retry start")
         else
           @retry_count = 0
           @reretry_count += 1
           if retry_in && (!retry_times || (@reretry_count < retry_times))
             new_time = Time.now + retry_in
-            process.schedule_in retry_in, :conditional_start, Eye::Reason::StartingGuard.new('starting_guard, reretry start')
+            process.schedule_in retry_in, :conditional_start, Eye::Reason::StartingGuard.new("starting_guard, reretry start")
           end
         end
       else
         new_time = Time.now + every
-        process.schedule_in every, :conditional_start, Eye::Reason::StartingGuard.new('starting_guard, retry start')
+        process.schedule_in every, :conditional_start, Eye::Reason::StartingGuard.new("starting_guard, retry start")
       end
     end
 
     retry_msg = new_time ? ", retry at '#{Eye::Utils.human_time2(new_time.to_i)}'" : ''
     process.switch :unmonitoring, Eye::Reason::StartingGuard.new("starting_guard, failed condition#{retry_msg}")
 
-    raise Eye::Process::StateError, 'starting_guard, refused to start'
+    raise Eye::Process::StateError.new("starting_guard, refused to start")
   end
-
 end

data/lib/eye/trigger/stop_children.rb

@@ -9,9 +9,9 @@ class Eye::Trigger::StopChildren < Eye::Trigger
   # default on stopped, crashed
   param_default :event, [:stopped, :crashed]
 
-  def check(_trans)
+  def check(trans)
     debug { 'stopping children' }
-    process.children.pmap { |_pid, c| c.stop }
+    process.children.pmap { |pid, c| c.stop }
   end
 
 end

data/lib/eye/trigger/transition.rb

@@ -4,7 +4,7 @@ class Eye::Trigger::Transition < Eye::Trigger
 
   param :do, [Proc, Symbol]
 
-  def check(_trans)
+  def check(trans)
     exec_proc :do
   end
 

data/lib/eye/trigger/wait_dependency.rb

@@ -1,5 +1,4 @@
 class Eye::Trigger::WaitDependency < Eye::Trigger
-
   param :names, [Array], true
   param :wait_timeout, [Numeric], nil, 15.seconds
   param :retry_after, [Numeric], nil, 1.minute
@@ -19,7 +18,7 @@ private
     processes = Eye::Utils::AliveArray.new(processes)
 
     processes.each do |p|
-      if p.state_name != :up && (should_start != false)
+      if p.state_name != :up && (should_start == nil || should_start)
         p.schedule :start, Eye::Reason.new(:start_dependency)
       end
     end
@@ -43,7 +42,7 @@ private
         process.schedule_in retry_after, :start, Eye::Reason.new(:wait_dependency)
       end
 
-      raise Eye::Process::StateError, 'stop transition because dependency is not up'
+      raise Eye::Process::StateError.new('stop transition because dependency is not up')
     end
   end
 

data/lib/eye/utils.rb

@@ -1,15 +1,14 @@
 require 'date'
 
 module Eye::Utils
-
   autoload :Tail,           'eye/utils/tail'
   autoload :AliveArray,     'eye/utils/alive_array'
   autoload :CelluloidChain, 'eye/utils/celluloid_chain'
 
   def self.deep_clone(value)
     case
-      when value.is_a?(Array) then value.map { |v| deep_clone(v) }
-      when value.is_a?(Hash) then value.each_with_object({}) { |(k, v), r| r[deep_clone(k)] = deep_clone(v) }
+      when value.is_a?(Array) then value.map{|v| deep_clone(v) }
+      when value.is_a?(Hash) then value.inject({}){|r, (k, v)| r[ deep_clone(k) ] = deep_clone(v); r }
       else value
     end
   end
@@ -48,7 +47,7 @@ module Eye::Utils
     env_vars = content.split("\n")
     h = {}
     env_vars.each do |e|
-      e = e.gsub(%r[#.+$], '').strip
+      e = e.gsub(/#.+$/, '').strip
       next unless e.include?('=')
       k, v = e.split('=', 2)
       h[k] = v

data/lib/eye/utils/alive_array.rb

@@ -1,21 +1,20 @@
 class Eye::Utils::AliveArray
-
   extend Forwardable
   include Enumerable
 
   def_delegators :@arr, :[], :<<, :clear, :delete, :size, :empty?, :push,
-                 :flatten, :present?, :uniq!, :select!
+                        :flatten, :present?, :uniq!, :select!
 
   def initialize(arr = [])
     @arr = arr
   end
 
   def each(&block)
-    @arr.each { |elem| elem && elem.alive? && block[elem] }
+    @arr.each{|elem| elem && elem.alive? && block[elem] }
   end
 
   def to_a
-    map { |x| x }
+    map{|x| x }
   end
 
   def full_size
@@ -34,10 +33,6 @@ class Eye::Utils::AliveArray
     self.class.new super
   end
 
-  def sort!
-    @arr.sort!
-  end
-
   def +(other)
     if other.is_a?(Eye::Utils::AliveArray)
       @arr += other.pure
@@ -59,4 +54,4 @@ class Eye::Utils::AliveArray
     end
   end
 
-end
+end

data/lib/eye/utils/celluloid_chain.rb

@@ -1,7 +1,6 @@
 require 'celluloid'
 
 class Eye::Utils::CelluloidChain
-
   include Celluloid
 
   def initialize(target)
@@ -11,21 +10,21 @@ class Eye::Utils::CelluloidChain
     @target_class = @target.class
   end
 
-  def add(method_name, *args)
-    @calls << { method_name: method_name, args: args }
+  def add(method_name, *args, &block)
+    @calls << {:method_name => method_name, :args => args, :block => block}
     ensure_process
   end
 
-  def add_wo_dups(method_name, *args)
-    h = { method_name: method_name, args: args }
+  def add_wo_dups(method_name, *args, &block)
+    h = {:method_name => method_name, :args => args, :block => block}
     if @calls[-1] != h
       @calls << h
       ensure_process
     end
   end
 
-  def add_wo_dups_current(method_name, *args)
-    h = { method_name: method_name, args: args }
+  def add_wo_dups_current(method_name, *args, &block)
+    h = {:method_name => method_name, :args => args, :block => block}
     if !@calls.include?(h) && @call != h
       @calls << h
       ensure_process
@@ -37,14 +36,14 @@ class Eye::Utils::CelluloidChain
   end
 
   def names_list
-    list.map { |el| el[:method_name].to_sym }
+    list.map{|el| el[:method_name].to_sym }
   end
 
   def clear
     @calls = []
   end
 
-  alias_method :clear_pending_list, :clear
+  alias :clear_pending_list :clear
 
   # need, because of https://github.com/celluloid/celluloid/issues/22
   def inspect
@@ -65,9 +64,8 @@ private
   def process
     while @call = @calls.shift
       @running = true
-      @target.send(@call[:method_name], *@call[:args]) if @target.alive?
+      @target.send(@call[:method_name], *@call[:args], &@call[:block]) if @target.alive?
     end
     @running = false
   end
-
-end
+end