ace-eye 0.6.1

data/lib/eye/cli/server.rb

@@ -0,0 +1,93 @@
+module Eye::Cli::Server
+private
+
+  def server_started?
+    _cmd(:ping) == :pong
+  end
+
+  def loader_path
+    filename = File.expand_path(File.join(File.dirname(__FILE__), %w[.. .. .. bin loader_eye]))
+    File.exists?(filename) ? filename : nil
+  end
+
+  def ruby_path
+    require 'rbconfig'
+    RbConfig::CONFIG['bindir'] + '/ruby'
+  end
+
+  def ensure_loader_path
+    unless loader_path
+      error! "start monitoring needs to run under ruby with installed gem 'eye'"
+    end
+  end
+
+  def server_start_foreground(conf = nil)
+    ensure_loader_path
+    Eye::Local.ensure_eye_dir
+
+    if server_started?
+      _cmd(:quit) && sleep(1) # stop previous server
+    end
+
+    args = []
+    args += ['--config', conf] if conf
+    args += ['--logger', 'stdout']
+    if Eye::Local.local_runner
+      args += ['--stop_all']
+      args += ['--dir', Eye::Local.dir]
+      args += ['--config', Eye::Local.eyefile] unless conf
+    end
+
+    Process.exec(ruby_path, loader_path, *args)
+  end
+
+  def server_start(configs)
+    ensure_loader_path
+    Eye::Local.ensure_eye_dir
+
+    ensure_stop_previous_server
+
+    args = []
+    args += ['--dir', Eye::Local.dir] if Eye::Local.local_runner
+
+    opts = {:out => '/dev/null', :err => '/dev/null', :in => '/dev/null',
+            :chdir => '/', :pgroup => true}
+
+    pid = Process.spawn(ruby_path, loader_path, *args, opts)
+    Process.detach(pid)
+    File.open(Eye::Local.pid_path, 'w'){|f| f.write(pid) }
+
+    unless wait_server
+      error! 'server has not started in 15 seconds, something is very wrong'
+    end
+
+    configs.unshift(Eye::Local.eyeconfig) if File.exists?(Eye::Local.eyeconfig)
+    configs << Eye::Local.eyefile if Eye::Local.local_runner
+
+    say 'Eye started!', :green
+
+    if !configs.empty?
+      say_load_result cmd(:load, *configs)
+    end
+  end
+
+  def ensure_stop_previous_server
+    Eye::Local.ensure_eye_dir
+    pid = File.read(Eye::Local.pid_path).to_i rescue nil
+    if pid
+      Process.kill(9, pid) rescue nil
+    end
+    File.delete(Eye::Local.pid_path) rescue nil
+    true
+  end
+
+  def wait_server(timeout = 15)
+    Timeout.timeout(timeout) do
+      sleep 0.3 while !server_started?
+    end
+    true
+  rescue Timeout::Error
+    false
+  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(Marshal.dump([cmd, *args]))
+  end
+
+  def attempt_command(pack)
+    Timeout.timeout(Eye::Local.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.write(pack)
+      data = socket.read
+      res = Marshal.load(data) rescue :corrupted_data
+    end
+  end
+
+end

data/lib/eye/config.rb

@@ -0,0 +1,91 @@
+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!(localize = true)
+    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 duplicates of the full pid_file
+
+    dupl_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
+    dupl_pids = dupl_pids.select{|k,v| v>1}
+
+    if dupl_pids.present?
+      raise Eye::Dsl::Error, "duplicate pid_files: #{dupl_pids.inspect}"
+    end
+
+    # Check duplicates of the full_name
+    dupl_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
+    dupl_names = dupl_names.select{|k,v| v>1}
+
+    if dupl_names.present?
+      raise Eye::Dsl::Error, "duplicate names: #{dupl_names.inspect}"
+    end
+
+    # validate processes with their own validate
+    all_processes.each do |process_cfg|
+      Eye::Process.validate process_cfg, localize
+    end
+
+    # just to be sure ENV was not removed
+    ENV[''] rescue raise Eye::Dsl::Error.new("ENV is not a hash '#{ENV.inspect}'")
+  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,54 @@
+require 'celluloid'
+require 'yaml'
+
+require_relative 'utils/celluloid_klass'
+require_relative 'utils/pmap'
+
+require_relative 'utils/leak_19'
+require_relative 'utils/mini_active_support'
+
+# Extend all objects with logger
+Object.send(:include, Eye::Logger::ObjectExt)
+
+Eye::Sigar # needs to preload
+
+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 :Options,        'eye/controller/options'
+
+  include Eye::Controller::Load
+  include Eye::Controller::Helpers
+  include Eye::Controller::Commands
+  include Eye::Controller::Status
+  include Eye::Controller::SendCommand
+  include Eye::Controller::Options
+
+  attr_reader :applications, :current_config
+
+  exclusive :load # load is hard command, so better to run it safely blocked
+
+  def initialize
+    @applications = []
+    @current_config = Eye::Config.new
+
+    Celluloid::logger = Eye::Logger.new('celluloid')
+    Eye::SystemResources.cache
+
+    info "starting #{Eye::ABOUT} <#{$$}>"
+  end
+
+  def settings
+    current_config.settings
+  end
+
+  def logger_tag
+    'Eye'
+  end
+
+end

data/lib/eye/controller/commands.rb

@@ -0,0 +1,88 @@
+module Eye::Controller::Commands
+
+  NOT_IMPORTANT_COMMANDS = [:info_data, :short_data, :debug_data, :history_data, :ping,
+    :logger_dev, :match, :explain, :check]
+
+  # Main method, answer for the client command
+  def command(cmd, *args)
+    msg = "command: #{cmd} #{args * ', '}"
+
+    log_str = "=> #{msg}"
+    NOT_IMPORTANT_COMMANDS.include?(cmd) ? debug(log_str) : info(log_str)
+
+    start_at = Time.now
+    cmd = cmd.to_sym
+
+    res = case cmd
+      when :start, :stop, :restart, :unmonitor, :monitor, :break_chain
+        send_command(cmd, *args)
+      when :delete
+        exclusive{ send_command(cmd, *args) }
+      when :signal
+        signal(*args)
+      when :load
+        load(*args)
+      when :quit
+        quit
+      when :stop_all
+        stop_all(*args)
+      when :check
+        check(*args)
+      when :explain
+        explain(*args)
+      when :match
+        match(*args)
+      when :ping
+        :pong
+      when :logger_dev
+        Eye::Logger.dev
+
+      # object commands, for api
+      when :info_data
+        info_data(*args)
+      when :short_data
+        short_data(*args)
+      when :debug_data
+        debug_data(*args)
+      when :history_data
+        history_data(*args)
+
+      else
+        :unknown_command
+    end
+
+    GC.start
+
+    log_str = "<= #{msg} (#{Time.now - start_at}s)"
+    NOT_IMPORTANT_COMMANDS.include?(cmd) ? debug(log_str) : info(log_str)
+
+    res
+  end
+
+private
+
+  def quit
+    info 'Quit!'
+    Eye::System.send_signal($$, :TERM)
+    sleep 1
+    Eye::System.send_signal($$, :KILL)
+  end
+
+  # stop all processes and wait
+  def stop_all(timeout = nil)
+    exclusive do
+      send_command :break_chain, 'all'
+      send_command :stop, 'all'
+    end
+
+    # wait until all processes goes to unmonitored
+    timeout ||= 100
+
+    all_processes.pmap do |p|
+      p.wait_for_condition(timeout, 0.3) do
+        p.state_name == :unmonitored
+      end
+    end
+  end
+
+end

data/lib/eye/controller/helpers.rb

@@ -0,0 +1,101 @@
+module Eye::Controller::Helpers
+
+  def set_proc_line
+    str = Eye::PROCLINE
+    str += " [#{@applications.map(&:name) * ', '}]" if @applications.present?
+    str += " (v #{ENV['EYE_V']})" if ENV['EYE_V']
+    str += " (in #{Eye::Local.dir})"
+    $0 = str
+  end
+
+  def save_cache
+    File.open(Eye::Local.cache_path, 'w') { |f| f.write(cache_str) }
+  rescue => ex
+    log_ex(ex)
+  end
+
+  def cache_str
+    all_processes.map{ |p| "#{p.full_name}=#{p.state}" } * "\n"
+  end
+
+  def process_by_name(name)
+    name = name.to_s
+    all_processes.detect { |c| c.name == name }
+  end
+
+  def process_by_full_name(name)
+    name = name.to_s
+    all_processes.detect { |c| c.full_name == name }
+  end
+
+  def find_nearest_process(name, group_name = nil, app_name = nil)
+    return process_by_full_name(name) if name.include?(':')
+
+    if app_name
+      app = application_by_name(app_name)
+      app.groups.each do |gr|
+        p = gr.processes.detect { |c| c.name == name }
+        return p if p
+      end
+    end
+
+    if group_name
+      gr = group_by_name(group_name)
+      p = gr.processes.detect { |c| c.name == name }
+      return p if p
+    end
+
+    process_by_name(name)
+  end
+
+  def group_by_name(name)
+    name = name.to_s
+    all_groups.detect { |c| c.name == name }
+  end
+
+  def application_by_name(name)
+    name = name.to_s
+    @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