eye 0.4.2 → 0.5

data/lib/eye.rb

@@ -1,5 +1,5 @@
 module Eye
-  VERSION   = "0.4.2"
+  VERSION   = "0.5"
   ABOUT     = "Eye v#{VERSION} (c) 2012-2013 @kostya"
   PROCLINE  = "eye monitoring v#{VERSION}"
 
@@ -14,13 +14,15 @@ module Eye
   autoload :Group,          'eye/group'
   autoload :Dsl,            'eye/dsl'
   autoload :Application,    'eye/application'
-  autoload :Settings,       'eye/settings'
+  autoload :Local,          'eye/local'
   autoload :Client,         'eye/client'
   autoload :Utils,          'eye/utils'
   autoload :Notify,         'eye/notify'
   autoload :Config,         'eye/config'
   autoload :Reason,         'eye/reason'
+  autoload :Sigar,          'eye/sigar'
 
   autoload :Controller,     'eye/controller'
   autoload :Control,        'eye/control'
+  autoload :Cli,            'eye/cli'
 end

data/lib/eye/application.rb

@@ -33,14 +33,14 @@ class Eye::Application
   end
 
   def status_data_short
-    h = Hash.new 0
+    h = Hash.new
     @groups.each do |c|
       c.processes.each do |p|
+        h[p.state] ||= 0
         h[p.state] += 1
       end
     end
-    str = h.sort_by{|a,b| a}.map{|k, v| "#{k}:#{v}" } * ', '
-    { name: @name, type: :application, state: str}
+    { name: @name, type: :application, states: h}
   end
 
   def debug_data

data/lib/eye/checker.rb

@@ -1,20 +1,23 @@
 class Eye::Checker
+  include Eye::Dsl::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 :FileTouched,'eye/checker/file_touched'
   autoload :Socket,     'eye/checker/socket'
   autoload :Nop,        'eye/checker/nop'
+  autoload :Runtime,    'eye/checker/runtime'
+  autoload :Cputime,    'eye/checker/cputime'
 
-  TYPES = {:memory => "Memory", :cpu => "Cpu", :http => "Http",
-           :ctime => "FileCTime", :fsize => "FileSize", :socket => "Socket",
-           :nop => "Nop" }
+  TYPES = {:memory => 'Memory', :cpu => 'Cpu', :http => 'Http',
+           :ctime => 'FileCTime', :fsize => 'FileSize', :file_touched => 'FileTouched',
+           :socket => 'Socket', :nop => 'Nop', :runtime => 'Runtime', :cputime => 'Cputime' }
 
   attr_accessor :value, :values, :options, :pid, :type, :check_count, :process
 
-  extend Eye::Dsl::Validation
   param :every, [Fixnum, Float], false, 5
   param :times, [Fixnum, Array], nil, 1
   param :fires, [Symbol, Array], nil, nil, [:stop, :restart, :unmonitor, :nothing, :start, :delete]
@@ -34,6 +37,9 @@ class Eye::Checker
   def self.get_class(type)
     klass = eval("Eye::Checker::#{TYPES[type]}") rescue nil
     raise "Unknown checker #{type}" unless klass
+    if deps = klass.depends_on
+      Array(deps).each { |d| require d }
+    end
     klass
   end
 
@@ -185,12 +191,15 @@ class Eye::Checker
   end
 
   def self.register(base)
-    name = base.to_s.gsub("Eye::Checker::", '')
+    name = base.to_s.gsub('Eye::Checker::', '')
     type = name.underscore.to_sym
     Eye::Checker::TYPES[type] = name
     Eye::Checker.const_set(name, base)
   end
 
+  def self.depends_on
+  end
+
   class CustomCell < Eye::Checker
     def self.inherited(base)
       super

data/lib/eye/checker/cputime.rb

@@ -0,0 +1,23 @@
+class Eye::Checker::Cputime < Eye::Checker
+
+  # check :cputime, :every => 1.minute, :below => 120.minutes
+
+  param :below, [Fixnum, Float], true
+
+  def get_value
+    Eye::SystemResources.cputime(@pid).to_f
+  end
+
+  def human_value(value)
+    "#{value / 60}m"
+  end
+
+  def good?(value)
+    if below
+      value < below
+    else
+      true
+    end
+  end
+
+end

data/lib/eye/checker/file_touched.rb

@@ -0,0 +1,15 @@
+class Eye::Checker::FileTouched < Eye::Checker
+
+  param :file, [String], true
+  param :delete, [TrueClass, FalseClass]
+
+  def get_value
+    File.exists?(file)
+  end
+
+  def good?(value)
+    File.delete(file) if value && delete
+    !value
+  end
+
+end

data/lib/eye/checker/http.rb

@@ -7,7 +7,7 @@ class Eye::Checker::Http < Eye::Checker::Defer
 
   param :url,           String, true
   param :pattern,       [String, Regexp]
-  param :kind
+  param :kind,          [String, Fixnum, Symbol]
   param :timeout,       [Fixnum, Float]
   param :open_timeout,  [Fixnum, Float]
   param :read_timeout,  [Fixnum, Float]
@@ -17,8 +17,7 @@ class Eye::Checker::Http < Eye::Checker::Defer
   def initialize(*args)
     super
 
-    @uri = URI.parse(url) rescue URI.parse('http://127.0.0.1')
-    @pattern = pattern
+    @uri = URI.parse(url)
     @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
@@ -40,7 +39,6 @@ class Eye::Checker::Http < Eye::Checker::Defer
       mes = ex.class.is_a?(Net::OpenTimeout) ? "OpenTimeout<#{@open_timeout}>" : "ReadTimeout<#{@read_timeout}>"
       {:exception => mes}
     else
-      error "#{ex.message}"
       {:exception => "Timeout<#{@open_timeout},#{@read_timeout}>"}
     end
 
@@ -55,13 +53,13 @@ class Eye::Checker::Http < Eye::Checker::Defer
       return false
     end
 
-    if @pattern
-      matched = if @pattern.is_a?(Regexp)
-        @pattern === value[:result].body
+    if pattern
+      matched = if pattern.is_a?(Regexp)
+        pattern === value[:result].body
       else
-        value[:result].body.include?(@pattern.to_s)
+        value[:result].body.include?(pattern.to_s)
       end
-      value[:notice] = "missing '#{@pattern.to_s}'" unless matched
+      value[:notice] = "missing '#{pattern.to_s}'" unless matched
       matched
     else
       true

data/lib/eye/checker/memory.rb

@@ -9,7 +9,7 @@ class Eye::Checker::Memory < Eye::Checker
   end
 
   def get_value
-    Eye::SystemResources.memory(@pid).to_i * 1024
+    Eye::SystemResources.memory(@pid).to_i
   end
 
   def human_value(value)

data/lib/eye/checker/runtime.rb

@@ -0,0 +1,28 @@
+class Eye::Checker::Runtime < Eye::Checker
+
+  # check :runtime, :every => 1.minute, :below => 120.minutes
+
+  param :below, [Fixnum, Float], true
+
+  def get_value
+    st = Eye::SystemResources.start_time(@pid)
+    if st
+      Time.now.to_i - st.to_i
+    else
+      0
+    end
+  end
+
+  def human_value(value)
+    "#{value / 60}m"
+  end
+
+  def good?(value)
+    if below
+      value < below
+    else
+      true
+    end
+  end
+
+end

data/lib/eye/checker/socket.rb

@@ -80,7 +80,7 @@ class Eye::Checker::Socket < Eye::Checker::Defer
 
         unless match
           warn "proc #{expect_data} not matched (#{value[:result].truncate(30)}) answer"
-          value[:notice] = "missing proc validation"
+          value[:notice] = 'missing proc validation'
         end
 
         return match
@@ -104,7 +104,7 @@ class Eye::Checker::Socket < Eye::Checker::Defer
       value[:exception]
     else
       if value[:result] == :listen
-        "listen"
+        'listen'
       else
         res = "#{value[:result].to_s.size}b"
         res += "<#{value[:notice]}>" if value[:notice]
@@ -138,7 +138,7 @@ private
   def _read_data(socket)
     case protocol
     when :em_object
-      content = ""
+      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?
@@ -149,4 +149,4 @@ private
     end
   end
 
-end
+end

data/lib/eye/cli.rb

@@ -0,0 +1,166 @@
+gem 'thor'
+require 'thor'
+
+class Eye::Cli < Thor
+  autoload :Server,     'eye/cli/server'
+  autoload :Commands,   'eye/cli/commands'
+  autoload :Render,     'eye/cli/render'
+
+  include Eye::Cli::Server
+  include Eye::Cli::Commands
+  include Eye::Cli::Render
+
+  desc "info [MASK]", "processes info"
+  def info(mask = nil)
+    res = cmd(:info_data, *Array(mask))
+    say render_info(res)
+    say
+  end
+
+  desc "status", "processes info (deprecated)"
+  def status
+    say ":status is deprecated, use :info instead", :yellow
+    info
+  end
+
+  desc "xinfo", "eye-deamon info (-c show current config)"
+  method_option :config, :type => :boolean, :aliases => "-c"
+  def xinfo
+    res = cmd(:debug_data, :config => options[:config])
+    say render_debug_info(res)
+    say
+  end
+
+  desc "oinfo", "onelined info"
+  def oinfo
+    res = cmd(:short_data)
+    say render_info(res)
+    say
+  end
+
+  desc "history [MASK,...]", "processes history"
+  def history(*masks)
+    res = cmd(:history_data, *masks)
+    say render_history(res)
+    say
+  end
+
+  desc "load [CONF, ...]", "load config (start eye-daemon if not) (-f foreground start)"
+  method_option :foreground, :type => :boolean, :aliases => "-f"
+  def load(*configs)
+    configs.map!{ |c| File.expand_path(c) } if !configs.empty?
+
+    if options[:foreground]
+      # in foreground we stop another server, and run just 1 current config version
+      error!("foreground expected only one config") if configs.size != 1
+      server_start_foreground(configs.first)
+
+    elsif server_started?
+      say_load_result cmd(:load, *configs)
+
+    else
+      server_start(configs)
+
+    end
+  end
+
+  desc "quit", "eye-daemon quit"
+  def quit
+    res = _cmd(:quit)
+
+    # if eye server got crazy, stop by force
+    ensure_stop_previous_server if res != :corrupted_data
+
+    # remove pid_file
+    File.delete(Eye::Local.pid_path) if File.exists?(Eye::Local.pid_path)
+
+    say "quit...", :yellow
+  end
+
+  [:start, :stop, :restart, :unmonitor, :monitor, :delete, :match].each do |_cmd|
+    desc "#{_cmd} MASK[,...]", "#{_cmd} app,group or process"
+    define_method(_cmd) do |*masks|
+      send_command(_cmd, *masks)
+    end
+  end
+
+  desc "signal SIG MASK[,...]", "send signal to app,group or process"
+  def signal(sig, *masks)
+    send_command(:signal, sig, *masks)
+  end
+
+  desc "break MASK[,...]", "break chain executing"
+  def break(*masks)
+    send_command(:break_chain, *masks)
+  end
+
+  desc "trace [MASK]", "tracing log(tail + grep) for app,group or process"
+  def trace(mask = "")
+    log_trace(mask)
+  end
+
+  map ["-v", "--version"] => :version
+  desc "version", "version"
+  def version
+    say Eye::ABOUT
+  end
+
+  desc "check CONF", "check config file syntax"
+  method_option :host, :type => :string, :aliases => "-h"
+  method_option :verbose, :type => :boolean, :aliases => "-v"
+  def check(conf)
+    conf = File.expand_path(conf) if conf && !conf.empty?
+
+    Eye::System.host = options[:host] if options[:host]
+    Eye::Dsl.verbose = options[:verbose]
+
+    say_load_result Eye::Controller.new.check(conf), :syntax => true
+  end
+
+  desc "explain CONF", "explain config tree"
+  method_option :host, :type => :string, :aliases => "-h"
+  method_option :verbose, :type => :boolean, :aliases => "-v"
+  def explain(conf)
+    conf = File.expand_path(conf) if conf && !conf.empty?
+
+    Eye::System.host = options[:host] if options[:host]
+    Eye::Dsl.verbose = options[:verbose]
+
+    say_load_result Eye::Controller.new.explain(conf), :print_config => true, :syntax => true
+  end
+
+  desc "watch [MASK]", "interactive processes info"
+  def watch(*args)
+    cmd = if `watch --version 2>&1`.chop > '0.2.0'
+      "watch -n 1 --color #{$0} i #{args * ' '}"
+    else
+      "watch -n 1 #{$0} i #{args * ' '}"
+    end
+
+    pid = Process.spawn(cmd)
+    Process.waitpid(pid)
+  rescue Interrupt
+  end
+
+private
+
+  def error!(msg)
+    say msg, :red
+    exit 1
+  end
+
+  def print(msg, new_line = true)
+    say msg if msg && !msg.empty?
+    say if new_line
+  end
+
+  def log_trace(tag = '')
+    log_file = cmd(:logger_dev)
+    if log_file && File.exists?(log_file)
+      Process.exec "tail -n 100 -f #{log_file} | grep '#{tag}'"
+    else
+      error! "log file not found #{log_file.inspect}"
+    end
+  end
+
+end

data/lib/eye/cli/commands.rb

@@ -0,0 +1,79 @@
+module Eye::Cli::Commands
+private
+
+  def client
+    @client ||= Eye::Client.new(Eye::Local.socket_path)
+  end
+
+  def _cmd(cmd, *args)
+    client.command(cmd, *args)
+  rescue Errno::ECONNREFUSED, Errno::ENOENT
+    :not_started
+  end
+
+  def cmd(cmd, *args)
+    res = _cmd(cmd, *args)
+
+    if res == :not_started
+      error! "socket(#{Eye::Local.socket_path}) not found, did you `eye load`?"
+    elsif res == :timeouted
+      error! 'eye does not answer, timeouted...'
+    end
+
+    res
+  end
+
+  def say_load_result(res = {}, opts = {})
+    error!(res) unless res.is_a?(Hash)
+    say_filename = (res.size > 1)
+    say 'eye started!', :green if opts[:started]
+    error = false
+    res.each do |filename, _res|
+      say "#{filename}: ", nil, true if say_filename
+      show_load_message(_res, opts)
+      error = true if _res[:error]
+    end
+
+    exit(1) if error
+  end
+
+  def show_load_message(res, opts = {})
+    if res[:error]
+      say res[:message], :red
+      res[:backtrace].to_a.each{|line| say line, :red }
+    else
+      if opts[:syntax]
+        say 'config ok!', :green if !res[:empty]
+      else
+        say 'config loaded!', :green if !res[:empty]
+      end
+
+      if opts[:print_config]
+        require 'pp'
+        PP.pp res[:config], STDOUT, 150
+      end
+    end
+  end
+
+  def send_command(_cmd, *args)
+    res = cmd(_cmd, *args)
+    if res == :unknown_command
+      error! "unknown command :#{_cmd}"
+    elsif res == :corrupted_data
+      error! 'something crazy wrong, check eye logs!'
+    elsif res.is_a?(Hash)
+      if res[:error]
+        error! "Error: #{res[:error]}"
+      elsif res = res[:result]
+        if res == []
+          error! "command :#{_cmd}, objects not found!"
+        else
+          say "command :#{_cmd} sended to [#{res * ", "}]"
+        end
+      end
+    else
+      error! "unknown result #{res.inspect}"
+    end
+  end
+
+end