eye 0.8.pre2 → 0.8.rc

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
-    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
+    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
 
@@ -29,4 +29,4 @@ private
     LEVELS[level].to_i
   end
 
-end
+end

data/lib/eye/process/scheduler.rb

@@ -2,32 +2,30 @@ module Eye::Process::Scheduler
 
   # ex: schedule :update_config, config, "reason: update_config"
   def schedule(command, *args, &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
+    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)
     end
   end
 
@@ -39,16 +37,16 @@ module Eye::Process::Scheduler
     end
   end
 
-  def scheduled_action(command, h = {}, &block)
-    reason = h.delete(:reason)
-    info "=> #{command} #{h[:args].present? ? "#{h[:args]*',' }" : nil} #{reason ? "(reason: #{reason})" : nil}"
+  def scheduled_action(command, h = {})
+    reason = h[: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], &block)
+    send(command, *h[:args], &h[:block])
     @current_scheduled_command = nil
     info "<= #{command}"
 
@@ -59,8 +57,14 @@ 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
@@ -69,6 +73,7 @@ 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,6 +2,7 @@ require 'state_machine'
 require 'state_machine/version'
 
 class Eye::Process
+
   class StateError < Exception; end
 
   # do transition
@@ -59,10 +60,10 @@ 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
@@ -80,7 +81,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}] #{@state_reason ? "(reason: #{@state_reason})" : nil}"
+      info "switch :#{transition.event} [:#{transition.from_name} => :#{transition.to_name}] #{"(reason: #{@state_reason})" if @state_reason}"
     end
   end
 

data/lib/eye/process/states_history.rb

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

data/lib/eye/process/system.rb

@@ -46,7 +46,8 @@ module Eye::Process::System
     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)})"
+      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
@@ -75,7 +76,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
 
@@ -90,7 +91,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
@@ -99,7 +100,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

data/lib/eye/process/trigger.rb

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

data/lib/eye/process/watchers.rb

@@ -32,7 +32,7 @@ module Eye::Process::Watchers
   end
 
   def remove_watchers
-    @watchers.each{|_, h| h[:timer].cancel }
+    @watchers.each { |_, h| h[:timer].cancel }
     @watchers = {}
   end
 
@@ -48,25 +48,22 @@ 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)
-    unless subject.check
-      return unless up?
-      subject.fire
-    end
+    # double up? test needed because state can changed while subject.check
+    subject.fire if up? && !subject.check && up?
   end
 
 end

data/lib/eye/reason.rb

@@ -13,11 +13,14 @@ 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,7 +1,8 @@
-require 'celluloid/io'
 require 'celluloid/current'
+require 'celluloid/io'
 
 class Eye::Server
+
   include Celluloid::IO
 
   attr_reader :socket_path, :server

data/lib/eye/system.rb

@@ -3,7 +3,9 @@ require 'etc'
 require 'timeout'
 
 module Eye::System
+
   class << self
+
     # Check that pid really exits
     # very fast
     # return result hash
@@ -14,9 +16,9 @@ module Eye::System
         false
       end
 
-      {:result => res}
+      { result: res }
     rescue => ex
-      {:error => ex}
+      { error: ex }
     end
 
     # Check that pid really exits
@@ -39,13 +41,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
@@ -55,12 +57,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
@@ -72,7 +74,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
@@ -82,17 +84,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
@@ -127,12 +129,13 @@ 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

data/lib/eye/system_resources.rb

@@ -45,7 +45,7 @@ class Eye::SystemResources
     end
 
     def deep_children(pid)
-      Array(pid_or_children(pid)).flatten.sort_by { |pid| -pid }
+      Array(pid_or_children(pid)).flatten.sort_by(&:-@)
     end
 
     def pid_or_children(pid)
@@ -62,19 +62,20 @@ class Eye::SystemResources
     end
 
     def resources(pid)
-      { :memory => memory(pid),
-        :cpu => cpu(pid),
-        :start_time => start_time(pid),
-        :pid => pid
-      }
+      { memory: memory(pid),
+        cpu: cpu(pid),
+        start_time: start_time(pid),
+        pid: pid }
     end
 
     def cache
       Celluloid::Actor[:system_resources_cache]
     end
+
   end
 
   class Cache
+
     include Celluloid
 
     attr_reader :expire
@@ -99,13 +100,15 @@ class Eye::SystemResources
     def proc_mem(pid)
       @memory[pid] ||= Eye::Sigar.proc_mem(pid) if pid
 
-    rescue ArgumentError # when incorrect PID
+    rescue ArgumentError
+      # when incorrect PID, just skip
     end
 
     def proc_cpu(pid)
       @cpu[pid] ||= Eye::Sigar.proc_cpu(pid) if pid
 
-    rescue ArgumentError # when incorrect PID
+    rescue ArgumentError
+      # when incorrect PID, just skip
     end
 
     def children(pid)
@@ -115,8 +118,10 @@ class Eye::SystemResources
         []
       end
     end
+
   end
 
   # Setup global sigar singleton here
   Cache.supervise(as: :system_resources_cache)
+
 end