eye 0.1.11

data/lib/eye/checker/validation.rb

@@ -0,0 +1,49 @@
+module Eye::Checker::Validation
+  class Error < Exception; end
+
+  def inherited(subclass)
+    subclass.validates = self.validates.clone
+    subclass.should_bes = self.should_bes.clone
+    subclass.defaults = self.defaults.clone
+  end
+
+  attr_accessor :validates, :should_bes, :defaults
+
+  def validates; @validates ||= {}; end
+  def should_bes; @should_bes ||= []; end
+  def defaults; @defaults ||= {}; end
+
+  def param(param, types = [], should_be = false, default = nil)
+    param = param.to_sym
+
+    validates[param] = types
+    should_bes << param if should_be
+    defaults[param] = default
+
+    define_method "#{param}" do
+      @options[param.to_sym] || default
+    end
+  end
+
+  def validate(options = {})    
+    options.each do |param, value|        
+      types = validates[param.to_sym]
+      unless types
+        if param.to_sym != :type
+          raise Error, "#{self.name} unknown param :#{param} value #{value.inspect}" 
+        end
+      end
+
+      next if types.blank?
+
+      types = Array(types)
+      good = types.any?{|type| value.is_a?(type) }
+      raise Error, "#{self.name} bad param :#{param} value #{value.inspect}, type #{types.inspect}" unless good
+    end
+
+    should_bes.each do |param|
+      raise Error, "#{self.name} bad param :#{param}, value should be" unless options[param.to_sym] || defaults[param.to_sym]
+    end
+  end
+
+end

data/lib/eye/child_process.rb

@@ -0,0 +1,75 @@
+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, :config, :watchers
+
+  def initialize(pid, config = {}, logger_prefix = nil)
+    raise 'Empty pid' unless pid
+
+    @pid = pid
+    @config = prepare_config(config)
+    @name = '=child='
+
+    @logger = Eye::Logger.new("#{logger_prefix} child:#{pid}")
+    
+    @watchers = {}
+
+    debug "start monitoring CHILD config: #{@config.inspect}"
+
+    start_checkers
+  end
+
+  def state
+    :up
+  end
+
+  def stop
+    kill_process
+  end
+
+  def restart
+    stop
+  end
+
+  def monitor
+  end
+
+  def unmonitor
+  end
+
+  def delete
+    remove_watchers
+    terminate
+  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/control.rb

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

data/lib/eye/controller.rb

@@ -0,0 +1,43 @@
+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'
+
+  include Eye::Logger::Helpers
+  include Eye::Controller::Load
+  include Eye::Controller::Helpers
+  include Eye::Controller::Commands
+  include Eye::Controller::Status
+  include Eye::Controller::SendCommand
+
+  attr_reader :applications, :current_config
+
+  def initialize
+    @applications = []
+    @current_config = Eye::Dsl.initial_config
+
+    Eye.instance_variable_set(:@logger, Eye::Logger.new('eye'))
+    @logger = Eye.logger 
+    Celluloid::logger = Eye.logger
+
+    Eye::SystemResources.setup
+  end
+
+end

data/lib/eye/controller/commands.rb

@@ -0,0 +1,64 @@
+module Eye::Controller::Commands
+
+  # Main method, answer for the client command
+  def command(cmd, *args)
+    debug "client command: #{cmd} #{args * ', '}"
+
+    start_at = Time.now
+    cmd = cmd.to_sym
+    
+    res = case cmd 
+      when :start, :stop, :restart, :unmonitor, :monitor
+        send_command(cmd, *args)
+      when :delete
+        exclusive{ send_command(cmd, *args) }
+      when :signal
+        signal(*args)
+      when :load
+        exclusive{ load(*args) }
+      when :info
+        info_string(*args)
+      when :object_info
+        info_data(*args)
+      when :xinfo
+        info_string_debug(*args)
+      when :oinfo
+        info_string_short
+      when :quit
+        quit
+      when :check
+        check(*args)
+      when :explain
+        explain(*args)
+      when :match
+        match(*args)
+      when :ping
+        :pong
+      when :logger_dev
+        Eye::Logger.dev
+      else
+        :unknown_command
+    end   
+
+    GC.start
+    info "client command: #{cmd} #{args * ', '} (#{Time.now - start_at}s)"
+
+    res  
+  end
+
+private
+
+  def quit
+    info 'exiting...'
+    delete
+    sleep 1
+    Eye::System.send_signal($$) # soft terminate
+    sleep 2
+    Eye::System.send_signal($$, 9)
+  end
+
+  def delete
+    send_command(:delete)
+  end
+
+end

data/lib/eye/controller/helpers.rb

@@ -0,0 +1,61 @@
+module Eye::Controller::Helpers
+
+  def set_proc_line
+    str = "eye monitoring v#{Eye::VERSION}"
+    str += " (#{@applications.map(&:name) * ', '})" if @applications.present?
+    $0 = str
+  end
+
+  def process_by_name(name)
+    all_processes.detect{|c| c.name == name}
+  end
+
+  def group_by_name(name)
+    all_groups.detect{|c| c.name == name}
+  end
+
+  def application_by_name(name)
+    @applications.detect{|c| c.name == name}
+  end
+
+  def all_processes
+    processes = []
+    all_groups.each do |gr|
+      processes += gr.processes.to_a
+    end
+
+    processes
+  end
+
+  def all_groups
+    groups = []
+    @applications.each do |app|
+      groups += app.groups.to_a
+    end
+
+    groups
+  end
+
+  # {'app_name' => {'group_name' => {'process_name' => 'pid_file'}}}
+  def short_tree
+    res = {}
+    @applications.each do |app|
+      res2 = {}
+
+      app.groups.each do |group|
+        res3 = {}
+
+        group.processes.each do |process|
+          res3[process.name] = process[:pid_file_ex]
+        end
+
+        res2[group.name] = res3
+      end
+
+      res[app.name] = res2
+    end
+
+    res
+  end
+
+end

data/lib/eye/controller/load.rb

@@ -0,0 +1,224 @@
+module Eye::Controller::Load
+  include Eye::Dsl::Validate
+
+  def check(filename = '')
+    catch_load_error(filename) do
+      parse_config(filename)
+    end
+  end
+
+  def explain(filename)
+    catch_load_error(filename) do
+      parse_set_of_configs(filename)
+    end
+  end
+
+  # filename is a path, or folder, or mask
+  def load(filename = '')
+    catch_load_error(filename) do
+      _load(filename)
+      set_proc_line
+    end
+  end
+
+private
+
+  # regexp for clean backtrace to show for user
+  BT_REGX = %r[/lib/eye/|lib/celluloid|internal:prelude|logger.rb:].freeze
+
+  def catch_load_error(filename, &block)
+    res = block.call
+
+    {:error => false, :config => res}
+  rescue Eye::Dsl::Error, Exception, NoMethodError => ex
+    error "load: config error <#{filename}>: #{ex.message}"
+
+    # filter backtrace for user output
+    bt = (ex.backtrace || []).reject{|line| line.to_s =~ BT_REGX }
+    error bt.join("\n")
+
+    res = {:error => true, :message => ex.message}
+    res.merge!(:backtrace => bt) if bt.present?
+    res
+  end
+
+  # return: result, config
+  def parse_config(filename = '', &block)
+    raise Eye::Dsl::Error, "config file '#{filename}' not found!" unless File.exists?(filename)
+
+    cfg = Eye::Dsl.parse(nil, filename)
+    validate( merge_configs(@current_config, cfg) )
+
+    cfg
+  end
+
+  def parse_set_of_configs(filename)
+    mask = if File.directory?(filename)
+      File.join filename, '{*.eye}'
+    else
+      filename
+    end
+
+    debug "load: globbing mask #{mask}"
+    configs = []
+
+    Dir[mask].each do |config_path|
+      info "load: config #{config_path}"
+      configs << parse_config(config_path)
+    end
+
+    raise Eye::Dsl::Error, "config file '#{mask}' not found!" if configs.blank?
+
+    new_cfg = @current_config
+    configs.each do |cfg| 
+      new_cfg = merge_configs(new_cfg, cfg)
+    end
+
+    validate(new_cfg)
+
+    new_cfg
+  end
+
+  def _load(filename)
+    new_cfg = parse_set_of_configs(filename)
+
+    load_config(new_cfg)
+
+    GC.start
+  end
+
+  def load_config(new_config)
+    load_options(new_config[:config])
+    create_objects(new_config[:applications])
+    @current_config = new_config
+  end
+
+  def merge_configs(old_config, new_config)
+    {:config => old_config[:config].merge(new_config[:config]),
+     :applications => old_config[:applications].merge(new_config[:applications])}
+  end
+
+  # load global config options
+  def load_options(opts)
+    return if opts.blank?
+
+    if opts[:logger]
+      # do not apply logger, if in stdout state
+      if !%w{stdout stderr}.include?(Eye::Logger.dev)
+        if opts[:logger].blank?
+          Eye::Logger.link_logger(nil)
+        else
+          Eye::Logger.link_logger(opts[:logger])
+        end
+      end
+      
+      Eye::Logger.log_level = opts[:logger_level] if opts[:logger_level]
+    end
+  end
+
+  # create objects as diff, from configs
+  def create_objects(apps_config)
+    debug 'create objects'
+    apps_config.each do |app_name, app_cfg|
+      update_or_create_application(app_name, app_cfg.clone)
+    end
+
+    # sorting applications
+    @applications.sort_by!(&:name)
+  end
+
+  def update_or_create_application(app_name, app_config)
+    @old_groups = {}
+    @old_processes = {}
+
+    app = @applications.detect{|c| c.name == app_name}
+
+    if app
+      app.groups.each do |group|
+        @old_groups[group.name] = group
+        group.processes.each do |proc|
+          @old_processes[proc.name] = proc
+        end
+      end
+
+      @applications.delete(app)
+
+      debug "update app #{app_name}"
+    else
+      debug "create app #{app_name}"
+    end
+
+    app = Eye::Application.new(app_name, app_config)
+    @applications << app
+    @added_groups, @added_processes = [], []
+
+    new_groups = app_config.delete(:groups) || {}
+    new_groups.each do |group_name, group_cfg|
+      group = update_or_create_group(group_name, group_cfg.clone)
+      app.add_group(group)
+      group.resort_processes
+    end
+
+    # now, need to clear @old_groups, and @old_processes    
+    @old_groups.each{|_, group| group.clear; group.send_command(:delete) }
+    @old_processes.each{|_, process| process.send_command(:delete) if process.alive? }
+
+    # schedule monitoring for new groups, processes
+    added_fully_groups = []
+    @added_groups.each do |group|
+      if group.processes.size > 0 && (group.processes.pure - @added_processes).size == 0
+        added_fully_groups << group
+        @added_processes -= group.processes.pure 
+      end
+    end
+
+    added_fully_groups.each{|group| group.send_command :monitor }
+    @added_processes.each{|process| process.send_command :monitor }
+
+    # remove links to prevent memory leaks
+    @old_groups = nil
+    @old_processes = nil
+    @added_groups = nil
+    @added_processes = nil
+
+    app
+  end
+
+  def update_or_create_group(group_name, group_config)
+    group = if @old_groups[group_name]
+      debug "update group #{group_name}"
+      group = @old_groups.delete(group_name)
+      group.schedule :update_config, group_config, 'load config'
+      group.clear
+      group
+    else
+      debug "create group #{group_name}"
+      gr = Eye::Group.new(group_name, group_config)
+      @added_groups << gr
+      gr
+    end
+
+    processes = group_config.delete(:processes) || {}
+    processes.each do |process_name, process_cfg|
+      process = update_or_create_process(process_name, process_cfg.clone)
+      group.add_process(process)
+    end
+
+    group
+  end
+
+  def update_or_create_process(process_name, process_cfg)
+    if @old_processes[process_name]
+      debug "update process #{process_name}"
+      process = @old_processes.delete(process_name)
+      process.schedule :update_config, process_cfg, 'load config'
+      process      
+    else
+      debug "create process #{process_name}"
+      process = Eye::Process.new(process_cfg)
+      @added_processes << process
+      process
+    end
+  end
+
+end