eye 0.1.11

data/lib/eye/process/states_history.rb

@@ -0,0 +1,62 @@
+class Eye::Process::StatesHistory < Eye::Utils::Tail
+
+  def push(state, reason = nil, tm = Time.now)
+    super(state: state, at: tm, reason: reason)
+  end
+
+  def states
+    self.map{|c| c[:state] }
+  end
+
+  def states_for_period(period)
+    tm = Time.now - period
+    self.select do |s|
+      s[:at] >= tm
+    end.map{|c| c[:state] }
+  end
+
+  def last_state
+    last[:state]
+  end
+
+  def last_state_changed_at
+    last[:at]
+  end
+
+  def seq?(*seq)
+    str = states * ','
+    substr = seq.flatten * ','
+    str.include?(substr)
+  end
+
+  def end?(*seq)
+    str = states * ','
+    substr = seq.flatten * ','
+    str.end_with?(substr)
+  end
+
+  def any?(*seq)
+    states.any? do |st|      
+      seq.flatten.include?(st)
+    end
+  end
+
+  def noone?(*seq)
+    !states.all? do |st|      
+      seq.flatten.include?(st)
+    end
+  end
+
+  def all?(*seq)
+    states.all? do |st|      
+      seq.flatten.include?(st)
+    end
+  end
+
+  def state_count(state)
+    states.count do |st|
+      st == state
+    end
+  end
+
+end

data/lib/eye/process/system.rb

@@ -0,0 +1,60 @@
+require 'timeout'
+
+module Eye::Process::System
+
+  def load_pid_from_file    
+    if File.exists?(self[:pid_file_ex])
+      _pid = File.read(self[:pid_file_ex]).to_i 
+      _pid > 0 ? _pid : nil
+    end
+  end
+
+  def set_pid_from_file
+    self.pid = load_pid_from_file
+  end
+
+  def save_pid_to_file
+    if self.pid
+      File.open(self[:pid_file_ex], 'w') do |f|
+        f.write self.pid
+      end
+    end
+
+    true
+  end
+
+  def clear_pid_file
+    File.unlink(self[:pid_file_ex])
+    true
+  rescue 
+    nil
+  end
+
+  def pid_file_ctime
+    File.ctime(self[:pid_file_ex]) rescue Time.now
+  end
+
+  def process_realy_running?
+    Eye::System.pid_alive?(self.pid) if self.pid
+  end
+
+  def send_signal(code)
+    debug "send signal #{code}"
+
+    res = Eye::System.send_signal(self.pid, code)
+    error(res[:message]) if res[:status] != :ok
+
+    res[:status] == :ok
+  end
+
+  def with_timeout(time, &block)
+    Timeout.timeout(time.to_f, &block)
+  rescue Timeout::Error
+    :timeout
+  end
+
+  def execute(cmd, cfg = {})
+    defer{ Eye::System::execute cmd, cfg }
+  end
+  
+end

data/lib/eye/process/trigger.rb

@@ -0,0 +1,32 @@
+module Eye::Process::Trigger
+
+  def add_triggers
+    if self[:triggers]
+      self[:triggers].each do |type, cfg|
+        add_trigger(cfg)
+      end      
+    end
+  end
+
+  def remove_triggers
+    self.triggers = []
+  end
+
+  def check_triggers
+    return if unmonitored?
+
+    self.triggers.each do |trigger|
+      if !trigger.check(self.states_history)
+        notify :crit, 'flapping!'
+        @flapping = true        
+      end
+    end
+  end
+
+private
+
+  def add_trigger(cfg = {})
+    self.triggers << Eye::Trigger.create(cfg, logger.prefix)
+  end
+
+end

data/lib/eye/process/watchers.rb

@@ -0,0 +1,67 @@
+module Eye::Process::Watchers
+
+  def add_watchers(force = false)
+    return unless self.up?
+
+    remove_watchers if force
+
+    if @watchers.blank?
+      # default watcher :check_alive
+      add_watcher(:check_alive, self[:check_alive_period]) do 
+        check_alive
+        GC.start if rand(1000) == 0
+      end
+
+      # monitor childs pids
+      if self[:monitor_children]
+        add_watcher(:check_childs, self[:childs_update_period]) do 
+          add_or_update_childs
+        end
+      end
+
+      # monitor conditional watchers
+      start_checkers
+    else
+      warn 'try add_watchers, but its already here'
+    end
+  end
+  
+  def remove_watchers
+    @watchers.each{|_, h| h[:timer].cancel }
+    @watchers = {}
+  end
+
+private  
+
+  def add_watcher(type, period = 2, subject = nil, &block)
+    return if @watchers[type]
+
+    debug "add watcher #{type}(#{period})"
+
+    timer = every(period.to_f) do
+      debug "check #{type}"
+      block.call(subject)
+    end    
+
+    @watchers[type] ||= {:timer => timer, :subject => subject}
+  end  
+  
+  def start_checkers
+    self[:checks].each{|type, cfg| start_checker(cfg) }
+  end
+
+  def start_checker(cfg)
+    subject = Eye::Checker.create(pid, cfg, logger.prefix)
+
+    # ex: {:type => :memory, :every => 5.seconds, :below => 100.megabytes, :times => [3,5]}
+    add_watcher("check_#{cfg[:type]}".to_sym, subject.every, subject, &method(:watcher_tick).to_proc)
+  end
+
+  def watcher_tick(subject)
+    unless subject.check
+      notify :crit, "Bounded #{subject.check_name}: #{subject.last_human_values}"
+      schedule :restart, "bounded #{subject.check_name}"
+    end
+  end
+
+end

data/lib/eye/server.rb

@@ -0,0 +1,51 @@
+require 'celluloid/io'
+require_relative 'io/unix_socket'
+require_relative 'io/unix_server'
+
+class Eye::Server
+  include Celluloid::IO
+  
+  attr_reader :socket_path, :server
+  
+  def initialize(socket_path)
+    @socket_path = socket_path
+    @server = begin
+      UNIXServer.open(socket_path)
+    rescue Errno::EADDRINUSE
+      unlink_socket_file
+      UNIXServer.open(socket_path)
+    end
+  end
+  
+  def finalize
+    @server.close if @server
+    unlink_socket_file
+  end
+
+  def run
+    loop { handle_connection! @server.accept }
+  end
+
+  def handle_connection(socket)
+    command, *args = socket.readline.strip.split('|')
+    response = command(command, *args)
+    socket.write(Marshal.dump(response))
+    
+  rescue Errno::EPIPE
+    # client timeouted
+    # do nothing
+    
+  ensure
+    socket.close
+  end
+
+  def command(cmd, *args)
+    Eye::Control.command(cmd, *args)
+  end
+
+  def unlink_socket_file
+    File.delete(@socket_path) if @socket_path
+  rescue
+  end
+
+end

data/lib/eye/settings.rb

@@ -0,0 +1,35 @@
+require 'fileutils'
+
+module Eye::Settings
+
+  module_function
+  
+  def dir
+    if Process::UID.eid == 0 # root
+      '/var/run/eye'
+    else
+      File.expand_path(File.join(ENV['HOME'], '.eye'))
+    end    
+  end
+  
+  def path(path)
+    File.join(dir, path)
+  end
+
+  def ensure_eye_dir
+    FileUtils.mkdir_p( dir )
+  end
+
+  def socket_path
+    path('sock')
+  end
+  
+  def pid_path
+    path('pid')
+  end
+  
+  def client_timeout
+    5
+  end
+
+end

data/lib/eye/system.rb

@@ -0,0 +1,145 @@
+require 'shellwords'
+require 'pathname'
+
+module Eye::System
+  class << self
+
+    # Check that pid realy exits
+    # very fast
+    def pid_alive?(pid)
+      pid ? ::Process.kill(0, pid) && true : false
+    rescue Errno::ESRCH, Errno::EPERM
+      false
+    end
+
+    # Send signal to process (uses for kill)
+    # code: TERM(15), KILL(9), QUIT(3), ...
+    def send_signal(pid, code = :TERM)      
+      code = 0 if code == '0'
+      if code.to_s.to_i != 0
+        code = code.to_i
+        code = -code if code < 0
+      end
+      code = code.to_s.upcase if code.is_a?(String) || code.is_a?(Symbol)
+
+      ::Process.kill(code, pid) if pid
+      {:status => :ok}
+
+    rescue Errno::ESRCH    
+      {:status => :error, :message => 'process not found'}
+
+    rescue Errno::EPERM
+      {:status => :error, :message => 'wrong permissions to kill'}
+
+    rescue => e
+      {:status => :error, :message => "failed signal #{code}: #{e.message}"}
+    end
+
+    # Daemonize cmd, and detach
+    # options:
+    #   :pid_file
+    #   :working_dir
+    #   :environment
+    #   :stdin, :stdout, :stderr
+    def daemonize(cmd, cfg = {})
+      opts = spawn_options(cfg)
+      pid  = Process::spawn(prepare_env(cfg), *Shellwords.shellwords(cmd), opts)
+      Process.detach(pid)
+      {:pid => pid}
+      
+    rescue Errno::ENOENT, Errno::EACCES => ex
+      {:error => ex}
+    end
+
+    # Execute cmd with blocking, return status (be careful: inside actor blocks it mailbox, use with defer)
+    # options
+    #   :working_dir
+    #   :environment
+    #   :stdin, :stdout, :stderr
+    def execute(cmd, cfg = {})
+      opts = spawn_options(cfg)
+      pid  = Process::spawn(prepare_env(cfg), *Shellwords.shellwords(cmd), opts)
+
+      Timeout.timeout(cfg[:timeout] || 1.second) do
+        Process.waitpid(pid)
+      end
+
+      {:pid => pid}
+
+    rescue Timeout::Error => ex      
+      send_signal(pid, 9)
+      {:error => ex}
+
+    rescue Errno::ENOENT, Errno::EACCES => ex
+      {:error => ex}
+    end
+
+    # get table
+    # {pid => {:rss =>, :cpu =>, :ppid => , :cmd => , :start_time}}
+    # slow
+    def ps_aux
+      cmd = if RUBY_PLATFORM.include?('darwin')
+        'ps axo pid,ppid,pcpu,rss,start,command'
+      else
+        'ps axo pid,ppid,pcpu,rss,start_time,command'
+      end
+
+      str = Process.send('`', cmd).force_encoding('binary')
+      lines = str.split("\n")
+      lines.shift # remove first line
+      lines.inject(Hash.new) do |mem, line|
+        chunk = line.strip.split(/\s+/).map(&:strip)
+        mem[chunk[0].to_i] = {
+          :rss => chunk[3].to_i, 
+          :cpu => chunk[2].to_i, 
+          :ppid => chunk[1].to_i, 
+          :start_time => chunk[4],
+          :cmd => chunk[5..-1].join(' ')
+        }
+        mem
+      end
+    end
+
+    # normalize file
+    def normalized_file(file, working_dir = nil)
+      Pathname.new(file).expand_path(working_dir).to_s
+    end
+
+    def host
+      @host ||= `hostname`.chomp
+    end
+
+    # set host for tests
+    def host=(hostname)
+      @host = hostname
+    end
+
+  private
+
+    def spawn_options(config = {})
+      o = {}
+      o = {chdir: config[:working_dir]} if config[:working_dir]
+      o.update(out: [config[:stdout], 'a']) if config[:stdout]
+      o.update(err: [config[:stderr], 'a']) if config[:stderr]
+      o.update(in: config[:stdin]) if config[:stdin]
+      o
+    end
+
+    def prepare_env(config = {})
+      env = {}
+
+      (config[:environment] || {}).each do |k,v|
+        env[k.to_s] = v.to_s if v
+      end
+
+      # return original LANG env, because ruby loose it (needs for unicorn)
+      env['LANG'] = ENV_LANG unless env['LANG']
+
+      # set PWD for unicorn respawn
+      env['PWD'] = config[:working_dir] if config[:working_dir]
+
+      env
+    end
+  end
+
+end