ace-eye 0.6.1

data/lib/eye/trigger.rb

@@ -0,0 +1,136 @@
+class Eye::Trigger
+  include Eye::Dsl::Validation
+
+  autoload :Flapping,   'eye/trigger/flapping'
+  autoload :Transition, 'eye/trigger/transition'
+  autoload :StopChildren, 'eye/trigger/stop_children'
+  autoload :WaitDependency, 'eye/trigger/wait_dependency'
+  autoload :CheckDependency, 'eye/trigger/check_dependency'
+
+  TYPES = {:flapping => 'Flapping', :transition => 'Transition', :stop_children => 'StopChildren',
+    :wait_dependency => 'WaitDependency', :check_dependency => 'CheckDependency'
+  }
+
+  attr_reader :message, :options, :process
+
+  def self.name_and_class(type)
+    type = type.to_sym
+    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]
+    end
+  end
+
+  def self.get_class(type)
+    klass = eval("Eye::Trigger::#{TYPES[type]}") rescue nil
+    raise "unknown trigger #{type}" unless klass
+    if deps = klass.requires
+      Array(deps).each { |d| require d }
+    end
+    klass
+  end
+
+  def self.create(process, options = {})
+    get_class(options[:type]).new(process, options)
+
+  rescue Exception, Timeout::Error => ex
+    log_ex(ex)
+    nil
+  end
+
+  def self.validate!(options = {})
+    get_class(options[:type]).validate(options)
+  end
+
+  def initialize(process, options = {})
+    @options = options
+    @process = process
+    @full_name = @process.full_name if @process
+
+    debug "add #{options}"
+  end
+
+  def inspect
+    "<#{self.class} @process='#{@full_name}' @options=#{@options}>"
+  end
+
+  def logger_tag
+    @process.logger.prefix
+  end
+
+  def logger_sub_tag
+    "trigger(#{@options[:type]})"
+  end
+
+  def notify(transition, reason)
+    debug "check (:#{transition.event}) :#{transition.from} => :#{transition.to}"
+    @reason = reason
+    @transition = transition
+
+    check(transition) if filter_transition(transition)
+
+  rescue Exception, Timeout::Error => ex
+    if ex.class == Eye::Process::StateError
+      raise ex
+    else
+      log_ex(ex)
+    end
+  end
+
+  param :to, [Symbol, Array]
+  param :from, [Symbol, Array]
+  param :event, [Symbol, Array]
+
+  def filter_transition(trans)
+    return true unless to || from || event
+
+    compare_state(trans.to_name, to) &&
+      compare_state(trans.from_name, from) &&
+      compare_state(trans.event, event)
+  end
+
+  def check(transition)
+    raise NotImplementedError
+  end
+
+  def run_in_process_context(p)
+    process.instance_exec(&p) if process.alive?
+  end
+
+  def defer(&block)
+    Celluloid::Future.new(&block).value
+  end
+
+  def self.register(base)
+    name = base.to_s.gsub('Eye::Trigger::', '')
+    type = name.underscore.to_sym
+    Eye::Trigger::TYPES[type] = name
+    Eye::Trigger.const_set(name, base)
+  end
+
+  def self.requires
+  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
+    end
+  end
+
+end

data/lib/eye/trigger/check_dependency.rb

@@ -0,0 +1,30 @@
+class Eye::Trigger::CheckDependency < Eye::Trigger
+  param :names, [Array], true, 5
+
+  def check(transition)
+    check_dependency(transition.to_name) if transition.from_name == :up
+  end
+
+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
+    return if processes.empty?
+    processes = Eye::Utils::AliveArray.new(processes)
+
+    act = case to
+      when :down, :restarting; :restart
+      when :stopping; :stop
+      when :unmonitored; :unmonitor
+    end
+
+    if act
+      processes.each do |p|
+        p.schedule act, Eye::Reason.new(:"#{act} dependecies")
+      end
+    end
+  end
+
+end

data/lib/eye/trigger/flapping.rb

@@ -0,0 +1,41 @@
+class Eye::Trigger::Flapping < Eye::Trigger
+
+  # trigger :flapping, :times => 10, :within => 1.minute,
+  #         :retry_in => 10.minutes, :retry_times => 15
+
+  param :times, [Fixnum], true, 5
+  param :within, [Float, Fixnum], true
+  param :retry_in, [Float, Fixnum]
+  param :retry_times, [Fixnum]
+
+  def check(transition)
+    on_flapping if transition.event == :crashed && !good?
+  end
+
+private
+
+  def good?
+    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
+      false
+    else
+      true
+    end
+  end
+
+  def on_flapping
+    debug 'flapping recognized!!!'
+
+    process.notify :error, 'flapping!'
+    process.schedule :unmonitor, Eye::Reason.new(:flapping)
+
+    return unless retry_in
+    return if retry_times && process.flapping_times >= retry_times
+
+    process.schedule_in(retry_in.to_f, :retry_start_after_flapping)
+  end
+
+end

data/lib/eye/trigger/stop_children.rb

@@ -0,0 +1,17 @@
+class Eye::Trigger::StopChildren < Eye::Trigger
+
+  # Kill process children when parent process crashed, or stopped:
+  #
+  # trigger :stop_children
+
+  param :timeout, [Fixnum, Float], nil, 60
+
+  # default on stopped, crashed
+  param_default :event, [:stopped, :crashed]
+
+  def check(trans)
+    debug 'stopping children'
+    process.children.pmap { |pid, c| c.stop }
+  end
+
+end

data/lib/eye/trigger/transition.rb

@@ -0,0 +1,15 @@
+class Eye::Trigger::Transition < Eye::Trigger
+
+  # trigger :transition, :to => :up, :from => :starting, :do => ->{ ... }
+
+  param :do, [Proc, Symbol]
+
+  def check(trans)
+    act = @options[:do]
+    if act
+      instance_exec(&@options[:do]) if act.is_a?(Proc)
+      send(act, process) if act.is_a?(Symbol)
+    end
+  end
+
+end

data/lib/eye/trigger/wait_dependency.rb

@@ -0,0 +1,49 @@
+class Eye::Trigger::WaitDependency < Eye::Trigger
+  param :names, [Array], true
+  param :wait_timeout, [Numeric], nil, 15.seconds
+  param :retry_after, [Numeric], nil, 1.minute
+  param :should_start, [TrueClass, FalseClass]
+
+  def check(transition)
+    wait_dependency if transition.to_name == :starting
+  end
+
+private
+
+  def wait_dependency
+    processes = names.map do |name|
+      Eye::Control.find_nearest_process(name, process.group_name_pure, process.app_name)
+    end.compact
+    return if processes.empty?
+    processes = Eye::Utils::AliveArray.new(processes)
+
+    processes.each do |p|
+      if p.state_name != :up && (should_start == nil || should_start)
+        p.schedule :start, Eye::Reason.new(:start_dependency)
+      end
+    end
+
+    res = true
+
+    processes.pmap do |p|
+      name = p.name
+
+      res &= process.wait_for_condition(wait_timeout, 0.5) do
+        info "wait for #{name} until it :up"
+        p.state_name == :up
+      end
+    end
+
+    unless res
+      warn "not waited for #{names} to be up"
+      process.switch :unmonitoring
+
+      if retry_after
+        process.schedule_in retry_after, :start, Eye::Reason.new(:wait_dependency)
+      end
+
+      raise Eye::Process::StateError.new('stop transition because dependency is not up')
+    end
+  end
+
+end

data/lib/eye/utils.rb

@@ -0,0 +1,45 @@
+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 }
+      else value
+    end
+  end
+
+  # deep merging b into a (a deeply changed)
+  def self.deep_merge!(a, b, allowed_keys = nil)
+    b.each do |k, v|
+      next if allowed_keys && !allowed_keys.include?(k)
+      if a[k].is_a?(Hash) && v.is_a?(Hash)
+        deep_merge!(a[k], v)
+      else
+        a[k] = v
+      end
+    end
+    a
+  end
+
+  D1 = '%H:%M'
+  D2 = '%b%d'
+
+  def self.human_time(unix_time)
+    time = Time.at(unix_time.to_i)
+    d1 = time.to_date
+    d2 = Time.now.to_date
+    time.strftime (d1 == d2) ? D1 : D2
+  end
+
+  DF = '%d %b %H:%M'
+
+  def self.human_time2(unix_time)
+    Time.at(unix_time.to_i).strftime(DF)
+  end
+
+end

data/lib/eye/utils/alive_array.rb

@@ -0,0 +1,57 @@
+class Eye::Utils::AliveArray
+  extend Forwardable
+  include Enumerable
+
+  def_delegators :@arr, :[], :<<, :clear, :delete, :size, :empty?, :push,
+                        :flatten, :present?, :uniq!, :select!
+
+  def initialize(arr = [])
+    @arr = arr
+  end
+
+  def each(&block)
+    @arr.each{|elem| elem && elem.alive? && block[elem] }
+  end
+
+  def to_a
+    map{|x| x }
+  end
+
+  def full_size
+    @arr.size
+  end
+
+  def pure
+    @arr
+  end
+
+  def sort_by(&block)
+    self.class.new super
+  end
+
+  def sort(&block)
+    self.class.new super
+  end
+
+  def +(other)
+    if other.is_a?(Eye::Utils::AliveArray)
+      @arr += other.pure
+    elsif other.is_a?(Array)
+      @arr += other
+    else
+      raise "Unexpected + #{other}"
+    end
+    self
+  end
+
+  def ==(other)
+    if other.is_a?(Eye::Utils::AliveArray)
+      @arr == other.pure
+    elsif other.is_a?(Array)
+      @arr == other
+    else
+      raise "Unexpected == #{other}"
+    end
+  end
+
+end

data/lib/eye/utils/celluloid_chain.rb

@@ -0,0 +1,71 @@
+require 'celluloid'
+
+class Eye::Utils::CelluloidChain
+  include Celluloid
+
+  def initialize(target)
+    @target = target
+    @calls = []
+    @running = false
+    @target_class = @target.class
+  end
+
+  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, &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, &block)
+    h = {:method_name => method_name, :args => args, :block => block}
+    if !@calls.include?(h) && @call != h
+      @calls << h
+      ensure_process
+    end
+  end
+
+  def list
+    @calls
+  end
+
+  def names_list
+    list.map{|el| el[:method_name].to_sym }
+  end
+
+  def clear
+    @calls = []
+  end
+
+  alias :clear_pending_list :clear
+
+  # need, because of https://github.com/celluloid/celluloid/issues/22
+  def inspect
+    "Celluloid::Chain(#{@target_class}: #{@calls.size})"
+  end
+
+  attr_reader :running
+
+private
+
+  def ensure_process
+    unless @running
+      @running = true
+      async.process
+    end
+  end
+
+  def process
+    while @call = @calls.shift
+      @running = true
+      @target.send(@call[:method_name], *@call[:args], &@call[:block]) if @target.alive?
+    end
+    @running = false
+  end
+end