reel-eye 0.3.1

data/lib/eye/checker/memory.rb

@@ -0,0 +1,27 @@
+class Eye::Checker::Memory < Eye::Checker
+
+  # checks :memory, :every => 3.seconds, :below => 80.megabytes, :times => [3,5]
+
+  param :below, [Fixnum, Float], true
+  
+  def check_name
+    @check_name ||= "memory(#{human_value(below)})"
+  end
+
+  def get_value
+    Eye::SystemResources.memory(@pid).to_i * 1024
+  end
+
+  def human_value(value)
+    "#{value.to_i / 1024 / 1024}Mb"
+  end
+
+  def good?(value)
+    if below
+      value < below
+    else
+      true
+    end
+  end
+
+end

data/lib/eye/checker/socket.rb

@@ -0,0 +1,152 @@
+class Eye::Checker::Socket < Eye::Checker::Defer
+
+  # checks :socket, :every => 5.seconds, :times => 1,
+  #  :addr => "unix:/var/run/daemon.sock", :timeout => 3.seconds,
+  #
+  # Available parameters:
+  # :addr          the socket addr to open. The format is tcp://<host>:<port> or unix:<path>
+  # :timeout       generic timeout for reading data from socket
+  # :open_timeout  override generic timeout for the connection
+  # :read_timeout  override generic timeout for data read/write
+  # :send_data     after connection send this data
+  # :expect_data   after sending :send_data expect this response. Can be a string, Regexp or a Proc
+  # :protocol      way of pack,unpack messages (default = socket default), example: :protocol => :em_object
+
+  param :addr,          String, true
+  param :timeout,       [Fixnum, Float]
+  param :open_timeout,  [Fixnum, Float]
+  param :read_timeout,  [Fixnum, Float]
+  param :send_data
+  param :expect_data,   [String, Regexp, Proc]
+  param :protocol,      [Symbol], nil, nil, [:default, :em_object]
+
+  def initialize(*args)
+    super
+    @open_timeout = (open_timeout || 1).to_f
+    @read_timeout = (read_timeout || timeout || 5).to_f
+
+    if addr =~ %r[\Atcp://(.*?):(.*?)\z]
+      @socket_family = :tcp
+      @socket_addr = $1
+      @socket_port = $2.to_i
+    elsif addr =~ %r[\Aunix:(.*)\z]
+      @socket_family = :unix
+      @socket_path = $1
+    end
+  end
+
+  def get_value
+    sock = begin
+      Timeout::timeout(@open_timeout){ open_socket }
+    rescue Timeout::Error
+      return { :exception => "OpenTimeout<#{@open_timeout}>" }
+    end
+
+    if send_data
+      begin
+        Timeout::timeout(@read_timeout) do
+          _write_data(sock, send_data)
+          result = _read_data(sock)
+
+          { :result => result }
+        end
+      rescue Timeout::Error
+        return { :exception => "ReadTimeout<#{@read_timeout}>" }
+      end
+    else
+      { :result => :listen }
+    end
+
+  rescue Exception => e
+    { :exception => "Error<#{e.message}>" }
+
+  ensure
+    sock.close if sock
+  end
+
+  def good?(value)
+    return false if !value[:result]
+
+    if expect_data
+      if expect_data.is_a?(Proc)                
+        match = begin
+          !!expect_data[value[:result]] 
+        rescue Timeout::Error, Exception => ex
+          mes = "proc match failed with '#{ex.message}'"
+          error(mes)
+          value[:notice] = mes
+          return false
+        end
+        
+        unless match
+          warn "proc #{expect_data} not matched (#{value[:result].truncate(30)}) answer" 
+          value[:notice] = "missing proc validation"
+        end
+
+        return match
+      end
+
+      return true if expect_data.is_a?(Regexp) && expect_data.match(value[:result])
+      return true if value[:result].to_s == expect_data.to_s
+
+      warn "#{expect_data} not matched (#{value[:result].truncate(30)}) answer"
+      value[:notice] = "missing '#{expect_data.to_s}'"
+      return false
+    end
+
+    return true
+  end
+
+  def human_value(value)
+    if !value.is_a?(Hash)
+      '-'
+    elsif value[:exception]
+      value[:exception]
+    else
+      if value[:result] == :listen
+        "listen"
+      else
+        res = "#{value[:result].to_s.size}b"
+        res += "<#{value[:notice]}>" if value[:notice]
+        res 
+      end
+    end
+  end
+
+private
+
+  def open_socket
+    if @socket_family == :tcp      
+      TCPSocket.open(@socket_addr, @socket_port)
+    elsif @socket_family == :unix
+      UNIXSocket.open(@socket_path)
+    else
+      raise "Unknown socket addr #{addr}"
+    end
+  end
+
+  def _write_data(socket, data)
+    case protocol
+    when :em_object
+      data = Marshal.dump(data)
+      socket.write([data.bytesize, data].pack('Na*'))
+    else
+      socket.write(data.to_s)
+    end
+  end
+
+  def _read_data(socket)
+    case protocol
+    when :em_object
+      content = ""
+      msg_size = socket.recv(4).unpack('N')[0] rescue 0
+      content << socket.recv(msg_size - content.length) while content.length < msg_size
+      if content.present?
+        Marshal.load(content) rescue 'corrupted_marshal'
+      end
+    else
+      socket.readline.chop
+    end
+  end
+
+end

data/lib/eye/child_process.rb

@@ -0,0 +1,101 @@
+require 'celluloid'
+
+class Eye::ChildProcess
+  include Celluloid
+
+  # needs: kill_process
+  include Eye::Process::Commands
+
+  # easy config + defaults: prepare_config, c, []
+  include Eye::Process::Config
+
+  # conditional watchers: start_checkers
+  include Eye::Process::Watchers
+
+  # system methods: send_signal
+  include Eye::Process::System
+
+  # logger methods: info, ...
+  include Eye::Logger::Helpers
+
+  # self_status_data
+  include Eye::Process::Data
+
+  # manage notify methods
+  include Eye::Process::Notify
+
+  # scheduler
+  include Eye::Process::Scheduler
+
+  attr_reader :pid, :name, :full_name, :config, :watchers
+
+  def initialize(pid, config = {}, logger_prefix = nil)
+    raise 'Empty pid' unless pid
+
+    @pid = pid
+    @config = prepare_config(config)
+    @name = "child-#{pid}"
+    @full_name = [logger_prefix, @name] * ':'
+
+    @logger = Eye::Logger.new(@full_name)
+    
+    @watchers = {}
+
+    debug "start monitoring CHILD config: #{@config.inspect}"
+
+    start_checkers
+  end
+
+  def state
+    :up
+  end
+
+  def up?
+    state == :up
+  end
+
+  def send_command(command, *args)
+    schedule command, *args, Eye::Reason::User.new(command)
+  end
+
+  def start
+  end
+
+  def stop
+    kill_process
+  end
+
+  def restart
+    if self[:restart_command]
+      execute_restart_command
+    else
+      stop
+    end    
+  end
+
+  def monitor
+  end
+
+  def unmonitor
+  end
+
+  def delete 
+  end
+
+  def destroy
+    remove_watchers
+    terminate
+  end
+
+  def signal(sig)
+    if self.pid
+      res = send_signal(sig)
+      info "send signal #{sig} to #{self.pid} = #{res}"
+    end
+  end
+
+  def status_data(debug = false)
+    self_status_data(debug)
+  end
+
+end

data/lib/eye/client.rb

@@ -0,0 +1,32 @@
+require 'socket'
+require 'timeout'
+
+class Eye::Client
+  attr_reader :socket_path
+
+  def initialize(socket_path)
+    @socket_path = socket_path
+  end
+  
+  def command(cmd, *args)
+    attempt_command([cmd, *args] * '|')
+  end
+  
+  def attempt_command(pack)
+    Timeout.timeout(Eye::Settings.client_timeout) do
+      return send_request(pack)
+    end
+
+  rescue Timeout::Error, EOFError
+    :timeouted
+  end
+
+  def send_request(pack)
+    UNIXSocket.open(@socket_path) do |socket|
+      socket.puts(pack)
+      data = socket.read
+      res = Marshal.load(data) rescue :corrupred_marshal
+    end
+  end
+  
+end

data/lib/eye/config.rb

@@ -0,0 +1,88 @@
+class Eye::Config
+
+  attr_reader :settings, :applications
+
+  def initialize(settings = {}, applications = {})
+    @settings = settings
+    @applications = applications
+  end
+
+  def merge(other_config)
+    Eye::Config.new(@settings.merge(other_config.settings), @applications.merge(other_config.applications))
+  end
+
+  def merge!(other_config)
+    @settings.merge!(other_config.settings)
+    @applications.merge!(other_config.applications)
+  end
+
+  def to_h
+    {:settings => @settings, :applications => @applications}
+  end
+
+  # raise an error if config wrong
+  def validate!
+    all_processes = processes
+
+    # Check blank pid_files
+    no_pid_file = all_processes.select{|c| c[:pid_file].blank? }
+    if no_pid_file.present?
+      raise Eye::Dsl::Error, "blank pid_file for: #{no_pid_file.map{|c| c[:name]} * ', '}"
+    end
+
+    # Check dublicates of the full pid_file
+
+    dubl_pids = all_processes.each_with_object(Hash.new(0)) do |o, h| 
+      ex_pid_file = Eye::System.normalized_file(o[:pid_file], o[:working_dir])
+      h[ex_pid_file] += 1
+    end
+    dubl_pids = dubl_pids.select{|k,v| v>1}
+
+    if dubl_pids.present?
+      raise Eye::Dsl::Error, "dublicate pid_files: #{dubl_pids.inspect}"
+    end
+
+    # Check dublicates of the full_name
+    dubl_names = all_processes.each_with_object(Hash.new(0)) do |o, h| 
+      full_name = "#{o[:application]}:#{o[:group]}:#{o[:name]}"
+      h[full_name] += 1
+    end
+    dubl_names = dubl_names.select{|k,v| v>1}
+
+    if dubl_names.present?
+      raise Eye::Dsl::Error, "dublicate names: #{dubl_names.inspect}"
+    end
+
+    # validate processes with their own validate
+    all_processes.each do |process_cfg|
+      Eye::Process.validate process_cfg
+    end
+  end
+
+  def processes
+    applications.values.map{|e| (e[:groups] || {}).values.map{|c| (c[:processes] || {}).values} }.flatten
+  end
+
+  def application_names
+    applications.keys
+  end
+
+  def delete_app(name)
+    applications.delete(name)
+  end
+
+  def delete_group(name)
+    applications.each do |app_name, app_cfg|
+      app_cfg[:groups].delete(name)
+    end
+  end
+
+  def delete_process(name)
+    applications.each do |app_name, app_cfg|
+      app_cfg[:groups].each do |gr_name, gr_cfg|
+        gr_cfg[:processes].delete(name)
+      end
+    end
+  end
+
+end

data/lib/eye/control.rb

@@ -0,0 +1,2 @@
+# controller global singlton
+Eye::Control = Eye::Controller.new

data/lib/eye/controller.rb

@@ -0,0 +1,53 @@
+require 'celluloid'
+
+require 'yaml'
+require 'active_support'
+require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/object/try'
+require 'active_support/core_ext/numeric'
+require 'active_support/core_ext/string/filters'
+
+require_relative 'utils/leak_19'
+
+Eye.send(:extend, Eye::Logger::Helpers)
+
+class Eye::Controller
+  include Celluloid
+
+  autoload :Load,           'eye/controller/load'
+  autoload :Helpers,        'eye/controller/helpers'
+  autoload :Commands,       'eye/controller/commands'
+  autoload :Status,         'eye/controller/status'
+  autoload :SendCommand,    'eye/controller/send_command'
+  autoload :ShowHistory,    'eye/controller/show_history'
+  autoload :Options,        'eye/controller/options'
+
+  include Eye::Logger::Helpers
+  include Eye::Controller::Load
+  include Eye::Controller::Helpers
+  include Eye::Controller::Commands
+  include Eye::Controller::Status
+  include Eye::Controller::SendCommand
+  include Eye::Controller::ShowHistory
+  include Eye::Controller::Options
+
+  attr_reader :applications, :current_config
+
+  def initialize
+    @applications = []
+    @current_config = Eye::Config.new
+
+    Eye.instance_variable_set(:@logger, Eye::Logger.new('eye'))
+    @logger = Eye.logger 
+    Celluloid::logger = Eye.logger
+
+    Eye::SystemResources.setup
+    
+    info "starting #{Eye::ABOUT} (#{$$})"
+  end
+
+  def settings
+    current_config.settings
+  end
+
+end