corl 0.4.16 → 0.4.17

data/lib/core/facade.rb

@@ -22,9 +22,9 @@ module Facade
   
   #---
   
-  def vagrant_config(directory, config)
+  def vagrant_config(directory, config, &code)
     require File.join(File.dirname(__FILE__), 'vagrant', 'config.rb')
-    Vagrant::Config.register(directory, config)
+    Vagrant::Config.register(directory, config, &code)
   end
     
   #-----------------------------------------------------------------------------

data/lib/core/mixin/lookup.rb

@@ -110,7 +110,7 @@ module Lookup
             debug_lookup(config, property, value, "Hiera lookup")
           end 
     
-          if provisioner && Util::Data.undef?(value)
+          if provisioner && value.nil?
             # Search the provisioner scope (only admins can provision a machine)
             value = CORL.provisioner({ :name => :lookup }, provisioner).lookup(property, default, config)
             debug_lookup(config, property, value, "Provisioner lookup")
@@ -118,14 +118,14 @@ module Lookup
         end
       end
     end
-    if Util::Data.undef?(value) # Resort to default
+    if value.nil? # Resort to default
       value = default
       debug_lookup(config, first_property, value, "Default value")
     end
     value = Util::Data.value(value, config.get(:undefined_value, :undefined))
     
-    if ! Config.get_property(first_property) || ! Util::Data.undef?(value)
-      Config.set_property(first_property.to_s, value)
+    if Config.get_property(first_property).nil? || value
+      Config.set_property(first_property, value)
     end
     
     debug_lookup(config, first_property, value, 'Internalized value')
@@ -161,7 +161,7 @@ module Lookup
     value = Util::Data.value(value, config.get(:undefined_value, :undefined))
     debug_lookup(config, property, value, "Final array value")
        
-    Config.set_property(property.to_s, value)
+    Config.set_property(property, value)
     CORL.ui.info("\n", { :prefix => false }) if config.get(:debug, false)
     value
   end
@@ -190,7 +190,7 @@ module Lookup
     value = Util::Data.value(value, config.get(:undefined_value, :undefined))
     debug_lookup(config, property, value, "Final hash value")
     
-    Config.set_property(property.to_s, value)
+    Config.set_property(property, value)
     CORL.ui.info("\n", { :prefix => false }) if config.get(:debug, false)
     value
   end

data/lib/core/mod/facter_loader.rb

@@ -0,0 +1,15 @@
+
+module Facter
+module Util
+class Loader
+  def load_dir(dir)
+    # TODO:  If this works submit a patch to Facter project
+    return if dir =~ /\/\.+$/ or dir =~ /\/util$/ or dir =~ /\/core$/ or dir =~ /\/lib$/
+
+    Dir.entries(dir).find_all { |f| f =~ /\.rb$/ }.sort.each do |file|
+      load_file(File.join(dir, file))
+    end
+  end      
+end
+end
+end

data/lib/core/mod/hiera_backend.rb

@@ -3,7 +3,7 @@ class Hiera
 module Backend
 class << self
   #
-  # NOTE: This function is overridden so we can collect accumulated hiera
+  # NOTE: This method is overridden so we can collect accumulated hiera
   # parameters and their values on a particular provisioning run for reporting 
   # purposes.
   #
@@ -37,8 +37,12 @@ class << self
     answer = resolve_answer(answer, resolution_type) unless answer.nil?
     answer = parse_string(default, scope) if answer.nil? and default.is_a?(String)
     answer = default if answer.nil?
-        
-    CORL::Config.set_property(key, answer) # This is why we override this function!!
+    
+    # This is why we override this method!!
+    # TODO: Submit a patch that allows for some kind of hook into the process.
+    if CORL::Config.get_property(key).nil? || answer    
+      CORL::Config.set_property(key, answer)
+    end
     return answer
   end
 end

data/lib/core/plugin/action.rb

@@ -159,13 +159,8 @@ class CloudAction < CORL.plugin_class(:action)
     end
     
     # Load network if it exists
-    network_config = extended_config(:network, { :directory => network_path, :name => network_path })
-    
-    network = CORL.network(
-      CORL.sha1(network_config), 
-      network_config, 
-      settings[:net_provider]
-    )
+    network_config = extended_config(:network, { :directory => network_path })
+    network        = CORL.network(network_path, network_config, settings[:net_provider])
     network  
   end
   

data/lib/core/plugin/configuration.rb

@@ -32,6 +32,12 @@ class Configuration < CORL.plugin_class(:base)
     
     set_location(@project)
   end
+  
+  #---
+  
+  def remove_plugin
+    CORL.remove_plugin(@project)
+  end
    
   #-----------------------------------------------------------------------------
   # Checks

data/lib/core/plugin/network.rb

@@ -3,7 +3,7 @@ module Nucleon
 module Plugin
 class Network < CORL.plugin_class(:base)
   
-  init_plugin_collection 
+  init_plugin_collection(:add_node, :batch) 
   
   #-----------------------------------------------------------------------------
   # Cloud plugin interface
@@ -17,6 +17,16 @@ class Network < CORL.plugin_class(:base)
     ignore('build')
   end
   
+  #---
+  
+  def remove_plugin
+    CORL.remove_plugin(config)
+    
+    each_plugin do |type, provider, name, plugin|
+      CORL.remove_plugin(plugin)  
+    end
+  end
+  
   #-----------------------------------------------------------------------------
   # Checks
   
@@ -226,8 +236,6 @@ class Network < CORL.plugin_class(:base)
   
   #---
   
-  execute_block_on_receiver :add_node
-  
   def add_node(provider, name, options = {})
     config = Config.ensure(options)
     
@@ -247,7 +255,7 @@ class Network < CORL.plugin_class(:base)
     })
     
     # Set node data
-    node = set_node(provider, name, node_options)
+    node        = set_node(provider, name, node_options)
     hook_config = { :node => node, :remote => remote_name, :config => config }
     success     = true
     
@@ -260,50 +268,86 @@ class Network < CORL.plugin_class(:base)
       end
       
       if success && node.save({ :remote => remote_name, :message => "Created machine #{name} on #{provider}" })
-        # Bootstrap new machine
-        success = node.bootstrap(home, extended_config(:bootstrap, config)) do |op, data|
-          block_given? ? yield("bootstrap_#{op}".to_sym, data) : data
-        end  
+        success = init_node(node, config.defaults({ :bootstrap => true, :seed => true })) do |op, data|
+          block_given? ? yield(op, data) : data  
+        end
+      end
+    end    
+    success 
+  end
+  
+  #---
+  
+  def init_node(node, options = {})
+    config  = Config.ensure(options)
+    success = true
+    
+    bootstrap = config.delete(:bootstrap, false)
+    seed      = config.delete(:seed, false)
+    
+    unless node.cache_setting(:initialized)
+      bootstrap = true
+      seed      = true
+    end
+       
+    provision = config.delete(:provision, true)
+    
+    if bootstrap
+      # Bootstrap machine
+      success = node.bootstrap(home, extended_config(:bootstrap, config)) do |op, data|
+        block_given? ? yield("bootstrap_#{op}".to_sym, data) : data
+      end
+    end
         
-        if success
-          seed_project = config.get(:project_reference, nil)
-          save_config  = { :commit => true, :remote => remote_name, :push => true }
+    if success
+      if seed
+        seed_project = config.get(:project_reference, nil)
+        save_config  = { :commit => true, :remote => remote_name, :push => true }
                          
-          if seed_project && remote_name
-            # Reset project remote
-            seed_info = Plugin::Project.translate_reference(seed_project)
+        if seed_project && remote_name
+          # Reset project remote
+          seed_info = Plugin::Project.translate_reference(seed_project)
                     
-            if seed_info
-              seed_url    = seed_info[:url]
-              seed_branch = seed_info[:revision] if seed_info[:revision]
-            else
-              seed_url = seed_project                
-            end
-            set_remote(:origin, seed_url) if remote_name.to_sym == :edit
-            set_remote(remote_name, seed_url)
-            save_config[:pull] = false
+          if seed_info
+            seed_url    = seed_info[:url]
+            seed_branch = seed_info[:revision] if seed_info[:revision]
+          else
+            seed_url = seed_project                
           end
+          set_remote(:origin, seed_url) if remote_name.to_sym == :edit
+          set_remote(remote_name, seed_url)
+          save_config[:pull] = false
+        end
           
-          # Save network changes (preliminary)
-          success = node.save(extended_config(:node_save, save_config))
+        # Save network changes (preliminary)
+        success = node.save(extended_config(:node_save, save_config))
         
-          if success && seed_project
-            # Seed machine with remote project reference
-            result = node.seed({
-              :project_reference => seed_project,
-              :project_branch    => seed_branch
-            }) do |op, data|
-              yield("seed_#{op}".to_sym, data)
-            end
-            success = result.status == code.success
+        if success && seed_project
+          # Seed machine with remote project reference
+          result = node.seed({
+            :project_reference => seed_project,
+            :project_branch    => seed_branch
+          }) do |op, data|
+            yield("seed_#{op}".to_sym, data)
           end
-        
-          # Update local network project
-          success = load({ :remote => remote_name, :pull => true }) if success
+          success = result.status == code.success
         end
       end
-    end    
-    success 
+      
+      node.set_cache_setting(:initialized, true) if success
+      
+      if success && provision
+        # Run configured provisioners on machine
+        result = node.provision(config) do |op, data|
+          yield("provision_#{op}".to_sym, data)  
+        end
+        success = result.status == code.success
+      end
+        
+      # Update local network project
+      success = load({ :remote => remote_name, :pull => true }) if success
+    end
+    success
   end
   
   #-----------------------------------------------------------------------------
@@ -321,8 +365,6 @@ class Network < CORL.plugin_class(:base)
   
   #---
   
-  execute_block_on_receiver :batch
-  
   def batch(node_references, default_provider = nil, parallel = true, &code)
     success = true
     
@@ -330,7 +372,7 @@ class Network < CORL.plugin_class(:base)
       # Execute action on selected nodes      
       nodes = nodes_by_reference(node_references, default_provider)
       
-      if parallel
+      if CORL.parallel? && parallel
         values = []
         nodes.each do |node|
           values << Celluloid::Future.new(node, &code)

data/lib/core/plugin/node.rb

@@ -3,7 +3,8 @@ module Nucleon
 module Plugin
 class Node < CORL.plugin_class(:base)
   
-  include Celluloid
+  include Parallel
+  external_block_exec :exec, :command, :action
   
   #-----------------------------------------------------------------------------
   # Node plugin interface
@@ -56,6 +57,13 @@ class Node < CORL.plugin_class(:base)
     @local_context       = true
     myself.local_machine = create_machine(:local_machine, :physical)
   end
+  
+  #---
+  
+  def remove_plugin
+    CORL.remove_plugin(local_machine) if local_machine
+    CORL.remove_plugin(machine) if machine
+  end
        
   #-----------------------------------------------------------------------------
   # Checks
@@ -567,8 +575,6 @@ class Node < CORL.plugin_class(:base)
   
   #---
   
-  execute_block_on_receiver :exec
-  
   def exec(options = {})
     default_error = Util::Shell::Result.new(:error, 255)
     results       = [ default_error ]
@@ -636,8 +642,6 @@ class Node < CORL.plugin_class(:base)
   
   #---
   
-  execute_block_on_receiver :command
-  
   def command(command, options = {})
     config   = Config.ensure(options)
     as_admin = config.delete(:as_admin, false)
@@ -654,14 +658,14 @@ class Node < CORL.plugin_class(:base)
     
     results = exec({ :commands => [ "#{admin_command} #{command.to_s}".strip ] }) do |op, data|
       yield(op, data) if block_given?  
-    end    
+    end
+    
+    CORL.remove_plugin(command)    
     results.first 
   end
   
   #---
   
-  execute_block_on_receiver :action
-  
   def action(provider, options = {})
     codes :network_load_error
     

data/lib/core/plugin/provisioner.rb

@@ -3,7 +3,7 @@ module Nucleon
 module Plugin
 class Provisioner < CORL.plugin_class(:base)
   
-  include Celluloid
+  include Parallel
   
   #-----------------------------------------------------------------------------
   # Provisioner plugin interface
@@ -105,25 +105,25 @@ class Provisioner < CORL.plugin_class(:base)
   #---
   
   def build_locations(reset = false)
-    locations = hash(myself[:build_locations])
+    locations = cache_setting(:build_locations, {}, :hash)
     build if reset || locations.empty?
-    myself[:build_locations]
+    cache_setting(:build_locations, {}, :hash)
   end
   
   #---
   
   def build_info(reset = false)
-    info = hash(myself[:build_info])
+    info = cache_setting(:build_info, {}, :hash)
     build if reset || info.empty?
-    myself[:build_info]
+    cache_setting(:build_info, {}, :hash)
   end
   
   #---
   
   def build_profiles(reset = false)
-    profiles = array(myself[:build_profiles])
+    profiles = cache_setting(:build_profiles, [], :array)
     build if reset || profiles.empty?
-    myself[:build_profiles]
+    cache_setting(:build_profiles, [], :array)
   end
   
   #-----------------------------------------------------------------------------
@@ -196,17 +196,10 @@ class Provisioner < CORL.plugin_class(:base)
       success = yield(locations, package_info) if block_given?
     
       if success
-        # Save the updates (should build the same on all nodes in same system)
-        myself[:build_locations] = locations.export
-        myself[:build_info]      = package_info.get([ :provisioners, plugin_provider ])
-        myself[:build_profiles]  = find_profiles
-    
-        success = network.save(config.import({
-          :commit      => true,
-          :allow_empty => true, 
-          :message     => config.get(:message, "Built #{plugin_provider} provisioner #{plugin_name}"),
-          :remote      => config.get(:remote, :edit)
-        }))
+        # 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)
       end
     end
     success

data/lib/core/util/puppet.rb

@@ -270,10 +270,10 @@ module Puppet
         value = puppet_scope.lookupvar("::#{search_property_name}")
         Config.debug_lookup(config, search_property_name, value, "Puppet override lookup")
         
-        break unless Util::Data.undef?(value)  
+        break unless value.nil?  
       end
     end
-    if Util::Data.undef?(value)
+    if value.nil?
       components = property.to_s.split('::')
       
       if components.length > 1
@@ -284,7 +284,7 @@ module Puppet
         Config.debug_lookup(config, search_property_name, value, "Puppet default lookup")
       end
     end
-    if Util::Data.undef?(value) && search_name
+    if value.nil? && search_name
       value = puppet_scope.lookupvar("::#{property}")
       Config.debug_lookup(config, property, value, "Puppet name lookup")
     end

data/lib/core/vagrant/action.rb

@@ -0,0 +1,39 @@
+
+module VagrantPlugins
+module CORL
+class BaseAction
+  
+  #-----------------------------------------------------------------------------
+  # Constructor / Destructor
+  
+  def initialize(app, env)
+    @app     = app
+    @env     = env[:machine].env
+     
+    @network = nil
+    @node    = nil
+    @vm      = nil
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Property accessor / modifiers
+  
+  attr_reader :network, :node, :vm
+  
+  #-----------------------------------------------------------------------------
+  # Action execution
+  
+  def call(env)
+    # Hackish solution to ensure our code has access to Vagrant machines.
+    # This serves as a Vagrant VM manager.
+    ::CORL::Vagrant.command = Command::Launcher.new([], @env)
+    
+    if @network = ::CORL::Vagrant::Config.load_network(env[:root_path])
+      @vm   = env[:machine]
+      @node = network.node(:vagrant, @vm.name) if @vm
+      yield if block_given? && @node 
+    end
+  end
+end    
+end
+end

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

@@ -0,0 +1,28 @@
+
+module VagrantPlugins
+module CORL
+module Action
+class CreateShares < BaseAction
+
+  def call(env)
+    super do
+      env[:ui].info I18n.t("corl.vagrant.actions.create_shares.start")
+      
+      vm.communicate.tap do |comm|
+        # TODO: Figure out a better solution for remote network path.
+        # Needs to work before facter and corl are installed
+        # Local searches of remote configurations in the project perhaps?
+        network_path = ::CORL::Config.fact(:corl_network)
+        
+        # Make sure the CORL network directory is properly set up
+        # Vagrant root (project) directory is shared by default
+        comm.sudo("rm -Rf #{network_path}")
+        comm.sudo("ln -s /vagrant #{network_path}")
+      end
+      @app.call env
+    end
+  end
+end
+end
+end
+end

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

@@ -0,0 +1,18 @@
+
+module VagrantPlugins
+module CORL
+module Action
+class DeleteCache < BaseAction
+
+  def call(env)
+    super do
+      @app.call env
+      
+      env[:ui].info I18n.t("corl.vagrant.actions.delete_cache.start")
+      node.clear_cache
+    end
+  end
+end
+end
+end
+end

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

@@ -0,0 +1,28 @@
+
+module VagrantPlugins
+module CORL
+module Action
+class InitKeys < BaseAction
+
+  def call(env)
+    super do
+      env[:ui].info I18n.t("corl.vagrant.actions.init_keys.start")
+      
+      if node.public_key
+        ssh_key = ::CORL::Util::Disk.read(node.public_key)
+        
+        if ssh_key && ! ssh_key.empty?
+          vm.communicate.tap do |comm|
+            comm.execute("echo '#{ssh_key}' > \$HOME/.ssh/authorized_keys")
+          end
+          node.set_cache_setting(:use_private_key, true)
+          node.machine.load
+        end
+      end      
+      @app.call env
+    end
+  end
+end
+end
+end
+end

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

@@ -4,7 +4,7 @@ module CORL
 module Command
 class Launcher < ::Vagrant.plugin("2", :command)
   
-  include Celluloid
+  include ::CORL::Parallel # Mainly for auto locking of resources
   
   #-----------------------------------------------------------------------------
   
@@ -24,7 +24,7 @@ class Launcher < ::Vagrant.plugin("2", :command)
 
   def execute
     # Set the base command so we can access in any actions executed
-    ::CORL::Vagrant.command = current_actor   
+    ::CORL::Vagrant.command = ::CORL.handle(self)   
     ::CORL.executable(@argv - [ "--" ], "vagrant corl")
   end
   

data/lib/core/vagrant/config.rb

@@ -81,11 +81,9 @@ module Config
           end
           
           # Provisioner configuration
-          unless configure_provisioner(network, node, machine)
+          unless configure_provisioner(network, node, machine, &code)
             raise "Configuration of Vagrant provisioner failed: #{node_name}"
           end
-          
-          code.call(network, node, machine) if code
         end        
       end
     end
@@ -95,10 +93,7 @@ module Config
   
   def self.load_network(directory)
     # Load network if it exists
-    CORL.network(
-      :vagrant, 
-      CORL.config(:vagrant_network, { :directory => directory, :name => directory })
-    )
+    @@network = CORL.network(directory, CORL.config(:vagrant_network, { :directory => directory }))
   end
   
   #---
@@ -272,14 +267,15 @@ module Config
   
   #---
   
-  def self.configure_provisioner(network, node, machine)
+  def self.configure_provisioner(network, node, machine, &code)
     success = true
     
     # CORL provisioning
     machine.vm.provision :corl do |provisioner|
-      provisioner.network_path = CORL::Config.fact(:corl_network)
-      provisioner.network      = network
-      provisioner.node         = node    
+      provisioner.network = network
+      provisioner.node    = node
+      
+      code.call(node, machine, provisioner) if code   
     end
     success  
   end