corl 0.5.4 → 0.5.5

data/lib/core/plugin/node.rb

@@ -547,8 +547,10 @@ class Node < Nucleon.plugin_class(:nucleon, :base)
     success = false if status.values.include?(false)
 
     if success
-      status  = parallel(:build_provisioners, provisioners, config)
-      success = false if status.values.include?(false)
+      if array(config[:providers]).empty? || array(config[:providers]).include?("package")
+        status  = parallel(:build_provisioners, provisioners, config)
+        success = false if status.values.include?(false)
+      end
 
       if success
         myself.build_time = Time.now.to_s if success
@@ -569,18 +571,20 @@ class Node < Nucleon.plugin_class(:nucleon, :base)
   end
 
   def build_provider(provider, plugin, config)
-    info("Building #{provider} components", { :i18n => false })
-    plugin.build(myself, config)
+    if array(config[:providers]).empty? || array(config[:providers]).include?(provider.to_s)
+      #info("Building #{provider} components", { :i18n => false })
+      plugin.build(myself, config)
+    end
   end
 
   def build_provisioners(provider, collection, config)
-    info("Building #{provider} provisioner collection", { :i18n => false })
+    #info("Building #{provider} provisioner collection", { :i18n => false })
     status = parallel(:build_provisioner, collection, provider, config)
     status.values.include?(false) ? false : true
   end
 
   def build_provisioner(name, plugin, provider, config)
-    info("Building #{provider} #{name} provisioner components", { :i18n => false })
+    #info("Building #{provider} #{name} provisioner components", { :i18n => false })
     plugin.build(myself, config)
   end
 
@@ -827,10 +831,14 @@ class Node < Nucleon.plugin_class(:nucleon, :base)
             test = active_machine.exec(commands, config.export) do |type, command, data|
               unless quiet
                 unless local?
-                  if type == :error
-                    warn(filter_output(type, data), { :i18n => false })
-                  else
-                    info(filter_output(type, data), { :i18n => false })
+                  text_output = filter_output(type, data).rstrip
+
+                  unless text_output.empty?
+                    if type == :error
+                      warn(text_output, { :i18n => false })
+                    else
+                      info(text_output, { :i18n => false })
+                    end
                   end
                 end
                 yield(:progress, { :type => type, :command => command, :data => data }) if block_given?
@@ -888,8 +896,10 @@ class Node < Nucleon.plugin_class(:nucleon, :base)
 
     admin_command = ''
     if as_admin
-      admin_command = 'sudo' if user.to_s != 'root'
+      admin_command = config.delete(:admin_command, 'sudo -i') if user.to_s != 'root'
       admin_command = extension_set(:admin_command, admin_command, config)
+    else
+      config.delete(:admin_command)
     end
 
     config[:commands] = [ "#{admin_command} #{command.to_s}".strip ]
@@ -921,8 +931,13 @@ class Node < Nucleon.plugin_class(:nucleon, :base)
       :data    => { :encoded => encoded_config }
     })
 
-    quiet  = config.get(:quiet, false)
-    result = command(:corl, { :subcommand => action_config, :as_admin => true, :quiet => quiet }) do |op, data|
+    quiet    = config.get(:quiet, false)
+    parallel = config.get(:parallel, true)
+
+    command_base  = 'corl'
+    command_base  = "NUCLEON_NO_PARALLEL=1 #{command_base}" unless parallel
+
+    result = command(command_base, { :subcommand => action_config, :as_admin => true, :quiet => quiet }) do |op, data|
       yield(op, data) if block_given?
     end
 
@@ -986,8 +1001,9 @@ class Node < Nucleon.plugin_class(:nucleon, :base)
     user_home  = config[:home]
     auth_files = config.get_array(:auth_files)
 
-    reboot    = config.get(:reboot, true)
-    dev_build = config.get(:dev_build, false)
+    reboot       = config.get(:reboot, true)
+    dev_build    = config.get(:dev_build, false)
+    ruby_version = config.get(:ruby_version, nil)
 
     codes :local_path_not_found,
           :home_path_lookup_failure,
@@ -1018,7 +1034,7 @@ class Node < Nucleon.plugin_class(:nucleon, :base)
           auth_files     = package_files.collect { |path| "'#{path}'"}
           root_home_path = config.get(:root_home, '/root')
 
-          result        = command("cp #{auth_files.join(' ')} #{root_home_path}", { :as_admin => true })
+          result        = command("cp #{auth_files.join(' ')} #{root_home_path}", { :as_admin => true, :admin_command => 'sudo' })
           myself.status = code.root_auth_copy_failure unless result.status == code.success
         end
 
@@ -1040,6 +1056,7 @@ class Node < Nucleon.plugin_class(:nucleon, :base)
             remote_script = File.join(remote_bootstrap_path, bootstrap_init)
             environment   = "HOSTNAME='#{hostname}' "
             environment  << "DEVELOPMENT_BUILD=1 " if dev_build
+            environment  << "RUBY_RVM_VERSION='#{ruby_version}' " if ruby_version
             script_names  = bootstrap_scripts.empty? ? '' : bootstrap_scripts.join(' ')
 
             myself.bootstrap_script = remote_script
@@ -1374,6 +1391,11 @@ class Node < Nucleon.plugin_class(:nucleon, :base)
       if data =~ /^Already evaluated [a-z]+ at [^,]+, reevaluating anyways$/
         data = ''
       end
+    elsif type == :error
+      # Hide Rubinius SAFE warning
+      if data == 'WARNING: $SAFE is not supported on Rubinius.'
+        data = ''
+      end
     end
     data
   end

data/lib/core/plugin/provisioner.rb

@@ -2,73 +2,73 @@
 module CORL
 module Plugin
 class Provisioner < Nucleon.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
-  
+
   #-----------------------------------------------------------------------------
   # Checks
 
   def initialized?(options = {})
   end
-  
+
   #-----------------------------------------------------------------------------
   # Property accessors / modifiers
 
   network_settings :provisioner
 
   #---
-  
+
   def directory=directory
     myself[:directory] = directory
   end
-  
+
   def directory
     File.join(network.directory, myself[:directory])
   end
-  
+
   #---
-  
+
   def build_directory
     File.join(network.build_directory, 'provisioners', plugin_provider.to_s)
   end
-  
+
   #---
-  
+
   def gateway=gateway
     myself[:gateway] = gateway
   end
-  
+
   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]      
+          gateway  = gateways[index]
         end
       end
-    end    
+    end
     gateway
   end
-  
+
   def package_gateways(node, reset = false)
     gateways = []
     build_info(node, reset).each do |package_name, package_info|
@@ -76,28 +76,28 @@ class Provisioner < Nucleon.plugin_class(:nucleon, :base)
     end
     gateways
   end
-  
+
   #---
-  
+
   def find_profiles(node, reset = false)
-    allowed_profiles = []  
+    allowed_profiles = []
     build_info(node, reset).each do |package_name, package_info|
       hash(package_info[:profiles]).each do |profile_name, profile_info|
         allowed_profiles << resource([ package_name, 'profile', profile_name ])
       end
     end
-    allowed_profiles  
+    allowed_profiles
   end
   protected :find_profiles
-  
+
   #---
-  
+
   def supported_profiles(node, profile_names = nil)
-    found    = []    
+    found    = []
     profiles = build_profiles(node)
-    
+
     if profile_names.nil?
-      found = profiles  
+      found = profiles
     else
       profile_names.each do |name|
         name = name.to_s
@@ -108,16 +108,16 @@ class Provisioner < Nucleon.plugin_class(:nucleon, :base)
     end
     found.empty? ? false : found
   end
-   
+
   #---
-  
+
   def profile_dependencies(node, profiles)
-    dependencies  = build_dependencies(node)[:profile]    
+    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)
@@ -125,196 +125,196 @@ class Provisioner < Nucleon.plugin_class(:nucleon, :base)
       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(node, reset = false)
     locations = cache_setting(:build_locations, {}, :hash)
     build(node) if reset || locations.empty?
     symbol_map(cache_setting(:build_locations, {}, :hash))
   end
-  
+
   #---
-  
+
   def build_info(node, reset = false)
     info = cache_setting(:build_info, {}, :hash)
     build(node) if reset || info.empty?
     symbol_map(cache_setting(:build_info, {}, :hash))
   end
-  
+
   #---
-  
+
   def build_profiles(node, reset = false)
     profiles = cache_setting(:build_profiles, [], :array)
     build(node) if reset || profiles.empty?
     cache_setting(:build_profiles, [], :array)
   end
-  
+
   #-----------------------------------------------------------------------------
   # Provisioner operations
- 
+
   def register(options = {})
     # Implement in providers
   end
-  
+
   #---
-  
+
   def build(node, options = {})
-    config        = Config.ensure(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
-    
+
     provider_info.each do |package, info|
       package_info = Config.new(info)
       profiles     = {}
-      
+
       hash(package_info[:profiles]).each do |name, profile_info|
         profiles[profile_id(package, name)] = profile_info
       end
-      
+
       package_info[:profiles] = profiles
-      combined_info.import(package_info)  
+      combined_info.import(package_info)
     end
-    
-    FileUtils.mkdir_p(build_directory)   
-    
+
+    FileUtils.mkdir_p(build_directory)
+
     status  = parallel(:build_provider, provider_info, environment, combined_info)
     success = status.values.include?(false) ? false : true
-    
-    if success    
+
+    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
-    success    
+    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
-  
+
   #---
-  
+
   def lookup(property, default = nil, options = {})
     # Implement in providers
     nil
   end
-  
+
   #---
-  
+
   def provision(node, profiles, options = {})
-    config   = Config.ensure(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
+
+    Config.save_properties(Config.get_options(:corl_log))
     success
   end
-       
+
   #-----------------------------------------------------------------------------
   # Utilities
-  
-  def self.build_info(namespace, plugin_type, data)  
+
+  def self.build_info(namespace, plugin_type, data)
     data = data.split(/\s*,\s*/) if data.is_a?(String)
     super(namespace, plugin_type, data)
   end
-  
+
   #---
-   
+
   def self.translate(data)
     options = super(data)
-    
-    case data        
+
+    case data
     when String
       options = { :profiles => array(data) }
     when Hash
       options = data
     end
-    
+
     if options.has_key?(:profiles)
       if matches = translate_reference(options[:profiles])
         options[:provider] = matches[:provider]
         options[:profiles] = matches[:profiles]
-        
-        logger.debug("Translating provisioner options: #{options.inspect}")  
+
+        logger.debug("Translating provisioner options: #{options.inspect}")
       end
     end
     options
   end
-  
+
   #---
-  
+
   def self.translate_reference(reference)
     # ex: puppetnode:::profile::something,profile::somethingelse
     if reference && reference.match(/^\s*([a-zA-Z0-9_-]+):::([^\s]+)\s*$/)
       provider = $1
       profiles = $2
-      
+
       logger.debug("Translating provisioner reference: #{provider} #{profiles}")
-      
+
       info = {
         :provider => provider,
         :profiles => profiles.split(/\s*,\s*/)
       }
-      
+
       logger.debug("Project reference info: #{info.inspect}")
       return info
     end
     nil
   end
-  
+
   #---
-  
+
   def translate_reference(reference)
     self.class.translate_reference(reference)
   end
-    
+
   #---
-  
+
   def profile_id(package, profile)
     concatenate([ package, 'profile', profile ], false)
   end