corl 0.5.6 → 0.5.7

data/lib/CORL/node/vagrant.rb

@@ -32,6 +32,18 @@ class Vagrant < Nucleon.plugin_class(:CORL, :node)
 
   #---
 
+  def public_ip(reset = false)
+    return machine.public_ip if machine
+    nil
+  end
+
+  def private_ip(reset = false)
+    return machine.private_ip if machine
+    nil
+  end
+
+  #---
+
   def vm=vm
     myself[:vm] = vm
   end
@@ -52,6 +64,17 @@ class Vagrant < Nucleon.plugin_class(:CORL, :node)
 
   #---
 
+  def image=image
+    # Images can not be set
+  end
+
+  def image(reset = false)
+    return machine.image if machine
+    nil
+  end
+
+  #---
+
   def shares=shares
     myself[:shares] = shares
     init_shares

data/lib/CORL/provisioner/puppetnode.rb

@@ -86,6 +86,9 @@ class Puppetnode < Nucleon.plugin_class(:CORL, :provisioner)
   # Puppet initialization
 
   def init_puppet(node, profiles)
+    require 'puppet'
+    require 'puppet/configurer'
+
     Puppet.initialize_settings
 
     apply_environment = nil
@@ -93,6 +96,8 @@ class Puppetnode < Nucleon.plugin_class(:CORL, :provisioner)
 
     environment, environment_directory = ensure_environment(node)
 
+    return nil unless environment
+
     Puppet::Util::Log.newdestination(id)
     Puppet::Transaction::Report.indirection.cache_class = :yaml
 
@@ -269,47 +274,57 @@ class Puppetnode < Nucleon.plugin_class(:CORL, :provisioner)
           start_time        = Time.now
           apply_environment = init_puppet(node, processed_profiles)
 
-          Puppet.override(:environments => Puppet::Environments::Static.new(apply_environment)) do
-            puppet_node = get_puppet_node(apply_environment.name)
-            @compiler   = Puppet::Parser::Compiler.new(puppet_node)
+          if apply_environment.nil?
+            success = false
+          else
+            Puppet.override(:environments => Puppet::Environments::Static.new(apply_environment)) do
+              puppet_node = get_puppet_node(apply_environment.name)
+              @compiler   = Puppet::Parser::Compiler.new(puppet_node)
 
-            # Register Puppet module plugins
-            register
+              # Register Puppet module plugins
+              register
 
-            # Include defaults
-            classes = include_location.call(:default, {}, true)
+              # Include defaults
+              classes = include_location.call(:default, {}, true)
 
-            # Import needed profiles
-            include_location.call(:profiles, {}, false)
+              # Import needed profiles
+              include_location.call(:profiles, {}, false)
 
-            processed_profiles.each do |profile|
-              classes[profile.to_s] = { :require => 'Anchor[profile_start]' }
-            end
+              processed_profiles.each do |profile|
+                classes[profile.to_s] = { :require => 'Anchor[profile_start]' }
+              end
 
-            puppet_node.classes = classes
+              puppet_node.classes = classes
 
-            # Compile catalog
-            compiler.compile
+              # Compile catalog
+              compiler.compile
 
-            catalog = compiler.catalog.to_ral
-            catalog.finalize
-            catalog.retrieval_duration = Time.now - start_time
+              catalog = compiler.catalog.to_ral
+              catalog.finalize
+              catalog.retrieval_duration = Time.now - start_time
 
-            unless config.get(:dry_run, false)
-              info("\n", { :prefix => false, :i18n => false })
-              info("Starting configuration run at #{Time.now.to_s}", { :i18n => false })
+              unless config.get(:dry_run, false)
+                info("\n", { :prefix => false, :i18n => false })
+                info("Starting configuration run at #{Time.now.to_s}", { :i18n => false })
 
-              # Configure the machine
-              Puppet.push_context({ :current_environment => apply_environment }, "CORL environment for configurer transaction")
+                # Configure the machine
+                Puppet.push_context({ :current_environment => apply_environment }, "CORL environment for configurer transaction")
 
-              configurer = Puppet::Configurer.new
-              if ! configurer.run(:catalog => catalog, :pluginsync => false)
-                success = false
+                configurer = Puppet::Configurer.new
+                if ! configurer.run(:catalog => catalog, :pluginsync => false)
+                  success = false
+                end
               end
             end
           end
 
         rescue Exception => error
+          if [ :debug, :info, :warn, :error ].include? CORL.log_level
+            logger.error("Puppetnode provisioner experienced an error:")
+            logger.error(error.inspect)
+            logger.error(error.message)
+            logger.error(Util::Data.to_yaml(error.backtrace))
+          end
           Puppet.log_exception(error)
           success = false
         end
@@ -326,7 +341,17 @@ class Puppetnode < Nucleon.plugin_class(:CORL, :provisioner)
   def ensure_environment(node)
     base_directory = Puppet[:environmentpath]
     environment    = node.lookup(:corl_environment)
-    env_directory  = File.join(base_directory, environment)
+
+    if environment.nil?
+      environment = node.lookup(:environment)
+
+      if environment.nil?
+        error("Environment facts 'corl_environment' or 'environment' must be set to provision", { :i18n => false })
+        return []
+      end
+    end
+
+    env_directory = File.join(base_directory, environment)
 
     FileUtils.mkdir_p(env_directory)
     FileUtils.mkdir_p(File.join(env_directory, 'manifests'))

data/lib/core/facade.rb

@@ -4,9 +4,9 @@ module Facade
 
   #-----------------------------------------------------------------------------
   # Facter lookup
-  
+
   @@facts = {}
-  
+
   def facts(reset = false)
     if reset || @@facts.empty?
       @@facts = {} if reset
@@ -18,103 +18,105 @@ module Facade
     end
     @@facts
   end
-  
+
   #---
-  
+
   def create_fact(name, value, weight = 1000)
-    Facter.collection.add(name.to_sym, { 
-      :value  => value, 
-      :weight => weight 
+    Facter.collection.add(name.to_sym, {
+      :value  => value,
+      :weight => weight
     })
   end
-  
+
   #---
-  
+
   def fact(name)
     silence do
       Facter.value(name)
     end
   end
-  
+
   #-----------------------------------------------------------------------------
   # Local identification
-  
+
   def public_ip
     if Config.fact(:vagrant_exists)
-      Config.fact(:ipaddress_eth1)  
+      ip_address = Config.fact(:ipaddress_eth1)
+      ip_address = Config.fact(:ipaddress_eth0) unless ip_address
+      ip_address
     else
-      CORL.ip_address  
+      CORL.ip_address
     end
   end
-  
+
   #-----------------------------------------------------------------------------
   # Vagrant related
-  
+
   def vagrant?
     Vagrant.command ? true : false
   end
-  
+
   #---
-  
+
   @@vagrant_config_loaded = false
-  
+
   def vagrant_config_loaded?
     @@vagrant_config_loaded
   end
-  
+
   def vagrant_config(directory, config, &code)
     Vagrant::Config.register(directory, config, &code)
     @@vagrant_config_loaded = true
   end
-    
+
   #-----------------------------------------------------------------------------
   # Core plugin type facade
-  
+
   def configuration(options, provider = nil)
     plugin(:CORL, :configuration, provider, options)
   end
-  
+
   def configurations(data, build_hash = false, keep_array = false)
     plugins(:CORL, :configuration, data, build_hash, keep_array)
   end
-  
+
   #-----------------------------------------------------------------------------
   # Cluster plugin type facade
-   
+
   def network(name, options = {}, provider = nil)
     plugin(:CORL, :network, provider, Config.ensure(options).import({ :name => name }))
   end
-  
+
   def networks(data, build_hash = false, keep_array = false)
     plugins(:CORL, :network, data, build_hash, keep_array)
   end
-   
+
   #---
-  
+
   def node(name, options = {}, provider = nil)
     plugin(:CORL, :node, provider, Config.ensure(options).import({ :name => name }))
   end
-  
+
   def nodes(data, build_hash = false, keep_array = false)
     plugins(:CORL, :node, data, build_hash, keep_array)
   end
-  
+
   #---
-  
+
   def builder(options, provider = nil)
     plugin(:CORL, :builder, provider, options)
   end
-  
+
   def builders(data, build_hash = false, keep_array = false)
     plugins(:CORL, :builder, data, build_hash, keep_array)
   end
-  
+
   #---
-  
+
   def provisioner(options, provider = nil)
     plugin(:CORL, :provisioner, provider, options)
   end
-  
+
   def provisioners(data, build_hash = false, keep_array = false)
     plugins(:CORL, :provisioner, data, build_hash, keep_array)
   end

data/lib/core/mixin/builder.rb

@@ -3,54 +3,54 @@ module CORL
 module Mixin
 module Builder
 module Global # Extend
-  
+
   #-----------------------------------------------------------------------------
   # Accessors / modifiers
-  
+
   def resource_joiner
     '::'
   end
-  
+
   #---
-  
+
   def id_joiner
     '__'
   end
-  
+
   #-----------------------------------------------------------------------------
   # Utilities
-  
+
   def id(name = nil)
     name = 'unknown' if name.nil?
     name       = [ name ] unless name.is_a?(Array)
     components = []
-    
+
     name.flatten.each do |component|
       components << component.to_s.gsub(resource_joiner, id_joiner)
     end
     components.join(id_joiner).to_sym
   end
-  
+
   #---
-  
+
   def resource(name = nil, capitalize = false)
     name = 'unknown' if name.nil?
     concatenate(name, capitalize, resource_joiner)
   end
-  
+
   #---
-  
+
   def concatenate(components, capitalize = false, joiner = nil)
     joiner = resource_joiner unless joiner
-    
+
     if components.is_a?(Array)
       components = components.collect do |str|
-        str.to_s.split(id_joiner)  
+        str.to_s.split(id_joiner)
       end.flatten
     else
       components = [ components.to_s.split(id_joiner) ].flatten
     end
-    
+
     if capitalize
       name = components.collect {|str| str.capitalize }.join(joiner)
     else
@@ -58,100 +58,100 @@ module Global # Extend
     end
     name
   end
-  
+
   #---
-  
+
   def process_environment(settings, environment = nil)
-    config      = Config.new(hash(settings))
+    config      = Config.new(hash(settings), {}, true, false)
     env_config  = config.delete(:environment)
     environment = environment.to_sym if environment
-    
-    if env_config    
+
+    if env_config
       if environment && env_config.has_key?(environment)
         local_env_config = env_config[environment]
-        
+
         while local_env_config && local_env_config.has_key?(:use) do
           local_env_config = env_config[local_env_config[:use].to_sym]
         end
-         
+
         config.defaults(local_env_config) if local_env_config
       end
       config.defaults(env_config[:default]) if env_config.has_key?(:default)
     end
-    config.export 
+    config.export
   end
 end
 
 #-------------------------------------------------------------------------------
 
 module Instance # Include
-  
+
   extend Global
-    
+
   #-----------------------------------------------------------------------------
   # Accessors / modifiers
-  
+
   def resource_joiner
     self.class.resource_joiner
   end
-  
+
   #---
-  
+
   def id_joiner
     self.class.id_joiner
   end
-  
+
   #---
-  
+
   def build_directory
     network.build_directory
   end
-  
+
   #---
-  
+
   def build_config
     return network.build if network
     nil
   end
- 
+
   #---
-  
+
   def build_lock
     self.class.build_lock
   end
-  
+
   #-----------------------------------------------------------------------------
   # Utilities
-  
+
   def id(name = nil)
     name = plugin_name if name.nil?
     self.class.id(name)
   end
-  
+
   #---
-  
+
   def resource(name = nil, capitalize = false)
     name = plugin_name if name.nil?
     self.class.resource(name, capitalize)
   end
-  
+
   #---
-  
+
   def concatenate(components, capitalize = false, joiner = nil)
     self.class.concatenate(components, capitalize, joiner)
   end
-  
+
   #---
-  
+
   def internal_path(directory)
     directory.gsub(network.directory + "/", '')
   end
-  
+
   #---
-  
+
   def process_environment(settings, environment = nil)
     self.class.process_environment(settings, environment)
-  end  
+  end
 end
 end
 end

data/lib/core/mixin/machine/ssh.rb

@@ -5,122 +5,122 @@ module SSH
 
   #-----------------------------------------------------------------------------
   # SSH Operations
-       
+
   def init_ssh_session(reset = false, tries = 12, sleep_secs = 5)
     ssh_wait_for_ready
-    
+
     success     = true
-    
-    public_ip   = node.public_ip
+
+    public_ip   = node.public_ip(true)
     user        = node.user
     ssh_port    = node.ssh_port
     private_key = node.private_key
-    
-    ssh_config  = Config.new({ 
+
+    ssh_config  = Config.new({
       :keypair  => node.keypair,
       :key_dir  => node.network.key_cache_directory,
-      :key_name => node.plugin_name 
+      :key_name => node.plugin_name
     })
-    
+
     begin
       Util::SSH.session(public_ip, user, ssh_port, private_key, reset, ssh_config)
       node.keypair = ssh_config[:keypair]
-            
+
     rescue Net::SSH::HostKeyMismatch => error
       error.remember_host!
       sleep 0.2
       reset = true
       retry
 
-    rescue Errno::ECONNREFUSED, Net::SSH::ConnectionTimeout, Net::SSH::Disconnect => error     
+    rescue Errno::ECONNREFUSED, Net::SSH::ConnectionTimeout, Net::SSH::Disconnect => error
       if tries > 1
         sleep(sleep_secs)
-        
+
         tries -= 1
         reset  = true
         retry
       else
         success = false
       end
-      
+
     rescue => error
       warn(error, { :i18n => false })
       success = false
     end
     success
   end
-  
+
   #---
-  
+
   def ssh_download(remote_path, local_path, options = {}, &code)
     config  = Config.ensure(options)
     success = false
-    
+
     begin
       if init_ssh_session
         Util::SSH.download(node.public_ip, node.user, remote_path, local_path, config.export) do |name, received, total|
           code.call(name, received, total) if code
         end
         success = true
-      end  
+      end
     rescue => error
       error(error.message, { :i18n => false })
     end
-    
+
     success
   end
-  
+
   #---
-  
+
   def ssh_upload(local_path, remote_path, options = {}, &code)
     config  = Config.ensure(options)
     success = false
-    
+
     begin
       if init_ssh_session
         Util::SSH.upload(node.public_ip, node.user, local_path, remote_path, config.export) do |name, sent, total|
           code.call(name, sent, total) if code
         end
         success = true
-      end  
+      end
     rescue => error
       error(error.message, { :i18n => false })
     end
-    
-    success  
+
+    success
   end
-  
+
   #---
-  
+
   def ssh_exec(commands, options = {}, &code)
     config  = Config.ensure(options)
     results = nil
-    
-    if commands && commands = commands.clone
+
+    if commands && commands = Util::Data.array(commands)
       if init_ssh_session
         results = Util::SSH.exec(node.public_ip, node.user, commands) do |type, command, data|
-          code.call(type, command, data) if code  
+          code.call(type, command, data) if code
         end
       end
     end
     results
   end
-  
+
   #---
-  
+
   def close_ssh_session
     Util::SSH.close_session(node.public_ip, node.user)
   end
-  
+
   #---
-  
+
   def ssh_terminal(user, options = {})
     Util::SSH.terminal(node.public_ip, user, Config.ensure(options).export)
   end
-  
+
   #-----------------------------------------------------------------------------
   # Utilities
-  
+
   def ssh_wait_for_ready
     # Override in class if needed (see Fog Machine provider)
   end

data/lib/core/mod/vagrant.rb

@@ -0,0 +1,32 @@
+
+module VagrantPlugins
+module CommunicatorSSH
+class Communicator
+  # Override Vagrant key insertion (we handle generated keys internally)
+  def ready?
+    @logger.debug("Checking whether SSH is ready...")
+
+    # Attempt to connect. This will raise an exception if it fails.
+    begin
+      connect
+      @logger.info("SSH is ready!")
+    rescue Vagrant::Errors::VagrantError => e
+      # We catch a `VagrantError` which would signal that something went
+      # wrong expectedly in the `connect`, which means we didn't connect.
+      @logger.info("SSH not up: #{e.inspect}")
+      dbg(e.inspect, 'error')
+      return false
+    end
+
+    # Verify the shell is valid
+    if execute("", error_check: false) != 0
+      raise Vagrant::Errors::SSHInvalidShell
+    end
+
+    # If we reached this point then we successfully connected
+    dbg('connected')
+    true
+  end
+end
+end
+end