eye 0.8.pre2 → 0.8.rc

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

data/lib/eye/trigger/starting_guard.rb

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

data/lib/eye/utils.rb

@@ -1,14 +1,15 @@
 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.inject({}){|r, (k, v)| r[ deep_clone(k) ] = deep_clone(v); r }
+      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) }
       else value
     end
   end
@@ -47,7 +48,7 @@ module Eye::Utils
     env_vars = content.split("\n")
     h = {}
     env_vars.each do |e|
-      e = e.gsub(/#.+$/, '').strip
+      e = e.gsub(%r[#.+$], '').strip
       next unless e.include?('=')
       k, v = e.split('=', 2)
       h[k] = v

data/lib/eye/utils/alive_array.rb

@@ -1,20 +1,21 @@
 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
@@ -33,6 +34,10 @@ 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
@@ -54,4 +59,4 @@ class Eye::Utils::AliveArray
     end
   end
 
-end
+end

data/lib/eye/utils/celluloid_chain.rb

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

data/lib/eye/utils/mini_active_support.rb

@@ -31,9 +31,9 @@ class String
     word = self.dup
     word.gsub!('::', '/')
     word.gsub!(/(?:([A-Za-z\d])|^)((?=a)b)(?=\b|[^a-z])/) { "#{$1}#{$1 && '_'}#{$2.downcase}" }
-    word.gsub!(/([A-Z\d]+)([A-Z][a-z])/,'\1_\2')
-    word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
-    word.tr!("-", "_")
+    word.gsub!(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2')
+    word.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
+    word.tr!('-', '_')
     word.downcase!
     word
   end
@@ -53,32 +53,32 @@ class Numeric
   def percents
     self
   end
-  alias :percent :percents
+  alias_method :percent, :percents
 
   def seconds
     self
   end
-  alias :second :seconds
+  alias_method :second, :seconds
 
   def minutes
     self * 60
   end
-  alias :minute :minutes
+  alias_method :minute, :minutes
 
   def hours
     self * 3600
   end
-  alias :hour :hours
+  alias_method :hour, :hours
 
   def days
-    self * 86400
+    self * 86_400
   end
-  alias :day :days
+  alias_method :day, :days
 
   def weeks
-    self * 86400 * 7
+    self * 86_400 * 7
   end
-  alias :week :weeks
+  alias_method :week, :weeks
 
   def ago
     ::Time.now - self
@@ -87,25 +87,25 @@ class Numeric
   def bytes
     self
   end
-  alias :byte :bytes
+  alias_method :byte, :bytes
 
   def kilobytes
     self * 1024
   end
-  alias :kilobyte :kilobytes
+  alias_method :kilobyte, :kilobytes
 
   def megabytes
     self * 1024 * 1024
   end
-  alias :megabyte :megabytes
+  alias_method :megabyte, :megabytes
 
   def gigabytes
     self * 1024 * 1024 * 1024
   end
-  alias :gigabyte :gigabytes
+  alias_method :gigabyte, :gigabytes
 
   def terabytes
     self * 1024 * 1024 * 1024 * 1024
   end
-  alias :terabyte :terabytes
+  alias_method :terabyte, :terabytes
 end