coral_core 0.2.26 → 0.2.30

data/lib/coral/network/default.rb

@@ -0,0 +1,26 @@
+
+module Coral
+module Network
+class Default < Plugin::Network
+ 
+  #-----------------------------------------------------------------------------
+  # Cloud plugin interface
+   
+  def normalize
+    super
+  end
+       
+  #-----------------------------------------------------------------------------
+  # Checks
+    
+   
+  #-----------------------------------------------------------------------------
+  # Property accessors / modifiers
+
+
+  #-----------------------------------------------------------------------------
+  # Coral cloud operations
+     
+end
+end
+end

data/lib/coral/node/rackspace.rb

@@ -0,0 +1,23 @@
+
+module Coral
+module Node
+class Rackspace < Plugin::Node
+ 
+  #-----------------------------------------------------------------------------
+  # Node plugin interface
+   
+  def normalize
+    #super
+    dbg('hello from rackspace node')
+  end
+       
+  #-----------------------------------------------------------------------------
+  # Checks
+    
+   
+  #-----------------------------------------------------------------------------
+  # Property accessors / modifiers
+    
+end
+end
+end

data/lib/coral_core.rb

@@ -13,6 +13,7 @@
 module Kernel
    
   def dbg(data, label = '')
+    # Invocations of this function should NOT be committed to the project
     require 'pp'
     
     puts '>>----------------------'
@@ -26,8 +27,9 @@ module Kernel
   
   #---  
     
-  def locate(command)
-    exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
+  def coral_locate(command)
+    command = command.to_s
+    exts    = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
     ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
       exts.each do |ext|
         exe = File.join(path, "#{command}#{ext}")
@@ -36,129 +38,103 @@ module Kernel
     end
     return nil
   end
+    
+  #---
+  
+  def coral_require(base_dir, name)
+    name = name.to_s
+    
+    require File.join(base_dir, "#{name}.rb")  
+    directory = File.join(base_dir, name)
+      
+    if File.directory?(directory)
+      Dir.glob(File.join(directory, '**', '*.rb')).each do |sub_file|
+        require sub_file
+      end
+    end  
+  end
 end
 
 #-------------------------------------------------------------------------------
-# Properties and 
+# Top level properties 
 
-home         = File.dirname(__FILE__)
-dependencies = File.join(home, 'dependency')
-
-git_location = locate('git')
+lib_dir      = File.dirname(__FILE__)
+core_dir     = File.join(lib_dir, 'coral_core')
+mixin_dir    = File.join(core_dir, 'mixin')
+macro_dir    = File.join(mixin_dir, 'macro')
+event_dir    = File.join(core_dir, 'event')
+template_dir = File.join(core_dir, 'template')
+util_dir     = File.join(core_dir, 'util')
+mod_dir      = File.join(core_dir, 'mod')
  
 #-------------------------------------------------------------------------------
+# Coral requirements
+
+git_location = coral_locate('git')
 
-$:.unshift(home) unless
-  $:.include?(home) || $:.include?(File.expand_path(home))
+$:.unshift(lib_dir) unless $:.include?(lib_dir) || $:.include?(File.expand_path(lib_dir))
 
 #---
   
 require 'rubygems'
 
-#---
+require 'i18n'
+require 'log4r'
+require 'deep_merge'
+require 'yaml'
+require 'multi_json'
+require 'digest/sha1'
 
-begin
-  require 'log4r'
-    
-rescue LoadError
-  log4r_lib = File.join(dependencies, 'log4r', 'lib')
-  
-  $:.push(log4r_lib)
-  require File.join(log4r_lib, 'log4r.rb')  
-end
+require 'puppet'
+require 'fog'
 
 #---
 
-begin
-  require 'deep_merge'
-    
-rescue LoadError
-  deep_merge_lib = File.join(dependencies, 'deep_merge', 'lib')
-  
-  $:.push(deep_merge_lib)
-  require File.join(deep_merge_lib, 'deep_merge.rb')  
-end
+# TODO: Make this dynamically settable
 
-#---
-
-begin
-  require 'json'
-    
-rescue LoadError
-  json_lib = File.join(dependencies, 'json', 'lib')
-  
-  $:.push(json_lib)
-  require File.join(json_lib, 'json.rb')  
-end
+I18n.load_path << File.expand_path(File.join('..', 'locales', 'en.yml'), lib_dir)
 
 #---
 
 if git_location
-  begin
-    require 'git'
-    
-  rescue LoadError
-    git_lib = File.join(dependencies, 'git', 'lib')
-  
-    $:.push(git_lib)
-    require File.join(git_lib, 'git.rb')  
-  end
+  require 'grit'
+  coral_require(util_dir, :git)
 end
 
 #---
 
-# Include pre core utilities (no internal dependencies)
-[ :data, :disk ].each do |name| 
-  require File.join('coral_core', 'util', name.to_s + ".rb") 
+# Object modifications (100% pure monkey patches)
+Dir.glob(File.join(mod_dir, '*.rb')).each do |file|
+  require file
 end
 
-if git_location
-  require File.join('coral_core', 'util', 'git.rb') 
+#---
 
-  # Include Git overrides
-  Dir.glob(File.join(home, 'coral_core', 'util', 'git', '*.rb')).each do |file|
-    require file
-  end
+# Mixins for classes
+Dir.glob(File.join(mixin_dir, '*.rb')).each do |file|
+  require file
 end
-
-# Include core
-[ :config, :interface, :core, :resource, :template ].each do |name| 
-  require File.join('coral_core', name.to_s + ".rb") 
+Dir.glob(File.join(macro_dir, '*.rb')).each do |file|
+  require file
 end
 
-# Include post core utilities 
-# ( normally inherit from core and have no reverse dependencies with 
-#   core classes )
-#
-[ :shell ].each do |name| 
-  require File.join('coral_core', 'util', name.to_s + ".rb") 
-end
+#---
 
-# Include data model
-[ :event, :command ].each do |name| 
-  require File.join('coral_core', name.to_s + ".rb") 
-end
+coral_require(util_dir, :data)
+coral_require(core_dir, :config)
+coral_require(util_dir, :interface) 
+coral_require(core_dir, :core) 
 
-if git_location
-  [ :repository, :memory ].each do |name| 
-    require File.join('coral_core', name.to_s + ".rb") 
-  end  
+# Include core utilities
+[ :cli, :disk, :process, :shell ].each do |name| 
+  coral_require(util_dir, name)
 end
 
-# Include specialized events
-Dir.glob(File.join(home, 'coral_core', 'event', '*.rb')).each do |file|
-  require file
-end
-
-# Include bundled templates
-Dir.glob(File.join(home, 'coral_core', 'template', '*.rb')).each do |file|
-  require file
+# Include core systems
+[ :event, :template, :repository, :resource, :plugin_base, :plugin ].each do |name|
+  coral_require(core_dir, name)
 end
 
-#---
-
-require 'hiera_backend.rb'
-
 #*******************************************************************************
 # Coral Core Library
 #
@@ -172,48 +148,167 @@ module Coral
   
   #---
   
-  @@ui = Coral::Core.ui
+  @@config_file = 'coral.json'
   
-  #---
+  #-----------------------------------------------------------------------------
   
   def self.ui
-    return @@ui
+    return Core.ui
+  end
+  
+  #---
+  
+  def self.logger
+    return Core.logger
   end
   
   #-----------------------------------------------------------------------------
-  # Initialization
   
-  def self.load(base_path)
-    if File.exists?(base_path)
-      Dir.glob(File.join(base_path, '*.rb')).each do |file|
-        require file
-      end
-      Dir.glob(File.join(base_path, 'event', '*.rb')).each do |file|
-        require file
-      end
-      Dir.glob(File.join(base_path, 'template', '*.rb')).each do |file|
-        require file
-      end  
-    end  
+  def self.config_file=file_name
+    @@config_file = file_name
   end
   
   #---
   
+  def self.config_file
+    return @@config_file
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Initialization
+  
   @@initialized = false
   
   def self.initialize
     unless @@initialized
       Config.set_property('time', Time.now.to_i)
       
-      # Include Coral extensions
-      Puppet::Node::Environment.new.modules.each do |mod|
-        load(File.join(mod.path, 'lib', 'coral'))
-      end      
+      begin
+        # Include Coral plugins
+        Puppet::Node::Environment.new.modules.each do |mod|
+          lib_path = File.join(mod.path, 'lib', 'coral')
+          Plugin.register(lib_path)
+        end
+      rescue
+      end
+      
+      Plugin.initialize
             
       @@initialized = true
     end    
   end
   
+  #---
+  
+  def self.initialized?
+    return @@initialized
+  end
+    
+  #-----------------------------------------------------------------------------
+  # Plugins
+  
+  def self.plugin(type, provider, options = {})
+    default_provider = Plugin.type_default(type)
+    
+    if options.is_a?(Hash) || options.is_a?(Coral::Config)
+      config   = Config.ensure(options)
+      provider = config.get(:provider, provider)
+      name     = config.get(:name, ( provider ? provider : default_provider ))
+      options  = config.export
+    end
+    provider          = default_provider unless provider # Sanity checking (see plugins)
+    existing_instance = Plugin.get_instance(type, name) if name
+    
+    return existing_instance if existing_instance
+    return Plugin.create_instance(type, provider, options)
+  end
+  
+  #---
+  
+  def self.plugins(type, data, build_hash = false, keep_array = false)
+    group = ( build_hash ? {} : [] )
+    klass = class_const([ :coral, :plugin, type ])    
+    data  = klass.build_info(type, data) if klass.respond_to?(:build_info)
+    
+    data.each do |options|
+      if plugin = plugin(type, options[:provider], options)
+        if build_hash
+          group[plugin.name] = plugin
+        else
+          group << plugin
+        end
+      end
+    end
+    return group.shift if ! build_hash && group.length == 1 && ! keep_array
+    return group  
+  end
+  
+  #---
+  
+  def self.get_plugin(type, name)
+    return Plugin.get_instance(type, name)
+  end
+  
+  #---
+  
+  def self.remove_plugin(plugin)
+    return Plugin.remove_instance(plugin)
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Core plugin type facade
+   
+  def self.network(name, options = {}, provider = nil)
+    plugin      = plugin(:network, provider, options)
+    plugin.name = name
+    return plugin
+  end
+  
+  #---
+  
+  def self.networks(data, build_hash = false, keep_array = false)
+    return plugins(:network, data, build_hash, keep_array)
+  end
+   
+  #---
+  
+  def self.node(name, options = {}, provider = nil)
+    plugin      = plugin(:node, provider, options)
+    plugin.name = name
+    return plugin
+  end
+  
+  #---
+  
+  def self.nodes(data, build_hash = false, keep_array = false)
+    return plugins(:node, data, build_hash, keep_array)
+  end
+   
+  #---
+  
+  def self.machine(options = {}, provider = nil)
+    plugin = plugin(:machine, provider, options)
+    return plugin
+  end
+  
+  #---
+  
+  def self.machines(data, build_hash = false, keep_array = false)
+    return plugins(:machine, data, build_hash, keep_array)
+  end
+  
+  #---
+  
+  def self.command(options, provider = nil)
+    return plugin(:command, provider, options)
+  end
+  
+  #---
+  
+  def self.commands(data, build_hash = false, keep_array = false)
+    return plugins(:command, data, build_hash, keep_array)
+  end
+     
   #-----------------------------------------------------------------------------
   # External execution
    
@@ -228,33 +323,53 @@ module Coral
       raise
     end
   end
-end
-
-#-------------------------------------------------------------------------------
-# 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?
+  #-----------------------------------------------------------------------------
+  # 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
-    return value
+    
+    components.collect! do |value|
+      value.to_s.strip.capitalize  
+    end
+    
+    if want_array
+      return components
+    end    
+    return 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
+    
+    return constant
   end
+  
+  #---
+  
+  def self.sha1(data)
+    return Digest::SHA1.hexdigest(Util::Data.to_json(data, false))
+  end  
 end
+
+#-------------------------------------------------------------------------------
+# Coral initialization
+
+Coral.initialize