ace-eye 0.6.1

data/lib/eye/child_process.rb

@@ -0,0 +1,101 @@
+require 'celluloid'
+
+class Eye::ChildProcess
+  include Celluloid
+
+  # needs: kill_process
+  include Eye::Process::Commands
+
+  # easy config + defaults: prepare_config, c, []
+  include Eye::Process::Config
+
+  # conditional watchers: start_checkers
+  include Eye::Process::Watchers
+
+  # system methods: send_signal
+  include Eye::Process::System
+
+  # self_status_data
+  include Eye::Process::Data
+
+  # manage notify methods
+  include Eye::Process::Notify
+
+  # scheduler
+  include Eye::Process::Scheduler
+
+  attr_reader :pid, :name, :full_name, :config, :watchers
+
+  def initialize(pid, config = {}, logger_prefix = nil, parent_pid = nil)
+    raise 'Empty pid' unless pid
+
+    @pid = pid
+    @parent_pid = parent_pid
+    @config = prepare_config(config)
+    @name = "child-#{pid}"
+    @full_name = [logger_prefix, @name] * ':'
+
+    @watchers = {}
+
+    debug "start monitoring CHILD config: #{@config.inspect}"
+
+    start_checkers
+  end
+
+  def logger_tag
+    full_name
+  end
+
+  def state
+    :up
+  end
+
+  def up?
+    state == :up
+  end
+
+  def send_command(command, *args)
+    schedule command, *args, Eye::Reason::User.new(command)
+  end
+
+  def start
+  end
+
+  def stop
+    kill_process
+  end
+
+  def restart
+    if self[:restart_command]
+      execute_restart_command
+    else
+      stop
+    end
+  end
+
+  def monitor
+  end
+
+  def unmonitor
+  end
+
+  def delete
+  end
+
+  def destroy
+    remove_watchers
+    terminate
+  end
+
+  def signal(sig)
+    send_signal(sig) if self.pid
+  end
+
+  def status_data(debug = false)
+    self_status_data(debug)
+  end
+
+  def prepare_command(command) # override
+    super.gsub('{PARENT_PID}', @parent_pid.to_s)
+  end
+end

data/lib/eye/cli.rb

@@ -0,0 +1,185 @@
+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))
+    if mask && res[:subtree] && res[:subtree].empty?
+      error!("command :info, objects not found!")
+    end
+    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(mask = nil)
+    res = cmd(:short_data, *Array(mask))
+    say render_info(res)
+    say
+  end
+
+  desc "history [MASK,...]", "processes history"
+  def history(*masks)
+    res = cmd(:history_data, *masks)
+    if !masks.empty? && res && res.empty?
+      error!("command :history, objects not found!")
+    end
+    say render_history(res)
+    say
+  end
+
+  desc "load [CONF, ...]", "load config (run eye-daemon if not) (-f foreground load)"
+  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"
+  method_option :stop_all, :type => :boolean, :aliases => "-s"
+  method_option :timeout, :type => :string, :aliases => "-t", :default => "600"
+  def quit
+    if options[:stop_all]
+      Eye::Local.client_timeout = options[:timeout].to_i
+      cmd(:stop_all, options[:timeout].to_i)
+    end
+
+    Eye::Local.client_timeout = 5
+    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::Local.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::Local.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)
+    error!("You should install watch utility") if `which watch`.empty?
+
+    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
+
+  def self.exit_on_failure?
+    true
+  end
+end

data/lib/eye/cli/commands.rb

@@ -0,0 +1,78 @@
+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 run `eye load`?"
+    elsif res == :timeouted
+      error! 'eye timed out without responding...'
+    end
+
+    res
+  end
+
+  def say_load_result(res = {}, opts = {})
+    error!(res) unless res.is_a?(Hash)
+    say_filename = (res.size > 1)
+    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} sent to [#{res * ", "}]"
+        end
+      end
+    else
+      error! "unknown result #{res.inspect}"
+    end
+  end
+
+end

data/lib/eye/cli/render.rb

@@ -0,0 +1,130 @@
+module Eye::Cli::Render
+private
+  def render_info(data)
+    error!("unexpected server response #{data.inspect}") unless data.is_a?(Hash)
+
+    make_str data
+  end
+
+  def make_str(data, level = -1)
+    return nil if !data || data.empty?
+
+    if data.is_a?(Array)
+      data.map{|el| make_str(el, level) }.compact * "\n"
+    else
+      str = nil
+
+      if data[:name]
+        return make_str(data[:subtree], level) if data[:name] == '__default__'
+
+        off = level * 2
+        off_str = ' ' * off
+
+        short_state = (data[:type] == :application && data[:states])
+        is_text = data[:state] || data[:states]
+
+        name = (data[:type] == :application && !is_text) ? "\033[1m#{data[:name]}\033[0m" : data[:name].to_s
+        off_len = 35
+        str = off_str + (name + ' ').ljust(off_len - off, is_text ? '.' : ' ')
+
+        if short_state
+          str += ' ' + data[:states].map { |k, v| "#{k}:#{v}" }.join(', ')
+        elsif data[:state]
+          str += ' ' + data[:state].to_s
+          str += '  (' + resources_str(data[:resources]) + ')' if data[:resources] && data[:state].to_sym == :up
+          str += " (#{data[:state_reason]} at #{Eye::Utils.human_time2(data[:state_changed_at])})" if data[:state_reason] && data[:state] == 'unmonitored'
+        elsif data[:current_command]
+          chain_progress = if data[:chain_progress]
+            " #{data[:chain_progress][0]} of #{data[:chain_progress][1]}" rescue ''
+          end
+          str += " \e[1;33m[#{data[:current_command]}#{chain_progress}]\033[0m"
+          str += " (#{data[:chain_commands] * ', '})" if data[:chain_commands]
+        end
+
+      end
+
+      if data[:subtree].nil?
+        str
+      elsif !data[:subtree] && data[:type] != :application
+        nil
+      else
+        [str, make_str(data[:subtree], level + 1)].compact * "\n"
+      end
+    end
+  end
+
+  def resources_str(r)
+    return '' if !r || r.empty?
+    memory, cpu, start_time, pid = r[:memory], r[:cpu], r[:start_time], r[:pid]
+    return '' unless memory && cpu && start_time
+
+    "#{Eye::Utils.human_time(start_time)}, #{cpu.to_i}%, #{memory / 1024 / 1024}Mb, <#{pid}>"
+  end
+
+  def render_debug_info(data)
+    error!("unexpected server response #{data.inspect}") unless data.is_a?(Hash)
+
+    s = ""
+
+    if config_yaml = data.delete(:config_yaml)
+      s << config_yaml
+
+    else
+      data.each do |k, v|
+        s << "#{"#{k}:".ljust(10)} "
+
+        case k
+        when :resources
+          s << resources_str(v)
+        else
+          s << "#{v}"
+        end
+
+        s << "\n"
+      end
+
+      s << "\n"
+    end
+
+    s
+  end
+
+  def render_history(data)
+    error!("unexpected server response #{data.inspect}") unless data.is_a?(Hash)
+
+    res = []
+    data.each do |name, data|
+      res << detail_process_info(name, data)
+    end
+
+    res * "\n"
+  end
+
+  def detail_process_info(name, history)
+    return if history.empty?
+
+    res = "\033[1m#{name}\033[0m\n"
+    history = history.reverse
+
+    history.chunk{|h| [h[:state], h[:reason].to_s] }.each do |_, hist|
+      if hist.size >= 3
+        res << detail_process_info_string(hist[0])
+        res << detail_process_info_string(:state => "... #{hist.size - 2} times", :reason => '...')
+        res << detail_process_info_string(hist[-1])
+      else
+        hist.each do |h|
+          res << detail_process_info_string(h)
+        end
+      end
+    end
+
+    res
+  end
+
+  def detail_process_info_string(h)
+    state = h[:state].to_s.ljust(14)
+    at = h[:at] ? Eye::Utils.human_time2(h[:at]) : '.' * 12
+    "#{at} - #{state} (#{h[:reason]})\n"
+  end
+
+end