corl 0.4.29 → 0.5.0

data/lib/core/plugin/provisioner.rb

@@ -1,15 +1,19 @@
 
-module Nucleon
+module CORL
 module Plugin
-class Provisioner < CORL.plugin_class(:base)
+class Provisioner < CORL.plugin_class(:nucleon, :base)
   
   include Parallel
   
+  extend Mixin::Builder::Global
+  include Mixin::Builder::Instance
+  
   #-----------------------------------------------------------------------------
   # Provisioner plugin interface
   
   def normalize(reload)
     super
+    build_config.register(:dependency, :dependencies) if build_config
     yield if block_given?
   end
   
@@ -26,13 +30,6 @@ class Provisioner < CORL.plugin_class(:base)
 
   #---
   
-  def id(name = nil)
-    name = plugin_name if name.nil?
-    name.to_s.gsub('::', '_').to_sym
-  end
-  
-  #---
-  
   def directory=directory
     myself[:directory] = directory
   end
@@ -44,7 +41,7 @@ class Provisioner < CORL.plugin_class(:base)
   #---
   
   def build_directory
-    File.join(network.build_directory, plugin_provider.to_s)
+    File.join(network.build_directory, 'provisioners', plugin_provider.to_s)
   end
   
   #---
@@ -53,41 +50,51 @@ class Provisioner < CORL.plugin_class(:base)
     myself[:gateway] = gateway
   end
   
-  def gateway
-    myself[:gateway]
+  def gateway(index = :first, reset = false)
+    gateway = myself[:gateway]
+    
+    unless gateway
+      gateways = package_gateways(reset)
+      
+      unless gateways.empty?
+        if index == :first || index == 0
+          gateway  = gateways[0]
+        elsif index == :last
+          gateway = gateways.pop
+        elsif index.integer?
+          gateway  = gateways[index]      
+        end
+      end
+    end    
+    gateway
   end
   
-  #---
-  
-  def packages
-    hash(myself[:packages])
+  def package_gateways(node, reset = false)
+    gateways = []
+    build_info(node, reset).each do |package_name, package_info|
+      gateways << File.join('packages', id(package_name).to_s, package_info[:gateway]) if package_info.has_key?(:gateway)
+    end
+    gateways
   end
   
   #---
   
-  def profiles
-    hash(myself[:profiles])
-  end
-  
-  def find_profiles(reset = false)
+  def find_profiles(node, reset = false)
     allowed_profiles = []  
-    build_info(reset).each do |package_name, package_info|
+    build_info(node, reset).each do |package_name, package_info|
       hash(package_info[:profiles]).each do |profile_name, profile_info|
-        allowed_profiles << concatenate([ package_name, 'profile', profile_name ])
+        allowed_profiles << resource([ package_name, 'profile', profile_name ])
       end
     end
-    profiles.each do |profile_name, profile_info|
-      allowed_profiles << concatenate([ plugin_name, 'profile', profile_name ])
-    end
     allowed_profiles  
   end
   protected :find_profiles
   
   #---
   
-  def supported_profiles(profile_names = nil)
+  def supported_profiles(node, profile_names = nil)
     found    = []    
-    profiles = build_profiles
+    profiles = build_profiles(node)
     
     if profile_names.nil?
       found = profiles  
@@ -101,28 +108,60 @@ class Provisioner < CORL.plugin_class(:base)
     end
     found.empty? ? false : found
   end
+   
+  #---
+  
+  def profile_dependencies(node, profiles)
+    dependencies  = build_dependencies(node)[:profile]    
+    profile_index = {}
+    
+    search_profiles = lambda do |profile|
+      profile = profile.to_sym
+            
+      if dependencies.has_key?(profile)
+        dependencies[profile].each do |parent_profile|
+          search_profiles.call(parent_profile)
+        end
+      end
+      profile_index[profile] = true
+    end
+    
+    profiles.each do |profile|
+      search_profiles.call(profile)
+    end
+    
+    profile_index.keys
+  end
+    
+  #---
+  
+  def build_dependencies(node, reset = false)
+    dependencies = cache_setting(:build_dependencies, {}, :hash)
+    build(node) if reset || dependencies.empty?
+    symbol_map(cache_setting(:build_dependencies, {}, :hash))
+  end
      
   #---
   
-  def build_locations(reset = false)
+  def build_locations(node, reset = false)
     locations = cache_setting(:build_locations, {}, :hash)
-    build if reset || locations.empty?
+    build(node) if reset || locations.empty?
     symbol_map(cache_setting(:build_locations, {}, :hash))
   end
   
   #---
   
-  def build_info(reset = false)
+  def build_info(node, reset = false)
     info = cache_setting(:build_info, {}, :hash)
-    build if reset || info.empty?
+    build(node) if reset || info.empty?
     symbol_map(cache_setting(:build_info, {}, :hash))
   end
   
   #---
   
-  def build_profiles(reset = false)
+  def build_profiles(node, reset = false)
     profiles = cache_setting(:build_profiles, [], :array)
-    build if reset || profiles.empty?
+    build(node) if reset || profiles.empty?
     cache_setting(:build_profiles, [], :array)
   end
   
@@ -135,73 +174,64 @@ class Provisioner < CORL.plugin_class(:base)
   
   #---
   
-  def build(options = {})
-    config       = Config.ensure(options)
-    success      = true    
-    locations    = Config.new({ :build => id.to_s, :package => {} })
-    package_info = Config.new
+  def build(node, options = {})
+    config        = Config.ensure(options)    
+    environment   = Util::Data.ensure_value(config[:environment], node.lookup(:corl_environment))
+    provider_info = network.build.config.get_hash([ :provisioners, plugin_provider ])
+    combined_info = Config.new
     
-    init_package = lambda do |name, reference|
-      package_directory = File.join(locations[:build], 'packages', id(name).to_s)
-      package_success   = true
-      
-      ui.info("Building package #{blue(name)} at #{purple(reference)} into #{green(package_directory)}")
+    provider_info.each do |package, info|
+      package_info = Config.new(info)
+      profiles     = {}
       
-      full_package_directory = File.join(build_directory, package_directory)
-        
-      project = CORL.configuration(extended_config(:package, {
-        :directory => full_package_directory,
-        :url       => reference,
-        :create    => File.directory?(full_package_directory) ? false : true
-      }))
-      unless project
-        ui.warn("Project #{cyan(name)} failed to initialize")
-        package_success = false
+      hash(package_info[:profiles]).each do |name, profile_info|
+        profiles[profile_id(package, name)] = profile_info
       end
       
-      if package_success
-        package_info.import(project.export)
-        locations[:package][name] = package_directory
-      
-        if project.get([ :provisioners, plugin_provider ], false)
-          project.get_hash([ :provisioners, plugin_provider ]).each do |prov_name, info|
-            if info.has_key?(:packages)
-              info[:packages].each do |sub_name, sub_reference|
-                unless init_package.call(sub_name, sub_reference)
-                  package_success = false
-                  break
-                end
-              end
-            end
-          end
-        end
-      end
-      package_success
+      package_info[:profiles] = profiles
+      combined_info.import(package_info)  
     end
     
-    local_build_directory = File.join(build_directory, locations[:build])   
+    FileUtils.mkdir_p(build_directory)   
     
-    FileUtils.mkdir_p(local_build_directory)
+    status  = parallel(:build_provider, provider_info, environment, combined_info)
+    success = status.values.include?(false) ? false : true
     
-    # Build packages
-    packages.each do |name, reference|
-      unless init_package.call(name, reference)
-        success = false
-        break
-      end
+    if success    
+      # Save the updates in the local project cache
+      set_cache_setting(:build_dependencies, network.build.dependencies.export)
+      set_cache_setting(:build_locations, network.build.locations.export)
+      set_cache_setting(:build_info, provider_info)
+      set_cache_setting(:build_profiles, find_profiles(node))
     end
-    
-    if success
-      # Build provider specific components 
-      success = yield(locations, package_info) if block_given?
-    
-      if success
-        # Save the updates in the local project cache
-        set_cache_setting(:build_locations, locations.export)
-        set_cache_setting(:build_info, package_info.get([ :provisioners, plugin_provider ]))
-        set_cache_setting(:build_profiles, find_profiles)
+    success    
+  end
+  
+  #---
+  
+  def build_provider(package, info, environment, combined_info)
+    profiles = hash(info[:profiles])
+    status = parallel(:build_profile, profiles, id(package), environment, hash(combined_info[:profiles]))
+    status.values.include?(false) ? false : true
+  end
+  
+  def build_profile(name, info, package, environment, profiles)
+    parents = []
+    config  = Config.new(info)
+    success = true
+           
+    while config.has_key?(:extend) do
+      array(config.delete(:extend)).each do |parent|
+        parent = profile_id(package, parent) unless parent.match('::')
+        
+        parents << parent
+        config.defaults(profiles[parent.to_sym])
       end
     end
+        
+    build_config.set_dependency(:profile, profile_id(package, name), parents)
+    
+    success = yield(process_environment(config, environment)) if block_given?
     success
   end
   
@@ -211,12 +241,15 @@ class Provisioner < CORL.plugin_class(:base)
     # Implement in providers
     nil
   end
-   
+  
   #---
   
-  def provision(profiles, options = {})
-    config  = Config.ensure(options)
-    success = yield(config) if block_given?
+  def provision(node, profiles, options = {})
+    config   = Config.ensure(options)    
+    profiles = profile_dependencies(node, profiles)
+    success  = true
+    
+    success = yield(profiles, config) if block_given?
     
     Config.save_properties(Config.get_options(:corl_log)) if success
     success
@@ -225,9 +258,9 @@ class Provisioner < CORL.plugin_class(:base)
   #-----------------------------------------------------------------------------
   # Utilities
   
-  def self.build_info(type, data)  
+  def self.build_info(namespace, plugin_type, data)  
     data = data.split(/\s*,\s*/) if data.is_a?(String)
-    super(type, data)
+    super(namespace, plugin_type, data)
   end
   
   #---
@@ -277,26 +310,13 @@ class Provisioner < CORL.plugin_class(:base)
   #---
   
   def translate_reference(reference)
-    myself.class.translate_reference(reference)
+    self.class.translate_reference(reference)
   end
-  
+    
   #---
   
-  def concatenate(components, capitalize = false, joiner = '::')
-    if components.is_a?(Array)
-      components = components.collect do |str|
-        str.to_s.split('__')  
-      end.flatten
-    else
-      components = [ components.to_s.split('__') ].flatten
-    end
-    
-    if capitalize
-      name = components.collect {|str| str.capitalize }.join(joiner)
-    else
-      name = components.join(joiner)
-    end
-    name
+  def profile_id(package, profile)
+    concatenate([ package, 'profile', profile ], false)
   end
 end
 end

data/lib/core/util/puppet/resource.rb

@@ -132,7 +132,7 @@ class Resource < Core
         config.set(:normalize_template, config.get("normalize_#{target}", true))
         config.set(:interpolate_template, config.get("interpolate_#{target}", true))
         
-        input_data       = resource[target]        
+        input_data       = resource[target]
         resource[target] = CORL.template(config, resource[name]).render(input_data)
         
         if config.get(:debug, false)

data/lib/core/vagrant/actions/delete_cache.rb

@@ -9,7 +9,13 @@ class DeleteCache < BaseAction
       @app.call env
       
       env[:ui].info I18n.t("corl.vagrant.actions.delete_cache.start")
-      node.clear_cache
+      
+      # Check for saved image
+      box     = node.cache_setting(:box)
+      box_url = node.cache_setting(:box_url)
+      
+      # Clear cache unless saved image
+      node.clear_cache unless box && box_url
     end
   end
 end

data/lib/core/vagrant/commands/launcher.rb

@@ -24,8 +24,8 @@ class Launcher < ::Vagrant.plugin("2", :command)
 
   def execute
     # Set the base command so we can access in any actions executed
-    ::CORL::Vagrant.command = ::CORL.handle(self)   
-    ::CORL.executable(@argv - [ "--" ], "[ vagrant ] corl")
+    ::CORL::Vagrant.command = ::CORL.handle(self)
+    ::CORL.executable(ARGV - [ 'corl', '--' ], "[ vagrant ] corl")
   end
   
   #-----------------------------------------------------------------------------

data/lib/core/vagrant/config.rb

@@ -128,8 +128,27 @@ module Config
     machine.ssh.guest_port = node.ssh_port
         
     if node.cache_setting(:use_private_key, false)
-      #dbg(node.private_key, 'ssh private key')
-      machine.ssh.private_key_path = node.private_key
+      key_dir     = node.network.key_cache_directory
+      key_name    = node.plugin_name
+      
+      ssh_config  = ::CORL::Config.new({ 
+        :keypair  => node.keypair,
+        :key_dir  => key_dir,
+        :key_name => key_name 
+      })
+      
+      if keypair = Util::SSH.unlock_private_key(node.private_key, ssh_config)
+        if keypair.is_a?(String)
+          machine.ssh.private_key_path = keypair
+        else
+          node.keypair                 = keypair                   
+          machine.ssh.private_key_path = keypair.private_key_file(key_dir, key_name)
+        end
+      end
+      unless keypair && File.exists?(machine.ssh.private_key_path)
+        machine.ssh.private_key_path = node.private_key
+      end
+      #dbg(machine.ssh.private_key_path, 'ssh private key')
     end
     
     Util::Data.hash(node.ssh).each do |name, data|
@@ -160,6 +179,14 @@ module Config
     box     = node.cache_setting(:box)
     box_url = node.cache_setting(:box_url)
     
+    if box_url
+      box_file = box_url.gsub(/^file\:\/\//, '')      
+      unless File.exists?(box_file)
+        box_url = nil        
+        node.clear_cache
+      end
+    end
+    
     if box && box_url
       #dbg(box, 'VM box')
       machine.vm.box     = box

data/lib/corl.rb

@@ -49,7 +49,6 @@ I18n.load_path << File.expand_path(File.join('..', 'locales', 'en.yml'), lib_dir
 # Include CORL libraries
 
 # Monkey patches (depreciate as fast as possible)
-nucleon_require(mod_dir, :facter_loader)
 
 #---
 
@@ -102,6 +101,7 @@ end
 nucleon_require(core_dir, :facade)
 
 # Include CORL core plugins
+nucleon_require(core_dir, :build)
 nucleon_require(core_dir, :plugin)
 
 # Include Vagrant plugins (only include if running inside Vagrant)
@@ -131,13 +131,14 @@ module CORL
 
   reload(true) do |op, manager|
     if op == :define
-      manager.define_namespace :CORL
-    
-      manager.define_type :configuration => :file,      # Core
-                          :network       => :default,   # Cluster
-                          :node          => :local,     # Cluster
-                          :machine       => :physical,  # Cluster
-                          :provisioner   => :puppetnode # Cluster
+      manager.define_types :CORL, {
+        :configuration => :file,      # Core
+        :network       => :corl,      # Cluster
+        :node          => :local,     # Cluster
+        :machine       => :physical,  # Cluster
+        :builder       => :package,   # Cluster
+        :provisioner   => :puppetnode # Cluster
+      }
     end
   end
 end

data/lib/facter/corl_config_ready.rb

@@ -5,7 +5,7 @@ Facter.add(:corl_config_ready) do
       require 'corl'      
       configured = CORL::Config.config_initialized?
       
-    rescue Exception # Prevent abortions.
+    rescue # Prevent abortions.
     end
   
     configured ? true : nil

data/lib/facter/vagrant_exists.rb

@@ -8,7 +8,7 @@ Facter.add(:vagrant_exists) do
       Facter::Util::Resolution::exec('id vagrant 2> /dev/null')
       vagrant_exists = true if $?.exitstatus == 0
       
-    rescue Exception # Prevent abortions.
+    rescue # Prevent abortions.
     end    
     vagrant_exists
   end

data/lib/nucleon/action/cloud/create.rb

@@ -0,0 +1,51 @@
+
+module Nucleon
+module Action
+module Cloud
+class Create < Nucleon.plugin_class(:nucleon, :cloud_action)
+
+  include Mixin::Action::Project
+ 
+  #-----------------------------------------------------------------------------
+  # Info
+  
+  def self.describe
+    super(:cloud, :create, 1000)
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Settings
+  
+  def configure
+    super do    
+      config.defaults(CORL.action_config(:project_create))      
+      config[:project_reference].default = 'github:::coralnexus/network-template'
+    end
+  end
+  
+  #---
+  
+  def arguments
+    [ :project_reference ]
+  end
+ 
+  #-----------------------------------------------------------------------------
+  # Operations
+   
+  def execute
+    super(false) do
+      info('nucleon.action.cloud.create.start')
+      
+      project       = project_load(settings[:path], true, true)
+      myself.status = code.project_failure unless project
+      
+      if project.remote(:origin) =~ /coralnexus\/network\-template/
+        project.delete_remote(:origin)
+        project.delete_remote(:edit)
+      end
+    end
+  end
+end
+end
+end
+end

data/lib/nucleon/action/cloud/hiera.rb

@@ -0,0 +1,61 @@
+
+module Nucleon
+module Action
+module Cloud
+class Hiera < CORL.plugin_class(:nucleon, :cloud_action)
+  
+  #-----------------------------------------------------------------------------
+  # Info
+  
+  def self.describe
+    super(:cloud, :hiera, 925)
+  end
+ 
+  #-----------------------------------------------------------------------------
+  # Settings
+ 
+  def configure
+    super do
+      register :properties, :array, []
+      config.defaults(CORL.action_config(:node_lookup))  
+    end
+  end
+  
+  #---
+  
+  def ignore
+    [ :property ]
+  end
+   
+  def arguments
+    [ :properties ]
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Operations
+   
+  def execute
+    super do |node, network|
+      ensure_node(node) do
+        if settings[:properties].empty?
+          ui.info("\n" + CORL.render_object(node.hiera_configuration) + "\n\n", { :prefix => false })
+        else
+          settings.delete(:properties).each do |property|
+            value = Util::Data.to_json(node.lookup(property, nil, settings), true)
+            
+            ui_group(property) do
+              if value.match(/\n/)      
+                ui.info("\n\n#{value}\n\n")
+              else
+                ui.info(value)  
+              end
+            end
+          end  
+        end        
+      end
+    end
+  end
+end
+end
+end
+end

data/lib/{CORL/action → nucleon/action/cloud}/images.rb

@@ -1,7 +1,15 @@
 
-module CORL
+module Nucleon
 module Action
-class Images < Plugin::CloudAction
+module Cloud
+class Images < CORL.plugin_class(:nucleon, :cloud_action)
+  
+  #-----------------------------------------------------------------------------
+  # Info
+  
+  def self.describe
+    super(:cloud, :images, 850)
+  end
 
   #-----------------------------------------------------------------------------
   # Settings
@@ -56,3 +64,4 @@ class Images < Plugin::CloudAction
 end
 end
 end
+end

data/lib/nucleon/action/cloud/inspect.rb

@@ -0,0 +1,47 @@
+
+module Nucleon
+module Action
+module Cloud
+class Inspect < CORL.plugin_class(:nucleon, :cloud_action)
+  
+  #-----------------------------------------------------------------------------
+  # Info
+  
+  def self.describe
+    super(:cloud, :inspect, 950)
+  end
+ 
+  #-----------------------------------------------------------------------------
+  # Settings
+ 
+  def configure
+    super do
+      register :elements, :array, []
+    end
+  end
+  
+  #---
+   
+  def arguments
+    [ :elements ]
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Operations
+   
+  def execute
+    super do |node, network|
+      ensure_network(network) do
+        if settings[:elements].empty?
+          data = network.config.export
+        else
+          data = network.config.get(settings[:elements])
+        end
+        ui.info("\n\n" + CORL.render_object(data) + "\n\n")
+      end
+    end
+  end
+end
+end
+end
+end