eye 0.4.2 → 0.5

data/lib/eye/cli/render.rb

@@ -0,0 +1,137 @@
+module Eye::Cli::Render
+private
+  DF = '%d %b %H:%M'
+
+  def render_info(data)
+    error!("unexpected server answer #{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 = short_state ? 20 : 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 #{data[:state_changed_at].strftime(DF)})" 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
+
+    res = "#{Eye::Utils.human_time(start_time)}, #{cpu.to_i}%"
+    res += ", #{memory / 1024 / 1024}Mb"
+    res += ", <#{pid}>"
+
+    res
+  end
+
+  def render_debug_info(data)
+    error!("unexpected server answer #{data.inspect}") unless data.is_a?(Hash)
+
+    s = ""
+
+    config_yaml = data.delete(:config_yaml)
+
+    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"
+
+    if config_yaml
+      s << "Current config:\n"
+      s << config_yaml
+    end
+
+    s
+  end
+
+  def render_history(data)
+    error!("unexpected server answer #{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 => '...', :at => hist[-1][:at])
+        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)
+    "#{Time.at(h[:at]).strftime(DF)} - #{state} (#{h[:reason]})\n"
+  end
+
+end

data/lib/eye/cli/server.rb

@@ -0,0 +1,85 @@
+module Eye::Cli::Server
+private
+
+  def server_started?
+    _cmd(:ping) == :pong
+  end
+
+  def loader_path
+    filename = File.expand_path(File.join(File.dirname(__FILE__), %w[.. .. .. bin loader_eye]))
+    File.exists?(filename) ? filename : nil
+  end
+
+  def ruby_path
+    require 'rbconfig'
+    RbConfig::CONFIG['bindir'] + '/ruby'
+  end
+
+  def ensure_loader_path
+    unless loader_path
+      error! "start monitoring needs to run under ruby with installed gem 'eye'"
+    end
+  end
+
+  def server_start_foreground(conf = nil)
+    ensure_loader_path
+    Eye::Local.ensure_eye_dir
+
+    if server_started?
+      _cmd(:quit) && sleep(1) # stop previous server
+    end
+
+    args = []
+    args += ['-c', conf] if conf
+    args += ['-l', 'stdout']
+
+    Process.exec(ruby_path, loader_path, *args)
+  end
+
+  def server_start(configs)
+    ensure_loader_path
+    Eye::Local.ensure_eye_dir
+
+    ensure_stop_previous_server
+
+    args = []
+    opts = {:out => '/dev/null', :err => '/dev/null', :in => '/dev/null',
+            :chdir => '/', :pgroup => true}
+
+    pid = Process.spawn(ruby_path, loader_path, *args, opts)
+    Process.detach(pid)
+    File.open(Eye::Local.pid_path, 'w'){|f| f.write(pid) }
+
+    unless wait_server
+      error! 'server not runned in 15 seconds, something crazy wrong'
+    end
+
+    configs.unshift(Eye::Local.eyeconfig) if File.exists?(Eye::Local.eyeconfig)
+
+    if !configs.empty?
+      say_load_result cmd(:load, *configs), :started => true
+    else
+      say 'started!', :green
+    end
+  end
+
+  def ensure_stop_previous_server
+    Eye::Local.ensure_eye_dir
+    pid = File.read(Eye::Local.pid_path).to_i rescue nil
+    if pid
+      Process.kill(9, pid) rescue nil
+    end
+    File.delete(Eye::Local.pid_path) rescue nil
+    true
+  end
+
+  def wait_server(timeout = 15)
+    Timeout.timeout(timeout) do
+      sleep 0.3 while !server_started?
+    end
+    true
+  rescue Timeout::Error
+    false
+  end
+
+end

data/lib/eye/client.rb

@@ -13,7 +13,7 @@ class Eye::Client
   end
 
   def attempt_command(pack)
-    Timeout.timeout(Eye::Settings.client_timeout) do
+    Timeout.timeout(Eye::Local.client_timeout) do
       return send_request(pack)
     end
 
@@ -25,8 +25,8 @@ class Eye::Client
     UNIXSocket.open(@socket_path) do |socket|
       socket.write(pack)
       data = socket.read
-      res = Marshal.load(data) rescue :corrupred_data
+      res = Marshal.load(data) rescue :corrupted_data
     end
   end
 
-end
+end

data/lib/eye/config.rb

@@ -30,33 +30,36 @@ class Eye::Config
       raise Eye::Dsl::Error, "blank pid_file for: #{no_pid_file.map{|c| c[:name]} * ', '}"
     end
 
-    # Check dublicates of the full pid_file
+    # Check duplicates of the full pid_file
 
-    dubl_pids = all_processes.each_with_object(Hash.new(0)) do |o, h|
+    dupl_pids = all_processes.each_with_object(Hash.new(0)) do |o, h|
       ex_pid_file = Eye::System.normalized_file(o[:pid_file], o[:working_dir])
       h[ex_pid_file] += 1
     end
-    dubl_pids = dubl_pids.select{|k,v| v>1}
+    dupl_pids = dupl_pids.select{|k,v| v>1}
 
-    if dubl_pids.present?
-      raise Eye::Dsl::Error, "dublicate pid_files: #{dubl_pids.inspect}"
+    if dupl_pids.present?
+      raise Eye::Dsl::Error, "duplicate pid_files: #{dupl_pids.inspect}"
     end
 
-    # Check dublicates of the full_name
-    dubl_names = all_processes.each_with_object(Hash.new(0)) do |o, h|
+    # Check duplicates of the full_name
+    dupl_names = all_processes.each_with_object(Hash.new(0)) do |o, h|
       full_name = "#{o[:application]}:#{o[:group]}:#{o[:name]}"
       h[full_name] += 1
     end
-    dubl_names = dubl_names.select{|k,v| v>1}
+    dupl_names = dupl_names.select{|k,v| v>1}
 
-    if dubl_names.present?
-      raise Eye::Dsl::Error, "dublicate names: #{dubl_names.inspect}"
+    if dupl_names.present?
+      raise Eye::Dsl::Error, "duplicate names: #{dupl_names.inspect}"
     end
 
     # validate processes with their own validate
     all_processes.each do |process_cfg|
       Eye::Process.validate process_cfg
     end
+
+    # just to be sure ENV was not removed
+    ENV[''] rescue raise Eye::Dsl::Error.new("ENV is not a hash '#{ENV.inspect}'")
   end
 
   def processes
@@ -73,16 +76,16 @@ class Eye::Config
 
   def delete_group(name)
     applications.each do |app_name, app_cfg|
-      app_cfg[:groups].delete(name)
+      (app_cfg[:groups] || {}).delete(name)
     end
   end
 
   def delete_process(name)
     applications.each do |app_name, app_cfg|
-      app_cfg[:groups].each do |gr_name, gr_cfg|
-        gr_cfg[:processes].delete(name)
+      (app_cfg[:groups] || {}).each do |gr_name, gr_cfg|
+        (gr_cfg[:processes] || {}).delete(name)
       end
     end
   end
 
-end
+end

data/lib/eye/controller.rb

@@ -1,19 +1,17 @@
 require 'celluloid'
-
 require 'yaml'
-require 'active_support'
-require 'active_support/core_ext/object/blank'
-require 'active_support/core_ext/object/try'
-require 'active_support/core_ext/numeric'
-require 'active_support/core_ext/string/filters'
-require 'active_support/core_ext/array/extract_options'
 
 require_relative 'utils/celluloid_klass'
 require_relative 'utils/pmap'
 
+require_relative 'utils/leak_19'
+require_relative 'utils/mini_active_support'
+
 # Extend all objects with logger
 Object.send(:include, Eye::Logger::ObjectExt)
 
+Eye::Sigar # needs to preload
+
 class Eye::Controller
   include Celluloid
 
@@ -22,7 +20,6 @@ class Eye::Controller
   autoload :Commands,       'eye/controller/commands'
   autoload :Status,         'eye/controller/status'
   autoload :SendCommand,    'eye/controller/send_command'
-  autoload :ShowHistory,    'eye/controller/show_history'
   autoload :Options,        'eye/controller/options'
 
   include Eye::Controller::Load
@@ -30,7 +27,6 @@ class Eye::Controller
   include Eye::Controller::Commands
   include Eye::Controller::Status
   include Eye::Controller::SendCommand
-  include Eye::Controller::ShowHistory
   include Eye::Controller::Options
 
   attr_reader :applications, :current_config
@@ -42,7 +38,7 @@ class Eye::Controller
     @current_config = Eye::Config.new
 
     Celluloid::logger = Eye::Logger.new('celluloid')
-    Eye::SystemResources.setup
+    Eye::SystemResources.cache
 
     info "starting #{Eye::ABOUT} (#{$$})"
   end

data/lib/eye/controller/commands.rb

@@ -16,14 +16,6 @@ module Eye::Controller::Commands
         signal(*args)
       when :load
         load(*args)
-      when :info
-        info_string(*args)
-      when :xinfo
-        info_string_debug(*args)
-      when :oinfo
-        info_string_short(*args)
-      when :history
-        history_string(*args)
       when :quit
         quit
       when :check
@@ -38,9 +30,13 @@ module Eye::Controller::Commands
         Eye::Logger.dev
 
       # object commands, for api
-      when :raw_info
+      when :info_data
         info_data(*args)
-      when :raw_history
+      when :short_data
+        short_data(*args)
+      when :debug_data
+        debug_data(*args)
+      when :history_data
         history_data(*args)
 
       else

data/lib/eye/controller/helpers.rb

@@ -8,7 +8,7 @@ module Eye::Controller::Helpers
   end
 
   def save_cache
-    File.open(Eye::Settings.cache_path, 'w') { |f| f.write(cache_str) }
+    File.open(Eye::Local.cache_path, 'w') { |f| f.write(cache_str) }
   rescue => ex
     log_ex(ex)
   end

data/lib/eye/controller/send_command.rb

@@ -35,8 +35,11 @@ private
 
   rescue Error => ex
     log_ex(ex)
-
     {:error => ex.message}
+
+  rescue Celluloid::DeadActorError => ex
+    log_ex(ex)
+    {:error => "'#{ex.message}', try again!"}
   end
 
   def remove_object_from_tree(obj)
@@ -75,7 +78,7 @@ private
     end
 
     res = Eye::Utils::AliveArray.new
-    obj_strs.map{|c| c.to_s.split(",")}.flatten.each do |mask|
+    obj_strs.map{|c| c.to_s.split(',')}.flatten.each do |mask|
       objs = find_objects_by_mask(mask.to_s.strip)
       objs.select! { |obj| obj.app_name == h[:application] } if h[:application]
       res += objs

data/lib/eye/controller/status.rb

@@ -1,50 +1,42 @@
 module Eye::Controller::Status
 
-  def info_string(*args)
-    make_str(info_data(*args)).to_s
-  end
-
-  def info_string_short(*args)
-    make_str({:subtree => @applications.map{|a| a.status_data_short } }).to_s
-  end
-
-  def info_string_debug(*args)
+  def debug_data(*args)
     h = args.extract_options!
     actors = Celluloid::Actor.all.map{|actor| actor.__klass__ }.group_by{|a| a}.map{|k,v| [k, v.size]}.sort_by{|a|a[1]}.reverse
 
-    str = <<-S
-About:  #{Eye::ABOUT}
-Info:   #{resources_str(Eye::SystemResources.resources($$))}
-Ruby:   #{RUBY_DESCRIPTION}
-Gems:   #{%w|Celluloid Celluloid::IO ActiveSupport StateMachine NIO|.map{|c| gem_version(c) }}
-Logger: #{Eye::Logger.dev}
-Socket: #{Eye::Settings::socket_path}
-Pid:    #{Eye::Settings::pid_path}
-Actors: #{actors.inspect}
-
-    S
+    res = {
+      :about => Eye::ABOUT,
+      :resources => Eye::SystemResources.resources($$),
+      :ruby => RUBY_DESCRIPTION,
+      :gems => %w|Celluloid Celluloid::IO StateMachine NIO Sigar|.map{|c| gem_version(c) },
+      :logger => Eye::Logger.dev,
+      :pid_path => Eye::Local::pid_path,
+      :actors => actors
+    }
 
-    str += make_str(info_data_debug) + "\n" if h[:processes].present?
+    res[:config_yaml] = YAML.dump(current_config.to_h) if h[:config].present?
 
-    if h[:config].present?
-      str += "\nCurrent config: \n"
-      str += YAML.dump(current_config.to_h)
-    end
-
-    GC.start
-    str
+    res
   end
 
   def info_data(*args)
     {:subtree => info_objects(*args).map{|a| a.status_data } }
   end
 
-private
+  def short_data(*args)
+    {:subtree => @applications.map{|a| a.status_data_short } }
+  end
 
-  def info_data_debug(*args)
-    {:subtree => info_objects(*args).map{|a| a.status_data(true) } }
+  def history_data(*args)
+    res = {}
+    history_objects(*args).each do |process|
+      res[process.full_name] = process.schedule_history.reject{|c| c[:state] == :check_crash }
+    end
+    res
   end
 
+private
+
   def info_objects(*args)
     res = []
     return @applications if args.empty?
@@ -52,79 +44,6 @@ private
     res
   end
 
-  def make_str(data, level = -1)
-    return nil if data.blank?
-
-    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
-        name = (data[:type] == :application && data[:state].blank?) ? "\033[1m#{data[:name]}\033[0m" : data[:name].to_s
-        off_len = (data[:type] == :application && !data[:state].blank?) ? 20 : 35
-        str = off_str + (name + ' ').ljust(off_len - off, data[:state] ? '.' : ' ')
-
-        if data[:debug]
-          str += ' | ' + debug_str(data[:debug])
-
-          # for group show chain data
-          if data[:debug][:chain]
-            str += " (chain: #{data[:debug][:chain].map(&:to_i)})"
-          end
-        elsif data[:state]
-          str += ' ' + data[:state].to_s
-          str += '  (' + resources_str(data[:resources]) + ')' if data[:resources].present? && data[:state].to_sym == :up
-          str += " (#{data[:state_reason]} at #{data[:state_changed_at].to_s(:short)})" 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].blank? && data[:type] != :application
-        nil
-      else
-        [str, make_str(data[:subtree], level + 1)].compact * "\n"
-      end
-    end
-  end
-
-  def resources_str(r)
-    return '' if r.blank?
-
-    res = "#{r[:start_time]}, #{r[:cpu]}%"
-    res += ", #{r[:memory] / 1024}Mb" if r[:memory]
-    res += ", <#{r[:pid]}>"
-
-    res
-  end
-
-  def debug_str(debug)
-    return '' unless debug
-
-    q = 'q(' + (debug[:queue] || []) * ',' + ')'
-    w = 'w(' + (debug[:watchers] || []) * ',' + ')'
-
-    [w, q] * '; '
-  end
-
-  def status_applications(app = nil)
-    apps = app.present? ? @applications.select{|a| a.name == app} : nil
-    apps = @applications unless apps
-    apps
-  end
-
   def gem_version(klass)
     v = nil
     begin
@@ -135,4 +54,17 @@ private
     "#{klass}=#{v}"
   end
 
-end
+  def history_objects(*args)
+    args = ['*'] if args.empty?
+    res = []
+    matched_objects(*args) do |obj|
+      if (obj.is_a?(Eye::Process) || obj.is_a?(Eye::ChildProcess))
+        res << obj
+      else
+        res += obj.processes.to_a
+      end
+    end
+    Eye::Utils::AliveArray.new(res)
+  end
+
+end