eye 0.5.1 → 0.5.2

data/lib/eye/process/children.rb

@@ -0,0 +1,60 @@
+module Eye::Process::Children
+
+  def add_children
+    add_or_update_children
+  end
+
+  def add_or_update_children
+    return unless self[:monitor_children]
+    return unless self.up?
+    return if @updating_children
+    @updating_children = true
+
+    unless self.pid
+      warn "can't add children; pid not set"
+      return
+    end
+
+    now_children = Eye::SystemResources.children(self.pid)
+    new_children = []
+    exist_children = []
+
+    now_children.each do |child_pid|
+      if self.children[child_pid]
+        exist_children << child_pid
+      else
+        new_children << child_pid
+      end
+    end
+
+    removed_children = self.children.keys - now_children
+
+    if new_children.present?
+      new_children.each do |child_pid|
+        self.children[child_pid] = Eye::ChildProcess.new(child_pid, self[:monitor_children], logger.prefix)
+      end
+    end
+
+    if removed_children.present?
+      removed_children.each{|child_pid| remove_child(child_pid) }
+    end
+
+    h = {:new => new_children.size, :removed => removed_children.size, :exists => exist_children.size }
+    debug "children info: #{ h.inspect }"
+
+    @updating_children = false
+    h
+  end
+
+  def remove_children
+    if children.present?
+      children.keys.each{|child_pid| remove_child(child_pid) }
+    end
+  end
+
+  def remove_child(child_pid)
+    child = self.children.delete(child_pid)
+    child.destroy if child && child.alive?
+  end
+
+end

data/lib/eye/process/commands.rb

@@ -6,7 +6,7 @@ module Eye::Process::Commands
     switch :starting
 
     unless self[:start_command]
-      warn 'no start command, so unmonitoring'
+      warn 'no :start_command found, unmonitoring'
       switch :unmonitoring, Eye::Reason.new(:no_start_command)
       return :no_start_command
     end
@@ -14,12 +14,13 @@ module Eye::Process::Commands
     result = self[:daemonize] ? daemonize_process : execute_process
 
     if !result[:error]
-      debug "process (#{self.pid}) ok started"
+      debug "process <#{self.pid}> started successfully"
       switch :started
     else
-      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)"
+      error "process <#{self.pid}> failed to start (#{result[:error].inspect})"
+
+      if process_really_running?
+        warn "killing <#{self.pid}> due to error"
         send_signal(:KILL)
         sleep 0.2 # little grace
       end
@@ -43,8 +44,8 @@ module Eye::Process::Commands
 
     kill_process
 
-    if process_realy_running?
-      warn 'NOT STOPPED, check command/signals, or tune stop_timeout/stop_grace, seems it was really soft'
+    if process_really_running?
+      warn "process <#{self.pid}> was not stopped; try checking your command/signals or tuning the stop_timeout/stop_grace values"
 
       switch :unmonitoring, Eye::Reason.new(:'not stopped (soft command)')
       nil
@@ -88,20 +89,21 @@ private
 
   def kill_process
     unless self.pid
-      error 'try to kill process without pid'
+      error 'cannot stop a process without a pid'
       return
     end
 
     if self[:stop_command]
       cmd = prepare_command(self[:stop_command])
-      res = execute(cmd, config.merge(:timeout => self[:stop_timeout]))
       info "executing: `#{cmd}` with stop_timeout: #{self[:stop_timeout].to_f}s and stop_grace: #{self[:stop_grace].to_f}s"
+      res = execute(cmd, config.merge(:timeout => self[:stop_timeout]))
 
       if res[:error]
-        error "raised with #{res[:error].inspect}"
 
         if res[:error].class == Timeout::Error
-          error 'you should tune stop_timeout setting'
+          error "stop_command failed with #{res[:error].inspect}; try tuning the stop_timeout value"
+        else
+          error "stop_command failed with #{res[:error].inspect}"
         end
       end
 
@@ -118,7 +120,7 @@ private
         delay = stop_signals.shift
         signal = stop_signals.shift
 
-        if wait_for_condition(delay.to_f, 0.3){ !process_realy_running? }
+        if wait_for_condition(delay.to_f, 0.3){ !process_really_running? }
           info 'has terminated'
           break
         end
@@ -135,8 +137,8 @@ private
       sleep_grace(:stop_grace)
 
       # 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(#{self.pid})"
+      if process_really_running?
+        warn "process <#{self.pid}> did not die after TERM, sending KILL"
         send_signal(:KILL)
         sleep 0.1 # little grace
       end
@@ -145,7 +147,7 @@ private
 
   def execute_restart_command
     unless self.pid
-      error 'try to execute restart_command without pid'
+      error 'cannot restart a process without a pid'
       return
     end
 
@@ -155,10 +157,11 @@ private
     res = execute(cmd, config.merge(:timeout => self[:restart_timeout]))
 
     if res[:error]
-      error "restart raised with #{res[:error].inspect}"
 
       if res[:error].class == Timeout::Error
-        error 'you should tune restart_timeout setting'
+        error "restart_command failed with #{res[:error].inspect}; try tuning the restart_timeout value"
+      else
+        error "restart_command failed with #{res[:error].inspect}"
       end
     end
 
@@ -170,13 +173,14 @@ private
     res = Eye::System.daemonize(self[:start_command], config)
     start_time = Time.now - time_before
 
-    info "daemonizing: `#{self[:start_command]}` with start_grace: #{self[:start_grace].to_f}s, env: #{self[:environment].inspect}, working_dir: #{self[:working_dir]} (pid:#{res[:pid]})"
+    info "daemonizing: `#{self[:start_command]}` with start_grace: #{self[:start_grace].to_f}s, env: #{self[:environment].inspect}, working_dir: #{self[:working_dir]}, <#{res[:pid]}>"
 
     if res[:error]
+
       if res[:error].message == 'Permission denied - open'
-        error "raised with #{res[:error].inspect}, seems #{[self[:stdout], self[:stderr]]} files are not writable"
+        error "daemonize failed with #{res[:error].inspect}; make sure #{[self[:stdout], self[:stderr]]} are writable"
       else
-        error "raised with #{res[:error].inspect}"
+        error "daemonize failed with #{res[:error].inspect}"
       end
 
       return {:error => res[:error].inspect}
@@ -185,15 +189,15 @@ private
     self.pid = res[:pid]
 
     unless self.pid
-      error 'returned empty pid, WTF O_o'
+      error 'no pid was returned'
       return {:error => :empty_pid}
     end
 
     sleep_grace(:start_grace)
 
-    unless process_realy_running?
-      error "process with pid(#{self.pid}) not found, may be crashed (#{check_logs_str})"
-      return {:error => :not_realy_running}
+    unless process_really_running?
+      error "process <#{self.pid}> not found, it may have crashed (#{check_logs_str})"
+      return {:error => :not_really_running}
     end
 
     unless failsafe_save_pid
@@ -211,14 +215,13 @@ private
     start_time = Time.now - time_before
 
     if res[:error]
+
       if res[:error].message == 'Permission denied - open'
-        error "raised with #{res[:error].inspect}, seems #{[self[:stdout], self[:stderr]]} files are not writable"
+        error "execution failed with #{res[:error].inspect}; ensure that #{[self[:stdout], self[:stderr]]} are writable"
+      elsif res[:error].class == Timeout::Error
+        error "execution failed with #{res[:error].inspect}; try increasing the start_timeout value (the current value of #{self[:start_timeout]}s seems too short)"
       else
-        error "raised with #{res[:error].inspect}"
-      end
-
-      if res[:error].class == Timeout::Error
-        error "try to increase start_timeout interval (current #{self[:start_timeout]} seems too small, for process self-daemonization)"
+        error "execution failed with #{res[:error].inspect}"
       end
 
       return {:error => res[:error].inspect}
@@ -227,25 +230,25 @@ private
     sleep_grace(:start_grace)
 
     unless set_pid_from_file
-      error "exit status #{res[:exitstatus]}, 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)"
+      error "exit status #{res[:exitstatus]}, pid_file (#{self[:pid_file_ex]}) did not appear within the start_grace period (#{self[:start_grace].to_f}s); check your start_command, or tune the start_grace value (eye expect process to create pid_file in self-daemonization mode)"
       return {:error => :pid_not_found}
     end
 
-    unless process_realy_running?
-      error "exit status #{res[:exitstatus]}, 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}
+    unless process_really_running?
+      error "exit status #{res[:exitstatus]}, process <#{self.pid}> (from #{self[:pid_file_ex]}) was not found; ensure that the pid_file is being updated correctly (#{check_logs_str})"
+      return {:error => :not_really_running}
     end
 
     res[:pid] = self.pid
-    info "process get pid:#{res[:pid]}, pid_file #{self[:pid_file_ex]}, exit status #{res[:exitstatus]}"
+    info "exit status #{res[:exitstatus]}, process <#{res[:pid]}> (from #{self[:pid_file_ex]}) was found"
     res
   end
 
   def check_logs_str
     if !self[:stdout] && !self[:stderr]
-      'maybe should add stdout/err/all logs'
+      'you may want to configure stdout/err/all logs for this process'
     else
-      "check also it stdout/err/all logs #{[self[:stdout], self[:stderr]]}"
+      "you should check the process logs #{[self[:stdout], self[:stderr]]}"
     end
   end
 

data/lib/eye/process/config.rb

@@ -15,7 +15,7 @@ module Eye::Process::Config
     :daemonize => false,
     :auto_start => true, # auto start on monitor action
 
-    :childs_update_period => 30.seconds,
+    :children_update_period => 30.seconds,
     :clear_pid => true # by default clear pid on stop
   }
 
@@ -24,7 +24,7 @@ module Eye::Process::Config
     h[:pid_file_ex] = Eye::System.normalized_file(h[:pid_file], h[:working_dir]) if h[:pid_file]
     h[:checks] = {} if h[:checks].blank?
     h[:triggers] = {} if h[:triggers].blank?
-    h[:childs_update_period] = h[:monitor_children][:childs_update_period] if h[:monitor_children] && h[:monitor_children][:childs_update_period]
+    h[:children_update_period] = h[:monitor_children][:children_update_period] if h[:monitor_children] && h[:monitor_children][:children_update_period]
 
     # check speedy flapping by default
     if h[:triggers].blank? || !h[:triggers][:flapping]
@@ -52,7 +52,7 @@ module Eye::Process::Config
     @full_name = nil
     @logger = nil
 
-    debug "update config to: #{@config.inspect}"
+    debug "updating config to: #{@config.inspect}"
 
     remove_triggers
     add_triggers
@@ -60,10 +60,10 @@ module Eye::Process::Config
     if up?
       # rebuild checks for this process
       remove_watchers
-      remove_childs
+      remove_children
 
       add_watchers
-      add_childs
+      add_children
     end
   end
 

data/lib/eye/process/controller.rb

@@ -6,16 +6,16 @@ module Eye::Process::Controller
 
   def start
     res = if set_pid_from_file
-      if process_realy_running?
-        info "process from pid_file(#{self.pid}) found and already running, so :up"
+      if process_really_running?
+        info "process <#{self.pid}> from pid_file is already running"
         switch :already_running
         :ok
       else
-        info "pid_file found, but process in pid_file(#{self.pid}) not found, starting..."
+        info "pid_file found, but process <#{self.pid}> is down, starting..."
         start_process
       end
     else
-      info 'pid_file not found, so starting process...'
+      info 'pid_file not found, starting...'
       start_process
     end
 
@@ -40,10 +40,10 @@ module Eye::Process::Controller
       start
     else
       if try_update_pid_from_file
-        info "process from pid_file(#{self.pid}) found and already running, so :up"
+        info "process <#{self.pid}> from pid_file is already running"
         switch :already_running
       else
-        warn 'process not found, so :unmonitor'
+        warn 'process not found, unmonitoring'
         schedule :unmonitor, Eye::Reason.new(:'not found')
       end
     end
@@ -60,7 +60,7 @@ module Eye::Process::Controller
     end
 
     remove_watchers
-    remove_childs
+    remove_children
     remove_triggers
 
     terminate
@@ -70,4 +70,4 @@ module Eye::Process::Controller
     send_signal(sig) if self.pid
   end
 
-end
+end

data/lib/eye/process/data.rb

@@ -19,10 +19,10 @@ module Eye::Process::Data
   def status_data(debug = false)
     p_st = self_status_data(debug)
 
-    if childs.present?
-      p_st.merge(:subtree => Eye::Utils::AliveArray.new(childs.values).map{|c| c.status_data(debug) } )
+    if children.present?
+      p_st.merge(:subtree => Eye::Utils::AliveArray.new(children.values).map{|c| c.status_data(debug) } )
     elsif self[:monitor_children] && self.up?
-      p_st.merge(:subtree => [{name: '=loading childs='}])
+      p_st.merge(:subtree => [{name: '=loading children='}])
     else
       # common state
       p_st
@@ -51,7 +51,7 @@ module Eye::Process::Data
 
   def sub_object?(obj)
     return false if self.class == Eye::ChildProcess
-    self.childs.each { |_, child| return true if child == obj }
+    self.children.each { |_, child| return true if child == obj }
     false
   end
 

data/lib/eye/process/monitor.rb

@@ -3,30 +3,30 @@ module Eye::Process::Monitor
 private
 
   def check_alive_with_refresh_pid_if_needed
-    if process_realy_running?
+    if process_really_running?
       return true
 
     else
-      warn 'process not realy running'
+      warn 'process not really running'
       try_update_pid_from_file
     end
   end
 
   def try_update_pid_from_file
-    # if pid file was rewrited
+    # if pid file was rewritten
     newpid = load_pid_from_file
     if newpid != self.pid
-      info "process changed pid to #{newpid}, updating..." if self.pid
+      info "process <#{self.pid}> changed pid to <#{newpid}>, updating..." if self.pid
       self.pid = newpid
 
-      if process_realy_running?
+      if process_really_running?
         return true
       else
-        warn "process with new_pid #{newpid} not found"
+        warn "process <#{newpid}> was not found"
         return false
       end
     else
-      debug 'process not found'
+      debug 'process was not found'
       return false
     end
   end
@@ -37,8 +37,8 @@ private
     if up?
 
       # check that process runned
-      unless process_realy_running?
-        warn "check_alive: process(#{self.pid}) not found!"
+      unless process_really_running?
+        warn "check_alive: process <#{self.pid}> not found"
         notify :info, 'crashed!'
         clear_pid_file if control_pid? && self.pid && load_pid_from_file == self.pid
 
@@ -48,25 +48,25 @@ private
         ppid = failsafe_load_pid
 
         if ppid != self.pid
-          msg = "check_alive: pid_file(#{self[:pid_file]}) changes by itself (pid:#{self.pid}) => (pid:#{ppid})"
+          msg = "check_alive: pid_file (#{self[:pid_file]}) changed by itself (<#{self.pid}> => <#{ppid}>)"
           if control_pid?
-            msg += ", not correct, pid_file is under eye control, so rewrited back pid:#{self.pid}"
+            msg += ", reverting to <#{self.pid}> (the pid_file is controlled by eye)"
             unless failsafe_save_pid
-              msg += ', (Can`t rewrite pid_file O_o)'
+              msg += ", pid_file write failed! O_o"
             end
           else
             if ppid == nil
-              msg += ', rewrited because empty'
+              msg += ", reverting to <#{self.pid}> (the pid_file is empty)"
               unless failsafe_save_pid
-                msg += ', (Can`t rewrite pid_file O_o)'
+                msg += ", pid_file write failed! 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)"
+              msg += " over #{REWRITE_FACKUP_PIDFILE_PERIOD}s ago, reverting to <#{self.pid}>"
               unless failsafe_save_pid
-                msg += ', (Can`t rewrite pid_file O_o)'
+                msg += ", pid_file write failed! O_o"
               end
             else
-              msg += ', not under eye control, so ignored'
+              msg += ', ignoring self-managed pid change'
             end
           end
 

data/lib/eye/process/scheduler.rb

@@ -4,7 +4,7 @@ module Eye::Process::Scheduler
   def schedule(command, *args, &block)
     if scheduler.alive?
       unless self.respond_to?(command, true)
-        warn "object not support :#{command} to schedule"
+        warn ":#{command} scheduling is unsupported"
         return
       end