ace-eye 0.6.1

data/lib/eye/dsl.rb

@@ -0,0 +1,53 @@
+require_relative 'dsl/helpers'
+
+Eye::BINDING = binding
+
+class Eye::Dsl
+
+  autoload :Main,                 'eye/dsl/main'
+  autoload :ApplicationOpts,      'eye/dsl/application_opts'
+  autoload :GroupOpts,            'eye/dsl/group_opts'
+  autoload :ProcessOpts,          'eye/dsl/process_opts'
+  autoload :ChildProcessOpts,     'eye/dsl/child_process_opts'
+  autoload :Opts,                 'eye/dsl/opts'
+  autoload :PureOpts,             'eye/dsl/pure_opts'
+  autoload :Chain,                'eye/dsl/chain'
+  autoload :ConfigOpts,           'eye/dsl/config_opts'
+  autoload :Validation,           'eye/dsl/validation'
+
+  class Error < Exception; end
+
+  class << self
+    attr_accessor :verbose
+
+    def debug(msg = '')
+      puts msg if verbose
+    end
+
+    def parse(content = nil, filename = nil)
+      Eye.parsed_config = Eye::Config.new
+      Eye.parsed_filename = filename
+      Eye.parsed_default_app = nil
+
+      content = File.read(filename) if content.blank?
+
+      silence_warnings do
+        Kernel.eval(content, Eye::BINDING, filename.to_s)
+      end
+
+      Eye.parsed_config.validate!(false)
+      Eye.parsed_config
+    end
+
+    def parse_apps(*args)
+      parse(*args).applications
+    end
+
+    def check_name(name)
+      raise Error, "':' is not allowed in name '#{name}'" if name.to_s.include?(':')
+    end
+  end
+end
+
+# extend here global module
+Eye.send(:extend, Eye::Dsl::Main)

data/lib/eye/dsl/application_opts.rb

@@ -0,0 +1,39 @@
+class Eye::Dsl::ApplicationOpts < Eye::Dsl::Opts
+
+  include Eye::Dsl::Chain
+
+  def disallow_options
+    [:pid_file, :start_command, :daemonize]
+  end
+
+  def not_seed_options
+    [:groups]
+  end
+
+  def group(name, &block)
+    Eye::Dsl.check_name(name)
+    Eye::Dsl.debug "=> group #{name}"
+
+    opts = Eye::Dsl::GroupOpts.new(name, self)
+    opts.instance_eval(&block)
+
+    @config[:groups] ||= {}
+    @config[:groups][name.to_s] ||= {}
+
+    if cfg = opts.config
+      Eye::Utils.deep_merge!(@config[:groups][name.to_s], cfg)
+    end
+
+    Eye::Dsl.debug "<= group #{name}"
+    opts
+  end
+
+  def process(name, &block)
+    res = nil
+    group('__default__'){ res = process(name.to_s, &block) }
+    res
+  end
+
+  alias xgroup nop
+  alias xprocess nop
+end

data/lib/eye/dsl/chain.rb

@@ -0,0 +1,12 @@
+module Eye::Dsl::Chain
+
+  def chain(opts = {})
+    acts = Array(opts[:action] || opts[:actions] || [:start, :restart])
+
+    acts.each do |act|
+      @config[:chain] ||= {}
+      @config[:chain][act] = opts.merge(:action => act)
+    end
+  end
+
+end

data/lib/eye/dsl/child_process_opts.rb

@@ -0,0 +1,13 @@
+class Eye::Dsl::ChildProcessOpts < Eye::Dsl::Opts
+
+  def allow_options
+    [:stop_command, :restart_command, :children_update_period,
+      :stop_signals, :stop_grace, :stop_timeout, :restart_timeout]
+  end
+
+  def triggers(*args)
+    raise Eye::Dsl::Error, 'triggers not allowed in monitor_children'
+  end
+  alias trigger triggers
+
+end

data/lib/eye/dsl/config_opts.rb

@@ -0,0 +1,55 @@
+class Eye::Dsl::ConfigOpts < Eye::Dsl::PureOpts
+
+  create_options_methods([:logger_level], Fixnum)
+  create_options_methods([:http], Hash)
+
+  def logger(*args)
+    if args.empty?
+      @config[:logger]
+    else
+      str = args[0]
+      raise Eye::Dsl::Error, "logger should be a String #{str.inspect}" if !(str.is_a?(String) || str == nil)
+      @config[:logger] = args
+    end
+  end
+  alias logger= logger
+
+  # ==== contact options ==============================
+  def self.add_notify(type)
+    create_options_methods([type], Hash)
+
+    define_method("set_#{type}") do |value|
+      value = value.merge(:type => type)
+      super(value)
+      Eye::Notify.validate!(value)
+    end
+  end
+
+  Eye::Notify::TYPES.keys.each { |name| add_notify(name) }
+
+  def contact(contact_name, contact_type, contact, contact_opts = {})
+    raise Eye::Dsl::Error, "unknown contact_type #{contact_type}" unless Eye::Notify::TYPES[contact_type]
+    raise Eye::Dsl::Error, 'contact should be a String' unless contact.is_a?(String)
+
+    notify_hash = @config[contact_type] || (@parent && @parent.config[contact_type]) || Eye::parsed_config.settings[contact_type] || {}
+    validate_hash = notify_hash.merge(contact_opts).merge(:type => contact_type)
+
+    Eye::Notify.validate!(validate_hash)
+
+    @config[:contacts] ||= {}
+    @config[:contacts][contact_name.to_s] = {name: contact_name.to_s, type: contact_type,
+      contact: contact, opts: contact_opts}
+  end
+
+  def contact_group(contact_group_name, &block)
+    c = Eye::Dsl::ConfigOpts.new nil, self, false
+    c.instance_eval(&block)
+    cfg = c.config
+    @config[:contacts] ||= {}
+    if cfg[:contacts].present?
+      @config[:contacts][contact_group_name.to_s] = cfg[:contacts].values
+      @config[:contacts].merge!(cfg[:contacts])
+    end
+  end
+
+end

data/lib/eye/dsl/group_opts.rb

@@ -0,0 +1,32 @@
+class Eye::Dsl::GroupOpts < Eye::Dsl::Opts
+
+  include Eye::Dsl::Chain
+
+  def disallow_options
+    [:pid_file, :start_command, :daemonize]
+  end
+
+  def not_seed_options
+    [:processes, :chain]
+  end
+
+  def process(name, &block)
+    Eye::Dsl.check_name(name)
+
+    Eye::Dsl.debug "=> process #{name}"
+
+    opts = Eye::Dsl::ProcessOpts.new(name, self)
+    opts.instance_eval(&block)
+    @config[:processes] ||= {}
+    @config[:processes][name.to_s] ||= {}
+    Eye::Utils.deep_merge!(@config[:processes][name.to_s], opts.config) if opts.config
+
+    Eye::Dsl.debug "<= process #{name}"
+    opts
+  end
+
+  alias xprocess nop
+  alias application parent
+  alias app application
+
+end

data/lib/eye/dsl/helpers.rb

@@ -0,0 +1,20 @@
+
+# Dsl Helpers
+
+# current eye parsed config path
+def current_config_path
+  Eye.parsed_filename && File.symlink?(Eye.parsed_filename) ? File.readlink(Eye.parsed_filename) : Eye.parsed_filename
+end
+
+# host name
+def hostname
+  Eye::Local.host
+end
+
+def example_process(proxy, name)
+  proxy.process(name) do
+    pid_file "/tmp/#{name}.pid"
+    start_command "sleep 100"
+    daemonize true
+  end
+end

data/lib/eye/dsl/main.rb

@@ -0,0 +1,51 @@
+module Eye::Dsl::Main
+  attr_accessor :parsed_config, :parsed_filename, :parsed_default_app
+
+  def application(name, &block)
+    Eye::Dsl.check_name(name)
+    name = name.to_s
+
+    Eye::Dsl.debug "=> app: #{name}"
+
+    if name == '__default__'
+      @parsed_default_app ||= Eye::Dsl::ApplicationOpts.new(name)
+      @parsed_default_app.instance_eval(&block)
+    else
+      opts = Eye::Dsl::ApplicationOpts.new(name, @parsed_default_app)
+      opts.instance_eval(&block)
+      @parsed_config.applications[name] = opts.config if opts.config
+    end
+
+    Eye::Dsl.debug "<= app: #{name}"
+  end
+
+  alias project application
+  alias app application
+
+  def load(glob = '')
+    return if glob.blank?
+
+    Eye::Dsl::Opts.with_parsed_file(glob) do |mask|
+      Dir[mask].each do |path|
+        Eye::Dsl.debug "=> load #{path}"
+        Eye.parsed_filename = path
+        res = Kernel.load(path)
+        Eye.info "load: subload #{path} (#{res})"
+        Eye::Dsl.debug "<= load #{path}"
+      end
+    end
+  end
+
+  def config(&block)
+    Eye::Dsl.debug '=> config'
+
+    opts = Eye::Dsl::ConfigOpts.new
+    opts.instance_eval(&block)
+    Eye::Utils.deep_merge!(@parsed_config.settings, opts.config)
+
+    Eye::Dsl.debug '<= config'
+  end
+
+  alias settings config
+
+end

data/lib/eye/dsl/opts.rb

@@ -0,0 +1,151 @@
+class Eye::Dsl::Opts < Eye::Dsl::PureOpts
+
+  STR_OPTIONS = [ :pid_file, :working_dir, :stdout, :stderr, :stdall, :stdin, :start_command,
+    :stop_command, :restart_command, :uid, :gid ]
+  create_options_methods(STR_OPTIONS, String)
+
+  BOOL_OPTIONS = [ :daemonize, :keep_alive, :auto_start, :stop_on_delete, :clear_pid, :preserve_fds, :use_leaf_child, :clear_env ]
+  create_options_methods(BOOL_OPTIONS, [TrueClass, FalseClass])
+
+  INTERVAL_OPTIONS = [ :check_alive_period, :start_timeout, :restart_timeout, :stop_timeout, :start_grace,
+    :restart_grace, :stop_grace, :children_update_period, :restore_in,
+    :auto_update_pidfile_grace, :revert_fuckup_pidfile_grace ]
+  create_options_methods(INTERVAL_OPTIONS, [Fixnum, Float])
+
+  create_options_methods([:environment], Hash)
+  create_options_methods([:stop_signals], Array)
+  create_options_methods([:umask], Fixnum)
+
+
+  def initialize(name = nil, parent = nil)
+    super(name, parent)
+
+    @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__' && parent.respond_to?(:full_name)
+  end
+
+  def checks(type, opts = {})
+    nac = Eye::Checker.name_and_class(type.to_sym)
+    raise Eye::Dsl::Error, "unknown checker type #{type}" unless nac
+
+    opts.merge!(:type => nac[:type])
+    Eye::Checker.validate!(opts)
+
+    @config[:checks] ||= {}
+    @config[:checks][nac[:name]] = opts
+  end
+
+  def triggers(type, opts = {})
+    nac = Eye::Trigger.name_and_class(type.to_sym)
+    raise Eye::Dsl::Error, "unknown trigger type #{type}" unless nac
+
+    opts.merge!(:type => nac[:type])
+    Eye::Trigger.validate!(opts)
+
+    @config[:triggers] ||= {}
+    @config[:triggers][nac[:name]] = opts
+  end
+
+  # clear checks from parent
+  def nochecks(type)
+    nac = Eye::Checker.name_and_class(type.to_sym)
+    raise Eye::Dsl::Error, "unknown checker type #{type}" unless nac
+    @config[:checks].try :delete, nac[:name]
+  end
+
+  # clear triggers from parent
+  def notriggers(type)
+    nac = Eye::Trigger.name_and_class(type.to_sym)
+    raise Eye::Dsl::Error, "unknown trigger type #{type}" unless nac
+    @config[:triggers].try :delete, nac[:name]
+  end
+
+  alias check checks
+  alias nocheck nochecks
+  alias trigger triggers
+  alias notrigger notriggers
+
+  def notify(contact, level = :warn)
+    unless Eye::Process::Notify::LEVELS[level]
+      raise Eye::Dsl::Error, "level should be in #{Eye::Process::Notify::LEVELS.keys}"
+    end
+
+    @config[:notify] ||= {}
+    @config[:notify][contact.to_s] = level
+  end
+
+  def nonotify(contact)
+    @config[:notify] ||= {}
+    @config[:notify].delete(contact.to_s)
+  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 dir working_dir
+  alias env environment
+
+  def set_stdall(value)
+    super
+
+    set_stdout value
+    set_stderr value
+  end
+
+  def set_uid(value)
+    raise Eye::Dsl::Error, ':uid not supported (use ruby >= 2.0)' unless Eye::Local.supported_setsid?
+    super
+  end
+
+  def set_gid(value)
+    raise Eye::Dsl::Error, ':gid not supported (use ruby >= 2.0)' unless Eye::Local.supported_setsid?
+    super
+  end
+
+  def daemonize!
+    set_daemonize true
+  end
+
+  def clear_bundler_env
+    env('GEM_PATH' => nil, 'GEM_HOME' => nil, 'RUBYOPT' => nil, 'BUNDLE_BIN_PATH' => nil, 'BUNDLE_GEMFILE' => nil)
+  end
+
+  def scoped(&block)
+    h = self.class.new(self.name, self)
+    h.instance_eval(&block)
+    Eye::Utils.deep_merge!(config, h.config, [:groups, :processes])
+  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::Local.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
+
+    scoped do
+      with_condition(on_server, &block)
+    end
+
+    on_server
+  end
+
+end

data/lib/eye/dsl/process_opts.rb

@@ -0,0 +1,36 @@
+class Eye::Dsl::ProcessOpts < Eye::Dsl::Opts
+
+  def monitor_children(&block)
+    opts = Eye::Dsl::ChildProcessOpts.new
+    opts.instance_eval(&block) if block
+    @config[:monitor_children] ||= {}
+    Eye::Utils.deep_merge!(@config[:monitor_children], opts.config)
+  end
+
+  alias xmonitor_children nop
+
+  def application
+    parent.try(:parent)
+  end
+  alias app application
+  alias group parent
+
+  def depend_on(names, opts = {})
+    names = Array(names).map(&:to_s)
+    trigger("wait_dependency_#{unique_num}", {:names => names}.merge(opts))
+    nm = @config[:name]
+    names.each do |name|
+      parent.process(name) do
+        trigger("check_dependency_#{unique_num}", :names => [ nm ] )
+      end
+    end
+  end
+
+private
+
+  def unique_num
+    $unique_num ||= 0
+    $unique_num += 1
+  end
+
+end