corl 0.4.0

data/lib/corl_core/config.rb

@@ -0,0 +1,337 @@
+
+module CORL
+class Config
+  
+  #-----------------------------------------------------------------------------
+  # Global interface
+
+  extend Mixin::ConfigOptions
+  extend Mixin::ConfigCollection
+  extend Mixin::Lookup
+  
+  #-----------------------------------------------------------------------------
+  # Instance generators
+  
+  def self.ensure(config)
+    case config
+    when CORL::Config
+      return config
+    when Hash
+      return new(config) 
+    end
+    return new
+  end
+  
+  #---
+  
+  def self.init(options, contexts = [], hierarchy = [], defaults = {})
+    contexts = contexts(contexts, hierarchy)
+    config   = new(get_options(contexts), defaults)
+    config.import(options) unless Util::Data.empty?(options)
+    return config
+  end
+  
+  #---
+  
+  def self.init_flat(options, contexts = [], defaults = {})
+    return init(options, contexts, [], defaults)
+  end
+   
+  #-----------------------------------------------------------------------------
+  # Constructor / Destructor
+   
+  def initialize(data = {}, defaults = {}, force = true)
+    @force      = force
+    @properties = {}
+    
+    if defaults.is_a?(Hash) && ! defaults.empty?
+      defaults = symbol_map(defaults)
+    end
+    
+    case data
+    when CORL::Config
+      @properties = Util::Data.merge([ defaults, data.export ], force)
+    when Hash
+      @properties = {}
+      if data.is_a?(Hash)
+        @properties = Util::Data.merge([ defaults, symbol_map(data) ], force)
+      end  
+    end
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Checks
+  
+  def has_key?(keys)
+    get(keys) ? true : false
+  end
+      
+  #-----------------------------------------------------------------------------
+  # Property accessors / modifiers
+  
+  def keys
+    @properties.keys
+  end
+  
+  #---
+    
+  def fetch(data, keys, default = nil, format = false)    
+    if keys.is_a?(String) || keys.is_a?(Symbol)
+      keys = [ keys ]
+    end    
+    key = keys.shift.to_sym
+    
+    if data.has_key?(key)
+      value = data[key]
+      
+      if keys.empty?
+        return filter(value, format)
+      else
+        return fetch(data[key], keys, default, format)  
+      end
+    end
+    return filter(default, format)
+  end
+  protected :fetch
+  
+  #---
+  
+  def modify(data, keys, value = nil) 
+    if keys.is_a?(String) || keys.is_a?(Symbol)
+      keys = [ keys ]
+    end
+        
+    key      = keys.shift.to_sym
+    has_key  = data.has_key?(key)
+    existing = { 
+      :key   => key, 
+      :value => ( has_key ? data[key] : nil ) 
+    }
+    
+    if keys.empty?      
+      existing[:value] = data[key] if has_key
+      
+      if value.nil?
+        data.delete(key) if has_key
+      else
+        data[key] = value
+      end
+    else      
+      data[key] = {} unless has_key
+      existing  = modify(data[key], keys, value)  
+    end
+    
+    return existing
+  end
+  protected :modify
+  
+  #---
+  
+  def get(keys, default = nil, format = false)
+    return fetch(@properties, array(keys).flatten, default, format)
+  end
+
+  #---
+ 
+  def [](name, default = nil, format = false)
+    get(name, default, format)
+  end
+  
+  #---
+  
+  def get_array(keys, default = [])
+    return get(keys, default, :array)
+  end
+  
+  #---
+  
+  def get_hash(keys, default = {})
+    return get(keys, default, :hash)
+  end
+  
+  #---
+  
+  def init(keys, default = nil)
+    return set(keys, get(keys, default))
+  end
+
+  #---
+  
+  def set(keys, value)
+    modify(@properties, array(keys).flatten, value)
+    return self
+  end
+  
+  #---
+  
+  def []=(name, value)
+    set(name, value)
+  end
+   
+  #---
+  
+  def delete(keys, default = nil)
+    existing = modify(@properties, array(keys).flatten, nil)
+    return existing[:value] if existing[:value]
+    return default
+  end
+  
+  #---
+  
+  def clear
+    @properties = {}
+    return self
+  end
+
+  #-----------------------------------------------------------------------------
+  # Import / Export
+ 
+  def import_base(properties, options = {})
+    config      = Config.new(options, { :force => @force }).set(:context, :hash)    
+    import_type = config.get(:import_type, :override)
+    
+    properties  = properties.export if properties.is_a?(CORL::Config)
+    
+    case properties
+    when Hash
+      data = [ @properties, symbol_map(properties) ]
+      data = data.reverse if import_type != :override
+      
+      @properties = Util::Data.merge(data, config)
+    
+    when String, Symbol
+      properties = self.class.lookup(properties.to_s, {}, config)
+      
+      data = [ @properties, symbol_map(properties) ]
+      data = data.reverse if import_type != :override
+    
+      @properties = Util::Data.merge(data, config)
+     
+    when Array
+      properties.each do |item|
+        import_base(item, config)
+      end
+    end
+    
+    return self
+  end
+  protected :import_base
+  
+  #---
+  
+  def import(properties, options = {})
+    return import_base(properties, options)
+  end
+  
+  #---
+  
+  def defaults(defaults, options = {})
+    config = Config.new(options).set(:import_type, :default)
+    return import_base(defaults, config)
+  end
+
+  #---
+  
+  def export
+    return @properties
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Utilities
+
+  def self.symbol_map(data)
+    return Util::Data.symbol_map(data)
+  end
+  
+  #---
+  
+  def symbol_map(data)
+    return self.class.symbol_map(data)
+  end
+  
+  #---
+  
+  def self.string_map(data)
+    return Util::Data.string_map(data)
+  end
+  
+  #---
+  
+  def string_map(data)
+    return self.class.string_map(data)
+  end
+  
+  #-----------------------------------------------------------------------------
+      
+  def self.filter(data, method = false)
+    return Util::Data.filter(data, method)
+  end
+  
+  #---
+  
+  def filter(data, method = false)
+    return self.class.filter(data, method)
+  end
+    
+  #-----------------------------------------------------------------------------
+          
+  def self.array(data, default = [], split_string = false)
+    return Util::Data.array(data, default, split_string)
+  end
+  
+  #---
+  
+  def array(data, default = [], split_string = false)
+    return self.class.array(data, default, split_string)
+  end
+    
+  #---
+        
+  def self.hash(data, default = {})
+    data = data.export if data.is_a?(CORL::Config)
+    return Util::Data.hash(data, default)
+  end
+  
+  #---
+  
+  def hash(data, default = {})
+    return self.class.hash(data, default)
+  end
+    
+  #---
+         
+  def self.string(data, default = '')
+    return Util::Data.string(data, default)
+  end
+  
+  #---
+  
+  def string(data, default = '')
+    return self.class.string(data, default)
+  end
+    
+  #---
+         
+  def self.symbol(data, default = :undefined)
+    return Util::Data.symbol(data, default)
+  end
+  
+  #---
+  
+  def symbol(data, default = :undefined)
+    return self.class.symbol(data, default)
+  end
+     
+  #---
+    
+  def self.test(data)
+    return Util::Data.test(data)
+  end
+  
+  #---
+  
+  def test(data)
+    return self.class.test(data)
+  end  
+end
+end

data/lib/corl_core/core.rb

@@ -0,0 +1,59 @@
+
+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

@@ -0,0 +1,254 @@
+
+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

@@ -0,0 +1,84 @@
+
+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