ace-eye 0.6.1

data/lib/eye/logger.rb

@@ -0,0 +1,104 @@
+require 'logger'
+
+class Eye::Logger
+  attr_accessor :prefix, :subprefix
+
+  class InnerLogger < Logger
+    FORMAT = '%d.%m.%Y %H:%M:%S'
+
+    def initialize(*args)
+      super
+
+      self.formatter = Proc.new do |s, d, p, m|
+        "#{d.strftime(FORMAT)} #{s.ljust(5)} -- #{m}\n"
+      end
+    end
+  end
+
+  module ObjectExt
+    def logger_tag
+      [Class, Module].include?(self.class) ? to_s : "<#{self.class.to_s}>"
+    end
+
+    def logger_sub_tag
+    end
+
+    def logger
+      @logger ||= Eye::Logger.new(logger_tag, logger_sub_tag)
+    end
+
+    Logger::Severity.constants.each do |level|
+      method_name = level.to_s.downcase
+      define_method method_name do |msg|
+        logger.send(method_name, msg)
+      end
+    end
+
+    def log_ex(ex)
+      error "#{ex.message} #{ex.backtrace}"
+      # notify here?
+    end
+  end
+
+  Logger::Severity.constants.each do |level|
+    method_name = level.to_s.downcase
+    define_method method_name do |msg|
+      self.class.inner_logger.send(method_name, "#{prefix_str}#{msg}")
+    end
+  end
+
+  def initialize(prefix = nil, subprefix = nil)
+    @prefix = prefix
+    @subprefix = subprefix
+  end
+
+  class << self
+    attr_reader :dev, :log_level, :args
+
+    def link_logger(dev, *args)
+      old_dev = @dev
+      @dev = dev ? dev.to_s : nil
+      @dev_fd = @dev
+      @args = args
+
+      @dev_fd = STDOUT if @dev.to_s.downcase == 'stdout'
+      @dev_fd = STDERR if @dev.to_s.downcase == 'stderr'
+
+      @inner_logger = InnerLogger.new(@dev_fd, *args)
+      @inner_logger.level = self.log_level || Logger::INFO
+
+    rescue Errno::ENOENT, Errno::EACCES
+      @dev = old_dev
+      raise
+    end
+
+    def reopen
+      link_logger(dev, *args)
+    end
+
+    def log_level=(level)
+      @log_level = level
+      @inner_logger.level = self.log_level if @inner_logger
+    end
+
+    def inner_logger
+      @inner_logger ||= InnerLogger.new(nil)
+    end
+  end
+
+private
+
+  def prefix_str
+    @pref_string ||= begin
+      pref_string = ''
+
+      if @prefix
+        pref_string = "[#{@prefix}] "
+        pref_string += "#{@subprefix} " if @subprefix
+      end
+
+      pref_string
+    end
+  end
+
+end

data/lib/eye/notify.rb

@@ -0,0 +1,118 @@
+require 'celluloid'
+
+class Eye::Notify
+  include Celluloid
+  include Eye::Dsl::Validation
+
+  autoload :Mail,     'eye/notify/mail'
+  autoload :Jabber,   'eye/notify/jabber'
+
+  TYPES = {:mail => 'Mail', :jabber => 'Jabber'}
+
+  def self.get_class(type)
+    klass = eval("Eye::Notify::#{TYPES[type]}") rescue nil
+    raise "unknown notifier :#{type}" unless klass
+    if deps = klass.requires
+      Array(deps).each { |d| require d }
+    end
+    klass
+  end
+
+  def self.validate!(options)
+    get_class(options[:type]).validate(options)
+  end
+
+  def self.notify(contact, message_h)
+    contact = contact.to_s
+    settings = Eye::Control.settings
+    needed_hash = (settings[:contacts] || {})[contact]
+
+    if needed_hash.blank?
+      error "contact #{contact} not found; check your configuration"
+      return
+    end
+
+    create_proc = lambda do |nh|
+      type = nh[:type]
+      config = (settings[type] || {}).merge(nh[:opts] || {}).merge(:contact => nh[:contact])
+      klass = get_class(type)
+      notify = klass.new(config, message_h)
+      notify.async_notify if notify
+    end
+
+    if needed_hash.is_a?(Array)
+      needed_hash.each{|nh| create_proc[nh] }
+    else
+      create_proc[needed_hash]
+    end
+
+  rescue Exception, Timeout::Error => ex
+    log_ex(ex)
+  end
+
+  TIMEOUT = 1 * 60
+
+  def initialize(options = {}, message_h = {})
+    @message_h = message_h
+    @options = options
+
+    debug "created notifier #{options}"
+  end
+
+  def logger_sub_tag
+    @options[:contact]
+  end
+
+  def async_notify
+    async.notify
+    after(TIMEOUT){ terminate }
+  end
+
+  def notify
+    debug "start notify #{@message_h}"
+    execute
+    debug "end notify #{@message_h}"
+    terminate
+  end
+
+  def execute
+    raise NotImplementedError
+  end
+
+  param :contact, [String]
+
+  def message_subject
+    "[#{msg_host}] [#{msg_full_name}] #{msg_message}"
+  end
+
+  def message_body
+    "#{message_subject} at #{Eye::Utils.human_time2(msg_at)}"
+  end
+
+  def self.register(base)
+    name = base.to_s.gsub('Eye::Notify::', '')
+    type = name.underscore.to_sym
+    Eye::Notify::TYPES[type] = name
+    Eye::Notify.const_set(name, base)
+    Eye::Dsl::ConfigOpts.add_notify(type)
+  end
+
+  def self.requires
+  end
+
+  class Custom < Eye::Notify
+    def self.inherited(base)
+      super
+      register(base)
+    end
+  end
+
+private
+
+  %w{at host message name full_name pid level}.each do |name|
+    define_method("msg_#{name}") do
+      @message_h[name.to_sym]
+    end
+  end
+
+end

data/lib/eye/notify/jabber.rb

@@ -0,0 +1,30 @@
+require 'xmpp4r'
+
+class Eye::Notify::Jabber < Eye::Notify
+
+  # Eye.config do
+  #   jabber :host => "some.host", :port => 12345, :user => "eye@some.host", :password => "123456"
+  #   contact :vasya, :jabber, "vasya@some.host"
+  # end
+
+  param :host, String, true
+  param :port, [String, Fixnum], true
+  param :user, String, true
+  param :password, String
+
+  def execute
+    debug "send jabber #{[host, port, user, password]} - #{[contact, message_body]}"
+
+    mes = ::Jabber::Message.new(contact, message_body)
+    mes.set_type(:normal)
+    mes.set_id('1')
+    mes.set_subject(message_subject)
+
+    client = ::Jabber::Client.new(::Jabber::JID.new("#{user}/Eye"))
+    client.connect(host, port)
+    client.auth(password)
+    client.send(mes)
+    client.close
+  end
+
+end

data/lib/eye/notify/mail.rb

@@ -0,0 +1,48 @@
+require 'net/smtp'
+
+class Eye::Notify::Mail < Eye::Notify
+
+  # Eye.config do
+  #   mail :host => "some.host", :port => 12345, :user => "eye@some.host", :password => "123456", :domain => "some.host"
+  #   contact :vasya, :mail, "vasya@some.host"
+  # end
+
+  param :host, String, true
+  param :port, [String, Fixnum], true
+
+  param :domain, String
+  param :user, String
+  param :password, String
+  param :auth, Symbol, nil, nil, [:plain, :login, :cram_md5]
+
+  param :starttls, [TrueClass, FalseClass]
+
+  param :from_mail, String
+  param :from_name, String, nil, 'eye'
+
+  def execute
+    smtp
+  end
+
+  def smtp
+    args = [host, port, domain, user, password, auth]
+    debug "called smtp with #{args}"
+    smtp = Net::SMTP.new host, port
+    smtp.enable_starttls if starttls
+
+    smtp.start(domain, user, password, auth) do |s|
+      s.send_message(message, from_mail || user, contact)
+    end
+  end
+
+  def message
+    h = []
+    h << "From: #{from_name} <#{from_mail || user}>" if from_mail || user
+    h << "To: <#{contact}>"
+    h << "Subject: #{message_subject}"
+    h << "Date: #{msg_at.httpdate}"
+    h << "Message-Id: <#{rand(1000000000).to_s(36)}.#{$$}.#{contact}>"
+    "#{h * "\n"}\n#{message_body}"
+  end
+
+end

data/lib/eye/process.rb

@@ -0,0 +1,85 @@
+require 'celluloid'
+
+class Eye::Process
+  include Celluloid
+
+  autoload :Config,           'eye/process/config'
+  autoload :Commands,         'eye/process/commands'
+  autoload :Data,             'eye/process/data'
+  autoload :Watchers,         'eye/process/watchers'
+  autoload :Monitor,          'eye/process/monitor'
+  autoload :System,           'eye/process/system'
+  autoload :Controller,       'eye/process/controller'
+  autoload :StatesHistory,    'eye/process/states_history'
+  autoload :Children,         'eye/process/children'
+  autoload :Trigger,          'eye/process/trigger'
+  autoload :Notify,           'eye/process/notify'
+  autoload :Scheduler,        'eye/process/scheduler'
+  autoload :Validate,         'eye/process/validate'
+
+  attr_accessor :pid, :watchers, :config, :states_history,
+                :children, :triggers, :name, :state_reason, :flapping_times,
+                :parent_pid
+
+  def initialize(config)
+    raise 'you must supply a pid_file location' unless config[:pid_file]
+
+    @config = prepare_config(config)
+
+    @watchers = {}
+    @children = {}
+    @triggers = []
+    @name = @config[:name]
+
+    @flapping_times = 0
+
+    @states_history = Eye::Process::StatesHistory.new(100)
+    @states_history << :unmonitored
+
+    debug "creating with config: #{@config.inspect}"
+
+    add_triggers
+
+    super() # for statemachine
+  end
+
+  # c(), self[]
+  include Eye::Process::Config
+
+  # full_name, status_data
+  include Eye::Process::Data
+
+  # commands:
+  # start_process, stop_process, restart_process
+  include Eye::Process::Commands
+
+  # start, stop, restart, monitor, unmonit, delete
+  include Eye::Process::Controller
+
+  # add_watchers, remove_watchers:
+  include Eye::Process::Watchers
+
+  # check alive, crash methods:
+  include Eye::Process::Monitor
+
+  # system methods:
+  include Eye::Process::System
+
+  # manage child methods
+  include Eye::Process::Children
+
+  # manage triggers methods
+  include Eye::Process::Trigger
+
+  # manage notify methods
+  include Eye::Process::Notify
+
+  # scheduler
+  include Eye::Process::Scheduler
+
+  # validate
+  extend Eye::Process::Validate
+end
+
+# include state_machine states
+require_relative 'process/states'

data/lib/eye/process/children.rb

@@ -0,0 +1,60 @@
+module Eye::Process::Children
+
+  def add_children
+    add_or_update_children
+  end
+
+  def add_or_update_children
+    return unless self[:monitor_children]
+    return unless self.up?
+    return if @updating_children
+    @updating_children = true
+
+    unless self.pid
+      warn "can't add children; pid not set"
+      return
+    end
+
+    now_children = Eye::SystemResources.children(self.pid)
+    new_children = []
+    exist_children = []
+
+    now_children.each do |child_pid|
+      if self.children[child_pid]
+        exist_children << child_pid
+      else
+        new_children << child_pid
+      end
+    end
+
+    removed_children = self.children.keys - now_children
+
+    if new_children.present?
+      new_children.each do |child_pid|
+        self.children[child_pid] = Eye::ChildProcess.new(child_pid, self[:monitor_children], logger.prefix, self.pid)
+      end
+    end
+
+    if removed_children.present?
+      removed_children.each{|child_pid| remove_child(child_pid) }
+    end
+
+    h = {:new => new_children.size, :removed => removed_children.size, :exists => exist_children.size }
+    debug "children info: #{ h.inspect }"
+
+    @updating_children = false
+    h
+  end
+
+  def remove_children
+    if children.present?
+      children.keys.each{|child_pid| remove_child(child_pid) }
+    end
+  end
+
+  def remove_child(child_pid)
+    child = self.children.delete(child_pid)
+    child.destroy if child && child.alive?
+  end
+
+end