reel-eye 0.3.1

data/lib/eye/loader.rb

@@ -0,0 +1,23 @@
+# mini bundler, for embedded server gem installation
+
+gem 'celluloid',     '~> 0.13.0'
+gem 'celluloid-io',  '~> 0.13.0'
+gem 'nio4r'
+gem 'timers'
+
+gem 'state_machine', '< 1.2'
+
+# activesupport
+gem 'activesupport', '~> 3.2.0'
+gem 'i18n'
+gem 'multi_json'
+
+# reel
+gem 'reel', '~> 0.4.0.pre'
+gem 'rack'
+gem 'http'
+gem 'http_parser.rb'
+gem 'certified'
+gem 'websocket_parser'
+
+gem 'cuba'

data/lib/eye/logger.rb

@@ -0,0 +1,80 @@
+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 Helpers
+    attr_reader :logger
+
+    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
+  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
+
+    def link_logger(dev)
+      @dev = dev ? dev.to_s.downcase : nil
+      @dev_fd = @dev
+
+      @dev_fd = STDOUT if @dev == 'stdout'
+      @dev_fd = STDERR if @dev == 'stderr'
+      
+      @inner_logger = InnerLogger.new(@dev_fd)
+      @inner_logger.level = self.log_level || Logger::INFO
+    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,86 @@
+class Eye::Notify
+  include Celluloid
+  include Eye::Logger::Helpers
+  extend 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 notify #{type}" unless klass
+    klass
+  end
+
+  def self.validate!(options)
+    get_class(options[:type]).validate(options)
+  end
+
+  def self.notify(contact, message_h)
+    settings = Eye::Control.settings
+    needed_hash = (settings[:contacts] || {})[contact.to_s]
+
+    return if needed_hash.blank?
+
+    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
+  end
+
+  TIMEOUT = 1.minute
+
+  def initialize(options = {}, message_h = {})
+    @logger = Eye::Logger.new("#{self.class.name.downcase} - #{options[:contact]}")
+    debug "created notifier #{options}"
+
+    @message_h = message_h
+    @options = options
+  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 "realize me"
+  end
+
+  param :contact, [String]
+
+  def message_subject
+    "[#{msg_host}] [#{msg_full_name}] #{msg_message}"
+  end
+  
+  def message_body
+    "#{message_subject} at #{msg_at.to_s(:short)}"
+  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 @@
+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
+    require 'xmpp4r'
+
+    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,44 @@
+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 :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}"
+
+    Net::SMTP.start(*args) do |smtp|
+      smtp.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,86 @@
+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 :Child,            'eye/process/child'
+  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, 
+                :childs, :triggers, :name, :state_reason
+  
+  def initialize(config)
+    raise 'pid file should be' unless config[:pid_file]
+
+    @config = prepare_config(config)
+    @logger = Eye::Logger.new(full_name)
+
+    @watchers = {}
+    @childs = {}
+    @triggers = []
+    @name = @config[:name]
+
+    @states_history = Eye::Process::StatesHistory.new(100)
+    @states_history << :unmonitored
+
+    debug "create 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 childs methods
+  include Eye::Process::Child
+
+  # manage triggers methods
+  include Eye::Process::Trigger
+
+  # manage notify methods
+  include Eye::Process::Notify
+
+  # logger methods
+  include Eye::Logger::Helpers
+
+  # scheduler
+  include Eye::Process::Scheduler
+
+  # validate
+  extend Eye::Process::Validate
+end
+
+# include state_machine states
+require_relative 'process/states'

data/lib/eye/process/child.rb

@@ -0,0 +1,58 @@
+module Eye::Process::Child
+
+  def add_childs
+    add_or_update_childs
+  end
+
+  def add_or_update_childs
+    return unless self[:monitor_children]
+
+    return unless self.up?
+
+    unless self.pid
+      warn 'Cant add childs, because no pid'
+      return
+    end
+
+    now_childs = Eye::SystemResources.childs(self.pid)
+    new_childs = []
+    exist_childs = []
+
+    now_childs.each do |child_pid|
+      if self.childs[child_pid]
+        exist_childs << child_pid
+      else
+        new_childs << child_pid
+      end
+    end
+
+    removed_childs = self.childs.keys - now_childs
+
+    if new_childs.present?
+      new_childs.each do |child_pid|
+        self.childs[child_pid] = Eye::ChildProcess.new(child_pid, self[:monitor_children], logger.prefix)
+      end      
+    end
+
+    if removed_childs.present?
+      removed_childs.each{|child_pid| remove_child(child_pid) }
+    end
+
+    h = {:new => new_childs.size, :removed => removed_childs.size, :exists => exist_childs.size }
+    debug "childs info: #{ h.inspect }"
+
+    h
+  end
+
+  def remove_childs
+    if childs.present?
+      childs.keys.each{|child_pid| remove_child(child_pid) }
+    end
+  end
+
+  def remove_child(child_pid)
+    child = self.childs.delete(child_pid)
+    child.destroy if child && child.alive?
+  end
+
+end

data/lib/eye/process/commands.rb

@@ -0,0 +1,256 @@
+module Eye::Process::Commands
+
+  def start_process
+    debug 'start_process command'
+
+    switch :starting
+
+    unless self[:start_command]
+      warn 'no start command, so unmonitoring'
+      switch :unmonitoring
+      return :no_start_command
+    end
+
+    result = self[:daemonize] ? daemonize_process : execute_process
+
+    if !result[:error]
+      debug "process (#{self.pid}) ok started"
+      switch :started
+    else
+      error "process (#{self.pid}) failed to start (#{result[:error].inspect})"
+      if process_realy_running?
+        warn "kill, what remains from process (#{self.pid}), because its failed to start (without pid_file impossible to monitoring)"
+        send_signal(:KILL)
+        sleep 0.2 # little grace
+      end
+
+      self.pid = nil
+      switch :crashed
+    end
+
+    result
+
+  rescue StateMachine::InvalidTransition => e
+    warn "wrong switch '#{e.message}'"
+
+    :state_error
+  end
+  
+  def stop_process
+    debug 'stop_process command'
+
+    switch :stopping
+
+    kill_process
+
+    if process_realy_running?
+      warn 'NOT STOPPED, check command/signals, or tune stop_timeout/stop_grace, seems it was really soft'
+
+      switch :unmonitoring
+      nil
+
+    else
+      switch :stopped
+
+      if control_pid?
+        info "delete pid_file: #{self[:pid_file_ex]}"
+        clear_pid_file 
+      end
+      
+      true
+
+    end
+
+  rescue StateMachine::InvalidTransition => e
+    warn "wrong switch '#{e.message}'"
+    nil
+  end
+
+  def restart_process
+    debug 'restart_process command'
+
+    switch :restarting
+
+    if self[:restart_command]
+      execute_restart_command
+      sleep self[:restart_timeout].to_f
+      result = check_alive_with_refresh_pid_if_needed
+      switch(result ? :restarted : :crashed)
+    else
+      stop_process
+      start_process
+    end
+
+    true
+
+  rescue StateMachine::InvalidTransition => e
+    warn "wrong switch '#{e.message}'"
+    nil
+  end
+
+private
+
+  def kill_process
+    return unless self.pid
+
+    if self[:stop_command]
+      cmd = prepare_command(self[:stop_command])
+      res = execute(cmd, config.merge(:timeout => self[:stop_timeout]))
+      info "executing: `#{cmd}` with stop_timeout: #{self[:stop_timeout].to_f}s and stop_grace: #{self[:stop_grace].to_f}s"
+
+      if res[:error]
+        error "raised with #{res[:error].inspect}"
+
+        if res[:error].class == Timeout::Error
+          error 'you should tune stop_timeout setting'
+        end
+      end
+
+      sleep self[:stop_grace].to_f
+
+    elsif self[:stop_signals]
+      info "executing stop_signals #{self[:stop_signals].inspect}"
+      stop_signals = self[:stop_signals].clone
+
+      signal = stop_signals.shift
+      send_signal(signal)
+
+      while stop_signals.present?
+        delay = stop_signals.shift
+        signal = stop_signals.shift
+
+        if wait_for_condition(delay.to_f, 0.1){ !process_realy_running? }
+          info 'has terminated'
+          break
+        end
+
+        send_signal(signal)
+      end
+
+      sleep self[:stop_grace].to_f
+
+    else # default command
+      info "executing: `kill -TERM #{self.pid}` with stop_grace: #{self[:stop_grace].to_f}s"
+      send_signal(:TERM)
+      
+      sleep self[:stop_grace].to_f
+
+      # if process not die here, by default we force kill it
+      if process_realy_running?
+        warn "process not die after TERM and stop_grace #{self[:stop_grace].to_f}s, so send KILL"
+        send_signal(:KILL)
+        sleep 0.1 # little grace
+      end
+    end
+  end
+
+  def execute_restart_command
+    cmd = prepare_command(self[:restart_command])
+    info "executing: `#{cmd}` with restart_timeout: #{self[:restart_timeout].to_f}s and restart_grace: #{self[:restart_grace].to_f}s"
+
+    res = execute(cmd, config.merge(:timeout => self[:restart_timeout]))
+
+    if res[:error]
+      error "restart raised with #{res[:error].inspect}"
+
+      if res[:error].class == Timeout::Error
+        error 'you should tune restart_timeout setting'
+      end
+    end
+
+    res
+  end
+  
+  def daemonize_process
+    time_before = Time.now
+    res = Eye::System.daemonize(self[:start_command], config)
+    start_time = Time.now - time_before
+
+    info "daemonizing: `#{self[:start_command]}` with start_grace: #{self[:start_grace].to_f}s, env: #{self[:environment].inspect}, working_dir: #{self[:working_dir]} (pid:#{res[:pid]})"
+
+    if res[:error]
+      error "raised with #{res[:error].inspect}"
+
+      if res[:error].message == 'Permission denied - open'
+        error 'seems stdout/err/all files is not writable'
+      end
+
+      return {:error => res[:error].inspect}
+    end
+    
+    self.pid = res[:pid]
+
+    unless self.pid
+      error 'returned empty pid, WTF O_o'
+      return {:error => :empty_pid}
+    end
+
+    sleep self[:start_grace].to_f
+
+    unless process_realy_running?
+      error "process with pid(#{self.pid}) not found, may be crashed (#{check_logs_str})"
+      return {:error => :not_realy_running}
+    end
+
+    unless failsafe_save_pid
+      return {:error => :cant_write_pid} 
+    end
+    
+    res
+  end
+
+  def execute_process
+    info "executing: `#{self[:start_command]}` with start_timeout: #{config[:start_timeout].to_f}s, start_grace: #{self[:start_grace].to_f}s, env: #{self[:environment].inspect}, working_dir: #{self[:working_dir]}"
+    time_before = Time.now
+
+    res = execute(self[:start_command], config.merge(:timeout => config[:start_timeout]))
+    start_time = Time.now - time_before    
+
+    if res[:error]
+      error "raised with #{res[:error].inspect}"
+
+      if res[:error].message == 'Permission denied - open'
+        error 'seems stdout/err/all files is not writable'
+      end
+
+      if res[:error].class == Timeout::Error
+        error "try to increase start_timeout interval (current #{self[:start_timeout]} seems too small, for process self-daemonization)"
+      end
+
+      return {:error => res[:error].inspect}
+    end
+
+    sleep self[:start_grace].to_f
+
+    unless set_pid_from_file
+      error "pid_file(#{self[:pid_file_ex]}) does not appears after start_grace #{self[:start_grace].to_f}, check start_command, or tune start_grace (eye dont know what to monitor without pid)"
+      return {:error => :pid_not_found}
+    end
+
+    unless process_realy_running?
+      error "process in pid_file(#{self[:pid_file_ex]})(#{self.pid}) not found, maybe process do not write there actual pid, or just crashed (#{check_logs_str})"
+      return {:error => :not_realy_running}
+    end
+
+    res[:pid] = self.pid
+    info "process get pid:#{res[:pid]}, pid_file #{self[:pid_file_ex]}"
+    res
+  end
+
+  def check_logs_str
+    if !self[:stdout] && !self[:stderr]
+      'maybe should add stdout/err/all logs'
+    else
+      "check also it stdout/err/all logs #{[self[:stdout], self[:stderr]].inspect}"
+    end    
+  end
+
+  def prepare_command(command)
+    if self.pid
+      command.to_s.gsub('{{PID}}', self.pid.to_s).gsub('{PID}', self.pid.to_s)
+    else
+      command
+    end
+  end
+
+end