eye 0.7 → 0.8.celluloid15

data/lib/eye/notify.rb

@@ -1,6 +1,7 @@
 require 'celluloid'
 
 class Eye::Notify
+
   include Celluloid
   include Eye::Dsl::Validation
 
@@ -8,7 +9,7 @@ class Eye::Notify
   autoload :Jabber,   'eye/notify/jabber'
   autoload :Slack,    'eye/notify/slack'
 
-  TYPES = {:mail => 'Mail', :jabber => 'Jabber', :slack => 'Slack'}
+  TYPES = { mail: 'Mail', jabber: 'Jabber', slack: 'Slack' }
 
   def self.get_class(type)
     klass = eval("Eye::Notify::#{TYPES[type]}") rescue nil
@@ -35,19 +36,19 @@ class Eye::Notify
 
     create_proc = lambda do |nh|
       type = nh[:type]
-      config = (settings[type] || {}).merge(nh[:opts] || {}).merge(:contact => nh[:contact])
+      config = (settings[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] }
+      needed_hash.each { |nh| create_proc[nh] }
     else
       create_proc[needed_hash]
     end
 
-  rescue Exception, Timeout::Error => ex
+  rescue Object => ex
     log_ex(ex)
   end
 
@@ -66,7 +67,7 @@ class Eye::Notify
 
   def async_notify
     async.notify
-    after(TIMEOUT){ terminate }
+    after(TIMEOUT) { terminate }
   end
 
   def notify
@@ -102,15 +103,18 @@ class Eye::Notify
   end
 
   class Custom < Eye::Notify
+
     def self.inherited(base)
       super
       register(base)
     end
+
   end
 
-  %w{at host message name full_name pid level}.each do |name|
+  %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

@@ -27,4 +27,4 @@ class Eye::Notify::Jabber < Eye::Notify
     client.close
   end
 
-end
+end

data/lib/eye/notify/mail.rb

@@ -41,8 +41,8 @@ class Eye::Notify::Mail < Eye::Notify
     h << "To: <#{contact}>"
     h << "Subject: #{message_subject}"
     h << "Date: #{msg_at.httpdate}"
-    h << "Message-Id: <#{rand(1000000000).to_s(36)}.#{$$}.#{contact}>"
+    h << "Message-Id: <#{rand(1_000_000_000).to_s(36)}.#{$$}.#{contact}>"
     "#{h * "\n"}\n#{message_body}"
   end
 
-end
+end

data/lib/eye/notify/slack.rb

@@ -8,8 +8,8 @@ class Eye::Notify::Slack < Eye::Notify
   # end
 
   param :webhook_url, String, true
-  param :channel,     String, nil, "#default"
-  param :username,    String, nil, "eye"
+  param :channel,     String, nil, '#default'
+  param :username,    String, nil, 'eye'
 
   param :icon, String
 
@@ -35,4 +35,5 @@ class Eye::Notify::Slack < Eye::Notify
     payload << "> #{msg_message}"
     payload
   end
-end
+
+end

data/lib/eye/process.rb

@@ -1,6 +1,7 @@
 require 'celluloid'
 
 class Eye::Process
+
   include Celluloid
 
   autoload :Config,           'eye/process/config'
@@ -77,6 +78,7 @@ class Eye::Process
 
   # validate
   extend Eye::Process::Validate
+
 end
 
 # include state_machine states

data/lib/eye/process/children.rb

@@ -31,17 +31,17 @@ module Eye::Process::Children
 
     if new_children.present?
       new_children.each do |child_pid|
-        cfg = self[:monitor_children].try :update, :notify => self[:notify]
+        cfg = self[:monitor_children].try :update, notify: self[:notify]
         self.children[child_pid] = Eye::ChildProcess.new(child_pid, cfg, logger.prefix, current_actor)
       end
     end
 
     if removed_children.present?
-      removed_children.each{|child_pid| remove_child(child_pid) }
+      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 }" }
+    h = { new: new_children.size, removed: removed_children.size, exists: exist_children.size }
+    debug { "children info: #{h.inspect}" }
 
     @updating_children = false
     h

data/lib/eye/process/commands.rb

@@ -25,7 +25,6 @@ module Eye::Process::Commands
         sleep 0.2 # little grace
       end
 
-      self.pid = nil
       switch :crashed
     end
 
@@ -42,6 +41,8 @@ module Eye::Process::Commands
 
     switch :stopping
 
+    return unless check_identity
+
     kill_process
 
     if process_really_running?
@@ -69,9 +70,11 @@ module Eye::Process::Commands
     switch :restarting
 
     if self[:restart_command]
-      execute_restart_command
-      sleep_grace(:restart_grace)
-      result = check_alive_with_refresh_pid_if_needed
+      return unless check_identity
+      if execute_restart_command
+        sleep_grace(:restart_grace)
+      end
+      result = process_really_running? || (load_external_pid_file == :ok)
       switch(result ? :restarted : :crashed)
     else
       stop_process
@@ -96,10 +99,9 @@ private
     if self[:stop_command]
       cmd = prepare_command(self[:stop_command])
       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]))
+      res = execute(cmd, config.merge(timeout: self[:stop_timeout]))
 
       if res[:error]
-
         if res[:error].class == Timeout::Error
           error "stop_command failed with #{res[:error].inspect}; try tuning the stop_timeout value"
         else
@@ -112,7 +114,6 @@ private
     elsif self[:stop_signals]
       info "executing stop_signals #{self[:stop_signals].inspect}"
       stop_signals = self[:stop_signals].clone
-
       signal = stop_signals.shift
       send_signal(signal)
 
@@ -120,7 +121,7 @@ private
         delay = stop_signals.shift
         signal = stop_signals.shift
 
-        if wait_for_condition(delay.to_f, 0.3){ !process_really_running? }
+        if wait_for_condition(delay.to_f, 0.3) { !process_really_running? }
           info 'has terminated'
           break
         end
@@ -133,7 +134,6 @@ private
     else # default command
       debug { "executing: `kill -TERM #{self.pid}` with stop_grace: #{self[:stop_grace].to_f}s" }
       send_signal(:TERM)
-
       sleep_grace(:stop_grace)
 
       # if process not die here, by default we force kill it
@@ -154,7 +154,7 @@ private
     cmd = prepare_command(self[:restart_command])
     info "executing: `#{cmd}` with restart_timeout: #{self[:restart_timeout].to_f}s and restart_grace: #{self[:restart_grace].to_f}s"
 
-    res = execute(cmd, config.merge(:timeout => self[:restart_timeout]))
+    res = execute(cmd, config.merge(timeout: self[:restart_timeout]))
 
     if res[:error]
 
@@ -169,11 +169,9 @@ private
   end
 
   def daemonize_process
-    time_before = Time.now
     res = 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: '#{environment_string}', <#{res[:pid]}> (in #{self[:working_dir]})"
+    info "daemonizing: `#{self[:start_command]}` with start_grace: #{self[:start_grace].to_f}s, env: '#{environment_string}'}" \
+      ", <#{res[:pid]}> (in #{self[:working_dir]})"
 
     if res[:error]
 
@@ -183,21 +181,21 @@ private
         error "daemonize failed with #{res[:error].inspect}"
       end
 
-      return {:error => res[:error].inspect}
+      return { error: res[:error].inspect }
     end
 
     self.pid = res[:pid]
 
     unless self.pid
       error 'no pid was returned'
-      return {:error => :empty_pid}
+      return { error: :empty_pid }
     end
 
     sleep_grace(:start_grace)
 
     unless process_really_running?
       error "process <#{self.pid}> not found, it may have crashed (#{check_logs_str})"
-      return {:error => :not_really_running}
+      return { error: :not_really_running }
     end
 
     # if we using leaf child stratedy, pid should be used as last child process
@@ -212,47 +210,46 @@ private
     end
 
     if control_pid? && !failsafe_save_pid
-      return {:error => :cant_write_pid}
+      return { error: :cant_write_pid }
     end
 
     res
   end
 
   def execute_process
-    info "executing: `#{self[:start_command]}` with start_timeout: #{config[:start_timeout].to_f}s, start_grace: #{self[:start_grace].to_f}s, env: '#{environment_string}' (in #{self[:working_dir]})"
-    time_before = Time.now
-
-    res = execute(self[:start_command], config.merge(:timeout => config[:start_timeout]))
-    start_time = Time.now - time_before
+    info "executing: `#{self[:start_command]}` with start_timeout: #{config[:start_timeout].to_f}s" \
+      ", start_grace: #{self[:start_grace].to_f}s, env: '#{environment_string}' (in #{self[:working_dir]})"
+    res = execute(self[:start_command], config.merge(timeout: config[:start_timeout]))
 
     if res[:error]
 
       if res[:error].message == 'Permission denied - open'
         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)"
+        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 "execution failed with #{res[:error].inspect}"
       end
 
-      return {:error => res[:error].inspect}
+      return { error: res[:error].inspect }
     end
 
     sleep_grace(:start_grace)
 
-    unless set_pid_from_file
-      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}
+    case load_external_pid_file
+      when :ok
+        res.merge(pid: self.pid)
+      when :no_pid_file
+        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)'
+        { error: :pid_not_found }
+      when :not_running
+        error "exit status #{res[:exitstatus]}, process <#{@last_loaded_pid}> (from #{self[:pid_file_ex]}) was not found; " \
+          "ensure that the pid_file is being updated correctly (#{check_logs_str})"
+        { error: :not_really_running }
     end
-
-    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 "exit status #{res[:exitstatus]}, process <#{res[:pid]}> (from #{self[:pid_file_ex]}) was found"
-    res
   end
 
   def check_logs_str
@@ -278,12 +275,14 @@ private
   end
 
   def execute_user_command(name, cmd)
+    return unless check_identity
+
     info "executing user command #{name} #{cmd.inspect}"
 
     # cmd is string, or array of signals
     if cmd.is_a?(String)
       cmd = prepare_command(cmd)
-      res = execute(cmd, config.merge(:timeout => 120))
+      res = execute(cmd, config.merge(timeout: 120))
       error "cmd #{cmd} error #{res.inspect}" if res[:error]
     elsif cmd.is_a?(Array)
       signals = cmd.clone
@@ -293,7 +292,7 @@ private
       while signals.present?
         delay = signals.shift
         signal = signals.shift
-        if wait_for_condition(delay.to_f, 0.3){ !process_really_running? }
+        if wait_for_condition(delay.to_f, 0.3) { !process_really_running? }
           info 'has terminated'
           break
         end

data/lib/eye/process/config.rb

@@ -1,25 +1,29 @@
 module Eye::Process::Config
 
   DEFAULTS = {
-    :keep_alive => true, # restart when crashed
-    :check_alive_period => 5.seconds,
+    keep_alive: true, # restart when crashed
+    check_alive_period: 5.seconds,
 
-    :start_timeout => 15.seconds,
-    :stop_timeout => 10.seconds,
-    :restart_timeout => 10.seconds,
+    check_identity: true,
+    check_identity_period: 60.seconds,
+    check_identity_grace: 60.seconds,
 
-    :start_grace => 2.5.seconds,
-    :stop_grace => 0.5.seconds,
-    :restart_grace => 1.second,
+    start_timeout: 15.seconds,
+    stop_timeout: 10.seconds,
+    restart_timeout: 10.seconds,
 
-    :daemonize => false,
-    :auto_start => true, # auto start on monitor action
+    start_grace: 2.5.seconds,
+    stop_grace: 0.5.seconds,
+    restart_grace: 1.second,
 
-    :children_update_period => 30.seconds,
-    :clear_pid => true, # by default clear pid on stop
+    daemonize: false,
+    auto_start: true, # auto start on monitor action
 
-    :auto_update_pidfile_grace => 30.seconds,
-    :revert_fuckup_pidfile_grace => 120.seconds,
+    children_update_period: 30.seconds,
+    clear_pid: true, # by default clear pid on stop
+
+    auto_update_pidfile_grace: 30.seconds,
+    revert_fuckup_pidfile_grace: 120.seconds
   }
 
   def prepare_config(new_config)
@@ -27,12 +31,14 @@ 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[:children_update_period] = h[:monitor_children][:children_update_period] if h[:monitor_children] && h[:monitor_children][:children_update_period]
+    if upd = h.try(:[], :monitor_children).try(:[], :children_update_period)
+      h[:children_update_period] = upd
+    end
 
     # check speedy flapping by default
     if h[:triggers].blank? || !h[:triggers][:flapping]
       h[:triggers] ||= {}
-      h[:triggers][:flapping] = {:type => :flapping, :times => 10, :within => 10.seconds}
+      h[:triggers][:flapping] = { type: :flapping, times: 10, within: 10.seconds }
     end
 
     h[:stdout] = Eye::System.normalized_file(h[:stdout], h[:working_dir]) if h[:stdout]

data/lib/eye/process/controller.rb

@@ -5,21 +5,12 @@ module Eye::Process::Controller
   end
 
   def start
-    res = if set_pid_from_file
-      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 <#{self.pid}> is down, starting..."
-        start_process
-      end
+    if load_external_pid_file == :ok
+      switch :already_running
+      :ok
     else
-      info 'pid_file not found, starting...'
       start_process
     end
-
-    res
   end
 
   def stop
@@ -28,10 +19,7 @@ module Eye::Process::Controller
   end
 
   def restart
-    unless pid # unmonitored case
-      try_update_pid_from_file
-    end
-
+    load_external_pid_file unless pid # unmonitored case
     restart_process
   end
 
@@ -39,11 +27,9 @@ module Eye::Process::Controller
     if self[:auto_start]
       start
     else
-      if try_update_pid_from_file
-        info "process <#{self.pid}> from pid_file is already running"
+      if load_external_pid_file == :ok
         switch :already_running
       else
-        warn 'process not found, unmonitoring'
         schedule :unmonitor, Eye::Reason.new(:'not found')
       end
     end