ace-eye 0.6.1

data/lib/eye/dsl/pure_opts.rb

@@ -0,0 +1,121 @@
+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, merge_parent_config = true)
+    @name = name.to_s
+    @full_name = @name
+
+    if parent
+      @parent = parent
+      if merge_parent_config
+        @config = Eye::Utils::deep_clone(parent.config)
+        parent.not_seed_options.each { |opt| @config.delete(opt) }
+      else
+        @config = {}
+      end
+      @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
+
+  def not_seed_options
+    []
+  end
+
+  def with_condition(cond = true, &block)
+    self.instance_eval(&block) if cond && block
+  end
+
+  def use(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
+
+  def nop(*args, &block); end
+
+private
+
+  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
+
+end

data/lib/eye/dsl/validation.rb

@@ -0,0 +1,88 @@
+module Eye::Dsl::Validation
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  class Error < Exception; end
+
+  module ClassMethods
+    def inherited(subclass)
+      subclass.validates = self.validates.clone
+      subclass.should_bes = self.should_bes.clone
+      subclass.defaults = self.defaults.clone
+      subclass.variants = self.variants.clone
+    end
+
+    attr_accessor :validates, :should_bes, :defaults, :variants
+
+    def validates; @validates ||= {}; end
+    def should_bes; @should_bes ||= []; end
+    def defaults; @defaults ||= {}; end
+    def variants; @variants ||= {}; end
+
+    def param(param, types = [], should_be = false, default = nil, _variants = nil)
+      param = param.to_sym
+
+      validates[param] = types
+      should_bes << param if should_be
+      param_default(param, default)
+      variants[param] = _variants
+
+      return if param == :do
+
+      define_method "#{param}" do
+        value = @options[param]
+        value.nil? ? default : value
+      end
+    end
+
+    def param_default(param, default)
+      param = param.to_sym
+      defaults[param] = default
+    end
+
+    def del_param(param)
+      param = param.to_sym
+      validates.delete(param)
+      should_bes.delete(param)
+      defaults.delete(param)
+      variants.delete(param)
+      remove_method(param)
+    end
+
+    def validate(options = {})
+      options.each do |param, value|
+        param = param.to_sym
+        types = validates[param]
+        unless types
+          if param != :type
+            raise Error, "#{self.name} unknown param :#{param} value #{value.inspect}"
+          end
+        end
+
+        if self.variants[param]
+          if value && !value.is_a?(Proc)
+            if value.is_a?(Array)
+              if (value - self.variants[param]).present?
+                raise Error, "#{value.inspect} should be within #{self.variants[param].inspect}"
+              end
+            elsif !self.variants[param].include?(value)
+              raise Error, "#{value.inspect} should be within #{self.variants[param].inspect}"
+            end
+          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} for param :#{param} value should be" unless options[param.to_sym] || defaults[param.to_sym]
+      end
+    end
+  end
+
+end

data/lib/eye/group.rb

@@ -0,0 +1,140 @@
+require 'celluloid'
+
+class Eye::Group
+  include Celluloid
+
+  autoload :Chain, 'eye/group/chain'
+
+  include Eye::Process::Scheduler
+  include Eye::Group::Chain
+
+  attr_reader :processes, :name, :hidden, :config
+
+  def initialize(name, config)
+    @name = name
+    @config = config
+    @processes = Eye::Utils::AliveArray.new
+    @hidden = (name == '__default__')
+    debug 'created'
+  end
+
+  def logger_tag
+    full_name
+  end
+
+  def app_name
+    @config[:application]
+  end
+
+  def full_name
+    @full_name ||= "#{app_name}:#{@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}"
+
+    case command
+      when :delete
+        delete *args
+      when :break_chain
+        break_chain *args
+      else
+        schedule command, *args, Eye::Reason::User.new(command)
+    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 break_chain
+    info 'break chain'
+    scheduler_clear_pending_list
+    @chain_breaker = true
+  end
+
+  def clear
+    @processes = Eye::Utils::AliveArray.new
+  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,81 @@
+module Eye::Group::Chain
+
+private
+
+  def chain_schedule(type, grace, command, *args)
+    info "starting #{type} with #{grace}s chain #{command} #{args}"
+
+    @chain_processes_count = @processes.size
+    @chain_processes_current = 0
+    @chain_breaker = false
+
+    started_at = Time.now
+
+    @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
+      break if @chain_breaker
+
+      # wait next process
+      sleep grace.to_f
+
+      break if @chain_breaker
+    end
+
+    debug "chain finished #{Time.now - started_at}s"
+
+    @chain_processes_count = nil
+    @chain_processes_current = nil
+  end
+
+  def chain_schedule_process(process, type, command, *args)
+    debug "chain_schedule_process #{process.name} #{type} #{command}"
+
+    if type == :sync
+      # sync command, with waiting
+      # this is very hackety, because call method of the process without its scheduler
+      # need to provide some scheduler future
+      process.last_scheduled_reason = self.last_scheduled_reason
+      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

data/lib/eye/loader.rb

@@ -0,0 +1,10 @@
+# add gems to $: by `gem` method
+#  this is only way when install eye as system wide
+
+gem 'celluloid',     '~> 0.15.0'
+gem 'celluloid-io',  '~> 0.15.0'
+gem 'nio4r'
+gem 'timers'
+
+gem 'state_machine'
+gem 'sigar',         '~> 0.7.2'

data/lib/eye/local.rb

@@ -0,0 +1,100 @@
+require 'fileutils'
+
+module Eye::Local
+  class << self
+    def dir
+      @dir ||= begin
+        if root?
+        '/var/run/eye'
+        else
+          File.expand_path(File.join(home, '.eye'))
+        end
+      end
+    end
+
+    def dir=(d)
+      @dir = d
+    end
+
+    def eyeconfig
+      if root?
+        '/etc/eye.conf'
+      else
+        File.expand_path(File.join(home, '.eyeconfig'))
+      end
+    end
+
+    def root?
+      Process::UID.eid == 0
+    end
+
+    def home
+      h = ENV['EYE_HOME'] || ENV['HOME']
+      raise "HOME undefined, should be HOME or EYE_HOME environment" unless h
+      h
+    end
+
+    def path(path)
+      File.join(dir, path)
+    end
+
+    def ensure_eye_dir
+      FileUtils.mkdir_p( dir )
+    end
+
+    def socket_path
+      path(ENV['EYE_SOCK'] || "sock#{ENV['EYE_V']}")
+    end
+
+    def pid_path
+      path(ENV['EYE_PID'] || "pid#{ENV['EYE_V']}")
+    end
+
+    def cache_path
+      path("processes#{ENV['EYE_V']}.cache")
+    end
+
+    def client_timeout
+      @client_timeout ||= 5
+    end
+
+    def client_timeout=(cl)
+      @client_timeout = cl
+    end
+
+    def supported_setsid?
+      RUBY_VERSION >= '2.0'
+    end
+
+    def host
+      @host ||= begin
+        require 'socket'
+        Socket.gethostname
+      end
+    end
+
+    def host=(hostname)
+      @host = hostname
+    end
+
+    def eyefile
+      @eyefile ||= find_eyefile('.')
+    end
+
+    def find_eyefile(start_from_dir)
+      fromenv = ENV['EYEFILE']
+      return fromenv if fromenv && !fromenv.empty? && File.exist?(fromenv)
+
+      previous = nil
+      current  = File.expand_path(start_from_dir)
+
+      until !File.directory?(current) || current == previous
+        filename = File.join(current, 'Eyefile')
+        return filename if File.file?(filename)
+        current, previous = File.expand_path('..', current), current
+      end
+    end
+
+    attr_accessor :local_runner
+  end
+end