eye 0.8.celluloid15 → 0.8.pre

data/lib/eye/process/notify.rb

@@ -5,21 +5,21 @@ module Eye::Process::Notify
   # 2) checker bounded to restart process [:warn]
   # 3) flapping + switch to unmonitored [:error]
 
-  LEVELS = { debug: 0, info: 1, warn: 2, error: 3, fatal: 4 }
+  LEVELS = {:debug => 0, :info => 1, :warn => 2, :error => 3, :fatal => 4}
 
   def notify(level, msg)
     # logging it
     error "NOTIFY: #{msg}" if ilevel(level) > ilevel(:info)
 
-    return if self[:notify].blank?
-
     # send notifies
-    message = { message: msg, name: name,
-                full_name: full_name, pid: pid, host: Eye::Local.host, level: level,
-                at: Time.now }
-
-    self[:notify].each do |contact, not_level|
-      Eye::Notify.notify(contact, message) if ilevel(level) >= ilevel(not_level)
+    if self[:notify].present?
+      message = {:message => msg, :name => name,
+        :full_name => full_name, :pid => pid, :host => Eye::Local.host, :level => level,
+        :at => Time.now }
+
+      self[:notify].each do |contact, not_level|
+        Eye::Notify.notify(contact, message) if ilevel(level) >= ilevel(not_level)
+      end
     end
   end
 
@@ -29,4 +29,4 @@ private
     LEVELS[level].to_i
   end
 
-end
+end

data/lib/eye/process/scheduler.rb

@@ -2,30 +2,32 @@ module Eye::Process::Scheduler
 
   # ex: schedule :update_config, config, "reason: update_config"
   def schedule(command, *args, &block)
-    return unless scheduler.alive?
-
-    if scheduler_freeze?
-      warn ":#{command} ignoring to schedule, because scheduler is freeze"
-      return
-    end
-
-    unless self.respond_to?(command, true)
-      warn ":#{command} scheduling is unsupported"
-      return
-    end
-
-    reason = args.pop if args.present? && args[-1].is_a?(Eye::Reason)
-
-    info "schedule :#{command} #{reason ? "(reason: #{reason})" : nil}"
-
-    if reason.class == Eye::Reason
-      # for auto reasons
-      # skip already running commands and all in chain
-      scheduler.add_wo_dups_current(:scheduled_action, command, args: args, reason: reason, block: block)
-    else
-      # for manual, or without reason
-      # skip only for last in chain
-      scheduler.add_wo_dups(:scheduled_action, command, args: args, reason: reason, block: block)
+    if scheduler.alive?
+      if scheduler_freeze?
+        warn ":#{command} ignoring to schedule, because scheduler is freeze"
+        return
+      end
+
+      unless self.respond_to?(command, true)
+        warn ":#{command} scheduling is unsupported"
+        return
+      end
+
+      reason = if args.present? && args[-1].kind_of?(Eye::Reason)
+        args.pop
+      end
+
+      info "schedule :#{command} #{reason ? "(reason: #{reason})" : nil}"
+
+      if reason.class == Eye::Reason
+        # for auto reasons
+        # skip already running commands and all in chain
+        scheduler.add_wo_dups_current(:scheduled_action, command, {:args => args, :reason => reason}, &block)
+      else
+        # for manual, or without reason
+        # skip only for last in chain
+        scheduler.add_wo_dups(:scheduled_action, command, {:args => args, :reason => reason}, &block)
+      end
     end
   end
 
@@ -37,16 +39,16 @@ module Eye::Process::Scheduler
     end
   end
 
-  def scheduled_action(command, h = {})
-    reason = h[:reason]
-    info "=> #{command} #{h[:args].present? ? "#{h[:args] * ','}" : nil} #{reason ? "(reason: #{reason})" : nil}"
+  def scheduled_action(command, h = {}, &block)
+    reason = h.delete(:reason)
+    info "=> #{command} #{h[:args].present? ? "#{h[:args]*',' }" : nil} #{reason ? "(reason: #{reason})" : nil}"
 
     @current_scheduled_command = command
     @last_scheduled_command = command
     @last_scheduled_reason = reason
     @last_scheduled_at = Time.now
 
-    send(command, *h[:args], &h[:block])
+    send(command, *h[:args], &block)
     @current_scheduled_command = nil
     info "<= #{command}"
 
@@ -57,14 +59,8 @@ module Eye::Process::Scheduler
     end
   end
 
-  def execute_proc(*_args, &block)
-    self.instance_exec(&block)
-  rescue Object => ex
-    log_ex(ex)
-  end
-
   def scheduler_actions_list
-    scheduler.list.map { |c| c[:args].first rescue nil }.compact
+    scheduler.list.map{|c| c[:args].first rescue nil }.compact
   end
 
   def scheduler_clear_pending_list
@@ -73,7 +69,6 @@ module Eye::Process::Scheduler
 
   def self.included(base)
     base.finalizer :remove_scheduler
-    base.execute_block_on_receiver :schedule
   end
 
   attr_accessor :current_scheduled_command

data/lib/eye/process/states.rb

@@ -2,7 +2,6 @@ require 'state_machine'
 require 'state_machine/version'
 
 class Eye::Process
-
   class StateError < Exception; end
 
   # do transition
@@ -28,7 +27,7 @@ class Eye::Process
     end
 
     event :crashed do
-      transition [:starting, :restarting, :stopping, :up] => :down
+      transition [:starting, :restarting, :up] => :down
     end
 
     event :stopping do
@@ -60,17 +59,16 @@ class Eye::Process
 
     after_transition any => :unmonitored, :do => :on_unmonitored
 
-    after_transition any - :up => :up, :do => :add_watchers
-    after_transition :up => any - :up, :do => :remove_watchers
+    after_transition any-:up => :up, :do => :add_watchers
+    after_transition :up => any-:up, :do => :remove_watchers
 
-    after_transition any - :up => :up, :do => :add_children
+    after_transition any-:up => :up, :do => :add_children
     after_transition any => [:unmonitored, :down], :do => :remove_children
 
     after_transition :on => :crashed, :do => :on_crashed
   end
 
   def on_crashed
-    self.pid = nil
     schedule :check_crash, Eye::Reason.new(:crashed)
   end
 
@@ -81,7 +79,7 @@ class Eye::Process
   def log_transition(transition)
     if transition.to_name != transition.from_name || @state_reason.is_a?(Eye::Reason::User)
       @states_history.push transition.to_name, @state_reason
-      info "switch :#{transition.event} [:#{transition.from_name} => :#{transition.to_name}] #{"(reason: #{@state_reason})" if @state_reason}"
+      info "switch :#{transition.event} [:#{transition.from_name} => :#{transition.to_name}] #{@state_reason ? "(reason: #{@state_reason})" : nil}"
     end
   end
 

data/lib/eye/process/states_history.rb

@@ -1,22 +1,17 @@
 class Eye::Process::StatesHistory < Eye::Utils::Tail
-
   def push(state, reason = nil, tm = Time.now)
     super(state: state, at: tm.to_i, reason: reason)
   end
 
   def states
-    self.map { |c| c[:state] }
+    self.map{|c| c[:state] }
   end
 
-  def states_for_period(period, from_time = nil, &block)
+  def states_for_period(period, from_time = nil)
     tm = Time.now - period
     tm = [tm, from_time].max if from_time
     tm = tm.to_f
-    if block
-      self.each { |s| block.call(s) if s[:at] >= tm }
-    else
-      self.select { |s| s[:at] >= tm }.map { |c| c[:state] }
-    end
+    self.select{|s| s[:at] >= tm }.map{|c| c[:state] }
   end
 
   def last_state
@@ -30,5 +25,4 @@ class Eye::Process::StatesHistory < Eye::Utils::Tail
   def last_state_changed_at
     Time.at(last[:at])
   end
-
 end

data/lib/eye/process/system.rb

@@ -3,7 +3,16 @@ require 'timeout'
 module Eye::Process::System
 
   def load_pid_from_file
-    File.read(self[:pid_file_ex]).to_i rescue nil
+    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
   end
 
   def save_pid_to_file
@@ -17,8 +26,7 @@ module Eye::Process::System
     end
   end
 
-  def clear_pid_file(check_content = false)
-    return if check_content && self.pid && load_pid_from_file != self.pid
+  def clear_pid_file
     info "delete pid_file: #{self[:pid_file_ex]}"
     File.unlink(self[:pid_file_ex])
     true
@@ -30,38 +38,14 @@ 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]
-      args = Eye::SystemResources.args(pid)
-      msg = "pid_file: '#{Eye::Utils.human_time2(id)}', process: '#{Eye::Utils.human_time2(st)}' (#{args})"
-      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
 
   def process_pid_running?(pid)
-    Eye::System.pid_alive?(pid)
+    res = Eye::System.check_pid_alive(pid)
+    debug { "process_really_running?: <#{pid}> #{res.inspect}" }
+    !!res[:result]
   end
 
   def send_signal(code)
@@ -74,7 +58,7 @@ module Eye::Process::System
     res[:result] == :ok
   end
 
-  def wait_for_condition(timeout, step = 0.1, &_block)
+  def wait_for_condition(timeout, step = 0.1, &block)
     res = nil
     sumtime = 0
 
@@ -89,7 +73,7 @@ module Eye::Process::System
   end
 
   def execute(cmd, cfg = {})
-    defer { Eye::System.execute cmd, cfg }.tap do |res|
+    defer { Eye::System::execute cmd, cfg }.tap do |res|
       notify(:debug, "Bad exit status of command #{cmd.inspect}(#{res[:exitstatus].inspect})") if res[:exitstatus] != 0
     end
   end
@@ -98,7 +82,7 @@ module Eye::Process::System
     Eye::System.daemonize(cmd, cfg)
   end
 
-  def execute_sync(cmd, opts = { timeout: 1.second })
+  def execute_sync(cmd, opts = {:timeout => 1.second})
     execute(cmd, self.config.merge(opts)).tap do |res|
       info "execute_sync `#{cmd}` with res: #{res}"
     end
@@ -113,12 +97,13 @@ module Eye::Process::System
   def failsafe_load_pid
     pid = load_pid_from_file
 
-    unless pid # this is can be symlink changed case
+    if !pid
+      # this is can be symlink changed case
       sleep 0.1
       pid = load_pid_from_file
     end
 
-    pid if pid && pid > 0
+    pid
   end
 
   def failsafe_save_pid

data/lib/eye/process/trigger.rb

@@ -1,7 +1,11 @@
 module Eye::Process::Trigger
 
   def add_triggers
-    (self[:triggers] || {}).each { |_type, cfg| add_trigger(cfg) }
+    if self[:triggers]
+      self[:triggers].each do |type, cfg|
+        add_trigger(cfg)
+      end
+    end
   end
 
   def remove_triggers

data/lib/eye/process/watchers.rb

@@ -11,12 +11,6 @@ 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
@@ -32,7 +26,7 @@ module Eye::Process::Watchers
   end
 
   def remove_watchers
-    @watchers.each { |_, h| h[:timer].cancel }
+    @watchers.each{|_, h| h[:timer].cancel }
     @watchers = {}
   end
 
@@ -48,22 +42,25 @@ private
       block.call(subject)
     end
 
-    @watchers[type] ||= { timer: timer, subject: subject }
+    @watchers[type] ||= {:timer => timer, :subject => subject}
   end
 
   def start_checkers
-    self[:checks].each { |name, cfg| start_checker(name, cfg) }
+    self[:checks].each{|name, cfg| start_checker(name, cfg) }
   end
 
   def start_checker(name, cfg)
-    # cfg: {:type => :memory, :every => 5.seconds, :below => 100.megabytes, :times => [3, 5]}
     subject = Eye::Checker.create(pid, cfg, current_actor)
+
+    # ex: {:type => :memory, :every => 5.seconds, :below => 100.megabytes, :times => [3,5]}
     add_watcher("check_#{name}".to_sym, subject.every, subject, &method(:watcher_tick).to_proc) if subject
   end
 
   def watcher_tick(subject)
-    # double up? test needed because state can changed while subject.check
-    subject.fire if up? && !subject.check && up?
+    unless subject.check
+      return unless up?
+      subject.fire
+    end
   end
 
 end

data/lib/eye/reason.rb

@@ -13,14 +13,11 @@ class Eye::Reason
   end
 
   class User < Eye::Reason
-
     def to_s
       "#{super} by user"
     end
-
   end
 
   class Flapping < Eye::Reason; end
   class StartingGuard < Eye::Reason; end
-
-end
+end

data/lib/eye/server.rb

@@ -1,8 +1,7 @@
-require 'celluloid/autostart'
 require 'celluloid/io'
+require 'celluloid/current'
 
 class Eye::Server
-
   include Celluloid::IO
 
   attr_reader :socket_path, :server

data/lib/eye/system.rb

@@ -3,9 +3,7 @@ require 'etc'
 require 'timeout'
 
 module Eye::System
-
   class << self
-
     # Check that pid really exits
     # very fast
     # return result hash
@@ -16,21 +14,17 @@ module Eye::System
         false
       end
 
-      { result: res }
+      {:result => res}
     rescue => ex
-      { error: ex }
+      {:error => ex}
     end
 
     # Check that pid really exits
     # very fast
     # return true/false
     def pid_alive?(pid)
-      if pid
-        ::Process.kill(0, pid)
-        true
-      end
-    rescue
-      false
+      res = check_pid_alive(pid)
+      !!res[:result]
     end
 
     # Send signal to process (uses for kill)
@@ -45,13 +39,13 @@ module Eye::System
 
       if pid
         ::Process.kill(code, pid)
-        { result: :ok }
+        {:result => :ok}
       else
-        { error: Exception.new('no_pid') }
+        {:error => Exception.new('no_pid')}
       end
 
     rescue => ex
-      { error: ex }
+      {:error => ex}
     end
 
     # Daemonize cmd, and detach
@@ -61,12 +55,12 @@ module Eye::System
     #   :environment
     #   :stdin, :stdout, :stderr
     def daemonize(cmd, cfg = {})
-      pid = ::Process.spawn(prepare_env(cfg), *Shellwords.shellwords(cmd), spawn_options(cfg))
+      pid = ::Process::spawn(prepare_env(cfg), *Shellwords.shellwords(cmd), spawn_options(cfg))
 
-      { pid: pid, exitstatus: 0 }
+      {:pid => pid, :exitstatus => 0}
 
     rescue Errno::ENOENT, Errno::EACCES => ex
-      { error: ex }
+      {:error => ex}
 
     ensure
       Process.detach(pid) if pid
@@ -78,7 +72,7 @@ module Eye::System
     #   :environment
     #   :stdin, :stdout, :stderr
     def execute(cmd, cfg = {})
-      pid = ::Process.spawn(prepare_env(cfg), *Shellwords.shellwords(cmd), spawn_options(cfg))
+      pid = ::Process::spawn(prepare_env(cfg), *Shellwords.shellwords(cmd), spawn_options(cfg))
 
       timeout = cfg[:timeout] || 1.second
       status = 0
@@ -88,17 +82,17 @@ module Eye::System
         status = st.exitstatus || st.termsig
       end
 
-      { pid: pid, exitstatus: status }
+      {:pid => pid, :exitstatus => status}
 
     rescue Timeout::Error => ex
       if pid
         warn "[#{cfg[:name]}] sending :KILL signal to <#{pid}> due to timeout (#{timeout}s)"
         send_signal(pid, 9)
       end
-      { error: ex }
+      {:error => ex}
 
     rescue Errno::ENOENT, Errno::EACCES => ex
-      { error: ex }
+      {:error => ex}
 
     ensure
       Process.detach(pid) if pid
@@ -133,13 +127,12 @@ module Eye::System
     def prepare_env(config = {})
       env = {}
 
-      (config[:environment] || {}).each do |k, v|
+      (config[:environment] || {}).each do |k,v|
         env[k.to_s] = v && v.to_s
       end
 
       env
     end
-
   end
 
 end