reel-eye 0.4.1 → 0.5

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,51 +1,43 @@
 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}
-Http:   #{@http ? "#{@http.host}:#{@http.port}" : '-'}
-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,
+      :http => @http ? "#{@http.host}:#{@http.port}" : '-',
+      :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?
@@ -53,79 +45,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
@@ -136,4 +55,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

data/lib/eye/dsl.rb

@@ -20,7 +20,7 @@ class Eye::Dsl
   class << self
     attr_accessor :verbose
 
-    def debug(msg = "")
+    def debug(msg = '')
       puts msg if verbose
     end
 

data/lib/eye/dsl/application_opts.rb

@@ -3,7 +3,7 @@ class Eye::Dsl::ApplicationOpts < Eye::Dsl::Opts
   include Eye::Dsl::Chain
 
   def disallow_options
-    [:pid_file, :start_command]
+    [:pid_file, :start_command, :daemonize]
   end
 
   def not_seed_options
@@ -15,6 +15,7 @@ class Eye::Dsl::ApplicationOpts < Eye::Dsl::Opts
 
     opts = Eye::Dsl::GroupOpts.new(name, self)
     opts.instance_eval(&block)
+
     if cfg = opts.config
       @config[:groups] ||= {}
 
@@ -26,10 +27,13 @@ class Eye::Dsl::ApplicationOpts < Eye::Dsl::Opts
     end
 
     Eye::Dsl.debug "<= group #{name}"
+    opts
   end
 
   def process(name, &block)
-    group("__default__"){ process(name.to_s, &block) }
+    res = nil
+    group('__default__'){ res = process(name.to_s, &block) }
+    res
   end
 
   alias xgroup nop

data/lib/eye/dsl/child_process_opts.rb

@@ -6,7 +6,8 @@ class Eye::Dsl::ChildProcessOpts < Eye::Dsl::Opts
   end
 
   def triggers(*args)
-    raise Eye::Dsl::Error, "triggers does not allowed in monitor_children"
+    raise Eye::Dsl::Error, 'triggers does not allowed in monitor_children'
   end
+  alias trigger triggers
 
-end
+end

data/lib/eye/dsl/config_opts.rb

@@ -23,7 +23,7 @@ class Eye::Dsl::ConfigOpts < Eye::Dsl::PureOpts
 
   def contact(contact_name, contact_type, contact, contact_opts = {})
     raise Eye::Dsl::Error, "unknown contact_type #{contact_type}" unless Eye::Notify::TYPES[contact_type]
-    raise Eye::Dsl::Error, "contact should be a String" unless contact.is_a?(String)
+    raise Eye::Dsl::Error, 'contact should be a String' unless contact.is_a?(String)
 
     notify_hash = @config[contact_type] || (@parent && @parent.config[contact_type]) || Eye::parsed_config.settings[contact_type] || {}
     validate_hash = notify_hash.merge(contact_opts).merge(:type => contact_type)
@@ -46,4 +46,4 @@ class Eye::Dsl::ConfigOpts < Eye::Dsl::PureOpts
     end
   end
 
-end
+end

data/lib/eye/dsl/group_opts.rb

@@ -3,7 +3,7 @@ class Eye::Dsl::GroupOpts < Eye::Dsl::Opts
   include Eye::Dsl::Chain
 
   def disallow_options
-    [:pid_file, :start_command]
+    [:pid_file, :start_command, :daemonize]
   end
 
   def not_seed_options
@@ -19,6 +19,7 @@ class Eye::Dsl::GroupOpts < Eye::Dsl::Opts
     @config[:processes][name.to_s] = opts.config if opts.config
 
     Eye::Dsl.debug "<= process #{name}"
+    opts
   end
 
   alias xprocess nop

data/lib/eye/dsl/main.rb

@@ -29,13 +29,15 @@ module Eye::Dsl::Main
   end
 
   def config(&block)
-    Eye::Dsl.debug "=> config"
+    Eye::Dsl.debug '=> config'
 
     opts = Eye::Dsl::ConfigOpts.new
     opts.instance_eval(&block)
     @parsed_config.settings.merge!(opts.config)
 
-    Eye::Dsl.debug "<= config"
+    Eye::Dsl.debug '<= config'
   end
 
+  alias settings config
+
 end

data/lib/eye/dsl/opts.rb

@@ -98,26 +98,33 @@ class Eye::Dsl::Opts < Eye::Dsl::PureOpts
   end
 
   def set_uid(value)
-    raise Eye::Dsl::Error, ":uid not supported by ruby (needed 2.0)" unless Eye::Settings.supported_setsid?
+    raise Eye::Dsl::Error, ':uid not supported (use ruby >= 2.0)' unless Eye::Local.supported_setsid?
     super
   end
 
   def set_gid(value)
-    raise Eye::Dsl::Error, ":gid not supported by ruby (needed 2.0)" unless Eye::Settings.supported_setsid?
+    raise Eye::Dsl::Error, ':gid not supported (use ruby >= 2.0)' unless Eye::Local.supported_setsid?
     super
   end
 
   def scoped(&block)
     h = self.class.new(self.name, self)
     h.instance_eval(&block)
+
     groups = h.config.delete :groups
-    processes = h.config.delete :processes
 
     if groups.present?
       config[:groups] ||= {}
-      config[:groups].merge!(groups)
+      groups.each do |name, cfg|
+        processes = cfg.delete(:processes) || {}
+        config[:groups][name] ||= {}
+        config[:groups][name].merge!(cfg)
+        config[:groups][name][:processes] ||= {}
+        config[:groups][name][:processes].merge!(processes)
+      end
     end
 
+    processes = h.config.delete :processes
     if processes.present?
       config[:processes] ||= {}
       config[:processes].merge!(processes)

data/lib/eye/dsl/validation.rb

@@ -1,66 +1,72 @@
 module Eye::Dsl::Validation
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
   class Error < Exception; end
 
-  def inherited(subclass)
-    subclass.validates = self.validates.clone
-    subclass.should_bes = self.should_bes.clone
-    subclass.defaults = self.defaults.clone
-    subclass.variants = self.variants.clone
-  end
+  module ClassMethods
+    def inherited(subclass)
+      subclass.validates = self.validates.clone
+      subclass.should_bes = self.should_bes.clone
+      subclass.defaults = self.defaults.clone
+      subclass.variants = self.variants.clone
+    end
 
-  attr_accessor :validates, :should_bes, :defaults, :variants
+    attr_accessor :validates, :should_bes, :defaults, :variants
 
-  def validates; @validates ||= {}; end
-  def should_bes; @should_bes ||= []; end
-  def defaults; @defaults ||= {}; end
-  def variants; @variants ||= {}; end
+    def validates; @validates ||= {}; end
+    def should_bes; @should_bes ||= []; end
+    def defaults; @defaults ||= {}; end
+    def variants; @variants ||= {}; end
 
-  def param(param, types = [], should_be = false, default = nil, _variants = nil)
-    param = param.to_sym
+    def param(param, types = [], should_be = false, default = nil, _variants = nil)
+      param = param.to_sym
 
-    validates[param] = types
-    should_bes << param if should_be
-    defaults[param] = default
-    variants[param] = _variants
+      validates[param] = types
+      should_bes << param if should_be
+      defaults[param] = default
+      variants[param] = _variants
 
-    return if param == :do
+      return if param == :do
 
-    define_method "#{param}" do
-      @options[param] || default
+      define_method "#{param}" do
+        @options[param] || default
+      end
     end
-  end
 
-  def validate(options = {})
-    options.each do |param, value|
-      param = param.to_sym
-      types = validates[param]
-      unless types
-        if param != :type
-          raise Error, "#{self.name} unknown param :#{param} value #{value.inspect}"
+    def validate(options = {})
+      options.each do |param, value|
+        param = param.to_sym
+        types = validates[param]
+        unless types
+          if param != :type
+            raise Error, "#{self.name} unknown param :#{param} value #{value.inspect}"
+          end
         end
-      end
 
-      if self.variants[param]
-        if value && !value.is_a?(Proc)
-          if value.is_a?(Array)
-            if (value - self.variants[param]).present?
+        if self.variants[param]
+          if value && !value.is_a?(Proc)
+            if value.is_a?(Array)
+              if (value - self.variants[param]).present?
+                raise Error, "#{value.inspect} should within #{self.variants[param].inspect}"
+              end
+            elsif !self.variants[param].include?(value)
               raise Error, "#{value.inspect} should within #{self.variants[param].inspect}"
             end
-          elsif !self.variants[param].include?(value)
-            raise Error, "#{value.inspect} should within #{self.variants[param].inspect}"
           end
         end
-      end
 
-      next if types.blank?
+        next if types.blank?
 
-      types = Array(types)
-      good = types.any?{|type| value.is_a?(type) }
-      raise Error, "#{self.name} bad param :#{param} value #{value.inspect}, type #{types.inspect}" unless good
-    end
+        types = Array(types)
+        good = types.any?{|type| value.is_a?(type) }
+        raise Error, "#{self.name} bad param :#{param} value #{value.inspect}, type #{types.inspect}" unless good
+      end
 
-    should_bes.each do |param|
-      raise Error, "#{self.name} for param :#{param} value should be" unless options[param.to_sym] || defaults[param.to_sym]
+      should_bes.each do |param|
+        raise Error, "#{self.name} for param :#{param} value should be" unless options[param.to_sym] || defaults[param.to_sym]
+      end
     end
   end