reel-eye 0.3.1

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,110 @@
+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
+      @config = merge_parent_config ? Eye::Utils::deep_clone(parent.config) : {}
+      @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 with_condition(cond = true, &block)
+    self.instance_eval(&block) if cond && block
+  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
+
+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,59 @@
+module Eye::Dsl::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
+    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
+    defaults[param] = default
+    variants[param] = _variants
+
+    define_method "#{param}" do
+      @options[param.to_sym] || default
+    end
+  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) && !self.variants[param].include?(value)
+          raise Error, "#{value.inspect} should within #{self.variants[param].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} for param :#{param} value should be" unless options[param.to_sym] || defaults[param.to_sym]
+    end
+  end
+
+end

data/lib/eye/group.rb

@@ -0,0 +1,134 @@
+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}"
+
+    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 "start #{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/http.rb

@@ -0,0 +1,31 @@
+require 'reel'
+
+class Eye::Http
+  autoload :Router,   'eye/http/router'
+
+  attr_reader :server, :host, :port
+
+  def initialize(host, port)
+    @host = host
+    @port = port.to_i
+    @router = Router
+  end
+
+  def start
+    stop 
+
+    @server = Reel::Server.supervise(@host, @port) do |connection|
+      while request = connection.request
+        status, headers, body = @router.call(Rack::MockRequest.env_for(request.url, :method => request.method, :input => request.body))
+        connection.respond(Reel::Response.new(status, headers, body))
+      end
+    end
+  end
+
+  def stop
+    if @server
+      @server.terminate
+      @server = nil
+    end
+  end
+end

data/lib/eye/http/router.rb

@@ -0,0 +1,25 @@
+require 'cuba'
+require 'json'
+
+Eye::Http::Router = Cuba.new do
+
+  def json(result)
+    res.headers['Content-Type'] = 'application/json; charset=utf-8'
+    res.write({ result: result }.to_json)
+  end
+
+  on root do
+    res.write Eye::ABOUT
+  end
+  
+  on "api/info", param("filter") do |filter|
+    json Eye::Control.command(:raw_info, filter)
+  end
+  
+  [:start, :stop, :restart, :delete, :unmonitor, :monitor].each do |act|
+    on put, "api/#{act}", param("filter") do |filter|
+      json Eye::Control.command(act, filter)
+    end
+  end
+
+end