corl 0.5.6 → 0.5.7

data/lib/core/plugin/cloud_action.rb

@@ -120,7 +120,7 @@ class CloudAction < Nucleon.plugin_class(:nucleon, :action)
     if network && network.has_nodes? && ! settings[:nodes].empty?
       # Execute action on remote nodes
       success = network.batch(settings[:nodes], settings[:node_provider], settings[:parallel]) do |node|
-        exec_config = Config.new(settings)
+        exec_config = Config.new(settings, {}, true, false)
         exec_config.delete(:nodes)
 
         result = node.action(plugin_provider, exec_config) do |op, data|

data/lib/core/plugin/machine.rb

@@ -2,181 +2,181 @@
 module CORL
 module Plugin
 class Machine < Nucleon.plugin_class(:nucleon, :base)
-      
+
   #-----------------------------------------------------------------------------
   # Checks
-  
+
   def created?
     false
   end
-  
+
   #---
-  
+
   def running?
     ( created? && false )
   end
-   
+
   #-----------------------------------------------------------------------------
   # Property accessors / modifiers
-  
+
   def node
     plugin_parent
   end
- 
+
   def node=node
     myself.plugin_parent = node
   end
-  
+
   #---
-  
+
   def state
     nil
   end
-  
+
   #---
-  
+
   def hostname
     nil
   end
-  
+
   #---
-  
+
   def public_ip
     nil
   end
-  
+
   #---
-  
+
   def private_ip
     nil
   end
-  
+
   #---
-    
+
   def machine_types
     []
   end
-  
+
   #---
-  
+
   def machine_type
     nil
   end
-  
+
   #---
-  
+
   def images
     []
   end
-  
+
   #---
-  
+
   def image
     nil
   end
-            
+
   #-----------------------------------------------------------------------------
   # Management
-  
+
   def load
     success = true
-    
+
     logger.debug("Loading #{plugin_provider} machine: #{plugin_name}")
-    success = yield if block_given?  
-        
+    success = yield if block_given?
+
     logger.warn("There was an error loading the machine #{plugin_name}") unless success
     success
   end
-  
+
   #---
-  
+
   def create(options = {})
     success = true
-    
+
     if created?
       logger.debug("Machine #{plugin_name} already exists")
     else
       logger.debug("Creating #{plugin_provider} machine with: #{options.inspect}")
       config  = Config.ensure(options)
-      success = yield(config) if block_given?  
+      success = yield(config) if block_given?
     end
-    
+
     logger.warn("There was an error creating the machine #{plugin_name}") unless success
     success
   end
-  
+
   #---
-  
+
   def download(remote_path, local_path, options = {})
     success = true
-    
+
     if running?
       logger.debug("Downloading #{local_path} from #{remote_path} on #{plugin_provider} machine with: #{options.inspect}")
-      config  = Config.ensure(options)      
+      config  = Config.ensure(options)
       success = yield(config, success) if block_given?
     else
-      logger.debug("Machine #{plugin_name} is not running")  
+      logger.debug("Machine #{plugin_name} is not running")
     end
-    
+
     logger.warn("There was an error downloading from the machine #{plugin_name}") unless success
     success
   end
-  
+
   #---
-  
+
   def upload(local_path, remote_path, options = {})
     success = true
-    
+
     if running?
       logger.debug("Uploading #{local_path} to #{remote_path} on #{plugin_provider} machine with: #{options.inspect}")
-      config  = Config.ensure(options)      
+      config  = Config.ensure(options)
       success = yield(config, success) if block_given?
     else
-      logger.debug("Machine #{plugin_name} is not running")  
+      logger.debug("Machine #{plugin_name} is not running")
     end
-    
+
     logger.warn("There was an error uploading to the machine #{plugin_name}") unless success
     success
   end
-  
+
   #---
-  
+
   def exec(commands, options = {})
     results = []
-    
+
     if running?
       logger.info("Executing commands ( #{commands.inspect} ) on machine #{plugin_name}")
-      config  = Config.ensure(options)      
+      config  = Config.ensure(options)
       results = yield(config, results) if block_given?
     else
-      logger.debug("Machine #{plugin_name} is not running")  
+      logger.debug("Machine #{plugin_name} is not running")
     end
-    
+
     logger.warn("There was an error executing command on the machine #{plugin_name}") unless results
     results
   end
-  
+
   #---
-  
+
   def terminal(user, options = {})
     status = code.unknown_status
-    
+
     if running?
       logger.debug("Launching #{user} terminal on #{plugin_provider} machine with: #{options.inspect}")
-      config = Config.ensure(options)      
+      config = Config.ensure(options)
       status = yield(config) if block_given?
     else
-      logger.debug("Machine #{plugin_name} is not running")  
-    end    
+      logger.debug("Machine #{plugin_name} is not running")
+    end
     logger.warn("There was an error launching a #{user} terminal on the machine #{plugin_name}") unless status == code.success
     status
   end
-  
+
   #---
-  
+
   def reload(options = {})
     success = true
-    
+
     if created?
       logger.debug("Reloading #{plugin_provider} machine with: #{options.inspect}")
       config  = Config.ensure(options)
@@ -184,72 +184,72 @@ class Machine < Nucleon.plugin_class(:nucleon, :base)
     else
       logger.debug("Machine #{plugin_name} does not yet exist")
     end
-    
+
     logger.warn("There was an error reloading the machine #{plugin_name}") unless success
     success
   end
 
   #---
-  
+
   def create_image(options = {})
     success = true
-    
+
     if running?
       logger.debug("Creating image of #{plugin_provider} machine with: #{options.inspect}")
-      config  = Config.ensure(options)      
+      config  = Config.ensure(options)
       success = yield(config) if block_given?
     else
-      logger.debug("Machine #{plugin_name} is not running")  
+      logger.debug("Machine #{plugin_name} is not running")
     end
-    
+
     logger.warn("There was an error creating an image of the machine #{plugin_name}") unless success
     success
   end
 
   #---
-  
+
   def stop(options = {})
     success = true
-    
+
     if running?
       logger.debug("Stopping #{plugin_provider} machine with: #{options.inspect}")
-      config  = Config.ensure(options)      
+      config  = Config.ensure(options)
       success = yield(config) if block_given?
     else
-      logger.debug("Machine #{plugin_name} is not running")  
+      logger.debug("Machine #{plugin_name} is not running")
     end
-    
+
     logger.warn("There was an error stopping the machine #{plugin_name}") unless success
     success
   end
-  
+
   #---
-  
+
   def start(options = {})
     success = true
-    
+
     if running?
-      logger.debug("Machine #{plugin_name} is already running")  
+      logger.debug("Machine #{plugin_name} is already running")
     else
       logger.debug("Starting #{plugin_provider} machine with: #{options.inspect}")
-      
+
       logger.debug("Machine #{plugin_name} is not running yet")
       if block_given?
-        success = yield(config)  
+        success = yield(config)
       else
-        success = create(options)  
-      end            
+        success = create(options)
+      end
     end
-    
+
     logger.warn("There was an error starting the machine #{plugin_name}") unless success
     success
   end
-  
+
   #---
 
-  def destroy(options = {})   
+  def destroy(options = {})
     success = true
-    
+
     if created?
       logger.debug("Destroying #{plugin_provider} machine with: #{options.inspect}")
       config  = Config.ensure(options)
@@ -257,11 +257,11 @@ class Machine < Nucleon.plugin_class(:nucleon, :base)
     else
       logger.debug("Machine #{plugin_name} does not yet exist")
     end
-    
+
     logger.warn("There was an error destroying the machine #{plugin_name}") unless success
     success
   end
-  
+
   #-----------------------------------------------------------------------------
   # Utilities
 

data/lib/core/plugin/network.rb

@@ -12,13 +12,22 @@ class Network < Nucleon.plugin_class(:nucleon, :base)
     super
 
     logger.info("Initializing network: reloading? #{reload}")
-    myself.config = CORL.configuration(Config.new(myself._export).import({ :autosave => false, :create => false, :new => true })) unless reload
+    myself.config = CORL.configuration(Config.new(myself._export, {}, true, false).import({ :autosave => false, :create => false, :new => true })) unless reload
 
     config.delete(:directory) # TODO: Figure out what to do with this??
 
     unless reload
       @build = Build.new
-      ignore([ 'build', File.join('config', 'identities') ])
+
+      config_identities_glob  = File.join('config', 'identities', '*')
+      vagrant_identities_path = File.join('config', 'identities', 'vagrant')
+
+      ignore([
+        'build',
+        config_identities_glob,
+        config_identities_glob + File::SEPARATOR,
+        "!#{vagrant_identities_path}"
+      ])
     end
   end
 
@@ -183,11 +192,11 @@ class Network < Nucleon.plugin_class(:nucleon, :base)
 
   #---
 
-  def node_by_ip(public_ip, require_new = false)
+  def node_lookup(public_ip, hostname, require_new = false)
     matches = {}
 
     each_node_config do |provider, name, info|
-      matches[provider] = name if info[:public_ip] == public_ip
+      matches[provider] = name if info[:public_ip] == public_ip && name.to_s == hostname.to_s
     end
 
     unless matches.empty?
@@ -203,11 +212,12 @@ class Network < Nucleon.plugin_class(:nucleon, :base)
   #---
 
   def local_node(require_new = false)
+    hostname   = lookup(:fqdn)
     ip_address = CORL.public_ip
-    local_node = node_by_ip(ip_address, require_new)
+    local_node = node_lookup(ip_address, hostname, require_new)
 
     if local_node.nil?
-      name       = Util::Data.ensure_value(lookup(:fqdn), ip_address)
+      name       = Util::Data.ensure_value(hostname, ip_address)
       local_node = CORL.node(name, extended_config(:local_node).import({ :meta => { :parent => myself }}), :local)
     else
       local_node.network = myself
@@ -259,6 +269,10 @@ class Network < Nucleon.plugin_class(:nucleon, :base)
     create_builder(:network_package_builder, :package, options)
   end
 
+  def project_builder(name, options = {})
+    create_builder(:network_project_builder, :project, options)
+  end
+
   #-----------------------------------------------------------------------------
   # Operations
 
@@ -316,7 +330,7 @@ class Network < Nucleon.plugin_class(:nucleon, :base)
 
     remote_name = config.delete(:remote, :edit)
 
-    node_options = Util::Data.clean({
+    node_config = extended_config(:network_new_node, Config.new(Util::Data.clean({
       :settings     => array(config.delete(:groups, [])) | [ "server" ],
       :region       => config.delete(:region, nil),
       :machine_type => config.delete(:machine_type, nil),
@@ -324,10 +338,10 @@ class Network < Nucleon.plugin_class(:nucleon, :base)
       :image        => config.delete(:image, nil),
       :user         => config.delete(:user, :root),
       :hostname     => name
-    })
+    })))
 
     # Set node data
-    node        = set_node(provider, name, node_options)
+    node        = set_node(provider, name, node_config.export)
     hook_config = { :node => node, :remote => remote_name, :config => config }
     success     = true
 

data/lib/core/plugin/node.rb

@@ -398,7 +398,7 @@ class Node < Nucleon.plugin_class(:nucleon, :base)
   def machine_config
     name   = setting(:id)
     name   = nil if name.nil? || name.empty?
-    config = Config.new({ :name => name })
+    config = Config.new({ :name => name }, {}, true, false)
 
     yield(config) if block_given?
     config
@@ -436,7 +436,7 @@ class Node < Nucleon.plugin_class(:nucleon, :base)
         node_facts = local? ? Util::Data.merge([ CORL.facts, custom_facts ]) : custom_facts
       end
 
-      self.fact_var = Config.new(node_facts).defaults(default_facts).export
+      self.fact_var = Config.new(node_facts, {}, true, false).defaults(default_facts).export
     end
     return fact_var.clone if clone
     fact_var
@@ -700,7 +700,7 @@ class Node < Nucleon.plugin_class(:nucleon, :base)
 
     if machine && machine.running?
       config      = Config.ensure(options)
-      hook_config = Config.new({ :local_path => local_path, :remote_path => remote_path, :config => config })
+      hook_config = Config.new({ :local_path => local_path, :remote_path => remote_path, :config => config }, {}, true, false)
       quiet       = config.get(:quiet, false)
 
       if extension_check(:download, hook_config)
@@ -739,7 +739,7 @@ class Node < Nucleon.plugin_class(:nucleon, :base)
 
     if machine && machine.running?
       config      = Config.ensure(options)
-      hook_config = Config.new({ :local_path => local_path, :remote_path => remote_path, :config => config })
+      hook_config = Config.new({ :local_path => local_path, :remote_path => remote_path, :config => config }, {}, true, false)
       quiet       = config.get(:quiet, false)
 
       if extension_check(:upload, hook_config)
@@ -828,7 +828,7 @@ class Node < Nucleon.plugin_class(:nucleon, :base)
           quiet = config.get(:quiet, false)
 
           begin
-            test = active_machine.exec(commands, config.export) do |type, command, data|
+            test = active_machine.exec(Util::Data.array(commands), config.export) do |type, command, data|
               unless quiet
                 unless local?
                   text_output = filter_output(type, data).rstrip
@@ -890,7 +890,7 @@ class Node < Nucleon.plugin_class(:nucleon, :base)
     remove_command = false
 
     unless command.is_a?(CORL::Plugin::Command)
-      command        = CORL.command(Config.new({ :command => command }).import(config), :bash)
+      command        = CORL.command(Config.new({ :command => command }, {}, true, false).import(config), :bash)
       remove_command = true
     end
 
@@ -1107,11 +1107,14 @@ class Node < Nucleon.plugin_class(:nucleon, :base)
       image(false)
     end
 
+    remote = config.get(:remote, :edit)
+    remote = nil unless network.remote(remote)
+
     network.save(config.import({
       :commit      => true,
       :allow_empty => true,
       :message     => config.get(:message, "Saving #{plugin_provider} node #{plugin_name}"),
-      :remote      => config.get(:remote, :edit)
+      :remote      => remote
     }))
   end
 

data/lib/core/plugin/provisioner.rb

@@ -178,10 +178,10 @@ class Provisioner < Nucleon.plugin_class(:nucleon, :base)
     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
+    combined_info = Config.new({}, {}, true, false)
 
     provider_info.each do |package, info|
-      package_info = Config.new(info)
+      package_info = Config.new(info, {}, true, false)
       profiles     = {}
 
       hash(package_info[:profiles]).each do |name, profile_info|
@@ -217,7 +217,7 @@ class Provisioner < Nucleon.plugin_class(:nucleon, :base)
 
   def build_profile(name, info, package, environment, profiles)
     parents = []
-    config  = Config.new(info)
+    config  = Config.new(info, {}, true, false)
     success = true
 
     while config.has_key?(:extend) do

data/lib/core/vagrant/action.rb

@@ -2,41 +2,43 @@
 module VagrantPlugins
 module CORL
 class BaseAction
-  
+
   #-----------------------------------------------------------------------------
   # Constructor / Destructor
-  
+
   def initialize(app, env)
     @app     = app
     @env     = env[:machine].env
-     
+
     @network = nil
     @node    = nil
     @vm      = nil
-    
+
     if @corl_config_loaded = ::CORL.vagrant_config_loaded?
-      # 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
       end
     end
+
+    unless ::CORL::Vagrant.command
+      # 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)
+    end
   end
-  
+
   #-----------------------------------------------------------------------------
   # Property accessor / modifiers
-  
+
   attr_reader :network, :node, :vm
-  
+
   #-----------------------------------------------------------------------------
   # Action execution
-  
+
   def call(env)
     yield if block_given? && @corl_config_loaded && @network && @node
   end
-end    
+end
 end
 end

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

@@ -0,0 +1,17 @@
+
+module VagrantPlugins
+module CORL
+module Action
+class IncludeOverrides < BaseAction
+
+  def call(env)
+    super do
+      # Ignore Vagrant key generation (we handle our own keys)
+      #load File.join(File.dirname(__FILE__), '..', '..', 'mod', 'vagrant.rb')
+      @app.call env
+    end
+  end
+end
+end
+end
+end

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

@@ -7,20 +7,24 @@ 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|
+          env[:machine].communicate.tap do |comm|
             comm.execute("echo '#{ssh_key}' > \$HOME/.ssh/authorized_keys")
           end
           node.set_cache_setting(:use_private_key, true)
           env[:machine].config.ssh.private_key_path = node.private_key
-          
+
+          # Needed for Vagrant 1.7+
+          vagrant_key_file = env[:machine].data_dir.join("private_key")
+          ::CORL::Util::Disk.delete(vagrant_key_file) if File.exists?(vagrant_key_file)
+
           node.machine.load
         end
-      end      
+      end
       @app.call env
     end
   end

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

@@ -56,8 +56,8 @@ class Launcher < ::Vagrant.plugin("2", :command)
     provider ||= env.default_provider
 
     machine = env.machine(name, provider, refresh)
-    machine.ui.opts[:color] = :default # TODO: Something better??
 
+    machine.ui.opts[:color] = :default # TODO: Something better??
     machine
   end
 end