eye 0.1.11

data/lib/eye/application.rb

@@ -0,0 +1,65 @@
+class Eye::Application
+
+  attr_reader :groups, :name
+
+  include Eye::Logger::Helpers
+
+  def initialize(name, config = {})
+    @groups = Eye::Utils::AliveArray.new
+    @name = name
+    @logger = Eye::Logger.new(full_name)
+    @config = config
+    debug 'created'
+  end
+
+  def full_name
+    @name
+  end
+
+  def update_config(cfg)
+    @config = cfg
+  end
+
+  def add_group(group)
+    @groups << group
+  end
+
+  def status_data(debug = false)
+    h = { name: @name, type: :application, subtree: @groups.map{|gr| gr.status_data(debug) }}
+    h.merge!(debug: debug_data) if debug
+    h
+  end
+
+  def status_data_short
+    h = Hash.new 0
+    @groups.each do |c| 
+      c.processes.each do |p|
+        h[p.state] += 1
+      end
+    end
+    str = h.sort_by{|a,b| a}.map{|k, v| "#{k}:#{v}" } * ', '
+    { name: @name, type: :application, state: str}
+  end
+
+  def debug_data
+  end
+
+  def send_command(command, *args)
+    debug "send_command #{command} #{args}"
+    
+    @groups.each do |group|
+      group.send_command(command, *args)
+    end
+  end
+
+  def alive?
+    true # emulate celluloid actor method
+  end
+
+  def sub_object?(obj)
+    res = @groups.include?(obj)
+    res = @groups.any?{|gr| gr.sub_object?(obj)} if !res
+    res
+  end
+
+end

data/lib/eye/checker.rb

@@ -0,0 +1,118 @@
+class Eye::Checker
+  include Eye::Logger::Helpers
+
+  autoload :Validation, 'eye/checker/validation'
+
+  autoload :Memory,     'eye/checker/memory'
+  autoload :Cpu,        'eye/checker/cpu'
+  autoload :Http,       'eye/checker/http'
+  autoload :FileCTime,  'eye/checker/file_ctime'
+  autoload :FileSize,   'eye/checker/file_size'
+  autoload :Socket,     'eye/checker/socket'
+
+  TYPES = {:memory => "Memory", :cpu => "Cpu", :http => "Http", 
+           :ctime => "FileCTime", :fsize => "FileSize", :socket => "Socket"}
+
+  attr_accessor :value, :values, :options, :pid, :type
+
+  def self.get_class(type)
+    klass = eval("Eye::Checker::#{TYPES[type]}") rescue nil
+    raise "Unknown checker #{type}" unless klass
+    klass
+  end
+
+  def self.create(pid, options = {}, logger_prefix = nil)
+    get_class(options[:type]).new(pid, options, logger_prefix)
+  end
+
+  def self.validate!(options)
+    get_class(options[:type]).validate(options)
+  end
+
+  def initialize(pid, options = {}, logger_prefix = nil)
+    @pid = pid
+    @options = options
+    @type = options[:type]
+
+    @logger = Eye::Logger.new(logger_prefix, "check:#{check_name}")
+    debug "create checker, with #{options}"
+    
+    @value = nil
+    @values = Eye::Utils::Tail.new(max_tries)
+  end
+
+  def last_human_values
+    h_values = @values.map do |v| 
+      sign = v[:good] ? '' : '*'
+      sign + human_value(v[:value]).to_s
+    end
+
+    '[' + h_values * ', ' + ']'
+  end
+
+  def check
+    @value = get_value
+    @values << {:value => @value, :good => good?(value)}
+
+    result = true
+
+    if @values.size == max_tries
+      bad_count = @values.count{|v| !v[:good] }
+      result = false if bad_count >= min_tries
+    end
+
+    info "#{last_human_values} => #{result ? 'OK' : 'Fail'}"
+    result
+  end
+
+  def get_value
+    raise 'Realize me'
+  end
+
+  def human_value(value)
+    value.to_s
+  end
+
+  # true if check ok
+  # false if check bad
+  def good?(value)
+    raise 'Realize me'
+  end
+
+  def check_name
+    self.class.to_s
+  end
+
+  def max_tries
+    @max_tries ||= if times
+      if times.is_a?(Array)
+        times[-1].to_i
+      else
+        times.to_i
+      end
+    else
+      1
+    end    
+  end
+
+  def min_tries
+    @min_tries ||= if times
+      if times.is_a?(Array)
+        times[0].to_i
+      else
+        max_tries
+      end
+    else
+      max_tries
+    end
+  end
+
+  def previous_value
+    @values[-1][:value] if @values.present?
+  end
+
+  extend Eye::Checker::Validation
+  param :every, [Fixnum, Float], false, 5
+  param :times, [Fixnum, Array]
+
+end

data/lib/eye/checker/cpu.rb

@@ -0,0 +1,27 @@
+class Eye::Checker::Cpu < Eye::Checker
+
+  # checks :cpu, :every => 3.seconds, :below => 80, :times => [3,5]
+
+  param :below, [Fixnum, Float], true
+
+  def check_name
+    "cpu(#{human_value(below)})"
+  end
+
+  def get_value
+    Eye::SystemResources.cpu(@pid).to_i # nil => 0
+  end
+
+  def human_value(value)
+    "#{value}%"
+  end
+
+  def good?(value)
+    if below
+      value < below
+    else
+      true
+    end
+  end
+
+end

data/lib/eye/checker/file_ctime.rb

@@ -0,0 +1,29 @@
+class Eye::Checker::FileCTime < Eye::Checker
+
+  # Check that file changes (log for example)
+
+  # checks :ctime, :every => 5.seconds, :file => "/tmp/1.log", :times => [3,5]
+
+  param :file, [String], true
+
+  def check_name
+    'ctime'
+  end
+
+  def get_value
+    File.ctime(file) rescue nil
+  end
+
+  def human_value(value)
+    if value == nil
+      'Err'
+    else
+      value.strftime('%H:%M')
+    end
+  end
+
+  def good?(value)
+    value.to_i > previous_value.to_i
+  end
+
+end

data/lib/eye/checker/file_size.rb

@@ -0,0 +1,38 @@
+class Eye::Checker::FileSize < Eye::Checker
+
+  # Check that file size changed (log for example)
+
+  # checks :fsize, :every => 5.seconds, :file => "/tmp/1.log", :times => [3,5], 
+  #      :below => 30.kilobytes, :above => 10.kilobytes
+
+  param :file, [String], true
+  param :below, [Fixnum, Float]
+  param :above, [Fixnum, Float]
+
+  def check_name
+    'fsize'
+  end
+
+  def get_value
+    File.size(file) rescue nil
+  end
+
+  def human_value(value)
+    "#{value.to_i / 1024}Kb"
+  end
+
+  def good?(value)
+    return true unless previous_value
+
+    diff = value.to_i - previous_value.to_i
+
+    return true if diff < 0 # case when logger nulled
+
+    return false if below && diff > below
+    return false if above && diff < above
+    return false if diff == 0
+
+    true
+  end
+
+end

data/lib/eye/checker/http.rb

@@ -0,0 +1,94 @@
+require 'net/http'
+
+class Eye::Checker::Http < Eye::Checker
+
+  # checks :http, :every => 5.seconds, :times => 1,
+  #  :url => "http://127.0.0.1:3000/", :kind => :success, :pattern => /OK/, :timeout => 3.seconds
+
+  param :url,           String, true
+  param :pattern,       [String, Regexp]
+  param :kind
+  param :timeout,       [Fixnum, Float]
+  param :open_timeout,  [Fixnum, Float]
+  param :read_timeout,  [Fixnum, Float]
+
+  attr_reader :session, :uri
+
+  def check_name
+    'http'
+  end
+
+  def initialize(*args)
+    super
+
+    @uri = URI.parse(url) rescue URI.parse('http://127.0.0.1')
+    @pattern = pattern
+    @kind = case kind
+              when Fixnum then Net::HTTPResponse::CODE_TO_OBJ[kind]
+              when String, Symbol then Net.const_get("HTTP#{kind.to_s.camelize}") rescue Net::HTTPSuccess
+            else
+              Net::HTTPSuccess
+            end
+    @open_timeout = (open_timeout || timeout || 5).to_i
+    @read_timeout = (read_timeout || timeout || 30).to_i
+
+    @session = Net::HTTP.new(@uri.host, @uri.port)
+    if @uri.scheme == 'https'
+      require 'net/https'
+      @session.use_ssl=true
+      @session.verify_mode = OpenSSL::SSL::VERIFY_NONE
+    end
+    @session.open_timeout = @open_timeout
+    @session.read_timeout = @read_timeout
+  end
+
+  def get_value
+    Celluloid::Future.new{ get_value_sync }.value
+  end
+
+  def get_value_sync
+    res = @session.start do |http|
+      http.get(@uri.path)
+    end
+
+    {:result => res}
+
+  rescue Timeout::Error
+    debug 'Timeout error'
+    {:exception => :timeout}
+
+  rescue => ex
+    error "Exception #{ex.message}"
+    {:exception => ex.message}
+  end
+
+  def good?(value)
+    return false unless value[:result]
+    return false unless value[:result].kind_of?(@kind)
+
+    if @pattern
+      if @pattern.is_a?(Regexp)
+        @pattern === value[:result].body
+      else
+        value[:result].body.include?(@pattern.to_s)
+      end
+    else
+      true
+    end
+  end
+
+  def human_value(value)
+    if !value.is_a?(Hash)
+      '-'
+    elsif value[:exception]
+      if value[:exception] == :timeout
+        'T-out'
+      else
+        'Err'
+      end
+    else
+      "#{value[:result].code}=#{value[:result].body.size/ 1024}Kb"
+    end
+  end
+
+end

data/lib/eye/checker/memory.rb

@@ -0,0 +1,27 @@
+class Eye::Checker::Memory < Eye::Checker
+
+  # checks :memory, :every => 3.seconds, :below => 80.megabytes, :times => [3,5]
+
+  param :below, [Fixnum, Float], true
+  
+  def check_name
+    "memory(#{human_value(below)})"
+  end
+
+  def get_value
+    Eye::SystemResources.memory(@pid).to_i * 1024
+  end
+
+  def human_value(value)
+    "#{value.to_i / 1024 / 1024}Mb"
+  end
+
+  def good?(value)
+    if below
+      value < below
+    else
+      true
+    end
+  end
+
+end

data/lib/eye/checker/socket.rb

@@ -0,0 +1,148 @@
+class Eye::Checker::Socket < Eye::Checker
+
+  # checks :socket, :every => 5.seconds, :times => 1,
+  #  :addr => "unix:/var/run/daemon.sock", :timeout => 3.seconds,
+  #
+  # Available parameters:
+  # :addr          the socket addr to open. The format is tcp://<host>:<port> or unix:<path>
+  # :timeout       generic timeout for opening the socket or reading data
+  # :open_timeout  override generic timeout for the connection
+  # :read_timeout  override generic timeout for data read/write
+  # :send_data     after connection send this data
+  # :expect_data   after sending :send_data expect this response. Can be a string, Regexp or a Proc
+  # :protocol      way of pack,unpack messages (default = socket default), example: :protocol => :em_object
+
+  param :addr,          String, true
+  param :timeout,       [Fixnum, Float]
+  param :open_timeout,  [Fixnum, Float]
+  param :read_timeout,  [Fixnum, Float]
+  param :send_data
+  param :expect_data,   [String, Regexp, Proc]
+  param :protocol,      [Symbol]
+
+  def check_name
+    'socket'
+  end
+
+  def initialize(*args)
+    super
+    @open_timeout = (open_timeout || 1).to_i
+    @read_timeout = (read_timeout || timeout || 5).to_i
+
+    if addr =~ %r[\Atcp://(.*?):(.*?)\z]
+      @socket_family = :tcp
+      @socket_addr = $1
+      @socket_port = $2.to_i
+    elsif addr =~ %r[\Aunix:(.*)\z]
+      @socket_family = :unix
+      @socket_path = $1
+    end
+  end
+
+  def get_value
+    Celluloid::Future.new{ get_value_sync }.value
+  end
+
+  def get_value_sync
+    sock = Timeout::timeout(@open_timeout) do
+      if @socket_family == :tcp      
+        TCPSocket.open(@socket_addr, @socket_port)
+      elsif @socket_family == :unix
+        UNIXSocket.open(@socket_path)
+      else
+        raise "Unknown socket addr #{addr}"
+      end
+    end
+
+    if send_data
+      Timeout::timeout(@read_timeout) do
+        _write_data(sock, send_data)
+        { :result => _read_data(sock) }
+      end
+    else
+      { :result => :listen }
+    end
+
+  rescue Timeout::Error
+    debug 'Timeout error'
+    { :exception => :timeout }
+
+  rescue Exception => e
+    warn "Exception #{e.message}"
+    { :exception => e.message }
+
+  ensure
+    sock.close if sock
+  end
+
+  def good?(value)
+    return false if !value[:result]
+
+    if expect_data
+      if expect_data.is_a?(Proc)                
+        match = begin
+          !!expect_data[value[:result]] 
+        rescue Timeout::Error, Exception => ex
+          error "proc match failed with #{ex.message}"
+          return false
+        end
+        
+        warn "proc #{expect_data} not matched (#{value[:result].truncate(30)}) answer" unless match
+        return match
+      end
+
+      return true if expect_data.is_a?(Regexp) && expect_data.match(value[:result])
+      return true if value[:result].to_s == expect_data.to_s
+
+      warn "#{expect_data} not matched (#{value[:result].truncate(30)}) answer"      
+      return false
+    end
+
+    return true
+  end
+
+  def human_value(value)
+    if !value.is_a?(Hash)
+      '-'
+    elsif value[:exception]
+      if value[:exception] == :timeout
+        'T-out'
+      else
+        "Err(#{value[:exception]})"
+      end
+    else
+      if value[:result] == :listen
+        "listen"
+      else
+        "#{value[:result].to_s.size}b"
+      end
+    end
+  end
+
+private
+
+  def _write_data(socket, data)
+    case protocol
+    when :em_object
+      data = Marshal.dump(data)
+      socket.write([data.bytesize, data].pack('Na*'))
+    else
+      socket.write(data.to_s)
+    end
+  end
+
+  def _read_data(socket)
+    case protocol
+    when :em_object
+      content = ""
+      msg_size = socket.recv(4).unpack('N')[0] rescue 0
+      content << socket.recv(msg_size - content.length) while content.length < msg_size
+      if content.present?
+        Marshal.load(content) rescue 'corrupted_marshal'
+      end
+    else
+      socket.readline.chop
+    end
+  end
+
+end