eye 0.1.11

data/lib/eye/controller/send_command.rb

@@ -0,0 +1,88 @@
+module Eye::Controller::SendCommand
+
+  def send_command(command, *obj_strs)
+    matched_objects(*obj_strs) do |obj|
+      obj.send_command(command)
+      
+      if command.to_sym == :delete
+        remove_object_from_tree(obj) 
+        set_proc_line # to sync proc line if was delete application
+        GC.start
+      end
+    end
+  end
+
+  def match(*obj_strs)
+    matched_objects(*obj_strs)
+  end  
+
+  def signal(sig, *obj_strs)
+    matched_objects(*obj_strs) do |obj|
+      obj.send_command :signal, sig || 0
+    end
+  end
+
+private
+
+  def matched_objects(*obj_strs, &block)
+    objs = find_objects(*obj_strs)
+    res = objs.map(&:full_name)
+    objs.each{|obj| block[obj] } if block
+    res    
+  end
+
+  def remove_object_from_tree(obj)
+    @applications.delete(obj)
+    @applications.each{|app| app.groups.delete(obj) }
+    @applications.each{|app| app.groups.each{|gr| gr.processes.delete(obj) }}
+  end
+
+  # find object to action, restart ... (app, group or process)
+  # nil if not found
+  def find_objects(*obj_strs)
+    return [] if obj_strs.blank?
+    return @applications if obj_strs.size == 1 && obj_strs[0].strip == 'all'
+
+    res = obj_strs.map{|c| c.split(",").map{|mask| find_objects_by_mask(mask) }}.flatten
+
+    if res.size > 1
+      # remove inherited targets
+
+      final = []
+      res.each do |obj|
+        sub_object = res.any?{|a| a.sub_object?(obj) }
+        final << obj unless sub_object
+      end
+
+      res = final
+    end
+
+    res.present? ? Eye::Utils::AliveArray.new(res) : res
+  end
+
+  def find_objects_by_mask(mask)
+    mask.strip!
+
+    res = []
+    str = Regexp.escape(mask).gsub('\*', '.*?')
+    r = %r{\A#{str}\z}
+
+    # find app
+    res = @applications.select{|a| a.name =~ r || a.full_name =~ r }
+
+    # find group
+    @applications.each do |a|
+      res += a.groups.select{|gr| gr.name =~ r || gr.full_name =~ r }
+    end
+
+    # find process
+    @applications.each do |a|
+      a.groups.each do |gr|
+        res += gr.processes.select{|p| p.name =~ r || p.full_name =~ r }
+      end
+    end
+
+    res
+  end
+
+end

data/lib/eye/controller/status.rb

@@ -0,0 +1,136 @@
+module Eye::Controller::Status
+
+  def info_objects(mask = nil)
+    res = []
+    return @applications unless mask
+    matched_objects(mask){|obj| res << obj }    
+    res
+  end
+
+  def info_data(mask = nil)
+    {:subtree => info_objects(mask).map{|a| a.status_data } }
+  end
+
+  def info_data_debug(mask = nil)
+    {:subtree => info_objects(mask).map{|a| a.status_data(true) } }
+  end
+
+  def info_string(mask = nil)
+    make_str(info_data(mask)).to_s
+  end
+
+  def info_string_short
+    make_str({:subtree => @applications.map{|a| a.status_data_short } }).to_s
+  end
+
+  def info_string_debug(show_config = false)
+    actors = Celluloid::Actor.all.map{|actor| actor.instance_variable_get(:@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($$), false)}
+Logger: #{Eye::Logger.dev}
+Socket: #{Eye::Settings::socket_path}
+PidPath: #{Eye::Settings::pid_path}
+Actors: #{actors.inspect}
+
+#{make_str(info_data_debug)}
+    S
+
+    if show_config      
+      str += "\nCurrent config: \n"
+      str += YAML.dump(current_config)
+    end
+
+    GC.start
+    str
+  end
+
+private  
+
+  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?
+        nil
+      else
+        [str, make_str(data[:subtree], level + 1)].compact * "\n"
+      end
+    end
+  end
+
+  REV_REGX = /r:([a-z0-9]{5,})/i
+
+  def resources_str(r, mb = true)
+    return '' if r.blank?
+    
+    res = "#{r[:start_time]}, #{r[:cpu]}%"
+
+    if r[:memory]
+      mem = mb ? "#{r[:memory] / 1024}Mb" : "#{r[:memory]}Kb"
+      res += ", #{mem}"
+    end
+
+    # show process revision, as parse from procline part: 'r:12345678'
+    if r[:cmd] && r[:cmd].to_s =~ REV_REGX
+      res += ", #{$1.to_s[0..5]}"
+    end
+
+    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
+
+end

data/lib/eye/dsl.rb

@@ -0,0 +1,52 @@
+require_relative 'dsl/helpers'
+
+class Eye::Dsl
+
+  autoload :Main,                 'eye/dsl/main'
+  autoload :ApplicationOpts,      'eye/dsl/application_opts'
+  autoload :GroupOpts,            'eye/dsl/group_opts'
+  autoload :ProcessOpts,          'eye/dsl/process_opts'
+  autoload :ChildProcessOpts,     'eye/dsl/child_process_opts'
+  autoload :Opts,                 'eye/dsl/opts'
+  autoload :PureOpts,             'eye/dsl/pure_opts'
+  autoload :Validate,             'eye/dsl/validate'
+  autoload :Chain,                'eye/dsl/chain'
+  autoload :ConfigOpts,           'eye/dsl/config_opts'
+
+  class Error < Exception; end
+  extend Eye::Dsl::Validate
+
+  class << self
+    attr_accessor :verbose
+
+    def debug(msg = "")
+      puts msg if verbose
+    end
+
+    def initial_config
+      {:config => {}, :applications => {}}
+    end
+
+    def parse(content = nil, filename = nil)
+      Eye.parsed_config = initial_config
+      Eye.parsed_filename = filename
+      
+      content = File.read(filename) if content.blank?
+      
+      silence_warnings do
+        Kernel.eval(content, ROOT_BINDING, filename.to_s)
+      end
+      
+      validate(Eye.parsed_config)
+
+      Eye.parsed_config
+    end
+
+    def parse_apps(*args)
+      parse(*args)[:applications] || {}
+    end
+  end
+end
+
+# extend here global module
+Eye.send(:extend, Eye::Dsl::Main)

data/lib/eye/dsl/application_opts.rb

@@ -0,0 +1,33 @@
+class Eye::Dsl::ApplicationOpts < Eye::Dsl::Opts
+
+  include Eye::Dsl::Chain
+
+  def disallow_options
+    [:pid_file, :start_command]
+  end
+
+  def group(name, &block) 
+    Eye::Dsl.debug "=> group #{name}"
+    
+    opts = Eye::Dsl::GroupOpts.new(name, self)
+    opts.instance_eval(&block)    
+    if cfg = opts.config
+      @config[:groups] ||= {}
+
+      processes = cfg.delete(:processes) || {}
+      @config[:groups][name.to_s] ||= {}
+      @config[:groups][name.to_s].merge!(cfg)
+      @config[:groups][name.to_s][:processes] ||= {}
+      @config[:groups][name.to_s][:processes].merge!(processes)      
+    end
+
+    Eye::Dsl.debug "<= group #{name}"
+  end
+
+  def process(name, &block)
+    group("__default__"){ process(name.to_s, &block) }
+  end
+
+  def xgroup(name, &block); end
+  def xprocess(name, &block); end
+end

data/lib/eye/dsl/chain.rb

@@ -0,0 +1,12 @@
+module Eye::Dsl::Chain
+
+  def chain(opts = {})
+    acts = Array(opts[:action] || opts[:actions] || [:start, :restart])
+
+    acts.each do |act|
+      @config[:chain] ||= {}
+      @config[:chain][act] = opts.merge(:action => act)
+    end
+  end
+
+end

data/lib/eye/dsl/child_process_opts.rb

@@ -0,0 +1,7 @@
+class Eye::Dsl::ChildProcessOpts < Eye::Dsl::Opts
+
+  def allow_options
+    [:stop_command, :restart_command, :childs_update_period]
+  end
+
+end

data/lib/eye/dsl/config_opts.rb

@@ -0,0 +1,11 @@
+class Eye::Dsl::ConfigOpts < Eye::Dsl::PureOpts
+
+  create_options_methods([:logger], String)
+  create_options_methods([:logger_level], Fixnum)
+  create_options_methods([:http], Hash)
+
+  def set_logger(logger)
+    logger.blank? ? super('') : super
+  end
+  
+end

data/lib/eye/dsl/group_opts.rb

@@ -0,0 +1,27 @@
+class Eye::Dsl::GroupOpts < Eye::Dsl::Opts
+
+  include Eye::Dsl::Chain
+
+  def disallow_options
+    [:pid_file, :start_command]
+  end
+
+  def process(name, &block)
+    Eye::Dsl.debug "=> process #{name}"
+
+    opts = Eye::Dsl::ProcessOpts.new(name, self)
+    opts.instance_eval(&block)
+    @config[:processes] ||= {}
+    @config[:processes][name.to_s] = opts.config if opts.config
+
+    Eye::Dsl.debug "<= process #{name}"
+  end
+
+  def xprocess(name, &block); end
+
+  def application
+    parent
+  end
+  alias :app :application
+
+end

data/lib/eye/dsl/helpers.rb

@@ -0,0 +1,12 @@
+
+# Dsl Helpers 
+
+# current eye parsed config path
+def current_config_path
+  Eye.parsed_filename && File.symlink?(Eye.parsed_filename) ? File.readlink(Eye.parsed_filename) : Eye.parsed_filename
+end
+
+# host name
+def hostname
+  Eye::System.host  
+end

data/lib/eye/dsl/main.rb

@@ -0,0 +1,58 @@
+module Eye::Dsl::Main
+  attr_accessor :parsed_config, :parsed_filename
+
+  def application(name, &block)
+    Eye::Dsl.debug "=> app: #{name}"    
+    opts = Eye::Dsl::ApplicationOpts.new(name)
+    opts.instance_eval(&block)
+
+    @parsed_config ||= {}
+    @parsed_config[:applications] ||= {}
+    @parsed_config[:applications][name.to_s] = opts.config if opts.config
+
+    Eye::Dsl.debug "<= app: #{name}"
+  end
+
+  alias :app :application 
+
+  def load(glob = '')
+    return if glob.blank?
+
+    Eye::Dsl::Opts.with_parsed_file(glob) do |mask|
+      Dir[mask].each do |path|
+        Eye::Dsl.debug "=> load #{path}"
+        Eye.parsed_filename = path
+        res = Kernel.load(path)
+        Eye.info "load: subload #{path} (#{res})"
+        Eye::Dsl.debug "<= load #{path}"
+      end
+    end
+  end
+
+  def config(&block)
+    Eye::Dsl.debug "=> config"
+
+    @parsed_config ||= {}
+    @parsed_config[:config] ||= {}
+
+    opts = Eye::Dsl::ConfigOpts.new
+    opts.instance_eval(&block)
+    @parsed_config[:config].merge!(opts.config)
+
+    Eye::Dsl.debug "<= config"
+  end
+
+  def logger=(log_path)
+    STDERR.puts "Eye.logger= is deprecated!"
+    @parsed_config ||= {}
+    @parsed_config[:config] ||= {}
+    @parsed_config[:config][:logger] = log_path
+  end
+  
+  def logger_level=(log_level)
+    STDERR.puts "Eye.logger_level= is deprecated!"
+    @parsed_config ||= {}
+    @parsed_config[:config] ||= {}
+    @parsed_config[:config][:logger_level] = log_level
+  end
+end