reel-eye 0.3.1

data/lib/eye/controller/show_history.rb

@@ -0,0 +1,62 @@
+module Eye::Controller::ShowHistory
+
+  def history_string(*obj_strs)
+    data = history_data(*obj_strs)
+
+    res = []
+    data.each do |name, data|
+      res << detail_process_info(name, data)
+    end
+
+    res * "\n"
+  end
+
+  def history_data(*obj_strs)
+    res = {}
+    get_processes_for_history(*obj_strs).each do |process|
+      res[process.full_name] = process.schedule_history.reject{|c| c[:state] == :check_crash }
+    end
+    res
+  end
+
+private
+
+  def get_processes_for_history(*obj_strs)
+    res = []
+    matched_objects(*obj_strs) 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
+
+  def detail_process_info(name, history)
+    return if history.empty?
+
+    res = "\033[1m#{name}\033[0m:\n"
+    history = history.reverse
+
+    history.chunk{|h| [h[:state], h[:reason].to_s] }.each do |_, hist|
+      if hist.size >= 3
+        res << detail_process_info_string(hist[0])
+        res << detail_process_info_string(:state => "... #{hist.size - 2} times", :reason => '...', :at => hist[-1][:at])
+        res << detail_process_info_string(hist[-1])
+      else
+        hist.each do |h|
+          res << detail_process_info_string(h)
+        end
+      end
+    end
+
+    res
+  end
+
+  def detail_process_info_string(h)
+    state = h[:state].to_s.ljust(14)
+    "#{Time.at(h[:at]).to_s(:db)} - #{state} (#{h[:reason]})\n"
+  end
+
+end

data/lib/eye/controller/status.rb

@@ -0,0 +1,131 @@
+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, show_processes = 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)}
+Ruby:   #{RUBY_DESCRIPTION}
+Logger: #{Eye::Logger.dev}
+Socket: #{Eye::Settings::socket_path}
+Pid:    #{Eye::Settings::pid_path}
+Actors: #{actors.inspect}
+
+    S
+
+    str += make_str(info_data_debug) + "\n" if show_processes.present?
+
+    if show_config.present?
+      str += "\nCurrent config: \n"
+      str += YAML.dump(current_config.to_h)
+    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? && data[:type] != :application
+        nil
+      else
+        [str, make_str(data[:subtree], level + 1)].compact * "\n"
+      end
+    end
+  end
+
+  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
+
+    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,48 @@
+require_relative 'dsl/helpers'
+
+Eye::BINDING = binding
+
+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 :Chain,                'eye/dsl/chain'
+  autoload :ConfigOpts,           'eye/dsl/config_opts'
+  autoload :Validation,           'eye/dsl/validation'
+
+  class Error < Exception; end
+
+  class << self
+    attr_accessor :verbose
+
+    def debug(msg = "")
+      puts msg if verbose
+    end
+
+    def parse(content = nil, filename = nil)
+      Eye.parsed_config = Eye::Config.new
+      Eye.parsed_filename = filename
+      
+      content = File.read(filename) if content.blank?
+      
+      silence_warnings do
+        Kernel.eval(content, Eye::BINDING, filename.to_s)
+      end
+      
+      Eye.parsed_config.validate!
+      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,8 @@
+class Eye::Dsl::ChildProcessOpts < Eye::Dsl::Opts
+
+  def allow_options
+    [:stop_command, :restart_command, :childs_update_period,
+      :stop_signals, :stop_grace, :stop_timeout, :restart_timeout]
+  end
+
+end

data/lib/eye/dsl/config_opts.rb

@@ -0,0 +1,48 @@
+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
+
+  # ==== contact options ==============================
+
+  Eye::Notify::TYPES.keys.each do |not_system|
+    create_options_methods([not_system], Hash)
+
+    define_method("set_#{not_system}") do |value|
+      value = value.merge(:type => not_system)
+      super(value)
+      Eye::Notify.validate!(value)
+    end
+  end
+
+  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)
+
+    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)
+
+    Eye::Notify.validate!(validate_hash)
+
+    @config[:contacts] ||= {}
+    @config[:contacts][contact_name.to_s] = {name: contact_name.to_s, type: contact_type, 
+      contact: contact, opts: contact_opts}
+  end
+
+  def contact_group(contact_group_name, &block)
+    c = Eye::Dsl::ConfigOpts.new nil, self, false
+    c.instance_eval(&block)
+    cfg = c.config
+    @config[:contacts] ||= {}
+    if cfg[:contacts].present?
+      @config[:contacts][contact_group_name.to_s] = cfg[:contacts].values
+      @config[:contacts].merge!(cfg[:contacts])
+    end
+  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,40 @@
+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.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"
+
+    opts = Eye::Dsl::ConfigOpts.new
+    opts.instance_eval(&block)
+    @parsed_config.settings.merge!(opts.config)
+
+    Eye::Dsl.debug "<= config"
+  end
+  
+end

data/lib/eye/dsl/opts.rb

@@ -0,0 +1,140 @@
+class Eye::Dsl::Opts < Eye::Dsl::PureOpts
+
+  STR_OPTIONS = [ :pid_file, :working_dir, :stdout, :stderr, :stdall, :start_command, 
+    :stop_command, :restart_command ]
+  create_options_methods(STR_OPTIONS, String)
+
+  BOOL_OPTIONS = [ :daemonize, :keep_alive, :control_pid, :auto_start, :stop_on_delete]
+  create_options_methods(BOOL_OPTIONS, [TrueClass, FalseClass])
+
+  INTERVAL_OPTIONS = [ :check_alive_period, :start_timeout, :restart_timeout, :stop_timeout, :start_grace,
+    :restart_grace, :stop_grace, :childs_update_period ]
+  create_options_methods(INTERVAL_OPTIONS, [Fixnum, Float])
+
+  OTHER_OPTIONS = [ :environment, :stop_signals ]
+  create_options_methods(OTHER_OPTIONS)
+
+
+  def initialize(name = nil, parent = nil)
+    super(name, parent)
+
+    # ensure delete subobjects which can appears from parent config
+    @config.delete :groups
+    @config.delete :processes
+
+    @config[:application] = parent.name if parent.is_a?(Eye::Dsl::ApplicationOpts)
+    @config[:group] = parent.name if parent.is_a?(Eye::Dsl::GroupOpts)
+
+    # hack for full name
+    @full_name = parent.full_name if @name == '__default__'
+  end
+
+  def checks(type, opts = {})
+    type = type.to_sym
+    raise Eye::Dsl::Error, "unknown checker type #{type}" unless Eye::Checker::TYPES[type]
+
+    opts.merge!(:type => type)
+    Eye::Checker.validate!(opts)
+    
+    @config[:checks] ||= {}
+    @config[:checks][type] = opts
+  end
+
+  def triggers(type, opts = {})
+    type = type.to_sym
+    raise Eye::Dsl::Error, "unknown trigger type #{type}" unless Eye::Trigger::TYPES[type]
+    
+    opts.merge!(:type => type)
+    Eye::Trigger.validate!(opts)
+
+    @config[:triggers] ||= {}
+    @config[:triggers][type] = opts
+  end
+
+  # clear checks from parent
+  def nochecks(type)
+    type = type.to_sym
+    raise Eye::Dsl::Error, "unknown checker type #{type}" unless Eye::Checker::TYPES[type]
+    @config[:checks].try :delete, type
+  end
+
+  # clear triggers from parent
+  def notriggers(type)
+    type = type.to_sym
+    raise Eye::Dsl::Error, "unknown trigger type #{type}" unless Eye::Trigger::TYPES[type]
+    @config[:triggers].try :delete, type
+  end
+
+  def notify(contact, level = :warn)
+    unless Eye::Process::Notify::LEVELS[level]
+      raise Eye::Dsl::Error, "level should be in #{Eye::Process::Notify::LEVELS.keys}" 
+    end
+
+    @config[:notify] ||= {}
+    @config[:notify][contact.to_s] = level
+  end
+
+  def nonotify(contact)
+    @config[:notify] ||= {}
+    @config[:notify].delete(contact.to_s)
+  end
+
+  def set_environment(value)
+    raise Eye::Dsl::Error, "environment should be a hash, but not #{value.inspect}" unless value.is_a?(Hash)
+    @config[:environment] ||= {}
+    @config[:environment].merge!(value)
+  end
+
+  alias :env :environment
+
+  def set_stdall(value)
+    super
+
+    set_stdout value
+    set_stderr value
+  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)
+    end
+
+    if processes.present?
+      config[:processes] ||= {}
+      config[:processes].merge!(processes)
+    end
+  end
+
+  # execute part of config on particular server
+  # array of strings
+  # regexp
+  # string
+  def with_server(glob = nil, &block)
+    on_server = true
+
+    if glob.present? 
+      host = Eye::System.host
+
+      if glob.is_a?(Array)
+        on_server = !!glob.any?{|elem| elem == host}
+      elsif glob.is_a?(Regexp)
+        on_server = !!host.match(glob)
+      elsif glob.is_a?(String) || glob.is_a?(Symbol)
+        on_server = (host == glob.to_s)
+      end
+    end
+
+    scoped do
+      with_condition(on_server, &block)
+    end
+
+    on_server
+  end
+
+end