reel-eye 0.3.1

data/lib/eye/controller/commands.rb

@@ -0,0 +1,73 @@
+module Eye::Controller::Commands
+
+  # Main method, answer for the client command
+  def command(cmd, *args)
+    debug "client command: #{cmd} #{args * ', '}"
+
+    start_at = Time.now
+    cmd = cmd.to_sym
+    
+    res = case cmd 
+      when :start, :stop, :restart, :unmonitor, :monitor
+        send_command(cmd, *args)
+      when :delete
+        exclusive{ send_command(cmd, *args) }
+      when :signal
+        signal(*args)
+      when :break_chain
+        break_chain(*args)
+      when :load
+        exclusive{ load(*args) }
+      when :info
+        info_string(*args)
+      when :xinfo
+        info_string_debug(*args)
+      when :oinfo
+        info_string_short
+      when :history
+        history_string(*args)
+      when :quit
+        quit
+      when :check
+        check(*args)
+      when :explain
+        explain(*args)
+      when :match
+        match(*args)
+      when :ping
+        :pong
+      when :logger_dev
+        Eye::Logger.dev
+
+      # object commands, for api
+      when :raw_info
+        info_data(*args)
+      when :raw_history
+        history_data(*args)
+
+      else
+        :unknown_command
+    end   
+
+    GC.start
+    info "client command: #{cmd} #{args * ', '} (#{Time.now - start_at}s)"
+
+    res  
+  end
+
+private
+
+  def quit
+    info 'exiting...'
+    delete
+    sleep 1
+    Eye::System.send_signal($$) # soft terminate
+    sleep 2
+    Eye::System.send_signal($$, 9)
+  end
+
+  def delete
+    send_command(:delete)
+  end
+
+end

data/lib/eye/controller/helpers.rb

@@ -0,0 +1,61 @@
+module Eye::Controller::Helpers
+
+  def set_proc_line
+    str = Eye::PROCLINE
+    str += " (#{@applications.map(&:name) * ', '})" if @applications.present?
+    $0 = str
+  end
+
+  def process_by_name(name)
+    all_processes.detect{|c| c.name == name}
+  end
+
+  def group_by_name(name)
+    all_groups.detect{|c| c.name == name}
+  end
+
+  def application_by_name(name)
+    @applications.detect{|c| c.name == name}
+  end
+
+  def all_processes
+    processes = []
+    all_groups.each do |gr|
+      processes += gr.processes.to_a
+    end
+
+    processes
+  end
+
+  def all_groups
+    groups = []
+    @applications.each do |app|
+      groups += app.groups.to_a
+    end
+
+    groups
+  end
+
+  # {'app_name' => {'group_name' => {'process_name' => 'pid_file'}}}
+  def short_tree
+    res = {}
+    @applications.each do |app|
+      res2 = {}
+
+      app.groups.each do |group|
+        res3 = {}
+
+        group.processes.each do |process|
+          res3[process.name] = process[:pid_file_ex]
+        end
+
+        res2[group.name] = res3
+      end
+
+      res[app.name] = res2
+    end
+
+    res
+  end
+
+end

data/lib/eye/controller/load.rb

@@ -0,0 +1,214 @@
+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(*obj_strs)
+    info "load: #{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
+
+    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].freeze
+
+  def catch_load_error(filename = nil, &block)
+    { :error => false, :config => yield }
+
+  rescue Eye::Dsl::Error, Exception, NoMethodError => ex
+    error "load: config error <#{filename}>: #{ex.message}"
+
+    # filter backtrace for user output
+    bt = (ex.backtrace || [])
+    bt = bt.reject{|line| line.to_s =~ BT_REGX }
+    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 "load: 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)    
+    raise Eye::Dsl::Error, "config file '#{filename}' not found!" unless File.exists?(filename)
+    debug "parse #{filename}"
+
+    cfg = Eye::Dsl.parse(nil, filename)
+    @current_config.merge(cfg).validate! # just validate summary config here
+    cfg
+  end
+
+  # !!! exclusive operation
+  def load_config(filename, config)
+    info "load #{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 'create 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[proc.name] = proc
+        end
+      end
+
+      @applications.delete(app)
+
+      debug "update app #{app_name}"
+    else
+      debug "create 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 "update 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 "create 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)
+    if @old_processes[process_name]
+      debug "update process #{process_name}"
+      process = @old_processes.delete(process_name)
+      process.schedule :update_config, process_cfg, Eye::Reason::User.new(:'load config')
+      process      
+    else
+      debug "create process #{process_name}"
+      process = Eye::Process.new(process_cfg)
+      @added_processes << process
+      process
+    end
+  end
+
+end

data/lib/eye/controller/options.rb

@@ -0,0 +1,48 @@
+module Eye::Controller::Options
+
+  def set_opt_logger(logger)
+    # do not apply logger, if in stdout state
+    if !%w{stdout stderr}.include?(Eye::Logger.dev)
+      if logger.blank?
+        Eye::Logger.link_logger(nil)
+      else
+        Eye::Logger.link_logger(logger)
+      end
+    end
+  end
+
+  def set_opt_logger_level(level)
+    Eye::Logger.log_level = level
+  end
+
+  def set_opt_http(params = {})
+    if params[:enable]
+      if @http
+        if params[:host] != @http.host || params[:host].to_i != @http.host
+          stop_http
+          start_http(params[:host], params[:port])
+        end
+      else
+        start_http(params[:host], params[:port])
+      end
+    else
+      stop_http if @http
+    end
+  end
+
+private
+
+  def stop_http
+    if @http
+      @http.stop
+      @http = nil
+    end
+  end
+
+  def start_http(host, port)
+    require 'eye/http' # ruby 2.0 autoload bug
+    @http = Eye::Http.new(host, port)
+    @http.start
+  end
+  
+end

data/lib/eye/controller/send_command.rb

@@ -0,0 +1,115 @@
+module Eye::Controller::SendCommand
+
+  def send_command(command, *obj_strs)
+    matched_objects(*obj_strs) do |obj|
+      if command.to_sym == :delete
+        remove_object_from_tree(obj) 
+        set_proc_line # to sync proc line if was delete application
+      end
+
+      obj.send_command(command)
+    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
+
+  def break_chain(*obj_strs)
+    matched_objects(*obj_strs) do |obj|
+      obj.send_command(:break_chain)
+    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)
+    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(*obj_strs)
+    return [] if obj_strs.blank?
+    return @applications.dup if obj_strs.size == 1 && (obj_strs[0].strip == 'all' || obj_strs[0].strip == '*')
+
+    res = []
+    obj_strs.map{|c| c.split(",")}.flatten.each do |mask|
+      res += find_objects_by_mask(mask)
+    end
+
+    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) : []
+  end
+
+  def find_objects_by_mask(mask)
+    mask.strip!
+
+    res = []
+    str = Regexp.escape(mask).gsub('\*', '.*?')
+    r = %r{\A#{str}}
+
+    # 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
+
+          if p.childs.present?
+            res += p.childs.values.select{|ch| ch.alive? && (ch.name =~ r || ch.full_name =~ r) }
+          end
+        end
+      end
+    end
+
+    res
+  end
+
+end