eye 0.8.pre → 0.8.pre2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4ea3a96041c3e00aa9a2844e50fa3b5c0be453c6
-  data.tar.gz: 8c81af5c7d106a079cfc49023b16472bf78600ad
+  metadata.gz: a9b7bd7917fbb58bb490f4f436c4c61736127eb4
+  data.tar.gz: 240e3c98f60432b0f43c2895e52782adf99d750f
 SHA512:
-  metadata.gz: dc19f2831994ee9bba061abb1d374d928f8687d1fd39b78e18281d9a8c688a02aec672bf949a5e40fbc024507fb2dfc274374c917fe89f76afd9398e7bfd1411
-  data.tar.gz: 71b61401efa1a893d781e561c73554ba165b3984de5bc9b359adcaf51cf0e6d18bfb7aade77816dae326a29142b15be57c0e1ba34f1b78776025908b9bd7a5e4
+  metadata.gz: f809b87646a8a2e3092df493af89fdc26155f88d01c6709df3a5efe50dda2c3bdbef0a99306bb54d86faaf387e9727e8341f2bbdb3578e15d8a14c3a28f8536a
+  data.tar.gz: 4af77bcf0306370cabaf0bbbbc0a635460e658177ecee12d2e6381a15decac7dabd52847bbe603912b9288f42a9e6a396cd746527ddc2c7190c20c0515132bb7

data/.travis.yml

@@ -4,4 +4,4 @@ rvm:
   - "2.0.0"
   - "2.1"
   - "2.2.2"
-script: bundle exec rake split_test N=15
+script: bundle exec rake N=15

data/README.md

@@ -137,6 +137,10 @@ foreground load:
 
 If the eye daemon has already started and you call the `load` command, the config will be updated (into eye daemon). New objects(applications, groups, processes) will be added and monitored. Processes removed from the config will be removed (and stopped if the process has `stop_on_delete true`). Other objects will update their configs.
 
+Two global configs loaded by default, if it exists (with the first eye load):
+
+    /etc/eye.conf
+    ~/.eyeconfig
 
 Process statuses:
 

data/Rakefile

@@ -6,7 +6,7 @@ require 'coveralls/rake/task'
 
 Coveralls::RakeTask.new
 
-task :default => :pspec
+task :default => :split_test
 
 desc "run parallel tests"
 task :pspec do

data/examples/custom_trigger.eye

@@ -0,0 +1,28 @@
+# send notify when many times crashed process, finally resolved
+
+class Eye::Trigger::FixCrash < Eye::Trigger::Custom
+  param :times, Fixnum, nil, 1
+  param_default :to, :up
+
+  def check(_)
+    # process states here like this: [..., :starting, :down, :starting, :down, :starting, :up]
+    states = process.states_history.states
+
+    # states to compare with
+    compare = [:starting, :down] * times + [:starting, :up]
+
+    if states[-compare.length..-1] == compare
+      process.notify(:info, "yahho, process up")
+    end
+  end
+end
+
+Eye.app :custom_trigger do
+  trigger :fix_crash
+
+  process :some do
+    pid_file '/tmp/custom_trigger_some.pid'
+    start_command "ruby -e 's = `cat /tmp/bla`; exit(1) unless s =~ /bla/; loop { sleep 1 } '"
+    daemonize!
+  end
+end

data/eye.gemspec

@@ -19,7 +19,7 @@ Gem::Specification.new do |gem|
   gem.required_ruby_version     = '>= 1.9.2'
   gem.required_rubygems_version = '>= 1.3.6'
 
-  gem.add_dependency 'celluloid',     '~> 0.17.0'
+  gem.add_dependency 'celluloid',     '~> 0.17.2'
   gem.add_dependency 'celluloid-io',  '~> 0.17.0'
   gem.add_dependency 'state_machine'
   gem.add_dependency 'thor'

data/lib/eye.rb

@@ -1,5 +1,5 @@
 module Eye
-  VERSION   = "0.8.pre"
+  VERSION   = "0.8.pre2"
   ABOUT     = "Eye v#{VERSION} (c) 2012-2015 @kostya"
   PROCLINE  = "eye monitoring v#{VERSION}"
 

data/lib/eye/cli.rb

@@ -21,8 +21,7 @@ class Eye::Cli < Thor
     end
 
     if options[:json]
-      require 'json'
-      say JSON.dump(res)
+      say_json(res)
     else
       say render_info(res)
       say
@@ -39,27 +38,42 @@ class Eye::Cli < Thor
 
   desc "xinfo", "eye-deamon info (-c show current config)"
   method_option :config, :type => :boolean, :aliases => "-c"
+  method_option :json, :type => :boolean, :aliases => "-j"
   def xinfo
     res = cmd(:debug_data, :config => options[:config])
-    say render_debug_info(res)
-    say
+    if options[:json]
+      say_json(res)
+    else
+      say render_debug_info(res)
+      say
+    end
   end
 
   desc "oinfo", "onelined info"
+  method_option :json, :type => :boolean, :aliases => "-j"
   def oinfo(mask = nil)
     res = cmd(:short_data, *Array(mask))
-    say render_info(res)
-    say
+    if options[:json]
+      say_json(res)
+    else
+      say render_info(res)
+      say
+    end
   end
 
   desc "history [MASK,...]", "processes history"
+  method_option :json, :type => :boolean, :aliases => "-j"
   def history(*masks)
     res = cmd(:history_data, *masks)
     if !masks.empty? && res && res.empty?
       error!("command :history, objects not found!")
     end
-    say render_history(res)
-    say
+    if options[:json]
+      say_json(res)
+    else
+      say render_history(res)
+      say
+    end
   end
 
   desc "load [CONF, ...]", "load config (run eye-daemon if not) (-f foreground load)"
@@ -202,6 +216,11 @@ private
     end
   end
 
+  def say_json(obj)
+    require 'json'
+    say JSON.dump(obj)
+  end
+
   def self.exit_on_failure?
     true
   end

data/lib/eye/dsl/opts.rb

@@ -4,12 +4,12 @@ class Eye::Dsl::Opts < Eye::Dsl::PureOpts
     :stop_command, :restart_command, :uid, :gid ]
   create_options_methods(STR_OPTIONS, String)
 
-  BOOL_OPTIONS = [ :daemonize, :keep_alive, :auto_start, :stop_on_delete, :clear_pid, :preserve_fds, :use_leaf_child, :clear_env ]
+  BOOL_OPTIONS = [ :daemonize, :keep_alive, :auto_start, :stop_on_delete, :clear_pid, :preserve_fds, :use_leaf_child, :clear_env, :check_identity ]
   create_options_methods(BOOL_OPTIONS, [TrueClass, FalseClass])
 
   INTERVAL_OPTIONS = [ :check_alive_period, :start_timeout, :restart_timeout, :stop_timeout, :start_grace,
     :restart_grace, :stop_grace, :children_update_period, :restore_in,
-    :auto_update_pidfile_grace, :revert_fuckup_pidfile_grace ]
+    :auto_update_pidfile_grace, :revert_fuckup_pidfile_grace, :check_identity_period, :check_identity_grace ]
   create_options_methods(INTERVAL_OPTIONS, [Fixnum, Float])
 
   create_options_methods([:environment], Hash)

data/lib/eye/group.rb

@@ -70,8 +70,9 @@ class Eye::Group
   def status_data_short
     h = Hash.new
     @processes.each do |p|
-      h[p.state] ||= 0
-      h[p.state] += 1
+      state = p.state
+      h[state] ||= 0
+      h[state] += 1
     end
     { name: (@name == '__default__' ? 'default' : @name), type: :group, states: h }
   end

data/lib/eye/loader.rb

@@ -1,10 +1,10 @@
 # add gems to $: by `gem` method
 #  this is only way when install eye as system wide
 
-gem 'celluloid',     '~> 0.17.0'
+gem 'celluloid',     '~> 0.17.2'
 gem 'celluloid-io',  '~> 0.17.0'
 gem 'nio4r'
 gem 'timers'
 
 gem 'state_machine'
-gem 'sigar',         '~> 0.7.2'
+gem 'sigar',         '~> 0.7.3'

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
@@ -240,19 +243,16 @@ private
 
     sleep_grace(:start_grace)
 
-    unless set_pid_from_file
+    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)"
-      return {:error => :pid_not_found}
+      { :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,6 +278,8 @@ 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

data/lib/eye/process/config.rb

@@ -4,6 +4,10 @@ module Eye::Process::Config
     :keep_alive => true, # restart when crashed
     :check_alive_period => 5.seconds,
 
+    :check_identity => true,
+    :check_identity_period => 60.seconds,
+    :check_identity_grace => 60.seconds,
+
     :start_timeout => 15.seconds,
     :stop_timeout => 10.seconds,
     :restart_timeout => 10.seconds,

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

data/lib/eye/process/monitor.rb

@@ -2,32 +2,28 @@ module Eye::Process::Monitor
 
 private
 
-  def check_alive_with_refresh_pid_if_needed
-    if process_really_running?
-      return true
-
-    else
-      warn 'process not really running'
-      try_update_pid_from_file
-    end
-  end
-
-  def try_update_pid_from_file
-    # if pid file was rewritten
-    newpid = load_pid_from_file
-    if newpid != self.pid
-      info "process <#{self.pid}> changed pid to <#{newpid}>, updating..." if self.pid
+  def load_external_pid_file
+    newpid = failsafe_load_pid
+
+    if !newpid
+      self.pid = nil
+      info "load_external_pid_file: pid_file not found"
+      :no_pid_file
+    elsif process_pid_running?(newpid)
       self.pid = newpid
-
-      if process_really_running?
-        return true
+      res = compare_identity
+      if res == :fail
+        warn "load_external_pid_file: process <#{self.pid}> from pid_file failed check_identity"
+        :bad_identity
       else
-        warn "process <#{newpid}> was not found"
-        return false
+        info "load_external_pid_file: process <#{self.pid}> from pid_file found and running (identity: #{res}) (#{Eye::SystemResources.args(self.pid)})"
+        :ok
       end
     else
-      debug { 'process was not found' }
-      return false
+      @last_loaded_pid = newpid
+      self.pid = nil
+      info "load_external_pid_file: pid_file found, but process <#{newpid}> not found"
+      :not_running
     end
   end
 
@@ -38,48 +34,61 @@ private
       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
+        clear_pid_file(true) if control_pid?
 
         switch :crashed, Eye::Reason.new(:crashed)
       else
-        # check that pid_file still here
-        ppid = failsafe_load_pid
-
-        if ppid != self.pid
-          msg = "check_alive: pid_file (#{self[:pid_file]}) changed by itself (<#{self.pid}> => <#{ppid}>)"
-          if control_pid?
-            msg += ", reverting to <#{self.pid}> (the pid_file is controlled by eye)"
-            unless failsafe_save_pid
-              msg += ", pid_file write failed! O_o"
-            end
-          else
-            changed_ago_s = Time.now - pid_file_ctime
-
-            if ppid == nil
-              msg += ", reverting to <#{self.pid}> (the pid_file is empty)"
-              unless failsafe_save_pid
-                msg += ", pid_file write failed! O_o"
-              end
-
-            elsif (changed_ago_s > self[:auto_update_pidfile_grace]) && process_pid_running?(ppid)
-              msg += ", trusting this change, and now monitor <#{ppid}>"
-              self.pid = ppid
-
-            elsif (changed_ago_s > self[:revert_fuckup_pidfile_grace])
-              msg += " over #{self[:revert_fuckup_pidfile_grace]}s ago, reverting to <#{self.pid}>, because <#{ppid}> not alive"
-              unless failsafe_save_pid
-                msg += ", pid_file write failed! O_o"
-              end
-
-            else
-              msg += ', ignoring self-managed pid change'
-            end
-          end
-
-          warn msg
+        check_pid_file
+      end
+    end
+  end
+
+  def check_pid_file
+    ppid = failsafe_load_pid
+    return if ppid == self.pid
+
+    msg = "check_alive: pid_file (#{self[:pid_file]}) changed by itself (<#{self.pid}> => <#{ppid}>)"
+    if control_pid?
+      msg += ", reverting to <#{self.pid}> (the pid_file is controlled by eye)"
+      unless failsafe_save_pid
+        msg += ", pid_file write failed! O_o"
+      end
+    else
+      changed_ago_s = Time.now - pid_file_ctime
+
+      if ppid == nil
+        msg += ", reverting to <#{self.pid}> (the pid_file is empty)"
+        unless failsafe_save_pid
+          msg += ", pid_file write failed! O_o"
+        end
+
+      elsif (changed_ago_s > self[:auto_update_pidfile_grace]) && process_pid_running?(ppid) && (compare_identity(ppid) != :fail)
+        msg += ", trusting this change, and now monitor <#{ppid}>"
+        self.pid = ppid
+
+      elsif (changed_ago_s > self[:revert_fuckup_pidfile_grace])
+        msg += " over #{self[:revert_fuckup_pidfile_grace]}s ago, reverting to <#{self.pid}>, because <#{ppid}> not alive"
+        unless failsafe_save_pid
+          msg += ", pid_file write failed! O_o"
         end
+
+      else
+        msg += ', ignoring self-managed pid change'
       end
     end
+
+    warn msg
+  end
+
+  def check_identity
+    if compare_identity == :fail
+      notify :info, 'crashed by identity!'
+      switch :crashed, Eye::Reason.new(:crashed_by_identity)
+      clear_pid_file if self[:clear_pid]
+      false
+    else
+      true
+    end
   end
 
   def check_crash

data/lib/eye/process/states.rb

@@ -27,7 +27,7 @@ class Eye::Process
     end
 
     event :crashed do
-      transition [:starting, :restarting, :up] => :down
+      transition [:starting, :restarting, :stopping, :up] => :down
     end
 
     event :stopping do
@@ -69,6 +69,7 @@ class Eye::Process
   end
 
   def on_crashed
+    self.pid = nil
     schedule :check_crash, Eye::Reason.new(:crashed)
   end
 

data/lib/eye/process/system.rb

@@ -3,16 +3,7 @@ require 'timeout'
 module Eye::Process::System
 
   def load_pid_from_file
-    res = if File.exist?(self[:pid_file_ex])
-      _pid = File.read(self[:pid_file_ex]).to_i
-      _pid > 0 ? _pid : nil
-    end
-
-    res
-  end
-
-  def set_pid_from_file
-    self.pid = load_pid_from_file
+    File.read(self[:pid_file_ex]).to_i rescue nil
   end
 
   def save_pid_to_file
@@ -26,7 +17,8 @@ module Eye::Process::System
     end
   end
 
-  def clear_pid_file
+  def clear_pid_file(check_content = false)
+    return if check_content && self.pid && load_pid_from_file != self.pid
     info "delete pid_file: #{self[:pid_file_ex]}"
     File.unlink(self[:pid_file_ex])
     true
@@ -38,6 +30,31 @@ module Eye::Process::System
     File.ctime(self[:pid_file_ex]) rescue Time.now
   end
 
+  def get_identity
+    File.mtime(self[:pid_file_ex])
+  rescue Errno::ENOENT
+    nil
+  end
+
+  def compare_identity(pid = self.pid)
+    return :ok unless self[:check_identity]
+    return :no_pid unless pid
+    id = get_identity
+    return :no_pid_file unless id
+    st = Eye::SystemResources.start_time(pid)
+    return :no_start_time unless st
+    st1 = st.to_i
+    id1 = id.to_i
+    if (id1 - st1).abs > self[:check_identity_grace]
+      msg = "pid_file: '#{Eye::Utils.human_time2(id)}', process: '#{Eye::Utils.human_time2(st)}' (#{Eye::SystemResources.args(pid)})"
+      res = (id1 < st1) ? :fail : :touched
+      warn "compare_identity: #{res}, #{msg}"
+      res
+    else
+      :ok
+    end
+  end
+
   def process_really_running?
     process_pid_running?(self.pid)
   end
@@ -97,13 +114,12 @@ module Eye::Process::System
   def failsafe_load_pid
     pid = load_pid_from_file
 
-    if !pid
-      # this is can be symlink changed case
+    unless pid # this is can be symlink changed case
       sleep 0.1
       pid = load_pid_from_file
     end
 
-    pid
+    pid if pid && pid > 0
   end
 
   def failsafe_save_pid

data/lib/eye/process/watchers.rb

@@ -11,6 +11,12 @@ module Eye::Process::Watchers
         check_alive
       end
 
+      if self[:check_identity]
+        add_watcher(:check_identity, self[:check_identity_period]) do
+          check_identity
+        end
+      end
+
       # monitor children pids
       if self[:monitor_children]
         add_watcher(:check_children, self[:children_update_period]) do

data/lib/eye/system_resources.rb

@@ -1,4 +1,4 @@
-require 'celluloid'
+require 'celluloid/current'
 
 class Eye::SystemResources
 
@@ -57,6 +57,10 @@ class Eye::SystemResources
       end
     end
 
+    def args(pid)
+      Eye::Sigar.proc_args(pid).join(' ').strip rescue '-'
+    end
+
     def resources(pid)
       { :memory => memory(pid),
         :cpu => cpu(pid),

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: eye
 version: !ruby/object:Gem::Version
-  version: 0.8.pre
+  version: 0.8.pre2
 platform: ruby
 authors:
 - Konstantin Makarchev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-14 00:00:00.000000000 Z
+date: 2015-10-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: celluloid
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.17.0
+        version: 0.17.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.17.0
+        version: 0.17.2
 - !ruby/object:Gem::Dependency
   name: celluloid-io
   requirement: !ruby/object:Gem::Requirement
@@ -311,6 +311,7 @@ files:
 - bin/eye
 - bin/leye
 - bin/loader_eye
+- examples/custom_trigger.eye
 - examples/delayed_job.eye
 - examples/dependency.eye
 - examples/notify.eye
@@ -438,7 +439,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.6
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.7
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: Process monitoring tool. Inspired from Bluepill and God. Requires Ruby(MRI)