corl 0.5.4 → 0.5.5

data/lib/CORL/provisioner/puppetnode.rb

@@ -2,33 +2,33 @@
 module CORL
 module Provisioner
 class Puppetnode < Nucleon.plugin_class(:CORL, :provisioner)
-  
+
   @@puppet_lock = Mutex.new
-  
+
   #---
-  
+
   @@status = {}
-  
+
   def self.status
     @@status
   end
-  
+
   #---
-  
+
   def self.network
     @@network
   end
-  
+
   def self.node
     @@node
   end
-  
+
   #-----------------------------------------------------------------------------
   # Provisioner plugin interface
-   
+
   def normalize(reload)
     super do
-      if CORL.log_level == :debug
+      if [ :debug, :info, :warn ].include? CORL.log_level
         Puppet.debug = true
       end
       unless reload
@@ -47,67 +47,70 @@ class Puppetnode < Nucleon.plugin_class(:CORL, :provisioner)
             str = msg.respond_to?(:multiline) ? msg.multiline : msg.to_s
             str = msg.source == "Puppet" ? str : "#{CORL.blue(msg.source)}: #{str}"
             level = levels[msg.level]
-            
-            if [ :warn, :error ].include?(level[:send])
+
+            if [ :error ].include?(level[:send])
               ::CORL::Provisioner::Puppetnode.status[name] = 111
             end
-        
+
             CORL.ui_group("puppetnode::#{name}(#{CORL.yellow(level[:name])})", :cyan) do |ui|
               ui.send(level[:send], str)
             end
+            puts caller if level[:send] == :error && [ :warn, :error ].include?(CORL.log_level)
           end
         end
       end
     end
   end
-    
+
   #---
-  
+
   def register(options = {})
     Util::Puppet.register_plugins(Config.ensure(options).defaults({ :puppet_scope => scope }))
   end
-  
+
   #-----------------------------------------------------------------------------
   # Property accessor / modifiers
-  
+
   def compiler
     @compiler
   end
-  
+
   #---
-  
+
   def scope
     return compiler.topscope if compiler
     nil
   end
-  
+
   #-----------------------------------------------------------------------------
   # Puppet initialization
-  
-  def init_puppet(node, profiles)    
+
+  def init_puppet(node, profiles)
     Puppet.initialize_settings
-    
+
     apply_environment = nil
     locations         = build_locations(node)
-    
-    environment, environment_directory = ensure_environment(node)    
-    
-    Puppet::Util::Log.newdestination(id)    
+
+    environment, environment_directory = ensure_environment(node)
+
+    Puppet::Util::Log.newdestination(id)
     Puppet::Transaction::Report.indirection.cache_class = :yaml
-    
+
     Puppet[:graph] = true if CORL.log_level == :error
-    
+
     Puppet[:node_terminus]         = :plain
     Puppet[:data_binding_terminus] = :corl
     Puppet[:default_file_terminus] = :file_server
-    
+
     unless profiles.empty?
       modulepath = profiles.collect do |profile|
-        profile_directory = File.join(network.directory, locations[:puppet_module][profile.to_sym])
-        File.directory?(profile_directory) ? profile_directory : nil
+        profile_path      = locations[:puppet_module][profile.to_sym]
+        profile_directory = nil
+        profile_directory = File.join(network.directory, profile_path) if profile_path
+        profile_directory && File.directory?(profile_directory) ? profile_directory : nil
       end.compact
     end
-    
+
     if manifest = gateway
       if manifest.match(/^packages\/.*/)
         manifest = File.join(network.build_directory, manifest)
@@ -115,54 +118,54 @@ class Puppetnode < Nucleon.plugin_class(:CORL, :provisioner)
         manifest = File.join(network.directory, directory, manifest)
       end
     end
-    
+
     Puppet[:environment] = environment
     Puppet::Node::Environment.create(environment.to_sym, modulepath, manifest)
   end
   protected :init_puppet
-    
+
   #---
-   
+
   def get_puppet_node(environment)
     Puppet[:node_name_value] = id.to_s
-    
+
     puppet_node = Puppet::Node.indirection.find(id.to_s, :environment => environment)
-    
-    puppet_node.merge(string_map(@@node.facts))    
+
+    puppet_node.merge(string_map(@@node.facts))
     puppet_node
   end
   protected :get_puppet_node
-  
+
   #-----------------------------------------------------------------------------
   # Provisioner interface operations
-  
+
   def build_profile(name, info, package, environment, profiles)
     super do |processed_info|
       package_id = id(package)
       directory  = File.join(internal_path(build_directory), package_id.to_s, name.to_s)
       success    = true
-        
-      info("Building CORL profile #{blue(name)} modules into #{green(directory)}", { :i18n => false })
-    
+
+      #info("Building CORL profile #{blue(name)} modules into #{green(directory)}", { :i18n => false })
+
       if processed_info.has_key?(:modules)
         status  = parallel(:build_module, hash(processed_info[:modules]), directory, name, environment)
         success = status.values.include?(false) ? false : true
-        
+
         build_config.set_location(:puppet_module, profile_id(package, name), directory) if success
       end
-      success("Build of profile #{blue(name)} finished", { :i18n => false }) if success
+      #success("Build of profile #{blue(name)} finished", { :i18n => false }) if success
       success
     end
   end
-  
+
   def build_module(name, project_reference, directory, profile, environment)
     module_directory      = File.join(directory, name.to_s)
     full_module_directory = File.join(network.directory, module_directory)
     module_project        = nil
     success               = true
-            
+
     info("Building #{blue(profile)} Puppet module #{blue(name)} at #{purple(project_reference)} into #{green(module_directory)}", { :i18n => false })
-    
+
     module_project = build_config.manage(:project, extended_config(:puppet_module, {
       :directory     => full_module_directory,
       :url           => project_reference,
@@ -175,55 +178,56 @@ class Puppetnode < Nucleon.plugin_class(:CORL, :provisioner)
       warn("Puppet module #{cyan(name)} failed to initialize", { :i18n => false })
       success = false
     end
-    success("Build of #{blue(profile)} #{blue(name)} finished", { :i18n => false }) if success
+    #success("Build of #{blue(profile)} #{blue(name)} finished", { :i18n => false }) if success
     success
   end
-  
+
   #---
-  
+
   def lookup(property, default = nil, options = {})
     Util::Puppet.lookup(property, default, Config.ensure(options).defaults({
       :provisioner  => :puppetnode,
       :puppet_scope => scope
     }))
   end
-  
+
   #--
-  
+
   def import(files, options = {})
     Util::Puppet.import(files, Config.ensure(options).defaults({
       :puppet_scope       => scope,
       :puppet_import_base => network.directory
     }))
   end
-  
+
   #---
-  
+
   def add_search_path(type, resource_name)
     Config.set_options([ :all, type ], { :search => [ resource_name.to_s ] })
   end
-   
+
   #---
-    
+
   def provision(node, profiles, options = {})
     super do |processed_profiles, config|
       locations = build_locations(node)
       success   = true
-    
+
       include_location = lambda do |type, parameters = {}, add_search_path = false|
         classes = {}
-            
-        locations[:package].each do |name, package_directory|
-          type_gateway = File.join(network.directory, package_directory, "#{type}.pp")
-          resource_name = resource([ name, type ])
-          
+
+        locations[:package].keys.reverse.each do |name|
+          package_directory = locations[:package][name]
+          type_gateway      = File.join(network.directory, package_directory, "#{type}.pp")
+          resource_name     = resource([ name, type ])
+
           add_search_path(type, resource_name) if add_search_path
-        
+
           if File.exists?(type_gateway)
             import(type_gateway)
             classes[resource_name] = parameters
           end
-        
+
           type_directory = File.join(network.directory, package_directory, type.to_s)
           Dir.glob(File.join(type_directory, '*.pp')).each do |file|
             resource_name = resource([ name, type, File.basename(file).gsub('.pp', '') ])
@@ -231,19 +235,19 @@ class Puppetnode < Nucleon.plugin_class(:CORL, :provisioner)
             classes[resource_name] = parameters
           end
         end
-    
+
         type_gateway = File.join(directory, "#{type}.pp")
         resource_name = resource([ plugin_name, type ])
-      
+
         add_search_path(type, resource_name) if add_search_path
-     
+
         if File.exists?(type_gateway)
           import(type_gateway)
           classes[resource_name] = parameters
         end
-    
+
         type_directory = File.join(directory, type.to_s)
-        
+
         if File.directory?(type_directory)
           Dir.glob(File.join(type_directory, '*.pp')).each do |file|
             resource_name = resource([ plugin_name, type, File.basename(file).gsub('.pp', '') ])
@@ -253,75 +257,77 @@ class Puppetnode < Nucleon.plugin_class(:CORL, :provisioner)
         end
         classes
       end
-      
+
       @@puppet_lock.synchronize do
         begin
           info("Starting catalog generation", { :i18n => false })
-          
+
           @@status[id] = code.success
-          @@network    = network    
+          @@network    = network
           @@node       = node
-          
+
           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)                 
+            puppet_node = get_puppet_node(apply_environment.name)
             @compiler   = Puppet::Parser::Compiler.new(puppet_node)
-            
+
             # Register Puppet module plugins
             register
-            
+
             # Include defaults
             classes = include_location.call(:default, {}, true)
-      
+
             # Import needed profiles
             include_location.call(:profiles, {}, false)
-      
+
             processed_profiles.each do |profile|
               classes[profile.to_s] = { :require => 'Anchor[profile_start]' }
             end
-            
+
             puppet_node.classes = classes
-            
+
             # Compile catalog
             compiler.compile
-            
+
             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", { :i18n => false })
-              
+
               # 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
               end
             end
           end
-        
+
         rescue Exception => error
           Puppet.log_exception(error)
-          raise error
+          success = false
         end
       end
-      
+
       success = false if @@status[id] != code.success
       success
     end
   end
-  
+
   #-----------------------------------------------------------------------------
   # Utilities
-  
+
   def ensure_environment(node)
     base_directory = Puppet[:environmentpath]
     environment    = node.lookup(:corl_environment)
     env_directory  = File.join(base_directory, environment)
-    
+
     FileUtils.mkdir_p(env_directory)
     FileUtils.mkdir_p(File.join(env_directory, 'manifests'))
     FileUtils.mkdir_p(File.join(env_directory, 'modules'))

data/lib/core/build.rb

@@ -1,37 +1,35 @@
 
 module CORL
-class Build < Core
-  
-  include Parallel
-  
+class Build
+
   #-----------------------------------------------------------------------------
   # Constructor / destructor
-  
+
   def initialize
-    @config    = Config.new
-    @locations = Config.new
-    
+    @config    = Config.new({}, {}, true, false)
+    @locations = Config.new({}, {}, true, false)
+
     @plurals   = {}
     @types     = {}
   end
-  
+
   #-----------------------------------------------------------------------------
   # Build lock
-  
+
   @@build_lock = Mutex.new
- 
+
   #---
-  
+
   def build_lock
     @@build_lock
   end
-  
+
   #-----------------------------------------------------------------------------
   # Type registration
-  
+
   def register(type, plural = nil)
     type = type.to_sym
-    
+
     if plural
       plural = plural.to_sym
     else
@@ -40,73 +38,73 @@ class Build < Core
     @plurals[plural] = type
     @types[type]     = Config.new
   end
-    
+
   #-----------------------------------------------------------------------------
   # Package configuration
-  
+
   def config
-    @config  
+    @config
   end
-  
+
   def import(config)
-    @config.import(config)  
+    @config.import(config)
   end
- 
+
   #-----------------------------------------------------------------------------
   # Build locations
-  
+
   def locations
     @locations
   end
-  
+
   def set_location(provider, name, directory)
     @locations.set([ provider, name ], directory)
   end
-  
+
   def remove_location(provider, name = nil)
     @locations.delete([ provider, name ])
   end
-  
+
   #-----------------------------------------------------------------------------
   # Addon build types
-    
+
   def method_missing(method, *args, &code)
     success = false
     result  = nil
-      
+
     if method.to_s.match(/^set\_([a-z].*)$/)
       name = $1.to_sym
-      
+
       if @types.has_key?(name) && args.length > 2
         @types[name].set([ args[0], args[1] ], args[2]) if args.length > 2
         success = true
       end
-      
+
     elsif method.to_s.match(/^remove\_([a-z].*)$/)
       name = $1.to_sym
-      
+
       if @types.has_key?(name) && args.length > 0
         @types[name].delete([ args[0], args[1] ])
         success = true
       end
-      
+
     else
       name = @plurals[method.to_sym]
-      
+
       if name && @types.has_key?(name)
         result  = @types[name]
         success = true
-      end  
+      end
     end
     super unless success # Raise NoMethodError
     result
   end
-  
+
   #-----------------------------------------------------------------------------
   # Builders
-  
+
   def manage(plugin_type, options = {})
     CORL.send(plugin_type, options)
-  end 
+  end
 end
 end

data/lib/core/plugin/network.rb

@@ -409,7 +409,7 @@ class Network < Nucleon.plugin_class(:nucleon, :base)
 
         if success && seed_project
           # Seed machine with remote project reference
-          result = node.node_seed({
+          result = node.action(:node_seed, {
             :project_reference => seed_project,
             :project_branch    => seed_branch
           }) do |op, data|
@@ -423,7 +423,7 @@ class Network < Nucleon.plugin_class(:nucleon, :base)
 
       if success && provision
         # Run configured provisioners on machine
-        result = node.node_provision(config) do |op, data|
+        result = node.action(:node_provision, config) do |op, data|
           yield("provision_#{op}".to_sym, data)
         end
         success = result.status == code.success