eye 0.1.11

data/lib/eye/system_resources.rb

@@ -0,0 +1,83 @@
+require 'celluloid'
+
+class Eye::SystemResources
+
+  # cached system resources
+  class << self
+
+    def memory(pid)
+      ps_aux[pid].try :[], :rss
+    end
+
+    def cpu(pid)
+      ps_aux[pid].try :[], :cpu
+    end
+
+    def childs(parent_pid)
+      parent_pid = parent_pid.to_i
+
+      childs = []
+      ps_aux.each do |pid, h|
+        childs << pid if h[:ppid] == parent_pid
+      end
+
+      childs
+    end
+
+    def cmd(pid)
+      ps_aux[pid].try :[], :cmd
+    end
+
+    def start_time(pid)
+      ps_aux[pid].try :[], :start_time
+    end
+
+    def resources(pid)
+      return {} unless ps_aux[pid]
+
+      { :memory => memory(pid), 
+        :cpu => cpu(pid), 
+        :start_time => start_time(pid),
+        :cmd => cmd(pid),
+        :pid => pid
+      }
+    end
+
+    # initialize actor, call 1 time before using
+    def setup
+      @actor ||= PsAxActor.new
+    end
+    
+  private
+  
+    def ps_aux
+      setup
+      @actor.get
+    end
+
+  end
+
+  class PsAxActor
+    include Celluloid
+
+    UPDATE_INTERVAL = 5 # seconds
+
+    def initialize
+      set
+    end
+
+    def get
+      set! if @at + UPDATE_INTERVAL < Time.now
+      @ps_aux
+    end
+
+  private
+
+    def set
+      @ps_aux = Eye::System.ps_aux
+      @at = Time.now
+    end
+
+  end
+
+end

data/lib/eye/trigger.rb

@@ -0,0 +1,53 @@
+class Eye::Trigger
+  include Eye::Logger::Helpers
+  
+  autoload :Flapping,   'eye/trigger/flapping'
+
+  # ex: { :type => :flapping, :times => 2, :within => 30.seconds}
+
+  TYPES = {:flapping => "Flapping"}
+
+  attr_reader :message, :options
+
+  def self.get_class(type)
+    klass = eval("Eye::Trigger::#{TYPES[type]}") rescue nil
+    raise "Unknown trigger #{type}" unless klass
+    klass
+  end
+
+  def self.create(options = {}, logger_prefix = nil)
+    get_class(options[:type]).new(options, logger_prefix)
+  end
+
+  def self.validate!(options = {})
+    get_class(options[:type]).validate(options)
+  end
+
+  def initialize(options = {}, logger_prefix = nil)
+    @options = options
+    @logger = Eye::Logger.new(logger_prefix, "trigger")
+
+    debug "add trigger #{options}"
+  end
+
+  def check(states_history)
+    @states_history = states_history
+
+    res = good?
+
+    if res
+      debug 'check flapping'
+    else
+      debug "!!! #{self.class} recognized !!!"
+    end
+    
+    res
+  end
+
+  def good?
+    raise 'realize me'
+  end
+
+  extend Eye::Checker::Validation
+
+end

data/lib/eye/trigger/flapping.rb

@@ -0,0 +1,24 @@
+class Eye::Trigger::Flapping < Eye::Trigger
+
+  # triggers :flapping, :times => 10, :within => 1.minute
+
+  param :times, [Fixnum], true
+  param :within, [Float, Fixnum], true
+
+  def good?
+    return true unless within
+
+    states = @states_history.states_for_period( within )
+
+    starting_count = states.count{|st| st == :starting}
+    down_count = states.count{|st| st == :down}
+    times_count = times || 5
+
+    if (starting_count >= times_count) && (down_count >= times_count)
+      false
+    else
+      true
+    end
+  end
+
+end

data/lib/eye/utils.rb

@@ -0,0 +1,5 @@
+module Eye::Utils
+  autoload :Tail,           'eye/utils/tail'
+  autoload :AliveArray,     'eye/utils/alive_array'
+  autoload :CelluloidChain, 'eye/utils/celluloid_chain'
+end

data/lib/eye/utils/alive_array.rb

@@ -0,0 +1,31 @@
+class Eye::Utils::AliveArray
+  extend Forwardable
+  include Enumerable
+
+  def_delegators :@arr, :[], :<<, :clear, :delete, :size, :empty?
+
+  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
+
+end

data/lib/eye/utils/celluloid_chain.rb

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

data/lib/eye/utils/leak_19.rb

@@ -0,0 +1,7 @@
+# http://stackoverflow.com/questions/7263268/ruby-symbolto-proc-leaks-references-in-1-9-2-p180
+
+class Symbol
+  def to_proc
+    lambda { |x| x.send(self) }
+  end
+end

data/lib/eye/utils/tail.rb

@@ -0,0 +1,20 @@
+class Eye::Utils::Tail < Array
+
+  # limited array
+
+  def initialize(max_size = 100)
+    @max_size = max_size
+    super()
+  end
+
+  def push(el)
+    super(el)
+    shift if length > @max_size 
+    self
+  end
+
+  def << (el)
+    push(el)
+  end
+
+end

data/spec/checker/cpu_spec.rb

@@ -0,0 +1,58 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+def chcpu(cfg = {})
+  Eye::Checker.create(123, {:type => :cpu, :every => 5.seconds, 
+        :times => 1}.merge(cfg))
+end
+
+describe "Eye::Checker::Cpu" do
+
+  describe "without below" do
+    subject{ chcpu }
+
+    it "get_value" do
+      mock(Eye::SystemResources).cpu(123){ 65 }
+      subject.get_value.should == 65
+    end
+
+    it "without below always true" do
+      stub(subject).get_value{ 15 }
+      subject.check.should == true
+
+      stub(subject).get_value{ 20 }
+      subject.check.should == true
+    end
+  end
+
+  describe "with below" do
+    subject{ chcpu(:below => 30) }
+
+    it "good" do
+      stub(subject).get_value{ 20 }
+      subject.check.should == true
+
+      stub(subject).get_value{ 25 }
+      subject.check.should == true
+    end
+
+    it "good" do
+      stub(subject).get_value{ 25 }
+      subject.check.should == true
+
+      stub(subject).get_value{ 35 }
+      subject.check.should == false
+    end
+
+  end
+
+  describe "validates" do
+    it "ok" do
+      Eye::Checker.validate!({:type => :cpu, :every => 5.seconds, :times => 1, :below => 100})
+    end
+
+    it "bad param below" do
+      expect{ Eye::Checker.validate!({:type => :cpu, :every => 5.seconds, :times => 1, :below => {1 => 2}}) }.to raise_error(Eye::Checker::Validation::Error)
+    end
+  end
+
+end

data/spec/checker/file_ctime_spec.rb

@@ -0,0 +1,34 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+def chctime(cfg = {})
+  Eye::Checker.create(nil, {:type => :ctime, :every => 5.seconds, 
+        :file => $logger_path, :times => 1}.merge(cfg))
+end
+
+describe "Eye::Checker::FileCTime" do
+
+  describe "" do
+    subject{ chctime }
+
+    it "get_value" do
+      subject.get_value.should == File.ctime($logger_path)
+    end
+
+    it "not good if size equal prevous" do
+      stub(subject).get_value{ Time.parse('00:00:01') }
+      subject.check.should == true
+
+      stub(subject).get_value{ Time.parse('00:00:01') }
+      subject.check.should == false
+    end
+
+    it "good when little different with previous" do
+      stub(subject).get_value{ Time.parse('00:00:01') }
+      subject.check.should == true
+
+      stub(subject).get_value{ Time.parse('00:00:02') }
+      subject.check.should == true
+    end
+  end
+
+end

data/spec/checker/file_size_spec.rb

@@ -0,0 +1,107 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+def chfsize(cfg = {})
+  Eye::Checker.create(nil, {:type => :fsize, :every => 5.seconds, 
+        :file => $logger_path, :times => 1}.merge(cfg))
+end
+
+describe "Eye::Checker::FileSize" do
+
+  describe "" do
+    subject{ chfsize }
+
+    it "get_value" do
+      subject.get_value.should be_within(10).of(File.size($logger_path))
+    end
+
+    it "not good if size equal prevous" do
+      stub(subject).get_value{1001}
+      subject.check.should == true
+
+      stub(subject).get_value{1001}
+      subject.check.should == false
+    end
+
+    it "good when little different with previous" do
+      stub(subject).get_value{1001}
+      subject.check.should == true
+
+      stub(subject).get_value{1002}
+      subject.check.should == true
+    end
+  end
+
+  describe "below" do
+    subject{ chfsize(:below => 10) }
+
+    it "good" do
+      stub(subject).get_value{1001}
+      subject.check.should == true
+
+      stub(subject).get_value{1005}
+      subject.check.should == true
+    end
+
+    it "bad" do
+      stub(subject).get_value{1001}
+      subject.check.should == true
+
+      stub(subject).get_value{1015}
+      subject.check.should == false
+    end
+
+  end
+
+  describe "above" do
+    subject{ chfsize(:above => 10) }
+
+    it "good" do
+      stub(subject).get_value{1001}
+      subject.check.should == true
+
+      stub(subject).get_value{1005}
+      subject.check.should == false
+    end
+
+    it "bad" do
+      stub(subject).get_value{1001}
+      subject.check.should == true
+
+      stub(subject).get_value{1015}
+      subject.check.should == true
+    end
+
+  end
+
+
+  describe "above and below" do
+    subject{ chfsize(:above => 10, :below => 30) }
+
+    it "bad" do
+      stub(subject).get_value{1001}
+      subject.check.should == true
+
+      stub(subject).get_value{1005}
+      subject.check.should == false
+    end
+
+    it "good" do
+      stub(subject).get_value{1001}
+      subject.check.should == true
+
+      stub(subject).get_value{1021}
+      subject.check.should == true
+    end
+
+    it "bad" do
+      stub(subject).get_value{1001}
+      subject.check.should == true
+
+      stub(subject).get_value{1045}
+      subject.check.should == false
+    end
+
+  end
+
+
+end