eye 0.7 → 0.8.celluloid15

data/lib/eye/checker/children_count.rb

@@ -32,7 +32,7 @@ private
 
   def ordered_by_date_children_pids
     children = process.children.values
-    children.sort_by { |ch| Eye::SystemResources.start_time(ch.pid).to_i }.map &:pid
+    children.sort_by { |ch| Eye::SystemResources.start_time(ch.pid).to_i }.map(&:pid)
   end
 
 end

data/lib/eye/checker/file_ctime.rb

@@ -15,7 +15,7 @@ class Eye::Checker::FileCTime < Eye::Checker
   end
 
   def human_value(value)
-    if value == nil
+    if value.nil?
       'Err'
     else
       value.strftime('%H:%M')

data/lib/eye/checker/http.rb

@@ -21,46 +21,43 @@ class Eye::Checker::Http < Eye::Checker::Defer
     @uri = URI.parse(url)
     @proxy_uri = URI.parse(proxy_url) if proxy_url
     @kind = case kind
-              when Fixnum then Net::HTTPResponse::CODE_TO_OBJ[kind.to_s]
-              when String, Symbol then Net.const_get("HTTP#{kind.to_s.camelize}") rescue Net::HTTPSuccess
-              else Net::HTTPSuccess
-            end
+      when Fixnum then Net::HTTPResponse::CODE_TO_OBJ[kind.to_s]
+      when String, Symbol then Net.const_get("HTTP#{kind.to_s.camelize}") rescue Net::HTTPSuccess
+      else Net::HTTPSuccess
+    end
     @open_timeout = (open_timeout || 3).to_f
     @read_timeout = (read_timeout || timeout || 15).to_f
   end
 
   def get_value
-    res = session.start{ |http| http.get(@uri.request_uri) }
-    {:result => res}
+    res = session.start { |http| http.get(@uri.request_uri) }
+    { result: res }
 
   rescue Timeout::Error => ex
     debug { ex.inspect }
 
     if defined?(Net::OpenTimeout) # for ruby 2.0
       mes = ex.is_a?(Net::OpenTimeout) ? "OpenTimeout<#{@open_timeout}>" : "ReadTimeout<#{@read_timeout}>"
-      {:exception => mes}
+      { exception: mes }
     else
-      {:exception => "Timeout<#{@open_timeout},#{@read_timeout}>"}
+      { exception: "Timeout<#{@open_timeout},#{@read_timeout}>" }
     end
 
   rescue => ex
-    {:exception => "Error<#{ex.message}>"}
+    { exception: "Error<#{ex.message}>" }
   end
 
   def good?(value)
     return false unless value[:result]
-
-    unless value[:result].kind_of?(@kind)
-      return false
-    end
+    return false unless value[:result].is_a?(@kind)
 
     if pattern
       matched = if pattern.is_a?(Regexp)
-        pattern === value[:result].body
+        !!value[:result].body.match(pattern)
       else
         value[:result].body.include?(pattern.to_s)
       end
-      value[:notice] = "missing '#{pattern.to_s}'" unless matched
+      value[:notice] = "missing '#{pattern}'" unless matched
       matched
     else
       true
@@ -102,4 +99,5 @@ private
       Net::HTTP.new(@uri.host, @uri.port)
     end
   end
+
 end

data/lib/eye/checker/nop.rb

@@ -3,4 +3,5 @@ class Eye::Checker::Nop < Eye::Checker
   # check :nop, :every => 10.hours # means restart every 10 hours
 
   def get_value; end
+
 end

data/lib/eye/checker/socket.rb

@@ -27,78 +27,75 @@ class Eye::Checker::Socket < Eye::Checker::Defer
 
     if addr =~ %r[\Atcp://(.*?):(.*?)\z]
       @socket_family = :tcp
-      @socket_addr = $1
-      @socket_port = $2.to_i
+      @socket_addr = Regexp.last_match(1)
+      @socket_port = Regexp.last_match(2).to_i
     elsif addr =~ %r[\Aunix:(.*)\z]
       @socket_family = :unix
-      @socket_path = $1
+      @socket_path = Regexp.last_match(1)
     end
   end
 
   def get_value
     sock = begin
-      Timeout::timeout(@open_timeout){ open_socket }
+      Timeout.timeout(@open_timeout) { open_socket }
     rescue Timeout::Error
-      return { :exception => "OpenTimeout<#{@open_timeout}>" }
+      return { exception: "OpenTimeout<#{@open_timeout}>" }
     end
 
-    if send_data
-      begin
-        Timeout::timeout(@read_timeout) do
-          _write_data(sock, send_data)
-          result = _read_data(sock)
+    return { result: :listen } unless send_data
 
-          { :result => result }
-        end
-      rescue Timeout::Error
-        if protocol == :raw
-          return { :result => @buffer }
-        else
-          return { :exception => "ReadTimeout<#{@read_timeout}>" }
-        end
+    begin
+      Timeout.timeout(@read_timeout) do
+        _write_data(sock, send_data)
+        result = _read_data(sock)
+
+        { result: result }
+      end
+    rescue Timeout::Error
+      if protocol == :raw
+        return { result: @buffer }
+      else
+        return { exception: "ReadTimeout<#{@read_timeout}>" }
       end
-    else
-      { :result => :listen }
     end
 
   rescue Exception => e
-    { :exception => "Error<#{e.message}>" }
+    { exception: "Error<#{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
-          mes = "proc match failed with '#{ex.message}'"
-          error(mes)
-          value[:notice] = mes
-          return false
-        end
-
-        unless match
-          warn "proc #{expect_data} not matched (#{value[:result].truncate(30)}) answer"
-          value[:notice] = 'missing proc validation'
-        end
-
-        return match
+    return false unless value[:result]
+
+    return true unless expect_data
+
+    if expect_data.is_a?(Proc)
+      match = begin
+        !!expect_data[value[:result]]
+      rescue Object => ex
+        mes = "proc match failed with '#{ex.message}'"
+        error(mes)
+        value[:notice] = mes
+        return false
       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
+      unless match
+        warn "proc #{expect_data} not matched (#{value[:result].truncate(30)}) answer"
+        value[:notice] = 'missing proc validation'
+      end
 
-      warn "#{expect_data} not matched (#{value[:result].truncate(30)}) answer"
-      value[:notice] = "missing '#{expect_data.to_s}'"
-      return false
+      return match
     end
 
-    return true
+    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"
+    value[:notice] = "missing '#{expect_data}'"
+
+    false
   end
 
   def human_value(value)
@@ -131,28 +128,28 @@ 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)
+      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
-    when :raw
-      @buffer = ''
-      loop { @buffer << socket.recv(1) }
-    else
-      socket.readline.chop
+      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
+      when :raw
+        @buffer = ''
+        loop { @buffer << socket.recv(1) }
+      else
+        socket.readline.chop
     end
   end
 

data/lib/eye/checker/ssl_socket.rb

@@ -1,17 +1,16 @@
 require 'openssl'
 
 class Eye::Checker::SslSocket < Eye::Checker::Socket
-  param :ctx,          Hash, nil, {ssl_version: :SSLv23, verify_mode: OpenSSL::SSL::VERIFY_NONE}
 
-  # other params inherits from socket check
+  # ctx params from http://ruby-doc.org/stdlib-1.9.3/libdoc/openssl/rdoc/OpenSSL/SSL/SSLContext.html
   #
   # examples:
   #
   #   check :ssl_socket, :addr => "tcp://127.0.0.1:443", :every => 5.seconds, :times => 1, :timeout => 1.second,
   #     :ctx => {ssl_version: :SSLv23, verify_mode: OpenSSL::SSL::VERIFY_NONE}
   #
-  #
-  #  ctx_params from http://ruby-doc.org/stdlib-1.9.3/libdoc/openssl/rdoc/OpenSSL/SSL/SSLContext.html
+
+  param :ctx, Hash, nil, ssl_version: :SSLv23, verify_mode: OpenSSL::SSL::VERIFY_NONE
 
 private
 
@@ -23,6 +22,7 @@ private
   end
 
   def ctx_params
-    @ctx_params ||= OpenSSL::SSL::SSLContext.new().tap { |c| c.set_params(ctx) }
+    @ctx_params ||= OpenSSL::SSL::SSLContext.new.tap { |c| c.set_params(ctx) }
   end
+
 end

data/lib/eye/child_process.rb

@@ -1,6 +1,7 @@
 require 'celluloid'
 
 class Eye::ChildProcess
+
   include Celluloid
 
   # needs: kill_process
@@ -33,7 +34,7 @@ class Eye::ChildProcess
     @parent = parent
     @config = prepare_config(config)
     @name = "child-#{pid}"
-    @full_name = [logger_prefix, @name] * ':'
+    @full_name = [logger_prefix, @name].join(':')
 
     @watchers = {}
 
@@ -88,14 +89,15 @@ class Eye::ChildProcess
   end
 
   def signal(sig)
-    send_signal(sig) if self.pid
+    send_signal(sig) if pid
   end
 
-  def status_data(debug = false)
-    self_status_data(debug)
+  def status_data(opts = {})
+    self_status_data(opts)
   end
 
   def prepare_command(command) # override
     super.gsub('{PARENT_PID}', @parent.pid.to_s)
   end
+
 end

data/lib/eye/cli.rb

@@ -4,6 +4,7 @@ gem 'thor'
 require 'thor'
 
 class Eye::Cli < Thor
+
   autoload :Server,     'eye/cli/server'
   autoload :Commands,   'eye/cli/commands'
   autoload :Render,     'eye/cli/render'
@@ -12,24 +13,27 @@ class Eye::Cli < Thor
   include Eye::Cli::Commands
   include Eye::Cli::Render
 
-  desc "info [MASK]", "processes info"
-  method_option :json, :type => :boolean, :aliases => "-j"
+  desc 'info [MASK]', 'processes info'
+  method_option :json, type: :boolean, aliases: '-j'
+  method_option :procline, type: :boolean, aliases: '-p'
   def info(mask = nil)
-    res = cmd(:info_data, *Array(mask))
+    h = {}
+    h[:procline] = true if options[:procline]
+
+    res = cmd(:info_data, *Array(mask), h)
     if mask && res[:subtree] && res[:subtree].empty?
-      error!("command :info, objects not found!")
+      error!('command :info, objects not found!')
     end
 
     if options[:json]
-      require 'json'
-      say JSON.dump(res)
+      say_json(res)
     else
       say render_info(res)
       say
     end
   end
 
-  desc "status NAME", "return exit status for process name 0-up, 3-unmonitored"
+  desc 'status NAME', 'return exit status for process name 0-up, 3-unmonitored'
   def status(name)
     res = cmd(:info_data, *Array(name))
     es, msg = render_status(res)
@@ -37,43 +41,58 @@ class Eye::Cli < Thor
     exit(es)
   end
 
-  desc "xinfo", "eye-deamon info (-c show current config)"
-  method_option :config, :type => :boolean, :aliases => "-c"
+  desc 'xinfo', 'eye-deamon info (-c show current config)'
+  method_option :config, type: :boolean, aliases: '-c'
+  method_option :json, type: :boolean, aliases: '-j'
   def xinfo
-    res = cmd(:debug_data, :config => options[:config])
-    say render_debug_info(res)
-    say
+    res = cmd(:debug_data, config: options[:config])
+    if options[:json]
+      say_json(res)
+    else
+      say render_debug_info(res)
+      say
+    end
   end
 
-  desc "oinfo", "onelined info"
+  desc 'oinfo', 'onelined info'
+  method_option :json, type: :boolean, aliases: '-j'
   def oinfo(mask = nil)
     res = cmd(:short_data, *Array(mask))
-    say render_info(res)
-    say
+    if options[:json]
+      say_json(res)
+    else
+      say render_info(res)
+      say
+    end
   end
 
-  desc "history [MASK,...]", "processes history"
+  desc 'history [MASK,...]', 'processes history'
+  method_option :json, type: :boolean, aliases: '-j'
   def history(*masks)
     res = cmd(:history_data, *masks)
     if !masks.empty? && res && res.empty?
-      error!("command :history, objects not found!")
+      error!('command :history, objects not found!')
+    end
+    if options[:json]
+      say_json(res)
+    else
+      say render_history(res)
+      say
     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"
+  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?
+    configs.map! { |c| File.expand_path(c) }
 
     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
+      error!('foreground expected only one config') if configs.size > 1
       server_start_foreground(configs.first)
 
     elsif server_started?
-      configs << Eye::Local.eyefile if Eye::Local.local_runner
+      configs << Eye::Local.eyefile if Eye::Local.local_runner && configs.empty? && Eye::Local.eyefile
       say_load_result cmd(:load, *configs)
 
     else
@@ -82,9 +101,9 @@ class Eye::Cli < Thor
     end
   end
 
-  desc "quit", "eye-daemon quit"
-  method_option :stop_all, :type => :boolean, :aliases => "-s"
-  method_option :timeout, :type => :string, :aliases => "-t", :default => "600"
+  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
@@ -100,7 +119,7 @@ class Eye::Cli < Thor
     # remove pid_file
     File.delete(Eye::Local.pid_path) if File.exist?(Eye::Local.pid_path)
 
-    say "Quit ಠ╭╮ಠ", :yellow
+    say "Eye quit ಠ╭╮ಠ (#{Eye::Local.home})", :yellow
   end
 
   [:start, :stop, :restart, :unmonitor, :monitor, :delete, :match].each do |command|
@@ -110,60 +129,61 @@ class Eye::Cli < Thor
     end
   end
 
-  desc "force_restart MASK[,...]", "restart by stop;start (not by restart_command)"
+  desc 'force_restart MASK[,...]', 'restart by stop;start (not by restart_command)'
   def force_restart(*masks)
     send_command(:stop, *masks)
     send_command(:start, *masks)
   end
 
-  desc "signal SIG MASK[,...]", "send signal to app,group or process"
+  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"
+  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 = "")
+  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"
+  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"
+  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
+    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"
+  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
+    say_load_result Eye::Controller.new.explain(conf), print_config: true, syntax: true
   end
 
-  desc "watch [MASK]", "interactive processes info"
+  desc 'watch [MASK]', 'interactive processes info'
+  method_option :procline, type: :boolean, aliases: '-p'
   def watch(*args)
-    error!("You should install watch utility") if `which watch`.empty?
+    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 * ' '}"
@@ -171,12 +191,14 @@ class Eye::Cli < Thor
       "watch -n 1 #{$0} i #{args * ' '}"
     end
 
+    cmd += ' -p' if options[:procline]
+
     pid = Process.spawn(cmd)
     Process.waitpid(pid)
   rescue Interrupt
   end
 
-  desc "user_command CMD [MASK]", "execute user_command (dsl command)"
+  desc 'user_command CMD [MASK]', 'execute user_command (dsl command)'
   def user_command(cmd, *args)
     send_command(:user_command, cmd, *args)
   end
@@ -202,7 +224,13 @@ private
     end
   end
 
+  def say_json(obj)
+    require 'json'
+    say JSON.dump(obj)
+  end
+
   def self.exit_on_failure?
     true
   end
+
 end