corl 0.4.0 → 0.4.1

data/lib/corl_core/config/collection.rb

@@ -1,57 +0,0 @@
-
-module CORL
-class Config
-class Collection
-
-  #-----------------------------------------------------------------------------
-  # Property accessor / modifiers
-
-  @@properties = {}
-  
-  #---
-  
-  def self.all
-    return @@properties
-  end
-  
-  #---
-  
-  def self.get(name)
-    return @@properties[name.to_sym]
-  end
-  
-  #---
-  
-  def self.set(name, value)
-    @@properties[name.to_sym] = value
-  end
-  
-  #---
-  
-  def self.delete(name)
-    @@properties.delete(name.to_sym)
-  end
-   
-  #---
-  
-  def self.clear
-    @@properties = {}
-  end
-  
-  #---
-  
-  def self.save
-    log_options = Options.get(:corl_log)
-    
-    unless Util::Data.empty?(log_options[:config_log])
-      config_log = log_options[:config_log]
-      
-      if log_options[:config_store]
-        Util::Disk.write(config_log, MultiJson.dump(@@properties, :pretty => true))
-        Util::Disk.close(config_log)
-      end
-    end
-  end
-end
-end
-end

data/lib/corl_core/config/options.rb

@@ -1,70 +0,0 @@
-
-module CORL
-class Config
-class Options
-  
-  #-----------------------------------------------------------------------------
-  # Property accessors / modifiers
-  
-  @@options = {}
-  
-  #---
-  
-  def self.contexts(contexts = [], hierarchy = [])
-    contexts = [ 'all', contexts ].flatten
-    
-    unless hierarchy.is_a?(Array)
-      hierarchy = ( ! Util::Data.empty?(hierarchy) ? [ hierarchy ].flatten : [] )
-    end
-    
-    hierarchy.each do |group|  
-      group_contexts = Util::Data.prefix(group, contexts)
-      contexts       = [ contexts, group_contexts ].flatten
-    end
-    
-    return contexts
-  end
-  
-  #---
-  
-  def self.get(contexts, force = true)
-    options = {}
-    
-    unless contexts.is_a?(Array)
-      contexts = ( ! Util::Data.empty?(contexts) ? [ contexts ].flatten : [] )
-    end
-    contexts.each do |name|
-      name = name.to_sym
-      if @@options.has_key?(name)
-        options = Util::Data.merge([ options, @@options[name] ], force)
-      end
-    end
-    return options
-  end
-  
-  #---
-  
-  def self.set(contexts, options, force = true)
-    unless contexts.is_a?(Array)
-      contexts = ( ! Util::Data.empty?(contexts) ? [ contexts ].flatten : [] )
-    end
-    contexts.each do |name|
-      name = name.to_sym    
-      current_options = ( @@options.has_key?(name) ? @@options[name] : {} )
-      @@options[name] = Util::Data.merge([ current_options, Config.symbol_map(options) ], force)
-    end  
-  end
-  
-  #---
-  
-  def self.clear(contexts)
-    unless contexts.is_a?(Array)
-      contexts = [ contexts ]
-    end
-    contexts.each do |name|
-      @@options.delete(name.to_sym)
-    end
-  end
-end
-end
-end

data/lib/corl_core/core.rb

@@ -1,59 +0,0 @@
-
-module CORL
-class Core < Config
-  
-  #-----------------------------------------------------------------------------
-  # Properties
-  
-  @@ui = Util::Interface.new("core")
-  
-  #-----------------------------------------------------------------------------
-  # Constructor / Destructor
-  
-  def initialize(data = {}, defaults = {}, force = true)
-    super(data, defaults, force)   
-    
-    class_label      = self.class.to_s.downcase.gsub(/^corl::/, '')
-    logger_name      = delete(:logger, class_label)
-    interface_config = Config.new(export).defaults({ :logger => logger_name, :resource => class_label })
-    
-    @ui = Util::Interface.new(interface_config)
-    logger.debug("Initialized instance interface")
-  end
-  
-  #-----------------------------------------------------------------------------
-  # Accessor / Modifiers
-  
-  attr_accessor :ui
-  
-  #---
-  
-  def self.ui
-    return @@ui
-  end
-  
-  #---
-  
-  def self.logger
-    return @@ui.logger
-  end
-  
-  #--- 
-   
-  def logger
-    return @ui.logger
-  end
- 
-  #-----------------------------------------------------------------------------
-  # General utilities
-  
-  def ui_group(resource)
-    ui_resource = ui.resource
-    ui.resource = resource
-    yield
-    
-  ensure
-    ui.resource = ui_resource  
-  end 
-end
-end

data/lib/corl_core/corl.rb

@@ -1,254 +0,0 @@
-
-module CORL
- 
-  VERSION = File.read(File.join(File.dirname(__FILE__), '..', '..', 'VERSION'))
-  
-  #-----------------------------------------------------------------------------
-  
-  def self.ui
-    Core.ui
-  end
-  
-  #---
-  
-  def self.logger
-    Core.logger
-  end
-  
-  #---
-  
-  def self.add_log_levels(*levels)
-    Util::Interface.add_log_levels(levels)  
-  end
-  
-  def self.log_level
-    Util::Interface.log_level
-  end
-  
-  def self.log_level=log_level
-    Util::Interface.log_level = log_level
-  end
-  
-  #-----------------------------------------------------------------------------
-  
-  def self.admin?
-    is_admin  = ( ENV['USER'] == 'root' )
-    ext_admin = exec(:check_admin) do |op, results|
-      if op == :reduce
-        results.values.include?(true)
-      else
-        results ? true : false
-      end
-    end
-    is_admin || ext_admin ? true : false
-  end
-  
-  #-----------------------------------------------------------------------------
-  # Status codes
-  
-  @@codes = Codes.new
-  
-  def self.code
-    @@codes
-  end
-  
-  def self.codes(*codes)
-    Codes.codes(*codes)
-  end
-
-  #-----------------------------------------------------------------------------
-  # Initialization
-  
-  def self.initialize
-    current_time = Time.now
-    
-    Celluloid.logger = logger
-      
-    logger.info("Initializing the CORL plugin system at #{current_time}")
-    Config.set_property('time', current_time.to_i)
-    
-    connection = Manager.connection
-      
-    connection.define_type :extension     => nil,         # Core
-                           :configuration => :file,       # Core
-                           :action        => :update,     # Core
-                           :project       => :git,        # Core
-                           :network       => :default,    # Cluster
-                           :node          => :local,      # Cluster
-                           :machine       => :physical,   # Cluster
-                           :provisioner   => :puppetnode, # Cluster
-                           :command       => :shell,      # Cluster
-                           :event         => :regex,      # Utility
-                           :template      => :json,       # Utility
-                           :translator    => :json        # Utility
-                           
-    connection.load_plugins(true)
-                                  
-    logger.info("Finished initializing CORL plugin system at #{Time.now}")    
-  end
-  
-  #-----------------------------------------------------------------------------
-  # Core plugin interface
-  
-  def self.plugin_load(type, provider, options = {})
-    config = Config.ensure(options)
-    name   = config.get(:name, nil)
-    
-    logger.info("Fetching plugin #{type} provider #{provider} at #{Time.now}")
-    logger.debug("Plugin options: #{config.export.inspect}")
-    
-    connection = Manager.connection
-    
-    if name
-      logger.debug("Looking up existing instance of #{name}")
-      
-      existing_instance = connection.get(type, name)
-      logger.info("Using existing instance of #{type}, #{name}") if existing_instance
-    end
-    
-    return existing_instance if existing_instance
-    connection.create(type, provider, config.export)  
-  end
-  
-  #---
-  
-  def self.plugin(type, provider, options = {})
-    default_provider = Manager.connection.type_default(type)
-    
-    if options.is_a?(Hash) || options.is_a?(CORL::Config)
-      config   = Config.ensure(options)
-      provider = config.get(:provider, provider)
-      options  = config.export
-    end
-    provider = default_provider unless provider # Sanity checking (see plugins)
-    
-    plugin_load(type, provider, options)
-  end
-  
-  #---
-  
-  def self.plugins(type, data, build_hash = false, keep_array = false)
-    logger.info("Fetching multiple plugins of #{type} at #{Time.now}")
-    
-    group = ( build_hash ? {} : [] )
-    klass = class_const([ 'CORL', :plugin, type ])    
-    data  = klass.build_info(type, data) if klass.respond_to?(:build_info)
-    
-    logger.debug("Translated plugin data: #{data.inspect}")
-    
-    data.each do |options|
-      if plugin = plugin(type, options[:provider], options)
-        if build_hash
-          group[plugin.plugin_name] = plugin
-        else
-          group << plugin
-        end
-      end
-    end
-    return group.shift if ! build_hash && group.length == 1 && ! keep_array
-    group  
-  end
-  
-  #---
-  
-  def self.get_plugin(type, name)
-    Manager.connection.get(type, name)
-  end
-  
-  #---
-  
-  def self.remove_plugin(plugin)
-    Manager.connection.remove(plugin)
-  end
-
-  #-----------------------------------------------------------------------------
-  # Plugin extensions
-   
-  def self.exec(method, options = {})
-    Manager.connection.exec(method, options) do |op, data|
-      data = yield(op, data) if block_given?
-      data
-    end
-  end
-  
-  #---
-  
-  def self.config(type, options = {})
-    Manager.connection.config(method, options)
-  end
-  
-  #---
-  
-  def self.check(method, options = {})
-    Manager.connection.check(method, options)
-  end
-  
-  #---
-  
-  def self.value(method, value, options = {})
-    Manager.connection.value(method, value, options)
-  end
-       
-  #-----------------------------------------------------------------------------
-  # External execution
-   
-  def self.run
-    begin
-      logger.debug("Running contained process at #{Time.now}")
-      yield
-      
-    rescue Exception => error
-      logger.error("CORL run experienced an error! Details:")
-      logger.error(error.inspect)
-      logger.error(error.message)
-      logger.error(Util::Data.to_yaml(error.backtrace))
-  
-      ui.error(error.message) if error.message
-      raise
-    end
-  end
-  
-  #-----------------------------------------------------------------------------
-  # Utilities
-  
-  def self.class_name(name, separator = '::', want_array = FALSE)
-    components = []
-    
-    case name
-    when String, Symbol
-      components = name.to_s.split(separator)
-    when Array
-      components = name 
-    end
-    
-    components.collect! do |value|
-      next value if value.to_s == 'CORL'
-      value.to_s.strip.capitalize  
-    end
-    
-    if want_array
-      return components
-    end    
-    components.join(separator)
-  end
-  
-  #---
-  
-  def self.class_const(name, separator = '::')
-    components = class_name(name, separator, TRUE)
-    constant   = Object
-    
-    components.each do |component|
-      constant = constant.const_defined?(component) ? 
-                  constant.const_get(component) : 
-                  constant.const_missing(component)
-    end
-    constant
-  end
-  
-  #---
-  
-  def self.sha1(data)
-    Digest::SHA1.hexdigest(Util::Data.to_json(data, false))
-  end  
-end

data/lib/corl_core/errors.rb

@@ -1,84 +0,0 @@
-
-module CORL
-module Errors
-  
-  #-----------------------------------------------------------------------------
-  # Base error (based on VagrantError)
-  
-  class CORLError < StandardError
-    
-    #---------------------------------------------------------------------------
-    # Error constructor / destructor
-    
-    def initialize(*args)
-      key     = args.shift if args.first.is_a?(Symbol)
-      message = args.shift if args.first.is_a?(Hash)
-      message ||= {}
-      
-      @extra_data = message.dup
-      
-      message[:key]       ||= error_key
-      message[:namespace] ||= error_namespace
-      message[:key]       = key if key
-
-      if message[:key]
-        message = translate_error(message)
-      else
-        message = error_message
-      end
-
-      super(message)
-    end
-
-    #---------------------------------------------------------------------------
-    # Property accessor / modifiers
-    
-    attr_accessor :extra_data
-    
-    #---
-
-    def self.error_key(key = nil, namespace = nil)
-      define_method(:error_key) { key }
-      error_namespace(namespace) if namespace
-    end
-    def error_key; nil; end # Default
-    
-    #---
-
-    def self.error_message(message)
-      define_method(:error_message) { message }
-    end
-    def error_message; "No error message"; end # Default
-    
-    #---
-
-    def self.error_namespace(namespace)
-      define_method(:error_namespace) { namespace }
-    end
-    def error_namespace; "corl.errors"; end # Default
-    
-    #---
-    
-    def self.status_code(code)
-      define_method(:status_code) { code }
-    end
-    def status_code; 1; end # Default
-    
-    #---------------------------------------------------------------------------
-    # Utilities
-
-    def translate_error(options)
-      return nil unless options[:key]
-      I18n.t("#{options[:namespace]}.#{options[:key]}", options)
-    end
-    protected :translate_error
-  end
-  
-  #-----------------------------------------------------------------------------
-  # Specialized errors
-
-  class BatchError < CORLError
-    error_key(:batch_error)
-  end
-end
-end