ace-eye 0.6.1

data/lib/eye/controller/load.rb

@@ -0,0 +1,224 @@
+module Eye::Controller::Load
+
+  def check(filename)
+    { filename => catch_load_error(filename) { parse_config(filename).to_h } }
+  end
+
+  def explain(filename)
+    { filename => catch_load_error(filename) { parse_config(filename).to_h } }
+  end
+
+  def load(*args)
+    h = args.extract_options!
+    obj_strs = args.flatten
+    info "=> loading: #{obj_strs}"
+
+    res = Hash.new
+
+    globbing(*obj_strs).each do |filename|
+      res[filename] = catch_load_error(filename) do
+        cfg = parse_config(filename)
+        load_config(filename, cfg)
+        nil
+      end
+    end
+
+    set_proc_line
+
+    info "<= loading: #{obj_strs}, in: <#{$$}>"
+
+    res
+  end
+
+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 }
+
+  rescue Eye::Dsl::Error, Exception, NoMethodError => ex
+    raise if ex.class.to_s.include?('RR') # skip RR exceptions
+
+    error "loading: config error <#{filename}>: #{ex.message}"
+
+    # filter backtrace for user output
+    bt = (ex.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.merge!(:backtrace => bt) if bt.present?
+    res
+  end
+
+  def globbing(*obj_strs)
+    res = []
+    return res if obj_strs.empty?
+
+    obj_strs.each do |filename|
+      mask = if File.directory?(filename)
+        File.join filename, '{*.eye}'
+      else
+        filename
+      end
+
+      debug "loading: globbing mask #{mask}"
+
+      sub = []
+      Dir[mask].each do |config_path|
+        sub << config_path
+      end
+      sub = [mask] if sub.empty?
+
+      res += sub
+    end
+
+    res
+  end
+
+  # return: result, config
+  def parse_config(filename)
+    debug "parsing: #{filename}"
+
+    cfg = Eye::Dsl.parse(nil, filename)
+    @current_config.merge(cfg).validate!(false) # just validate summary config here
+    Eye.parsed_config = nil # remove link on config, for better gc
+    cfg
+  end
+
+  # !!! exclusive operation
+  def load_config(filename, config)
+    info "loading: #{filename}"
+    new_cfg = @current_config.merge(config)
+    new_cfg.validate!
+
+    load_options(new_cfg.settings)
+    create_objects(new_cfg.applications, config.application_names)
+    @current_config = new_cfg
+  end
+
+  # load global config options
+  def load_options(opts)
+    return if opts.blank?
+
+    opts.each do |key, value|
+      method = "set_opt_#{key}"
+      send(method, value) if value && respond_to?(method)
+    end
+  end
+
+  # create objects as diff, from configs
+  def create_objects(apps_config, changed_apps = [])
+    debug 'creating objects'
+
+    apps_config.each do |app_name, app_cfg|
+      update_or_create_application(app_name, app_cfg.clone) if changed_apps.include?(app_name)
+    end
+
+    # sorting applications
+    @applications.sort_by!(&:name)
+  end
+
+  def update_or_create_application(app_name, app_config)
+    @old_groups = {}
+    @old_processes = {}
+
+    app = @applications.detect { |c| c.name == app_name }
+
+    if app
+      app.groups.each do |group|
+        @old_groups[group.name] = group
+        group.processes.each do |proc|
+          @old_processes[group.name + ":" + proc.name] = proc
+        end
+      end
+
+      @applications.delete(app)
+
+      debug "updating app: #{app_name}"
+    else
+      debug "creating app: #{app_name}"
+    end
+
+    app = Eye::Application.new(app_name, app_config)
+    @applications << app
+    @added_groups, @added_processes = [], []
+
+    new_groups = app_config.delete(:groups) || {}
+    new_groups.each do |group_name, group_cfg|
+      group = update_or_create_group(group_name, group_cfg.clone)
+      app.add_group(group)
+      group.resort_processes
+    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? }
+
+    # schedule monitoring for new groups, processes
+    added_fully_groups = []
+    @added_groups.each do |group|
+      if group.processes.size > 0 && (group.processes.pure - @added_processes).size == 0
+        added_fully_groups << group
+        @added_processes -= group.processes.pure
+      end
+    end
+
+    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
+    @old_processes = nil
+    @added_groups = nil
+    @added_processes = nil
+
+    app.resort_groups
+
+    app
+  end
+
+  def update_or_create_group(group_name, group_config)
+    group = if @old_groups[group_name]
+      debug "updating group: #{group_name}"
+      group = @old_groups.delete(group_name)
+      group.schedule :update_config, group_config, Eye::Reason::User.new(:'load config')
+      group.clear
+      group
+    else
+      debug "creating group: #{group_name}"
+      gr = Eye::Group.new(group_name, group_config)
+      @added_groups << gr
+      gr
+    end
+
+    processes = group_config.delete(:processes) || {}
+    processes.each do |process_name, process_cfg|
+      process = update_or_create_process(process_name, process_cfg.clone)
+      group.add_process(process)
+    end
+
+    group
+  end
+
+  def update_or_create_process(process_name, process_cfg)
+    postfix = ":" + process_name
+    name = process_cfg[:group] + postfix
+    key = @old_processes[name] ? name : @old_processes.keys.detect { |n| n.end_with?(postfix) }
+
+    if @old_processes[key]
+      debug "updating process: #{name}"
+      process = @old_processes.delete(key)
+      process.schedule :update_config, process_cfg, Eye::Reason::User.new(:'load config')
+      process
+    else
+      debug "creating process: #{name}"
+      process = Eye::Process.new(process_cfg)
+      @added_processes << process
+      process
+    end
+  end
+
+end

data/lib/eye/controller/options.rb

@@ -0,0 +1,18 @@
+module Eye::Controller::Options
+
+  def set_opt_logger(logger_args)
+    # do not apply logger, if in stdout state
+    if !%w{stdout stderr}.include?(Eye::Logger.dev)
+      Eye::Logger.link_logger(*logger_args)
+    end
+  end
+
+  def set_opt_logger_level(level)
+    Eye::Logger.log_level = level
+  end
+
+  def set_opt_http(opts = {})
+    warn "Warning, set http options not in reel-eye gem" if opts.present?
+  end
+
+end

data/lib/eye/controller/send_command.rb

@@ -0,0 +1,177 @@
+module Eye::Controller::SendCommand
+
+  def send_command(command, *args)
+    matched_objects(*args) do |obj|
+      if command.to_sym == :delete
+        remove_object_from_tree(obj)
+
+        set_proc_line
+      end
+
+      obj.send_command(command)
+    end
+  end
+
+  def match(*args)
+    matched_objects(*args)
+  end
+
+  def signal(signal, *args)
+    matched_objects(*args) do |obj|
+      obj.send_command :signal, signal || 0
+    end
+  end
+
+private
+
+  class Error < Exception; end
+
+  def matched_objects(*args, &block)
+    objs = find_objects(*args)
+    res = objs.map(&:full_name)
+    objs.each{|obj| block[obj] } if block
+    {:result => res}
+
+  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)
+    klass = obj.class
+
+    if klass == Eye::Application
+      @applications.delete(obj)
+      @current_config.delete_app(obj.name)
+    end
+
+    if klass == Eye::Group
+      @applications.each{|app| app.groups.delete(obj) }
+      @current_config.delete_group(obj.name)
+    end
+
+    if klass == Eye::Process
+      @applications.each{|app| app.groups.each{|gr| gr.processes.delete(obj) }}
+      @current_config.delete_process(obj.name)
+    end
+  end
+
+  # find object to action, restart ... (app, group or process)
+  # nil if not found
+  def find_objects(*args)
+    h = args.extract_options!
+    obj_strs = args
+
+    return [] if obj_strs.blank?
+
+    if obj_strs.size == 1 && (obj_strs[0].to_s.strip == 'all' || obj_strs[0].to_s.strip == '*')
+      if h[:application]
+        return @applications.select { |app| app.name == h[:application]}
+      else
+        return @applications.dup
+      end
+    end
+
+    res = Eye::Utils::AliveArray.new
+    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
+    end
+    res
+  end
+
+  def find_objects_by_mask(mask)
+    res = find_all_objects_by_mask(mask)
+
+    if res.size > 1
+      final = Eye::Utils::AliveArray.new
+
+      # try to find exactly matched
+      if mask[-1] != '*'
+        r = exact_regexp(mask)
+        res.each do |obj|
+          final << obj if obj.name =~ r || obj.full_name =~ r
+        end
+      end
+
+      res = final if final.present?
+      final = Eye::Utils::AliveArray.new
+
+      # remove inherited targets
+      res.each do |obj|
+        sub_object = res.any?{|a| a.sub_object?(obj) }
+        final << obj unless sub_object
+      end
+
+      res = final
+
+      # try to remove objects with different applications
+      apps, objs = Eye::Utils::AliveArray.new, Eye::Utils::AliveArray.new
+      res.each do |obj|
+        if obj.is_a?(Eye::Application)
+          apps << obj
+        else
+          objs << obj
+        end
+      end
+
+      return apps if apps.size > 0
+
+      if objs.map(&:app_name).uniq.size > 1
+        raise Error, "cannot match targets from different applications: #{res.map(&:full_name)}"
+      end
+    end
+
+    res
+  end
+
+  def find_all_objects_by_mask(mask)
+    res = Eye::Utils::AliveArray
+    r = left_regexp(mask)
+
+    # 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|
+        gr.processes.each do |p|
+          res << p if p.name =~ r || p.full_name =~ r
+
+          # child matching
+          if p.children.present?
+            children = p.children.values
+            res += children.select do |ch|
+              name = ch.name rescue ''
+              full_name = ch.full_name rescue ''
+              name =~ r || full_name =~ r
+            end
+          end
+
+        end
+      end
+    end
+
+    res
+  end
+
+  def left_regexp(mask)
+    str = Regexp.escape(mask).gsub('\*', '.*?')
+    %r|\A#{str}|
+  end
+
+  def exact_regexp(mask)
+    str = Regexp.escape(mask).gsub('\*', '.*?')
+    %r|\A#{str}\z|
+  end
+end

data/lib/eye/controller/status.rb

@@ -0,0 +1,72 @@
+module Eye::Controller::Status
+
+  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
+
+    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.args.present? ? [Eye::Logger.dev, *Eye::Logger.args] : Eye::Logger.dev,
+      :pid_path => Eye::Local::pid_path,
+      :sock_path => Eye::Local::socket_path,
+      :actors => actors
+    }
+
+    res[:config_yaml] = YAML.dump(current_config.to_h) if h[:config].present?
+
+    res
+  end
+
+  def info_data(*args)
+    {:subtree => info_objects(*args).map{|a| a.status_data } }
+  end
+
+  def short_data(*args)
+    {:subtree => info_objects(*args).select{ |o| o.class == Eye::Application }.map{|a| a.status_data_short } }
+  end
+
+  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?
+    matched_objects(*args){|obj| res << obj }
+    res
+  end
+
+  def gem_version(klass)
+    v = nil
+    begin
+      v = eval("#{klass}::VERSION::STRING")
+    rescue
+      v = eval("#{klass}::VERSION") rescue ''
+    end
+    "#{klass}=#{v}"
+  end
+
+  def history_objects(*args)
+    args = ['*'] if args.empty?
+    res = []
+    matched_objects(*args) do |obj|
+      if obj.is_a?(Eye::Process)
+        res << obj
+      elsif obj.is_a?(Eye::ChildProcess)
+      else
+        res += obj.processes.to_a
+      end
+    end
+    Eye::Utils::AliveArray.new(res)
+  end
+
+end