corl 0.5.4 → 0.5.5

data/lib/core/util/puppet.rb

@@ -2,24 +2,24 @@
 module CORL
 module Util
 module Puppet
-  
+
   def self.logger
     CORL.logger
   end
-  
+
   #-----------------------------------------------------------------------------
   # Plugins
-  
+
   @@register = {}
-  
+
   #---
-  
+
   def self.register_plugins(options = {})
     config = Config.ensure(options)
-    
+
     puppet_scope = config.get(:puppet_scope, nil)
     return unless puppet_scope
-    
+
     each_module(config) do |mod|
       unless @@register.has_key?(mod.path)
         lib_dir = File.join(mod.path, 'lib')
@@ -31,91 +31,91 @@ module Puppet
       end
     end
   end
-    
+
   #-----------------------------------------------------------------------------
   # Resources
-           
+
   def self.type_info(type_name, options = {})
     config = Config.ensure(options)
     reset  = config.get(:reset, false)
-    
+
     puppet_scope = config.get(:puppet_scope, nil)
     return nil unless puppet_scope
-    
+
     type_name = type_name.to_s.downcase
     type_info = config.get(:type_info, {})
-    
-    if reset || ! type_info.has_key?(type_name)    
-      resource_type = nil       
+
+    if reset || ! type_info.has_key?(type_name)
+      resource_type = nil
       type_exported, type_virtual = false
-        
+
       if type_name.start_with?('@@')
         type_name     = type_name[2..-1]
         type_exported = true
-          
+
       elsif type_name.start_with?('@')
         type_name    = type_name[1..-1]
         type_virtual = true
       end
-        
+
       if type_name == 'class'
         resource_type = :class
       else
         if resource = ::Puppet::Type.type(type_name.to_sym)
           resource_type = :type
-            
+
         elsif resource = puppet_scope.find_definition(type_name)
           resource_type = :define
         end
       end
-      
+
       type_info[type_name] = {
-        :name     => type_name, 
-        :type     => resource_type, 
-        :resource => resource, 
-        :exported => type_exported, 
-        :virtual  => type_virtual 
+        :name     => type_name,
+        :type     => resource_type,
+        :resource => resource,
+        :exported => type_exported,
+        :virtual  => type_virtual
       }
       config.set(:type_info, type_info)
     end
-    
-    type_info[type_name]  
+
+    type_info[type_name]
   end
-  
+
   #-----------------------------------------------------------------------------
   # Catalog alterations
-      
+
   def self.add(type_name, resources, defaults = {}, options = {})
     config  = Config.ensure(options)
-    
-    puppet_scope = config.get(:puppet_scope, nil)    
+
+    puppet_scope = config.get(:puppet_scope, nil)
     return unless puppet_scope
-    
+
     info = type_info(type_name, options)
-    
+
     if config.get(:debug, false)
       CORL.ui.info("\n", { :prefix => false })
       CORL.ui_group(Util::Console.purple(info[:name])) do |ui|
         ui.info("-----------------------------------------------------")
       end
-    end   
+    end
     ResourceGroup.new(info, defaults).add(resources, config)
   end
-  
+
   #---
-  
+
   def self.add_resource(type, title, properties, options = {})
     config  = Config.ensure(options)
-    
-    puppet_scope = config.get(:puppet_scope, nil)    
+
+    puppet_scope = config.get(:puppet_scope, nil)
     return unless puppet_scope
-    
+
     if type.is_a?(String)
       type = type_info(type, config)
     end
-    
+
     display_name = puppet_scope.parent_module_name ? puppet_scope.parent_module_name : 'toplevel'
-    
+
     case type[:type]
     when :type, :define
       CORL.ui_group(Util::Console.cyan(display_name)) do |ui|
@@ -135,82 +135,82 @@ module Puppet
   end
 
   #---
-  
+
   def self.add_class(title, properties, options = {})
-    config       = Config.ensure(options)    
+    config       = Config.ensure(options)
     puppet_scope = config.get(:puppet_scope, nil)
-        
+
     if puppet_scope
       klass = puppet_scope.find_hostclass(title)
       return unless klass
-      
+
       debug_resource(config, title, properties)
       klass.ensure_in_catalog(puppet_scope, properties)
       puppet_scope.catalog.add_class(title)
-    end  
+    end
   end
-    
+
   #---
-  
+
   def self.add_definition(type, title, properties, options = {})
     config = Config.ensure(options)
-    
-    puppet_scope = config.get(:puppet_scope, nil)    
+
+    puppet_scope = config.get(:puppet_scope, nil)
     return unless puppet_scope
-        
+
     type = type_info(type, config) if type.is_a?(String)
-        
+
     resource          = ::Puppet::Parser::Resource.new(type[:name], title, :scope => puppet_scope, :source => type[:resource])
     resource.virtual  = type[:virtual]
     resource.exported = type[:exported]
-    
+
     namevar       = namevar(type[:name], title).to_sym
     resource_name = properties.has_key?(namevar) ? properties[namevar] : title
     properties    = { :name => resource_name }.merge(properties)
-    
+
     properties.each do |key, value|
       resource.set_parameter(key, value)
     end
     if type[:type] == :define
       type[:resource].instantiate_resource(puppet_scope, resource)
     end
-    
+
     debug_resource(config, title, properties)
     puppet_scope.compiler.add_resource(puppet_scope, resource)
   end
-    
+
   #--
-  
+
   def self.import(files, options = {})
-    config = Config.ensure(options)    
-    
-    puppet_scope = config.get(:puppet_scope, nil)  
+    config = Config.ensure(options)
+
+    puppet_scope = config.get(:puppet_scope, nil)
     return unless puppet_scope
-    
+
     if types = puppet_scope.environment.known_resource_types
       Util::Data.array(files).each do |file|
         types.loader.import(file, config.get(:puppet_import_base, nil))
       end
     end
   end
-  
+
   #---
-  
+
   def self.include(resource_name, properties = {}, options = {})
     config     = Config.ensure(options)
     class_data = {}
-        
+
     puppet_scope = config.get(:puppet_scope, nil)
     return false unless puppet_scope
-    
+
     display_name = puppet_scope.parent_module_name ? puppet_scope.parent_module_name : 'toplevel'
-    
+
     if resource_name.is_a?(Array)
       resource_name = resource_name.flatten
     else
       resource_name = [ resource_name ]
     end
-    
+
     resource_name.each do |name|
       classes = Config.lookup(name, nil, config)
       if classes.is_a?(Array)
@@ -224,19 +224,19 @@ module Puppet
         end
       end
     end
-    
-    if config.get(:debug, false)      
+
+    if config.get(:debug, false)
       CORL.ui.info("\n", { :prefix => false })
       CORL.ui_group(Util::Console.cyan("#{display_name} include")) do |ui|
         ui.info("-----------------------------------------------------")
-        
-        dump = Util::Console.green(Util::Data.to_json(class_data, true))        
-        
+
+        dump = Util::Console.green(Util::Data.to_json(class_data, true))
+
         ui.info(":\n#{dump}")
-        ui.info("\n", { :prefix => false }) 
+        ui.info("\n", { :prefix => false })
       end
     end
-    
+
     klasses = puppet_scope.compiler.evaluate_classes(class_data, puppet_scope, false)
     missing = class_data.keys.find_all do |klass|
       ! klasses.include?(klass)
@@ -244,46 +244,46 @@ module Puppet
     return false unless missing.empty?
     true
   end
-    
+
   #-----------------------------------------------------------------------------
   # Lookup
-  
+
   def self.lookup(property, default = nil, options = {})
     config = Config.ensure(options)
     value  = nil
-    
-    puppet_scope   = config.get(:puppet_scope, nil)    
-    base_names     = config.get(:search, nil)     
+
+    puppet_scope   = config.get(:puppet_scope, nil)
+    base_names     = config.get(:search, nil)
     search_name    = config.get(:search_name, true)
     reverse_lookup = config.get(:reverse_lookup, true)
-    
+
     return default unless puppet_scope
-    
+
     log_level = ::Puppet::Util::Log.level
     ::Puppet::Util::Log.level = :err # Don't want failed parameter lookup warnings here.
-      
+
     if base_names
       if base_names.is_a?(String)
         base_names = [ base_names ]
       end
       base_names = base_names.reverse if reverse_lookup
-        
+
       base_names.each do |base|
         search_property_name = "#{base}::#{property}"
-        
+
         value = puppet_scope.lookupvar("::#{search_property_name}")
         Config.debug_lookup(config, search_property_name, value, "Puppet override lookup")
-        
-        break unless value.nil?  
+
+        break unless value.nil?
       end
     end
     if value.nil?
       components = property.to_s.split('::')
-      
+
       if components.length > 1
         components          += [ 'default', components.pop ]
         search_property_name = components.flatten.join('::')
-        
+
         value = puppet_scope.lookupvar("::#{search_property_name}")
         Config.debug_lookup(config, search_property_name, value, "Puppet default lookup")
       end
@@ -292,65 +292,65 @@ module Puppet
       value = puppet_scope.lookupvar("::#{property}")
       Config.debug_lookup(config, property, value, "Puppet name lookup")
     end
-    
+
     ::Puppet::Util::Log.level = log_level
-    value      
+    value
   end
-   
+
   #-----------------------------------------------------------------------------
   # Utilities
-  
+
   def self.each_module(options = {}, &code)
     config = Config.ensure(options)
     values = []
-    
-    puppet_scope = config.get(:puppet_scope, nil)  
+
+    puppet_scope = config.get(:puppet_scope, nil)
     return nil unless puppet_scope
-    
+
     puppet_scope.compiler.environment.modules.each do |mod|
       values << code.call(mod)
     end
     values
   end
-  
+
   #---
- 
+
   def self.to_name(name)
     Util::Data.value(name).to_s.gsub(/[\/\\\-\.]/, '_')
   end
-  
+
   #---
-  
+
   def self.type_name(value)
     return :main if value == :main
     return "Class" if value == "" or value.nil? or value.to_s.downcase == "component"
     value.to_s.split("::").collect { |s| s.capitalize }.join("::")
   end
-  
+
   #---
-  
+
   def self.namevar(type_name, resource_name)
     resource = ::Puppet::Resource.new(type_name.sub(/^\@?\@/, ''), resource_name)
-    
+
     if resource.builtin_type? and type = resource.resource_type and type.key_attributes.length == 1
       type.key_attributes.first.to_s
     else
       'name'
     end
   end
-  
+
   #---
-  
+
   def self.debug_resource(config, title, properties)
     if config.get(:debug, false)
       CORL.ui_group(Util::Console.cyan(title.to_s)) do |ui|
-        dump = Util::Console.green(Util::Data.to_json(properties, true))        
-        
+        dump = Util::Console.green(Util::Data.to_json(properties, true))
+
         ui.info(":\n#{dump}")
-        ui.info("\n", { :prefix => false })       
+        ui.info("\n", { :prefix => false })
       end
     end
-  end      
+  end
 end
 end
 end

data/lib/core/vagrant/provisioner/config.rb

@@ -11,67 +11,80 @@ class CORL < ::Vagrant.plugin("2", :config)
     super
     @network           = UNSET_VALUE
     @node              = UNSET_VALUE
-    
+
     @force_updates     = false
     @user_home         = UNSET_VALUE
     @user_home_env_var = UNSET_VALUE
-    
+
     @root_user         = UNSET_VALUE
     @root_home         = UNSET_VALUE
-    
+
     @bootstrap         = UNSET_VALUE
     @bootstrap_path    = UNSET_VALUE
     @bootstrap_glob    = UNSET_VALUE
     @bootstrap_init    = UNSET_VALUE
+    @bootstrap_scripts = UNSET_VALUE
+    @reboot            = true
+    @dev_build         = false
+    @ruby_version      = UNSET_VALUE
+
     @auth_files        = UNSET_VALUE
-    
+
     @seed              = UNSET_VALUE
     @project_reference = UNSET_VALUE
     @project_branch    = UNSET_VALUE
-    
+
+    @environment       = UNSET_VALUE
+    @build             = true
     @provision         = false
     @dry_run           = false
   end
-  
+
   #---
-  
+
   def finalize!
     super
     @user_home         = nil if @user_home == UNSET_VALUE
     @user_home_env_var = nil if @user_home_env_var == UNSET_VALUE
-    
+
     @root_user         = nil if @root_user == UNSET_VALUE
     @root_home         = nil if @root_home == UNSET_VALUE
-    
+
     @bootstrap         = nil if @bootstrap == UNSET_VALUE
     @bootstrap_path    = nil if @bootstrap_path == UNSET_VALUE
     @bootstrap_glob    = nil if @bootstrap_glob == UNSET_VALUE
     @bootstrap_init    = nil if @bootstrap_init == UNSET_VALUE
+    @bootstrap_scripts = nil if @bootstrap_scripts == UNSET_VALUE
+    @ruby_version      = nil if @ruby_version == UNSET_VALUE
+
     @auth_files        = nil if @auth_files == UNSET_VALUE
-    
+
     @seed              = nil if @seed == UNSET_VALUE
     @project_reference = nil if @project_reference == UNSET_VALUE
     @project_branch    = nil if @project_branch == UNSET_VALUE
+
+    @environment       = nil if @environment == UNSET_VALUE
   end
-  
+
   #-----------------------------------------------------------------------------
   # Property accessor / modifiers
-  
-  attr_accessor :network, :node  
+
+  attr_accessor :network, :node
   attr_accessor :force_updates, :user_home, :user_home_env_var, :root_user, :root_home
-  
-  attr_accessor :bootstrap, :bootstrap_path, :bootstrap_glob, :bootstrap_init, :auth_files 
+
+  attr_accessor :bootstrap, :bootstrap_path, :bootstrap_glob, :bootstrap_init, :bootstrap_scripts
+  attr_accessor :reboot, :dev_build, :ruby_version, :auth_files
   attr_accessor :seed, :project_reference, :project_branch
-  attr_accessor :provision, :dry_run
-  
+  attr_accessor :environment, :build, :provision, :dry_run
+
   #-----------------------------------------------------------------------------
   # Validation
 
   def validate(machine)
     errors = _detected_errors
-    
+
     # TODO: Validation (with action config validators)
-        
+
     { "CORL provisioner" => errors }
   end
 end

data/lib/core/vagrant/provisioner/provisioner.rb

@@ -3,20 +3,20 @@ module VagrantPlugins
 module CORL
 module Provisioner
 class CORL < ::Vagrant.plugin("2", :provisioner)
- 
+
   #-----------------------------------------------------------------------------
   # Constructor / Destructor
- 
+
   def initialize(machine, config)
     super
   end
-  
+
   #-----------------------------------------------------------------------------
   # Operations
 
   def configure(root_config)
   end
-  
+
   #---
 
   def provision
@@ -26,10 +26,10 @@ class CORL < ::Vagrant.plugin("2", :provisioner)
         # This serves as a Vagrant VM manager.
         ::CORL::Vagrant.command = Command::Launcher.new([], @machine.env)
       end
-    
+
       network = config.network
       node    = config.node
-      
+
       if network && node
         # Provision the server
         success = network.init_node(node, clean(::CORL.config(:vagrant_node_init, {
@@ -42,30 +42,36 @@ class CORL < ::Vagrant.plugin("2", :provisioner)
           :bootstrap_path    => config.bootstrap_path,
           :bootstrap_glob    => config.bootstrap_glob,
           :bootstrap_init    => config.bootstrap_init,
+          :bootstrap_scripts => config.bootstrap_scripts,
+          :reboot            => config.reboot,
+          :dev_build         => config.dev_build,
+          :ruby_version      => config.ruby_version,
           :auth_files        => config.auth_files,
           :seed              => config.seed,
           :project_reference => config.project_reference,
           :project_branch    => config.project_branch,
+          :environment       => config.environment,
+          :build             => config.build,
           :provision         => config.provision,
           :dry_run           => config.dry_run
         }).export))
-        
+
         node.warn("CORL provisioner failed", { :i18n => false }) unless success
       end
     end
   end
-  
+
   #-----------------------------------------------------------------------------
   # Utilities
-  
+
   def clean(options)
     options.keys.each do |key|
       value = options[key]
       if value.nil?
         options.delete(key)
-      end  
+      end
     end
-    options  
+    options
   end
   protected :clean
 end

data/lib/nucleon/action/node/bootstrap.rb

@@ -25,6 +25,8 @@ class Bootstrap < Nucleon.plugin_class(:nucleon, :cloud_action)
       register_str :home_env_var, 'HOME'
       register_str :home, nil
 
+      register_str :ruby_version, nil
+
       register_str :bootstrap_glob, '**/*.sh'
       register_str :bootstrap_init, 'bootstrap.sh'
 

data/lib/nucleon/action/node/build.rb

@@ -3,42 +3,43 @@ module Nucleon
 module Action
 module Node
 class Build < Nucleon.plugin_class(:nucleon, :cloud_action)
-  
+
   #-----------------------------------------------------------------------------
   # Info
-  
+
   def self.describe
     super(:node, :build, 620)
   end
- 
+
   #-----------------------------------------------------------------------------
   # Settings
-  
+
   def configure
     super do
       register_str :environment
+      register_array :providers
     end
   end
-  
+
   #---
-  
+
   def arguments
     [ :environment ]
   end
 
   #-----------------------------------------------------------------------------
   # Operations
-   
+
   def execute
     super do |node|
-      info('start') 
+      info('start')
+
       ensure_node(node) do
         settings.delete(:environment) if settings[:environment] == ''
-        
+
         if settings.has_key?(:environment)
-          node.create_fact(:corl_environment, settings[:environment])
-        end 
-        
+          CORL.create_fact(:corl_environment, settings[:environment])
+        end
         node.build(settings)
       end
     end