eye 0.1.11 → 0.2

data/lib/eye/controller/send_command.rb

@@ -2,13 +2,12 @@ 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
+
+      obj.send_command(command)
     end
   end
 
@@ -32,9 +31,29 @@ private
   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) }}
+    klass = obj.class
+
+    if klass == Eye::Application
+      @applications.delete(obj)
+      @current_config[:applications].delete(obj.name)
+    end
+
+    if klass == Eye::Group
+      @applications.each{|app| app.groups.delete(obj) }
+      @current_config[:applications].each do |app_name, app_cfg|
+        app_cfg[:groups].delete(obj.name)
+      end
+    end
+
+    if klass == Eye::Process
+      @applications.each{|app| app.groups.each{|gr| gr.processes.delete(obj) }}
+
+      @current_config[:applications].each do |app_name, app_cfg|
+        app_cfg[:groups].each do |gr_name, gr_cfg|
+          gr_cfg[:processes].delete(obj.name)
+        end
+      end
+    end    
   end
 
   # find object to action, restart ... (app, group or process)
@@ -78,7 +97,13 @@ private
     # find process
     @applications.each do |a|
       a.groups.each do |gr|
-        res += gr.processes.select{|p| p.name =~ r || p.full_name =~ r }
+        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.name =~ r || ch.full_name =~ r }
+          end
+        end
       end
     end
 

data/lib/eye/controller/status.rb

@@ -23,7 +23,7 @@ module Eye::Controller::Status
     make_str({:subtree => @applications.map{|a| a.status_data_short } }).to_s
   end
 
-  def info_string_debug(show_config = false)
+  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
@@ -34,10 +34,11 @@ Socket: #{Eye::Settings::socket_path}
 PidPath: #{Eye::Settings::pid_path}
 Actors: #{actors.inspect}
 
-#{make_str(info_data_debug)}
     S
 
-    if show_config      
+    str += make_str(info_data_debug) + "\n" if show_processes.present?
+
+    if show_config.present?
       str += "\nCurrent config: \n"
       str += YAML.dump(current_config)
     end

data/lib/eye/dsl/config_opts.rb

@@ -3,9 +3,46 @@ 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[:config][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/opts.rb

@@ -2,24 +2,19 @@ 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)
 
@@ -70,6 +65,18 @@ class Eye::Dsl::Opts < Eye::Dsl::PureOpts
     @config[:triggers].try :delete, type
   end
 
+  def notify(contact, level = :crit)
+    raise Eye::Dsl::Error, "level should be in #{[:warn, :crit]}" unless Eye::Process::Notify::LEVELS[level]
+
+    @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] ||= {}

data/lib/eye/dsl/pure_opts.rb

@@ -43,13 +43,13 @@ class Eye::Dsl::PureOpts
   attr_reader :name, :full_name
   attr_reader :config, :parent
 
-  def initialize(name = nil, parent = nil)
+  def initialize(name = nil, parent = nil, merge_parent_config = true)
     @name = name.to_s    
     @full_name = @name
 
     if parent
       @parent = parent
-      @config = Marshal.load(Marshal.dump(parent.config)) # O_o ruby recommended deep clone
+      @config = merge_parent_config ? Eye::Utils::deep_clone(parent.config) : {}
       @full_name = "#{parent.full_name}:#{@full_name}"
     else
       @config = {}

data/lib/eye/dsl/validate.rb

@@ -36,6 +36,11 @@ module Eye::Dsl::Validate
     if dubl_names.present?
       raise Eye::Dsl::Error, "dublicate names: #{dubl_names.inspect}"
     end
+
+    # validate processes with their own validate
+    all_processes.each do |process_cfg|
+      Eye::Process.validate process_cfg
+    end
   end
 
 end

data/lib/eye/group.rb

@@ -105,7 +105,7 @@ class Eye::Group
   end
 
   def clear
-    @processes.clear
+    @processes = Eye::Utils::AliveArray.new
   end
 
   def sub_object?(obj)

data/lib/eye/group/chain.rb

@@ -25,6 +25,8 @@ private
   end
 
   def chain_schedule_process(process, type, command, *args)
+    debug "chain_schedule_process #{process.name} #{type} #{command}"
+    
     if type == :sync
       # sync command, with waiting
       process.send(command, *args)

data/lib/eye/notify.rb

@@ -0,0 +1,86 @@
+class Eye::Notify
+  include Celluloid
+  include Eye::Logger::Helpers
+  extend Eye::Checker::Validation
+
+  autoload :Mail,     'eye/notify/mail'
+  autoload :Jabber,   'eye/notify/jabber'
+
+  TYPES = {:mail => "Mail", :jabber => "Jabber"}
+
+  def self.get_class(type)
+    klass = eval("Eye::Notify::#{TYPES[type]}") rescue nil
+    raise "Unknown notify #{type}" unless klass
+    klass
+  end
+
+  def self.validate!(options)
+    get_class(options[:type]).validate(options)
+  end
+
+  def self.notify(contact, message_h)
+    current_config = Eye::Control.current_config[:config] # Warning, using global reference here !!! (not so nice)
+    needed_hash = (current_config[:contacts] || {})[contact.to_s]
+
+    return if needed_hash.blank?
+
+    create_proc = lambda do |nh|
+      type = nh[:type]
+      config = (current_config[type] || {}).merge(nh[:opts] || {}).merge(:contact => nh[:contact])
+      klass = get_class(type)
+      notify = klass.new(config, message_h)
+      notify.async_notify if notify
+    end
+
+    if needed_hash.is_a?(Array)
+      needed_hash.each{|nh| create_proc[nh] }
+    else
+      create_proc[needed_hash]
+    end
+  end
+
+  TIMEOUT = 1.minute
+
+  def initialize(options = {}, message_h = {})
+    @logger = Eye::Logger.new("#{self.class.name.downcase} - #{options[:contact]}")
+    debug "created notifier #{options}"
+
+    @message_h = message_h
+    @options = options
+  end
+
+  def async_notify
+    async.notify
+    after(TIMEOUT){ terminate }
+  end
+
+  def notify
+    debug "start notify #{@message_h}"
+    execute
+    debug "end notify #{@message_h}"
+    terminate
+  end
+
+  def execute
+    raise "realize me"
+  end
+
+  param :contact, [String]
+
+  def message_subject
+    "[#{msg_host}] [#{msg_full_name}] #{msg_message}"
+  end
+  
+  def message_body
+    "#{message_subject} at #{msg_at.to_s(:short)}"
+  end
+
+private
+
+  %w{at host message name full_name pid level}.each do |name|
+    define_method("msg_#{name}") do
+      @message_h[name.to_sym]
+    end
+  end
+
+end

data/lib/eye/notify/jabber.rb

@@ -0,0 +1,30 @@
+class Eye::Notify::Jabber < Eye::Notify
+  
+  # Eye.config do
+  #   jabber :host => "some.host", :port => 12345, :user => "eye@some.host", :password => "123456"
+  #   contact :vasya, :jabber, "vasya@some.host"
+  # end
+  
+  param :host, String, true
+  param :port, [String, Fixnum], true
+  param :user, String, true
+  param :password, String
+
+  def execute
+    require 'xmpp4r'
+
+    debug "send jabber #{[host, port, user, password]} - #{[contact, message_body]}"
+
+    mes = ::Jabber::Message.new(contact, message_body)
+    mes.set_type(:normal)
+    mes.set_id('1')
+    mes.set_subject(message_subject)
+
+    client = ::Jabber::Client.new(::Jabber::JID.new("#{user}/Eye"))
+    client.connect(host, port)
+    client.auth(password)
+    client.send(mes)
+    client.close
+  end
+
+end

data/lib/eye/notify/mail.rb

@@ -0,0 +1,44 @@
+require 'net/smtp'
+
+class Eye::Notify::Mail < Eye::Notify
+
+  # Eye.config do
+  #   mail :host => "some.host", :port => 12345, :user => "eye@some.host", :password => "123456", :domain => "some.host"
+  #   contact :vasya, :mail, "vasya@some.host"
+  # end
+
+  param :host, String, true
+  param :port, [String, Fixnum], true
+
+  param :domain, String
+  param :user, String
+  param :password, String
+  param :auth, Symbol # :plain, :login, :cram_md5
+  
+  param :from_mail, String
+  param :from_name, String, nil, 'eye'
+  
+  def execute
+    smtp
+  end
+
+  def smtp
+    args = [host, port, domain, user, password, auth]
+    debug "called smtp with #{args}"
+
+    Net::SMTP.start(*args) do |smtp|
+      smtp.send_message(message, from_mail || user, contact)
+    end
+  end
+
+  def message
+    h = []
+    h << "From: #{from_name} <#{from_mail || user}>" if from_mail || user
+    h << "To: <#{contact}>"
+    h << "Subject: #{message_subject}"
+    h << "Date: #{msg_at.httpdate}"
+    h << "Message-Id: <#{rand(1000000000).to_s(36)}.#{$$}.#{contact}>"
+    "#{h * "\n"}\n#{message_body}"
+  end
+
+end

data/lib/eye/process.rb

@@ -15,6 +15,7 @@ class Eye::Process
   autoload :Trigger,          'eye/process/trigger'
   autoload :Notify,           'eye/process/notify'
   autoload :Scheduler,        'eye/process/scheduler'
+  autoload :Validate,         'eye/process/validate'
 
   attr_accessor :pid, :watchers, :config, :states_history, 
                 :childs, :triggers, :flapping, :name
@@ -24,7 +25,7 @@ class Eye::Process
 
     @config = prepare_config(config)
     @logger = Eye::Logger.new(full_name)
-    
+
     @watchers = {}
     @childs = {}
     @triggers = []
@@ -77,6 +78,9 @@ class Eye::Process
 
   # scheduler
   include Eye::Process::Scheduler
+
+  # validate
+  extend Eye::Process::Validate
 end
 
 # include state_machine states

data/lib/eye/process/child.rb

@@ -35,10 +35,7 @@ module Eye::Process::Child
     end
 
     if removed_childs.present?
-      removed_childs.each do |child_pid|
-        child = self.childs.delete(child_pid)
-        child.delete if child && child.alive?
-      end      
+      removed_childs.each{|child_pid| remove_child(child_pid) }
     end
 
     h = {:new => new_childs.size, :removed => removed_childs.size, :exists => exist_childs.size }
@@ -49,13 +46,15 @@ module Eye::Process::Child
 
   def remove_childs
     if childs.present?
-      childs.keys.each do |child_pid|
-        child = childs.delete(child_pid)
-        child.delete if child && child.alive?
-      end
+      childs.keys.each{|child_pid| remove_child(child_pid) }
     else
       debug 'No childs to clear'
     end
   end
 
+  def remove_child(child_pid)
+    child = self.childs.delete(child_pid)
+    child.destroy if child && child.alive?
+  end
+
 end