eye 0.7 → 0.8.celluloid15

data/lib/eye/cli/commands.rb

@@ -1,4 +1,5 @@
 module Eye::Cli::Commands
+
 private
 
   def client
@@ -39,12 +40,10 @@ private
   def show_load_message(res, opts = {})
     if res[:error]
       say res[:message], :red
-      res[:backtrace].to_a.each{|line| say line, :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]
+      unless res[:empty]
+        say(opts[:syntax] ? 'Config ok!' : 'Config loaded!', :green)
       end
 
       if opts[:print_config]

data/lib/eye/cli/render.rb

@@ -1,9 +1,11 @@
 module Eye::Cli::Render
+
 private
+
   def render_status(data)
     return [1, "unexpected server response #{data.inspect}"] unless data.is_a?(Hash)
     data = data[:subtree]
-    return [1, "match #{data.size} objects (#{data.map{|d| d[:name]}}), but expected only 1 process"] if data.size != 1
+    return [1, "match #{data.size} objects (#{data.map { |d| d[:name] }}), but expected only 1 process"] if data.size != 1
     process = data[0]
     return [1, "unknown status for :#{process[:type]}=#{process[:name]}"] unless process[:type] == :process
 
@@ -24,37 +26,14 @@ private
     return nil if !data || data.empty?
 
     if data.is_a?(Array)
-      data.map{|el| make_str(el, level) }.compact * "\n"
+      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[:type] == :group) && 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
-
+        str = render_element(data, level)
       end
 
       if data[:subtree].nil?
@@ -67,18 +46,10 @@ private
     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 = ""
+    s = ''
 
     if config_yaml = data.delete(:config_yaml)
       s << config_yaml
@@ -88,10 +59,10 @@ private
         s << "#{"#{k}:".ljust(10)} "
 
         case k
-        when :resources
-          s << resources_str(v)
-        else
-          s << "#{v}"
+          when :resources
+            s << resources_str(v)
+          else
+            s << "#{v}"
         end
 
         s << "\n"
@@ -114,10 +85,10 @@ private
     res = "\033[1m#{name}\033[0m\n"
     history = history.reverse
 
-    history.chunk{|h| [h[:state], h[:reason].to_s] }.each do |_, hist|
+    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(state: "... #{hist.size - 2} times", reason: '...')
         res << detail_process_info_string(hist[-1])
       else
         hist.each do |h|
@@ -135,4 +106,53 @@ private
     "#{at} - #{state} (#{h[:reason]})\n"
   end
 
+private
+
+  def render_element(data, level)
+    off = level * 2
+    off_str = ' ' * off
+
+    short_state = (data[:type] == :application || data[:type] == :group) && 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
+      if data[:resources] && data[:state].to_sym == :up
+        str += '  (' + resources_str(data[:resources])
+        str += ", <#{data[:procline]}>" if data[:procline]
+        str += ')'
+      end
+      if data[:state_reason] && data[:state] == 'unmonitored'
+        str += " (#{data[:state_reason]} at #{Eye::Utils.human_time2(data[:state_changed_at])})"
+      end
+    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
+
+    str
+  end
+
+  def resources_str(r)
+    return '' if !r || r.empty?
+
+    memory = r[:memory]
+    cpu = r[:cpu]
+    start_time = r[:start_time]
+    pid = r[:pid]
+
+    return '' unless memory && cpu && start_time
+
+    "#{Eye::Utils.human_time(start_time)}, #{cpu.to_i}%, #{memory / 1024 / 1024}Mb, <#{pid}>"
+  end
+
 end

data/lib/eye/cli/server.rb

@@ -1,6 +1,7 @@
 # encoding: utf-8
 
 module Eye::Cli::Server
+
 private
 
   def server_started?
@@ -26,17 +27,15 @@ private
     ensure_loader_path
     Eye::Local.ensure_eye_dir
 
-    if server_started?
-      _cmd(:quit) && sleep(1) # stop previous server
-    end
-
     args = []
     args += ['--config', conf] if conf
     args += ['--logger', 'stdout']
+    args += ['--stop_all']
     if Eye::Local.local_runner
-      args += ['--stop_all']
       args += ['--dir', Eye::Local.dir]
-      args += ['--config', Eye::Local.eyefile] unless conf
+      if !conf && Eye::Local.eyefile
+        args += ['--config', Eye::Local.eyefile]
+      end
     end
 
     Process.exec(ruby_path, loader_path, *args)
@@ -51,12 +50,18 @@ private
     args = []
     args += ['--dir', Eye::Local.dir] if Eye::Local.local_runner
 
-    opts = {:out => '/dev/null', :err => '/dev/null', :in => '/dev/null',
-            :chdir => '/', :pgroup => true}
+    chdir = if Eye::Local.local_runner
+      Eye::Local.home
+    else
+      '/'
+    end
+
+    opts = { out: '/dev/null', err: '/dev/null', in: '/dev/null',
+             chdir: 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) }
+    File.open(Eye::Local.pid_path, 'w') { |f| f.write(pid) }
 
     unless wait_server
       error! 'server has not started in 15 seconds, something is very wrong'
@@ -64,11 +69,11 @@ private
 
     configs.unshift(Eye::Local.global_eyeconfig) if File.exist?(Eye::Local.global_eyeconfig)
     configs.unshift(Eye::Local.eyeconfig) if File.exist?(Eye::Local.eyeconfig)
-    configs << Eye::Local.eyefile if Eye::Local.local_runner
+    configs << Eye::Local.eyefile if Eye::Local.local_runner && Eye::Local.eyefile
 
-    say 'Eye started! ㋡', :green
+    say "Eye started! ㋡ (#{Eye::Local.home})", :green
 
-    if !configs.empty?
+    if configs.any?
       say_load_result cmd(:load, *configs)
     end
   end
@@ -76,16 +81,14 @@ private
   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
+    Process.kill(9, pid) rescue nil if pid
     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?
+      sleep 0.3 until server_started?
     end
     true
   rescue Timeout::Error

data/lib/eye/client.rb

@@ -2,6 +2,7 @@ require 'socket'
 require 'timeout'
 
 class Eye::Client
+
   attr_reader :socket_path
 
   def initialize(socket_path)

data/lib/eye/config.rb

@@ -32,71 +32,74 @@ class Eye::Config
 
   # raise an error if config wrong
   def validate!(validate_apps = [])
-    all_processes = processes
-
     # Check blank pid_files
-    no_pid_file = all_processes.select{|c| c[:pid_file].blank? }
-    if no_pid_file.present?
-      raise Eye::Dsl::Error, "blank pid_file for: #{no_pid_file.map{|c| c[:name]} * ', '}"
+    no_pid_file = []
+    each_process { |c| no_pid_file << c if c[:pid_file].blank? }
+    if no_pid_file.any?
+      raise Eye::Dsl::Error, "blank pid_file for: #{no_pid_file.map { |c| c[:name] } * ', '}"
     end
 
     # Check duplicates of the full pid_file
 
-    dupl_pids = all_processes.each_with_object(Hash.new(0)) do |o, h|
+    dupl_pids = Hash.new(0)
+    each_process do |o|
       ex_pid_file = Eye::System.normalized_file(o[:pid_file], o[:working_dir])
-      h[ex_pid_file] += 1
+      dupl_pids[ex_pid_file] += 1
     end
-    dupl_pids = dupl_pids.select{|k,v| v>1}
+    dupl_pids = dupl_pids.select { |_, v| v > 1 }
 
-    if dupl_pids.present?
+    if dupl_pids.any?
       raise Eye::Dsl::Error, "duplicate pid_files: #{dupl_pids.inspect}"
     end
 
     # Check duplicates of the full_name
-    dupl_names = all_processes.each_with_object(Hash.new(0)) do |o, h|
+    dupl_names = Hash.new(0)
+    each_process do |o|
       full_name = "#{o[:application]}:#{o[:group]}:#{o[:name]}"
-      h[full_name] += 1
+      dupl_names[full_name] += 1
     end
-    dupl_names = dupl_names.select{|k,v| v>1}
+    dupl_names = dupl_names.select { |_, v| v > 1 }
 
-    if dupl_names.present?
+    if dupl_names.any?
       raise Eye::Dsl::Error, "duplicate names: #{dupl_names.inspect}"
     end
 
     # validate processes with their own validate
-    all_processes.each do |process_cfg|
+    each_process do |process_cfg|
       Eye::Process.validate process_cfg, validate_apps.include?(process_cfg[:application])
     end
 
     # just to be sure ENV was not removed
-    ENV[''] rescue raise Eye::Dsl::Error.new("ENV is not a hash '#{ENV.inspect}'")
+    ENV[''] rescue raise Eye::Dsl::Error, "ENV is not a hash '#{ENV.inspect}'"
   end
 
   def transform!
-    all_processes = processes
-
     # transform syslog option
-    all_processes.each do |process|
+    each_process do |process|
       out = process[:stdout] && process[:stdout].start_with?(':syslog')
       err = process[:stderr] && process[:stderr].start_with?(':syslog')
-      if err || out
-        redir = err ? '2>&1' : ''
-        process[:stdout] = nil if out
-        process[:stderr] = nil if err
+      next unless err || out
 
-        escaped_start_command = process[:start_command].to_s.gsub(%{"}, %{\\"})
+      redir = err ? '2>&1' : ''
+      process[:stdout] = nil if out
+      process[:stderr] = nil if err
 
-        names = [process[:application], process[:group] == '__default__' ? nil :  process[:group], process[:name]].compact
-        logger = "logger -t \"#{names.join(':')}\""
+      escaped_start_command = process[:start_command].to_s.gsub(%{"}, %{\\"})
 
-        process[:start_command] = %{sh -c "#{escaped_start_command} #{redir} | #{logger}"}
-        process[:use_leaf_child] = true if process[:daemonize]
-      end
+      names = [process[:application], process[:group] == '__default__' ? nil : process[:group], process[:name]].compact
+      logger = "logger -t \"#{names.join(':')}\""
+
+      process[:start_command] = %{sh -c "#{escaped_start_command} #{redir} | #{logger}"}
+      process[:use_leaf_child] = true if process[:daemonize]
     end
   end
 
-  def processes
-    applications.values.map{|e| (e[:groups] || {}).values.map{|c| (c[:processes] || {}).values} }.flatten
+  def each_process(&block)
+    applications.each_value do |app_cfg|
+      (app_cfg[:groups] || {}).each_value do |gr_cfg|
+        (gr_cfg[:processes] || {}).each_value(&block)
+      end
+    end
   end
 
   def application_names
@@ -108,14 +111,14 @@ class Eye::Config
   end
 
   def delete_group(name)
-    applications.each do |app_name, app_cfg|
+    applications.each do |_app_name, app_cfg|
       (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|
+    applications.each do |_app_name, app_cfg|
+      (app_cfg[:groups] || {}).each do |_gr_name, gr_cfg|
         (gr_cfg[:processes] || {}).delete(name)
       end
     end

data/lib/eye/controller.rb

@@ -2,8 +2,6 @@ require 'celluloid'
 require 'yaml'
 
 require_relative 'utils/pmap'
-
-require_relative 'utils/leak_19'
 require_relative 'utils/mini_active_support'
 
 # Extend all objects with logger
@@ -14,6 +12,7 @@ Eye::Sigar
 Eye::SystemResources
 
 class Eye::Controller
+
   include Celluloid
 
   autoload :Load,           'eye/controller/load'
@@ -36,7 +35,7 @@ class Eye::Controller
     @applications = []
     @current_config = Eye::Config.new
 
-    Celluloid::logger = Eye::Logger.new('celluloid')
+    Celluloid.logger = Eye::Logger.new('celluloid')
 
     info "starting #{Eye::ABOUT} <#{$$}>"
   end

data/lib/eye/controller/commands.rb

@@ -1,7 +1,7 @@
 module Eye::Controller::Commands
 
   NOT_IMPORTANT_COMMANDS = [:info_data, :short_data, :debug_data, :history_data, :ping,
-    :logger_dev, :match, :explain, :check]
+                            :logger_dev, :match, :explain, :check]
 
   # Main method, answer for the client command
   def command(cmd, *args)

data/lib/eye/controller/helpers.rb

@@ -5,7 +5,7 @@ module Eye::Controller::Helpers
     str = 'l' + str if Eye::Local.local_runner
     str += " [#{@applications.map(&:name) * ', '}]" if @applications.present?
     str += " (v #{ENV['EYE_V']})" if ENV['EYE_V']
-    str += " (in #{Eye::Local.dir})"
+    str += " (in #{Eye::Local.home})"
     $0 = str
   end
 
@@ -16,7 +16,7 @@ module Eye::Controller::Helpers
   end
 
   def cache_str
-    all_processes.map{ |p| "#{p.full_name}=#{p.state}" } * "\n"
+    all_processes.map { |p| "#{p.full_name}=#{p.state}" } * "\n"
   end
 
   def process_by_name(name)

data/lib/eye/controller/load.rb

@@ -13,7 +13,7 @@ module Eye::Controller::Load
     obj_strs = args.flatten
     info "=> loading: #{obj_strs}"
 
-    res = Hash.new
+    res = {}
 
     globbing(*obj_strs).each do |filename|
       res[filename] = catch_load_error(filename) do
@@ -35,8 +35,8 @@ private
   # regexp for clean backtrace to show for user
   BT_REGX = %r[/lib/eye/|lib/celluloid|internal:prelude|logger.rb:|active_support/core_ext|shellwords.rb|kernel/bootstrap].freeze
 
-  def catch_load_error(filename = nil, &block)
-    { :error => false, :config => yield }
+  def catch_load_error(filename = nil, &_block)
+    { error: false, config: yield }
 
   rescue Eye::Dsl::Error, Exception, NoMethodError => ex
     raise if ex.class.to_s.include?('RR') # skip RR exceptions
@@ -45,10 +45,10 @@ private
 
     # filter backtrace for user output
     bt = (ex.backtrace || [])
-    bt = bt.reject{|line| line.to_s =~ BT_REGX } unless ENV['EYE_FULL_BACKTRACE']
+    bt = bt.reject { |line| line.to_s =~ BT_REGX } unless ENV['EYE_FULL_BACKTRACE']
     error bt.join("\n")
 
-    res = { :error => true, :message => ex.message }
+    res = { error: true, message: ex.message }
     res[:backtrace] = bt if bt.present?
     res
   end
@@ -58,6 +58,8 @@ private
     return res if obj_strs.empty?
 
     obj_strs.each do |filename|
+      next unless filename
+
       mask = File.directory?(filename) ? File.join(filename, '{*.eye}') : filename
       debug { "loading: globbing mask #{mask}" }
 
@@ -76,11 +78,7 @@ private
   # return: result, config
   def parse_config(filename)
     debug { "parsing: #{filename}" }
-
-    cfg = Eye::Dsl.parse(nil, filename)
-    @current_config.merge(cfg).validate! # just validate summary config here
-    Eye.parsed_config = nil # remove link on config, for better gc
-    cfg
+    Eye::Dsl.parse(nil, filename)
   end
 
   # !!! exclusive operation
@@ -126,7 +124,7 @@ private
       app.groups.each do |group|
         @old_groups[group.name] = group
         group.processes.each do |proc|
-          @old_processes[group.name + ":" + proc.name] = proc
+          @old_processes[group.name + ':' + proc.name] = proc
         end
       end
 
@@ -139,7 +137,8 @@ private
 
     app = Eye::Application.new(app_name, app_config)
     @applications << app
-    @added_groups, @added_processes = [], []
+    @added_groups = []
+    @added_processes = []
 
     new_groups = app_config.delete(:groups) || {}
     new_groups.each do |group_name, group_cfg|
@@ -149,8 +148,11 @@ private
     end
 
     # now, need to clear @old_groups, and @old_processes
-    @old_groups.each{|_, group| group.clear; group.send_command(:delete) }
-    @old_processes.each{|_, process| process.send_command(:delete) if process.alive? }
+    @old_groups.each do |_, group|
+      group.clear
+      group.send_command(:delete)
+    end
+    @old_processes.each { |_, process| process.send_command(:delete) if process.alive? }
 
     # schedule monitoring for new groups, processes
     added_fully_groups = []
@@ -161,8 +163,8 @@ private
       end
     end
 
-    added_fully_groups.each{|group| group.send_command :monitor }
-    @added_processes.each{|process| process.send_command :monitor }
+    added_fully_groups.each { |group| group.send_command :monitor }
+    @added_processes.each { |process| process.send_command :monitor }
 
     # remove links to prevent memory leaks
     @old_groups = nil
@@ -199,7 +201,7 @@ private
   end
 
   def update_or_create_process(process_name, process_cfg)
-    postfix = ":" + process_name
+    postfix = ':' + process_name
     name = process_cfg[:group] + postfix
     key = @old_processes[name] ? name : @old_processes.keys.detect { |n| n.end_with?(postfix) }