eye 0.2.1 → 0.2.2

data/lib/eye/dsl/pure_opts.rb

@@ -66,49 +66,10 @@ class Eye::Dsl::PureOpts
     []
   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
-
-    with_condition(on_server, &block)
-
-    on_server
-  end
-
   def with_condition(cond = true, &block)
     self.instance_eval(&block) if cond && block
   end
 
-  def self.with_parsed_file(file_name)
-    saved_parsed_filename = Eye.parsed_filename
-
-    require 'pathname'
-
-    real_filename = Eye.parsed_filename && File.symlink?(Eye.parsed_filename) ? File.readlink(Eye.parsed_filename) : Eye.parsed_filename
-    dirname = File.dirname(real_filename) rescue nil
-    path = Pathname.new(file_name).expand_path(dirname).to_s
-
-    Eye.parsed_filename = path
-    yield path
-  ensure
-    Eye.parsed_filename = saved_parsed_filename
-  end
-
   def include(proc, *args)
     if proc.is_a?(String)
       self.class.with_parsed_file(proc) do |path|
@@ -129,4 +90,21 @@ class Eye::Dsl::PureOpts
     end
   end
 
+private
+
+  def self.with_parsed_file(file_name)
+    saved_parsed_filename = Eye.parsed_filename
+
+    require 'pathname'
+
+    real_filename = Eye.parsed_filename && File.symlink?(Eye.parsed_filename) ? File.readlink(Eye.parsed_filename) : Eye.parsed_filename
+    dirname = File.dirname(real_filename) rescue nil
+    path = Pathname.new(file_name).expand_path(dirname).to_s
+
+    Eye.parsed_filename = path
+    yield path
+  ensure
+    Eye.parsed_filename = saved_parsed_filename
+  end
+
 end

data/lib/eye/{checker → dsl}/validation.rb

@@ -1,24 +1,27 @@
-module Eye::Checker::Validation
+module Eye::Dsl::Validation
   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
 
-  attr_accessor :validates, :should_bes, :defaults
+  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 param(param, types = [], should_be = false, default = nil)
+  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
 
     define_method "#{param}" do
       @options[param.to_sym] || default
@@ -27,13 +30,20 @@ module Eye::Checker::Validation
 
   def validate(options = {})    
     options.each do |param, value|        
-      types = validates[param.to_sym]
+      param = param.to_sym
+      types = validates[param]
       unless types
-        if param.to_sym != :type
+        if param != :type
           raise Error, "#{self.name} unknown param :#{param} value #{value.inspect}" 
         end
       end
 
+      if self.variants[param]
+        if value && !value.is_a?(Proc) && !self.variants[param].include?(value)
+          raise Error, "#{value.inspect} should within #{self.variants[param].inspect}" 
+        end
+      end
+
       next if types.blank?
 
       types = Array(types)

data/lib/eye/group.rb

@@ -68,10 +68,13 @@ class Eye::Group
   def send_command(command, *args)
     info "send_command: #{command}"
 
-    if command == :delete
-      delete *args
-    else
-      schedule command, *args, "#{command} by user"
+    case command
+      when :delete
+        delete *args
+      when :break_chain 
+        break_chain *args
+      else 
+        schedule command, *args, "#{command} by user"
     end
   end
 
@@ -104,6 +107,12 @@ class Eye::Group
     async_schedule :signal, sig
   end
 
+  def break_chain
+    info "break chain"
+    scheduler.clear_pending_list
+    @chain_breaker = true    
+  end
+
   def clear
     @processes = Eye::Utils::AliveArray.new
   end

data/lib/eye/group/chain.rb

@@ -7,6 +7,9 @@ private
 
     @chain_processes_count = @processes.size
     @chain_processes_current = 0
+    @chain_breaker = false
+
+    started_at = Time.now
 
     @processes.each do | process |
       chain_schedule_process(process, type, command, *args)
@@ -15,11 +18,16 @@ private
 
       # to skip last sleep
       break if @chain_processes_current.to_i == @chain_processes_count.to_i 
+      break if @chain_breaker
 
       # wait next process
       sleep grace.to_f
+
+      break if @chain_breaker
     end
 
+    debug "chain finished #{Time.now - started_at}s"
+
     @chain_processes_count = nil
     @chain_processes_current = nil
   end
@@ -29,6 +37,9 @@ private
     
     if type == :sync
       # sync command, with waiting
+      # this is very hackety, because call method of the process without its scheduler
+      # need to provide some scheduler future
+      process.last_scheduled_reason = self.last_scheduled_reason
       process.send(command, *args)
     else
       # async command

data/lib/eye/notify.rb

@@ -1,7 +1,7 @@
 class Eye::Notify
   include Celluloid
   include Eye::Logger::Helpers
-  extend Eye::Checker::Validation
+  extend Eye::Dsl::Validation
 
   autoload :Mail,     'eye/notify/mail'
   autoload :Jabber,   'eye/notify/jabber'

data/lib/eye/notify/mail.rb

@@ -13,7 +13,7 @@ class Eye::Notify::Mail < Eye::Notify
   param :domain, String
   param :user, String
   param :password, String
-  param :auth, Symbol # :plain, :login, :cram_md5
+  param :auth, Symbol, nil, nil, [:plain, :login, :cram_md5]
   
   param :from_mail, String
   param :from_name, String, nil, 'eye'

data/lib/eye/process/child.rb

@@ -47,8 +47,6 @@ module Eye::Process::Child
   def remove_childs
     if childs.present?
       childs.keys.each{|child_pid| remove_child(child_pid) }
-    else
-      debug 'No childs to clear'
     end
   end
 

data/lib/eye/process/commands.rb

@@ -17,8 +17,8 @@ module Eye::Process::Commands
       debug "process (#{self.pid}) ok started"
       switch :started
     else
-      debug "process (#{self.pid}) failed to start (#{result[:error].inspect})"
-      if self.pid && Eye::System.pid_alive?(self.pid)
+      error "process (#{self.pid}) failed to start (#{result[:error].inspect})"
+      if process_realy_running?
         warn "kill, what remains from process (#{self.pid}), because its failed to start (without pid_file impossible to monitoring)"
         send_signal(:KILL)
         sleep 0.2 # little grace
@@ -53,7 +53,7 @@ module Eye::Process::Commands
       switch :stopped
 
       if control_pid?
-        info "delete pid_file: #{self[:pid_file]}"
+        info "delete pid_file: #{self[:pid_file_ex]}"
         clear_pid_file 
       end
       
@@ -135,7 +135,7 @@ private
       
       sleep self[:stop_grace].to_f
 
-      # if process not die here, by default we kill it force
+      # if process not die here, by default we force kill it
       if process_realy_running?
         warn "process not die after TERM and stop_grace #{self[:stop_grace].to_f}s, so send KILL"
         send_signal(:KILL)
@@ -188,17 +188,14 @@ private
     sleep self[:start_grace].to_f
 
     unless process_realy_running?
-      error "process with pid (#{self.pid}) not found, may be crashed (#{check_logs_str})"
+      error "process with pid(#{self.pid}) not found, may be crashed (#{check_logs_str})"
       return {:error => :not_realy_running}
     end
 
-    begin
-      save_pid_to_file
-    rescue => ex
-      error "save pid to file raised with #{ex.inspect}"
-      return {:error => :cant_write_pid}
+    unless failsafe_save_pid
+      return {:error => :cant_write_pid} 
     end
-
+    
     res
   end
 
@@ -226,17 +223,17 @@ private
     sleep self[:start_grace].to_f
 
     unless set_pid_from_file
-      error "pid_file(#{self[:pid_file]}) does not appears after start_grace #{self[:start_grace].to_f}, check start_command, or tune start_grace (eye dont know what to monitor without pid)"
+      error "pid_file(#{self[:pid_file_ex]}) does not appears after start_grace #{self[:start_grace].to_f}, check start_command, or tune start_grace (eye dont know what to monitor without pid)"
       return {:error => :pid_not_found}
     end
 
     unless process_realy_running?
-      error "process in pid_file(#{self[:pid_file]})(#{self.pid}) not found, maybe process do not write there actual pid, or just crashed (#{check_logs_str})"
+      error "process in pid_file(#{self[:pid_file_ex]})(#{self.pid}) not found, maybe process do not write there actual pid, or just crashed (#{check_logs_str})"
       return {:error => :not_realy_running}
     end
 
     res[:pid] = self.pid
-    info "process get pid:#{res[:pid]}"
+    info "process get pid:#{res[:pid]}, pid_file #{self[:pid_file_ex]}"
     res
   end
 

data/lib/eye/process/monitor.rb

@@ -38,7 +38,7 @@ private
 
       # check that process runned
       unless process_realy_running?
-        warn 'check_alive: process not found'
+        warn "check_alive: process(#{self.pid}) not found!"
         notify :warn, 'crashed!'
         switch :crashed
       else
@@ -49,14 +49,20 @@ private
           msg = "check_alive: pid_file(#{self[:pid_file]}) changes by itself (pid:#{self.pid}) => (pid:#{ppid})"
           if control_pid?
             msg += ", not correct, pid_file is under eye control, so rewrited back pid:#{self.pid}"
-            save_pid_to_file rescue msg += ', (Can`t rewrite pid_file O_o)'
+            unless failsafe_save_pid
+              msg += ', (Can`t rewrite pid_file O_o)'
+            end
           else
             if ppid == nil
               msg += ', rewrited because empty'
-              save_pid_to_file rescue msg += ', (Can`t rewrite pid_file O_o)'
+              unless failsafe_save_pid
+                msg += ', (Can`t rewrite pid_file O_o)'
+              end
             elsif (Time.now - pid_file_ctime > REWRITE_FACKUP_PIDFILE_PERIOD)
               msg += ", > #{REWRITE_FACKUP_PIDFILE_PERIOD.inspect} ago, so rewrited (even if pid_file not under eye control)"
-              save_pid_to_file rescue msg += ', (Can`t rewrite pid_file O_o)'
+              unless failsafe_save_pid
+                msg += ', (Can`t rewrite pid_file O_o)'
+              end
             else
               msg += ', not under eye control, so ignored'
             end
@@ -68,18 +74,6 @@ private
     end
   end
 
-  def failsafe_load_pid
-    pid = load_pid_from_file
-
-    if !pid 
-      # this is can be symlink changed case
-      sleep 0.1
-      pid = load_pid_from_file
-    end
-
-    pid
-  end
-
   def check_crash
     if down?
       if self[:keep_alive] && !@flapping

data/lib/eye/process/scheduler.rb

@@ -3,18 +3,23 @@ module Eye::Process::Scheduler
   # ex: schedule :update_config, config, "reason: update_config"
   def schedule(command, *args, &block)
     if scheduler.alive?
+      unless self.respond_to?(command)
+        warn "object not support :#{command} to schedule"
+        return
+      end
+
       reason = if args.present? && [String, Symbol].include?(args[-1].class)
         args.pop
       end
 
-      info "schedule :#{command} (#{reason})"
+      info "schedule :#{command} #{reason ? "(reason: #{reason})" : nil}"
       scheduler.add_wo_dups(:scheduled_action, command, {:args => args, :reason => reason}, &block)
     end
   end
 
   def scheduled_action(command, h = {}, &block)
     reason = h.delete(:reason)
-    info "=> #{command} #{h[:args].present? ? "#{h[:args]*',' }" : nil}(#{reason})"
+    info "=> #{command} #{h[:args].present? ? "#{h[:args]*',' }" : nil} #{reason ? "(reason: #{reason})" : nil}"
 
     @current_scheduled_command = command
     @last_scheduled_command = command
@@ -47,4 +52,4 @@ private
     @scheduler ||= Eye::Utils::CelluloidChain.new(current_actor)
   end
 
-end
+end

data/lib/eye/process/states.rb

@@ -1,4 +1,3 @@
-gem 'state_machine'
 require 'state_machine'
 
 class Eye::Process
@@ -82,7 +81,7 @@ class Eye::Process
 
   def log_transition(transition)
     @states_history.push transition.to_name, @state_reason
-    info "switch :#{transition.event} [:#{transition.from_name} => :#{transition.to_name}] #{@state_reason ? "(#{@state_reason})" : nil}"
+    info "switch :#{transition.event} [:#{transition.from_name} => :#{transition.to_name}] #{@state_reason ? "(reason: #{@state_reason})" : nil}"
   end
 
   def upd_for_triggers(transition)

data/lib/eye/process/system.rb

@@ -18,9 +18,10 @@ module Eye::Process::System
       File.open(self[:pid_file_ex], 'w') do |f|
         f.write self.pid
       end
+      true
+    else
+      false
     end
-
-    true
   end
 
   def clear_pid_file
@@ -35,16 +36,26 @@ module Eye::Process::System
   end
 
   def process_realy_running?
-    Eye::System.pid_alive?(self.pid) if self.pid
+    if self.pid
+      res = Eye::System.check_pid_alive(self.pid)
+      if res[:error] && res[:error].class != Errno::ESRCH
+        error "process_realy_running?: check_pid_alive returns '#{res[:error].message}'" 
+      end
+      res[:result]
+    else
+      debug "process_realy_running?: called without pid"
+      nil
+    end
   end
 
   def send_signal(code)
-    debug "send signal #{code}"
-
     res = Eye::System.send_signal(self.pid, code)
-    error(res[:message]) if res[:status] != :ok
 
-    res[:status] == :ok
+    msg = "send_signal #{code} to #{self.pid}"
+    msg += ", error<#{res[:error]}>" if res[:error]
+    info msg
+
+    res[:result] == :ok
   end
 
   # non blocking actor timeout
@@ -56,6 +67,26 @@ module Eye::Process::System
     defer{ Eye::System::execute cmd, cfg }
   end
 
+  def failsafe_load_pid
+    pid = load_pid_from_file
+
+    if !pid 
+      # this is can be symlink changed case
+      sleep 0.1
+      pid = load_pid_from_file
+    end
+
+    pid
+  end
+
+  def failsafe_save_pid
+    save_pid_to_file 
+    true
+  rescue => ex
+    error "failsafe_save_pid: #{ex.message}"
+    false
+  end
+
 private
 
   def wait_for_condition_sync(timeout, step, &block)