eye 0.1.11

data/lib/eye/dsl/opts.rb

@@ -0,0 +1,88 @@
+class Eye::Dsl::Opts < Eye::Dsl::PureOpts
+
+  STR_OPTIONS = [ :pid_file, :working_dir, :stdout, :stderr, :stdall, :start_command, 
+    :stop_command, :restart_command ]
+
+  create_options_methods(STR_OPTIONS, String)
+
+  BOOL_OPTIONS = [ :daemonize, :keep_alive, :control_pid, :auto_start, :stop_on_delete]
+
+  create_options_methods(BOOL_OPTIONS, [TrueClass, FalseClass])
+
+  INTERVAL_OPTIONS = [ :check_alive_period, :start_timeout, :restart_timeout, :stop_timeout, :start_grace,
+    :restart_grace, :stop_grace, :childs_update_period ]
+
+  create_options_methods(INTERVAL_OPTIONS, [Fixnum, Float])
+
+  OTHER_OPTIONS = [ :environment, :stop_signals ]
+
+  create_options_methods(OTHER_OPTIONS)
+
+
+
+  def initialize(name = nil, parent = nil)
+    super(name, parent)
+
+    # ensure delete subobjects which can appears from parent config
+    @config.delete :groups
+    @config.delete :processes
+
+    @config[:application] = parent.name if parent.is_a?(Eye::Dsl::ApplicationOpts)
+    @config[:group] = parent.name if parent.is_a?(Eye::Dsl::GroupOpts)
+
+    # hack for full name
+    @full_name = parent.full_name if @name == '__default__'
+  end
+
+  def checks(type, opts = {})
+    type = type.to_sym
+    raise Eye::Dsl::Error, "unknown checker type #{type}" unless Eye::Checker::TYPES[type]
+
+    opts.merge!(:type => type)
+    Eye::Checker.validate!(opts)
+    
+    @config[:checks] ||= {}
+    @config[:checks][type] = opts
+  end
+
+  def triggers(type, opts = {})
+    type = type.to_sym
+    raise Eye::Dsl::Error, "unknown trigger type #{type}" unless Eye::Trigger::TYPES[type]
+    
+    opts.merge!(:type => type)
+    Eye::Trigger.validate!(opts)
+
+    @config[:triggers] ||= {}
+    @config[:triggers][type] = opts
+  end
+
+  # clear checks from parent
+  def nochecks(type)
+    type = type.to_sym
+    raise Eye::Dsl::Error, "unknown checker type #{type}" unless Eye::Checker::TYPES[type]
+    @config[:checks].try :delete, type
+  end
+
+  # clear triggers from parent
+  def notriggers(type)
+    type = type.to_sym
+    raise Eye::Dsl::Error, "unknown trigger type #{type}" unless Eye::Trigger::TYPES[type]
+    @config[:triggers].try :delete, type
+  end
+
+  def set_environment(value)
+    raise Eye::Dsl::Error, "environment should be a hash, but not #{value.inspect}" unless value.is_a?(Hash)
+    @config[:environment] ||= {}
+    @config[:environment].merge!(value)
+  end
+
+  alias :env :environment
+
+  def set_stdall(value)
+    super
+
+    set_stdout value
+    set_stderr value
+  end
+
+end

data/lib/eye/dsl/process_opts.rb

@@ -0,0 +1,21 @@
+class Eye::Dsl::ProcessOpts < Eye::Dsl::Opts
+
+  def monitor_children(&block)
+    opts = Eye::Dsl::ChildProcessOpts.new
+    opts.instance_eval(&block)
+    @config[:monitor_children] ||= {}
+    @config[:monitor_children].merge!(opts.config)
+  end
+
+  def xmonitor_children(&block); end
+
+  def application
+    parent.try(:parent)
+  end
+  alias :app :application
+
+  def group
+    parent
+  end
+
+end

data/lib/eye/dsl/pure_opts.rb

@@ -0,0 +1,132 @@
+class Eye::Dsl::PureOpts
+
+  def self.create_options_methods(arr, types = nil)
+    m = Module.new do
+      arr.each do |opt|
+        define_method("set_#{opt}") do |arg|
+          key = opt.to_sym
+
+          if (disallow_options && disallow_options.include?(key)) || (allow_options && !allow_options.include?(key))
+            raise Eye::Dsl::Error, "disallow option #{key} for #{self.class.inspect}"
+          end
+
+          if types
+            good_type = Array(types).any?{|type| arg.is_a?(type) } || arg.nil?
+            raise Eye::Dsl::Error, "bad :#{opt} value #{arg.inspect}, type should be #{types.inspect}" unless good_type
+          end
+
+          @config[key] = arg
+        end
+
+        define_method("get_#{opt}") do
+          @config[ opt.to_sym ]
+        end
+
+        define_method(opt) do |*args|
+          if args.blank?
+            # getter
+            send "get_#{opt}"
+          else
+            send "set_#{opt}", *args
+          end
+        end
+
+        define_method("#{opt}=") do |arg|
+          send opt, arg
+        end
+      end
+    end
+
+    self.send :include, m
+  end
+
+  attr_reader :name, :full_name
+  attr_reader :config, :parent
+
+  def initialize(name = nil, parent = nil)
+    @name = name.to_s    
+    @full_name = @name
+
+    if parent
+      @parent = parent
+      @config = Marshal.load(Marshal.dump(parent.config)) # O_o ruby recommended deep clone
+      @full_name = "#{parent.full_name}:#{@full_name}"
+    else
+      @config = {}
+    end
+
+    @config[:name] = @name if @name.present?
+  end
+
+  def allow_options
+    nil
+  end
+
+  def disallow_options
+    []
+  end
+
+  # execute part of config on particular server
+  # array of strings
+  # regexp
+  # string
+  def with_server(glob = nil, &block)
+    on_server = true
+
+    if glob.present? 
+      host = Eye::System.host
+
+      if glob.is_a?(Array)
+        on_server = !!glob.any?{|elem| elem == host}
+      elsif glob.is_a?(Regexp)
+        on_server = !!host.match(glob)
+      elsif glob.is_a?(String) || glob.is_a?(Symbol)
+        on_server = (host == glob.to_s)
+      end
+    end
+
+    with_condition(on_server, &block)
+
+    on_server
+  end
+
+  def with_condition(cond = true, &block)
+    self.instance_eval(&block) if cond && block
+  end
+
+  def self.with_parsed_file(file_name)
+    saved_parsed_filename = Eye.parsed_filename
+
+    require 'pathname'
+
+    real_filename = Eye.parsed_filename && File.symlink?(Eye.parsed_filename) ? File.readlink(Eye.parsed_filename) : Eye.parsed_filename
+    dirname = File.dirname(real_filename) rescue nil
+    path = Pathname.new(file_name).expand_path(dirname).to_s
+
+    Eye.parsed_filename = path
+    yield path
+  ensure
+    Eye.parsed_filename = saved_parsed_filename
+  end
+
+  def include(proc, *args)
+    if proc.is_a?(String)
+      self.class.with_parsed_file(proc) do |path|
+        if File.exists?(path)
+          Eye::Dsl.debug "=> load #{path}"
+          self.instance_eval(File.read(path)) 
+          Eye::Dsl.debug "<= load #{path}"
+        end
+      end
+    else
+      ie = if args.present?
+        lambda{|i| proc[i, *args] }
+      else
+        proc
+      end
+
+      self.instance_eval(&ie)
+    end
+  end
+
+end

data/lib/eye/dsl/validate.rb

@@ -0,0 +1,41 @@
+module Eye::Dsl::Validate
+
+  # validate global config rules
+  def validate(config)
+    cfg = config[:config]
+    config = config[:applications]
+
+    all_processes = config.values.map{|e| (e[:groups] || {}).values.map{|c| (c[:processes] || {}).values} }.flatten
+
+    # 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
+  end
+
+end

data/lib/eye/group.rb

@@ -0,0 +1,125 @@
+require 'celluloid'
+
+class Eye::Group
+  include Celluloid
+
+  autoload :Chain, 'eye/group/chain'
+
+  include Eye::Logger::Helpers
+  include Eye::Process::Scheduler
+  include Eye::Group::Chain
+
+  attr_reader :processes, :name, :hidden, :config
+
+  def initialize(name, config)
+    @name = name
+    @config = config
+    @logger = Eye::Logger.new(full_name)
+    @processes = Eye::Utils::AliveArray.new
+    @hidden = (name == '__default__')
+    debug 'created'
+  end
+
+  def full_name
+    @full_name ||= "#{@config[:application]}:#{@name}"
+  end
+
+  def update_config(cfg)
+    @config = cfg
+    @full_name = nil
+  end
+
+  def add_process(process)
+    @processes << process
+  end
+
+  # sort processes in name order
+  def resort_processes
+    @processes = @processes.sort_by(&:name)
+  end
+
+  def status_data(debug = false)
+    plist = @processes.map{|p| p.status_data(debug) }
+
+    h = { name: name, type: :group, subtree: plist }
+
+    h.merge!(debug: debug_data) if debug
+
+    # show current chain
+    if current_scheduled_command
+      h.update(current_command: current_scheduled_command) 
+
+      if (chain_commands = scheduler_actions_list) && chain_commands.present?
+        h.update(chain_commands: chain_commands) 
+      end
+
+      if @chain_processes_current && @chain_processes_count
+        h.update(chain_progress: [@chain_processes_current, @chain_processes_count]) 
+      end
+    end
+
+    h
+  end
+
+  def debug_data
+    {:queue => scheduler_actions_list, :chain => chain_status}
+  end
+
+  def send_command(command, *args)
+    info "send_command: #{command}"
+
+    if command == :delete
+      delete *args
+    else
+      schedule command, *args, "#{command} by user"
+    end
+  end
+
+  def start
+    chain_command :start
+  end
+
+  def stop
+    async_schedule :stop
+  end
+
+  def restart
+    chain_command :restart
+  end
+
+  def delete
+    async_schedule :delete
+    terminate
+  end
+
+  def monitor
+    chain_command :monitor
+  end
+
+  def unmonitor
+    async_schedule :unmonitor
+  end
+
+  def signal(sig)
+    async_schedule :signal, sig
+  end
+
+  def clear
+    @processes.clear
+  end
+
+  def sub_object?(obj)
+    @processes.include?(obj)
+  end
+
+private
+
+  def async_schedule(command, *args)
+    info "send to all processes #{command} #{args.present? ? args*',' : nil}"
+    
+    @processes.each do |process|
+      process.send_command(command, *args)
+    end    
+  end
+
+end

data/lib/eye/group/chain.rb

@@ -0,0 +1,68 @@
+module Eye::Group::Chain
+
+private
+
+  def chain_schedule(type, grace, command, *args)
+    info "start #{type} with #{grace}s chain #{command} #{args}"
+
+    @chain_processes_count = @processes.size
+    @chain_processes_current = 0
+
+    @processes.each do | process |
+      chain_schedule_process(process, type, command, *args)
+
+      @chain_processes_current = @chain_processes_current.to_i + 1
+
+      # to skip last sleep
+      break if @chain_processes_current.to_i == @chain_processes_count.to_i 
+
+      # wait next process
+      sleep grace.to_f
+    end
+
+    @chain_processes_count = nil
+    @chain_processes_current = nil
+  end
+
+  def chain_schedule_process(process, type, command, *args)
+    if type == :sync
+      # sync command, with waiting
+      process.send(command, *args)
+    else
+      # async command
+      process.send_command(command, *args)
+    end
+  end
+
+  def chain_status
+    if @config[:chain]
+      [:start, :restart].map{|c| @config[:chain][c].try(:[], :grace) }
+    end
+  end
+
+  def chain_command(command, *args)
+    chain_opts = chain_options(command)
+    chain_schedule(chain_opts[:type], chain_opts[:grace], command, *args)
+  end
+
+  # with such delay will chained processes by default
+  DEFAULT_CHAIN = 0.2
+
+  def chain_options(command)
+    command = :start if command == :monitor # hack for monitor command, work as start
+
+    if @config[:chain] && @config[:chain][command]
+      type = @config[:chain][command].try :[], :type
+      type = [:async, :sync].include?(type) ? type : :async
+
+      grace = @config[:chain][command].try :[], :grace
+      grace = grace ? (grace.to_f rescue DEFAULT_CHAIN) : DEFAULT_CHAIN
+
+      {:type => type, :grace => grace}
+    else
+      # default chain case            
+      {:type => :async, :grace => DEFAULT_CHAIN}
+    end
+  end
+
+end