coral_core 0.2.26 → 0.2.30

data/lib/coral_core/mixin/settings.rb

@@ -0,0 +1,46 @@
+
+# Should be included via include
+#
+# include Mixin::Settings
+#
+
+module Coral
+module Mixin
+module Settings
+  
+  def settings(name)
+    return get_hash([ :settings, name ])
+  end
+    
+  #---
+
+  def set_settings(name, settings = {})
+    return set([ :settings, name ], settings)
+  end
+    
+  #---
+
+  def delete_settings(name)
+    return delete([ :settings, name ])
+  end
+    
+  #---
+   
+  def setting(name, key, default = '', format = false)
+    return get([ :settings, name, key ], default, format)
+  end
+     
+  #---
+
+  def set_setting(name, key, value = '')
+    return set([ :settings, name, key ], value)
+  end
+     
+  #---
+
+  def delete_setting(name, key)
+    return delete([ :settings, name, key ])
+  end
+end
+end
+end

data/lib/coral_core/mixin/sub_config.rb

@@ -0,0 +1,208 @@
+
+# Should be included via include
+#
+# include Mixin::SubConfig
+#
+
+module Coral
+module Mixin
+module SubConfig
+  
+  #-----------------------------------------------------------------------------
+  # Initialization
+  
+  def init_subconfig(reset = false)
+    return if @subconfig_initialized && ! reset
+    
+    unless @config
+      @config = Config.new
+    end
+    
+    @subconfig_initialized = true
+  end
+  protected :init_subconfig
+  
+  #-----------------------------------------------------------------------------
+  # Propety accessors / modifiers
+  
+  def name
+    return _get(:name)
+  end
+  
+  #---
+  
+  def name=name
+    _set(:name, string(name))
+  end
+  
+  #---
+  
+  def config
+    return @config
+  end
+  
+  #---
+  
+  def config=config
+    @config = config
+  end
+  
+  #---
+  
+  def directory
+    init_subconfig
+    
+    if config.is_a?(Config::Project)
+      return config.project.directory
+    else
+      return nil
+    end
+  end
+  
+  #---
+  
+  def directory=directory
+    init_subconfig
+    
+    if config.is_a?(Config::Project)
+      config.set_location(directory)
+    end
+  end
+     
+  #-----------------------------------------------------------------------------
+
+  def _get(keys, default = nil, format = false)
+    return fetch(@properties, array(keys).flatten, default, format)
+  end
+  protected :_get
+  
+  #---
+  
+  def get(keys, default = nil, format = false)
+    init_subconfig
+    return config.get(keys, default, format)
+  end
+  
+  #---
+  
+  def _init(keys, default = nil)
+    return _set(keys, _get(keys, default))
+  end
+  protected :_init
+
+  #---
+ 
+  def _set(keys, value = '')
+    modify(@properties, array(keys).flatten, value)
+    return self
+  end
+  protected :_set
+  
+  #---
+    
+  def set(keys, value = '')
+    init_subconfig
+    config.set(keys, value)
+    return self
+  end
+  
+  #---
+ 
+  def _delete(keys, default = nil)
+    existing = modify(@properties, array(keys).flatten, nil)
+    return existing[:value] if existing[:value]
+    return default 
+  end
+  protected :_delete
+  
+  #---
+   
+  def delete(keys, default = nil)
+    init_subconfig
+    config.delete(keys, default)
+    return self
+  end
+ 
+  #---
+ 
+  def _clear
+    @properties = {}
+    return self
+  end
+  protected :_clear
+  
+  #---
+  
+  def clear
+    init_subconfig
+    config.clear
+    return self
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Import / Export
+  
+  def _import(properties, options = {})
+    return import_base(properties, options)
+  end
+  protected :_import
+  
+  #---
+  
+  def import(properties, options = {})
+    init_subconfig
+    config.import(properties, options)
+    return self
+  end
+  
+  #---
+  
+  def _defaults(defaults, options = {})
+    config = new(options).set(:import_type, :default)
+    return import_base(defaults, config)
+  end
+  protected :_defaults
+  
+  #---
+  
+  def defaults(defaults, options = {})
+    init_subconfig
+    config.defaults(defaults, options)
+    return self
+  end
+  
+  #---
+  
+  def _export
+    return @properties
+  end
+  protected :_export
+  
+  #---
+  
+  def export
+    init_subconfig
+    return config.export
+  end
+      
+  #-----------------------------------------------------------------------------
+  # Configuration loading saving
+    
+  def load(options = {})
+    if config.respond_to?(:load)
+      config.load(options)
+    end
+    return self  
+  end
+    
+  #---
+    
+  def save(options = {})
+    if config.respond_to?(:save)
+      config.save(options)
+    end
+    return self  
+  end  
+end
+end
+end

data/lib/coral_core/mod/hash.rb

@@ -0,0 +1,29 @@
+
+#-------------------------------------------------------------------------------
+# Hash data type alterations
+
+class Hash
+  def search(search_key, options = {})
+    config = Coral::Config.ensure(options)
+    value  = nil
+    
+    recurse       = config.get(:recurse, false)
+    recurse_level = config.get(:recurse_level, -1)
+        
+    self.each do |key, data|
+      if key == search_key
+        value = data
+        
+      elsif data.is_a?(Hash) && 
+        recurse && (recurse_level == -1 || recurse_level > 0)
+        
+        recurse_level -= 1 unless recurse_level == -1
+        value = value.search(search_key, 
+          Coral::Config.new(config).set(:recurse_level, recurse_level)
+        )
+      end
+      break unless value.nil?
+    end
+    return value
+  end
+end

data/lib/coral_core/plugin.rb

@@ -0,0 +1,261 @@
+
+module Coral
+module Plugin
+ 
+  #-----------------------------------------------------------------------------
+  # Plugin instances
+  
+  @@load_info = {}
+  @@types     = {}
+  @@plugins   = {}
+  
+  #---
+
+  @@gems = {}
+  @@core = nil
+  
+  #---
+  
+  def self.create_instance(type, provider, options = {})
+    type     = type.to_sym
+    provider = provider.to_sym
+       
+    return nil unless @@types.has_key?(type)
+    
+    options  = translate_type(type, options)
+    provider = options.delete(:provider).to_sym if options.has_key?(:provider)    
+    info     = @@load_info[type][provider] if Util::Data.exists?(@@load_info, [ type, provider ])
+        
+    if info
+      options       = translate(type, provider, options)      
+      instance_name = "#{provider}_" + Coral.sha1(options)
+      
+      @@plugins[type] = {} unless @@plugins.has_key?(type)
+      
+      unless instance_name && @@plugins[type].has_key?(instance_name)
+        info[:instance_name] = instance_name
+        options[:meta]       = info
+        
+        plugin = Coral.class_const([ :coral, type, provider ]).new(type, provider, options)
+        
+        @@plugins[type][instance_name] = plugin 
+      end
+           
+      return @@plugins[type][instance_name]
+    end      
+    return nil
+  end
+  
+  #---
+  
+  def self.get_instance(type, name)
+    if @@plugins.has_key?(type)
+      @@plugins[type].each do |instance_name, plugin|
+        return plugin if plugin.name.to_s == name.to_s
+      end
+    end
+    return nil  
+  end
+  
+  #---
+  
+  def self.remove_instance(plugin)
+    if plugin && plugin.is_a?(Plugin::Base) && @@plugins.has_key?(plugin.plugin_type)
+      @@plugins[plugin.plugin_type].delete(plugin.plugin_instance_name)
+    end
+  end
+ 
+  #-----------------------------------------------------------------------------
+  # Plugins and resources
+  
+  def self.core
+    return @@core
+  end
+  
+  #---
+  
+  def self.register_gem(spec)
+    plugin_path = File.join(spec.full_gem_path, 'lib', 'coral')
+    if File.directory?(plugin_path)
+      @@gems[spec.name] = {
+        :lib_dir => plugin_path,
+        :spec    => spec
+      }
+      if spec.name == 'coral_core'
+        @@core = spec
+      else
+        register(plugin_path) # Autoload plugins and related files  
+      end      
+    end  
+  end
+  
+  #---
+  
+  def self.gems(reset = false)
+    if reset || Util::Data.empty?(@@gems)
+      if defined?(Gem) 
+        if ! defined?(Bundler) && Gem::Specification.respond_to?(:latest_specs)
+          Gem::Specification.latest_specs(true).each do |spec|
+            register_gem(spec)
+          end
+        else
+          Gem.loaded_specs.each do |name, spec|
+            register_gem(spec)
+          end     
+        end
+      end
+    end
+    return @@gems
+  end
+  
+  #-----------------------------------------------------------------------------
+  
+  def self.define_type(type_info)
+    if type_info.is_a?(Hash)
+      type_info.each do |type, default_provider|
+        @@types[type.to_sym] = default_provider
+      end
+    end
+  end
+  
+  #---
+  
+  def self.types
+    return @@types.keys
+  end
+  
+  #---
+  
+  def self.type_default(type)
+    return @@types[type.to_sym]
+  end
+  
+  #---
+  
+  def self.plugins(type = nil)
+    results = {}
+    
+    if type
+      results[type] = @@plugins[type] if @@plugins.has_key?(type)
+    else
+      results = @@plugins
+    end    
+    return results
+  end
+ 
+  #---
+  
+  def self.add_build_info(type, file)
+    type = type.to_sym
+    
+    @@load_info[type] = {} unless @@load_info.has_key?(type)
+    
+    components = file.split(File::SEPARATOR)
+    provider   = components.pop.sub(/\.rb/, '').to_sym
+    directory  = components.join(File::SEPARATOR) 
+    
+    puts 'Loading ' + type.to_s + ' plugin: ' + provider.to_s
+        
+    unless @@load_info[type].has_key?(provider)
+      data = {
+        :type      => type,
+        :provider  => provider,        
+        :directory => directory,
+        :file      => file
+      }
+      @@load_info[type][provider] = data
+    end
+  end
+ 
+  #-----------------------------------------------------------------------------
+  # Plugin autoloading
+  
+  def self.register_type(base_path, plugin_type)
+    base_directory = File.join(base_path, plugin_type.to_s)
+    
+    if File.directory?(base_directory)
+      Dir.glob(File.join(base_directory, '*.rb')).each do |file|
+        add_build_info(plugin_type, file)
+      end
+    end
+  end
+  
+  #---
+ 
+  def self.register(base_path)
+    if File.directory?(base_path)
+      Dir.glob(File.join(base_path, '*.rb')).each do |file|
+        require file
+      end
+      
+      Dir.entries(base_path).each do |path|
+        unless path.match(/^\.\.?$/)
+          register_type(base_path, path)          
+        end
+      end
+    end  
+  end
+  
+  #---
+  
+  def self.autoload
+    @@load_info.keys.each do |type|
+      @@load_info[type].each do |provider, plugin|
+        coral_require(plugin[:directory], provider)
+      end      
+    end 
+  end
+    
+  #---
+  
+  @@initialized = false
+  
+  #---
+  
+  def self.initialize
+    unless @@initialized
+      # Register core plugins
+      register(File.join(File.dirname(__FILE__), '..', 'coral'))      
+      
+      # Register external Gem defined plugins
+      gems(true)
+      
+      # Autoload the registered plugins
+      autoload
+           
+      @@initialized = true
+    end    
+  end
+  
+  #---
+  
+  def self.initialized?
+    return @@initialized
+  end
+ 
+  #-----------------------------------------------------------------------------
+  # Utilities
+  
+  def self.translate_type(type, info, method = :translate)
+    klass = Coral.class_const([ :coral, :plugin, type ])          
+    info  = klass.send(method, info) if klass.respond_to?(method)
+    return info  
+  end
+  
+  #---
+  
+  def self.translate(type, provider, info, method = :translate)
+    klass = Coral.class_const([ :coral, type, provider ])          
+    info  = klass.send(method, info) if klass.respond_to?(method)
+    return info  
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Core plugin types
+  
+  define_type :network => :default, 
+              :node    => :rackspace,
+              :machine => :fog,
+              :command => :shell
+end
+end