ace-eye 0.6.1

data/lib/eye/process/trigger.rb

@@ -0,0 +1,34 @@
+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(transition)
+    self.triggers.each { |trigger| trigger.notify(transition, state_reason) }
+  end
+
+  def retry_start_after_flapping
+    return unless unmonitored?
+    return unless state_reason.to_s.include?('flapping') # TODO: remove hackety
+
+    schedule :start, Eye::Reason.new(:'retry start after flapping')
+    self.flapping_times += 1
+  end
+
+private
+
+  def add_trigger(cfg = {})
+    trigger = Eye::Trigger.create(current_actor, cfg)
+    self.triggers << trigger if trigger
+  end
+
+end

data/lib/eye/process/validate.rb

@@ -0,0 +1,33 @@
+require 'shellwords'
+require 'etc'
+
+module Eye::Process::Validate
+
+  class Error < Exception; end
+
+  def validate(config, localize = true)
+    if (str = config[:start_command])
+      # it should parse with Shellwords and not raise
+      spl = Shellwords.shellwords(str) * '#'
+
+      if config[:daemonize] && !config[:use_leaf_child]
+        if spl =~ %r[sh#\-c|#&&#|;#]
+          raise Error, "#{config[:name]}, daemonize does not support concats like '&&' in start_command"
+        end
+      end
+    end
+
+    Shellwords.shellwords(config[:stop_command]) if config[:stop_command]
+    Shellwords.shellwords(config[:restart_command]) if config[:restart_command]
+
+    if localize
+      Etc.getpwnam(config[:uid]) if config[:uid]
+      Etc.getpwnam(config[:gid]) if config[:gid]
+
+      if config[:working_dir]
+        raise Error, "working_dir '#{config[:working_dir]}' is invalid" unless File.directory?(config[:working_dir])
+      end
+    end
+  end
+
+end

data/lib/eye/process/watchers.rb

@@ -0,0 +1,66 @@
+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
+      end
+
+      # monitor children pids
+      if self[:monitor_children]
+        add_watcher(:check_children, self[:children_update_period]) do
+          add_or_update_children
+        end
+      end
+
+      # monitor conditional watchers
+      start_checkers
+    else
+      warn 'add_watchers failed, watchers are already present'
+    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 "adding 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{|name, cfg| start_checker(name, cfg) }
+  end
+
+  def start_checker(name, cfg)
+    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
+  end
+
+end

data/lib/eye/reason.rb

@@ -0,0 +1,20 @@
+class Eye::Reason
+
+  def initialize(mes = nil)
+    @message = mes
+  end
+
+  def to_s
+    @message.to_s
+  end
+
+  def user?
+    self.class == User
+  end
+
+  class User < Eye::Reason
+    def to_s
+      "#{super} by user"
+    end
+  end
+end

data/lib/eye/server.rb

@@ -0,0 +1,60 @@
+require 'celluloid/io'
+require 'celluloid/autostart'
+
+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 run
+    loop { async.handle_connection @server.accept }
+  end
+
+  def handle_connection(socket)
+    text = socket.read
+
+    begin
+      command, *args = Marshal.load(text)
+    rescue => ex
+      error "Failed to read from socket: #{ex.message}"
+      return
+    end
+
+    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
+
+  finalizer :close_socket
+
+  def close_socket
+    @server.close if @server
+    unlink_socket_file
+  end
+
+end

data/lib/eye/sigar.rb

@@ -0,0 +1,5 @@
+require 'sigar'
+require 'logger'
+
+Eye::Sigar = ::Sigar.new
+Eye::Sigar.logger = ::Logger.new(nil)

data/lib/eye/system.rb

@@ -0,0 +1,139 @@
+require 'shellwords'
+require 'pathname'
+require 'etc'
+require 'timeout'
+
+module Eye::System
+  class << self
+    # Check that pid really exits
+    # very fast
+    # return result hash
+    def check_pid_alive(pid)
+      res = if pid
+        ::Process.kill(0, pid)
+      else
+        false
+      end
+
+      {:result => res}
+    rescue => ex
+      {:error => ex}
+    end
+
+    # Check that pid really exits
+    # very fast
+    # return true/false
+    def pid_alive?(pid)
+      res = check_pid_alive(pid)
+      !!res[:result]
+    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)
+
+      if pid
+        ::Process.kill(code, pid)
+        {:result => :ok}
+      else
+        {:error => Exception.new('no_pid')}
+      end
+
+    rescue => ex
+      {:error => ex}
+    end
+
+    # Daemonize cmd, and detach
+    # options:
+    #   :pid_file
+    #   :working_dir
+    #   :environment
+    #   :stdin, :stdout, :stderr
+    def daemonize(cmd, cfg = {})
+      pid = ::Process::spawn(prepare_env(cfg), *Shellwords.shellwords(cmd), spawn_options(cfg))
+
+      {:pid => pid, :exitstatus => 0}
+
+    rescue Errno::ENOENT, Errno::EACCES => ex
+      {:error => ex}
+
+    ensure
+      Process.detach(pid) if pid
+    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 = {})
+      pid = ::Process::spawn(prepare_env(cfg), *Shellwords.shellwords(cmd), spawn_options(cfg))
+
+      timeout = cfg[:timeout] || 1.second
+      status = 0
+
+      Timeout.timeout(timeout) do
+        _, st = Process.waitpid2(pid)
+        status = st.exitstatus || st.termsig
+      end
+
+      {: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}
+
+    rescue Errno::ENOENT, Errno::EACCES => ex
+      {:error => ex}
+
+    ensure
+      Process.detach(pid) if pid
+    end
+
+    # normalize file
+    def normalized_file(file, working_dir = nil)
+      Pathname.new(file).expand_path(working_dir).to_s
+    end
+
+    def spawn_options(config = {})
+      options = {
+        pgroup: true,
+        chdir: config[:working_dir] || '/'
+      }
+
+      options[:out]   = [config[:stdout], 'a'] if config[:stdout]
+      options[:err]   = [config[:stderr], 'a'] if config[:stderr]
+      options[:in]    = config[:stdin] if config[:stdin]
+      options[:umask] = config[:umask] if config[:umask]
+      options[:close_others] = false if config[:preserve_fds]
+      options[:unsetenv_others] = true if config[:clear_env]
+
+      if Eye::Local.root?
+        options[:uid] = Etc.getpwnam(config[:uid]).uid if config[:uid]
+        options[:gid] = Etc.getpwnam(config[:gid]).gid if config[:gid]
+      end
+
+      options
+    end
+
+    def prepare_env(config = {})
+      env = {}
+
+      (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

@@ -0,0 +1,99 @@
+require 'celluloid'
+
+class Eye::SystemResources
+
+  # cached system resources
+  class << self
+
+    def memory(pid)
+      cache.proc_mem(pid).try(:resident)
+    end
+
+    def cpu(pid)
+      if cpu = cache.proc_cpu(pid)
+        cpu.percent * 100
+      end
+    end
+
+    def children(parent_pid)
+      cache.children(parent_pid)
+    end
+
+    def start_time(pid) # unixtime
+      if cpu = cache.proc_cpu(pid)
+        cpu.start_time.to_i / 1000
+      end
+    end
+
+    # total cpu usage in seconds
+    def cputime(pid)
+      if cpu = cache.proc_cpu(pid)
+        cpu.total.to_f / 1000
+      end
+    end
+
+    # last child in a children tree
+    def leaf_child(pid)
+      c = children(pid)
+      return if c.empty?
+      c += children(c.shift) while c.size > 1
+      c[0]
+    end
+
+    def resources(pid)
+      { :memory => memory(pid),
+        :cpu => cpu(pid),
+        :start_time => start_time(pid),
+        :pid => pid
+      }
+    end
+
+    def cache
+      @cache ||= Cache.new
+    end
+  end
+
+  class Cache
+    include Celluloid
+
+    attr_reader :expire
+
+    def initialize
+      clear
+      setup_expire
+    end
+
+    def setup_expire(expire = 5)
+      @expire = expire
+      @timer.cancel if @timer
+      @timer = every(@expire) { clear }
+    end
+
+    def clear
+      @memory = {}
+      @cpu = {}
+      @ppids = {}
+    end
+
+    def proc_mem(pid)
+      @memory[pid] ||= Eye::Sigar.proc_mem(pid) if pid
+
+    rescue ArgumentError # when incorrect PID
+    end
+
+    def proc_cpu(pid)
+      @cpu[pid] ||= Eye::Sigar.proc_cpu(pid) if pid
+
+    rescue ArgumentError # when incorrect PID
+    end
+
+    def children(pid)
+      if pid
+        @ppids[pid] ||= Eye::Sigar.proc_list("State.Ppid.eq=#{pid}")
+      else
+        []
+      end
+    end
+  end
+
+end