corl 0.4.3 → 0.4.4

data/lib/core/mod/hiera_backend.rb

@@ -1,63 +1,46 @@
-begin
-  require 'hiera/backend'
 
-  class Hiera
-    module Backend
-      #
-      # NOTE: This function is overridden so we can collect accumulated hiera
-      # parameters and their values on a particular puppet run for reporting 
-      # purposes.
-      #
-      # Calls out to all configured backends in the order they
-      # were specified.  The first one to answer will win.
-      #
-      # This lets you declare multiple backends, a possible
-      # use case might be in Puppet where a Puppet module declares
-      # default data using in-module data while users can override
-      # using JSON/YAML etc.  By layering the backends and putting
-      # the Puppet one last you can override module author data
-      # easily.
-      #
-      # Backend instances are cached so if you need to connect to any
-      # databases then do so in your constructor, future calls to your
-      # backend will not create new instances
-      def lookup(key, default, scope, order_override, resolution_type)
-        @backends ||= {}
-        answer = nil
+class Hiera
+module Backend
+class << self
+  #
+  # NOTE: This function is overridden so we can collect accumulated hiera
+  # parameters and their values on a particular provisioning run for reporting 
+  # purposes.
+  #
+  def lookup(key, default, scope, order_override, resolution_type)
+    @backends ||= {}
+    answer = nil
 
-        Config[:backends].each do |backend|
-          if constants.include?("#{backend.capitalize}_backend") || constants.include?("#{backend.capitalize}_backend".to_sym)
-            @backends[backend] ||= Backend.const_get("#{backend.capitalize}_backend").new
-            new_answer = @backends[backend].lookup(key, scope, order_override, resolution_type)
+    Config[:backends].each do |backend|
+      if constants.include?("#{backend.capitalize}_backend") || constants.include?("#{backend.capitalize}_backend".to_sym)
+        @backends[backend] ||= Backend.const_get("#{backend.capitalize}_backend").new
+        new_answer = @backends[backend].lookup(key, scope, order_override, resolution_type)
 
-            if not new_answer.nil?
-              case resolution_type
-              when :array
-                raise Exception, "Hiera type mismatch: expected Array and got #{new_answer.class}" unless new_answer.kind_of? Array or new_answer.kind_of? String
-                answer ||= []
-                answer << new_answer
-              when :hash
-                raise Exception, "Hiera type mismatch: expected Hash and got #{new_answer.class}" unless new_answer.kind_of? Hash
-                answer ||= {}
-                answer = merge_answer(new_answer,answer)
-              else
-              answer = new_answer
-              break
-              end
-            end
+        if not new_answer.nil?
+          case resolution_type
+          when :array
+            raise Exception, "Hiera type mismatch: expected Array and got #{new_answer.class}" unless new_answer.kind_of? Array or new_answer.kind_of? String
+            answer ||= []
+            answer << new_answer
+          when :hash
+            raise Exception, "Hiera type mismatch: expected Hash and got #{new_answer.class}" unless new_answer.kind_of? Hash
+            answer ||= {}
+            answer = merge_answer(new_answer,answer)
+          else
+            answer = new_answer
+            break
           end
         end
-
-        answer = resolve_answer(answer, resolution_type) unless answer.nil?
-        answer = parse_string(default, scope) if answer.nil? and default.is_a?(String)
-
-        answer = default if answer.nil?
-        
-        CORL::Config.set_property(key, answer) # This is why we override this function!!
-        return answer
       end
     end
-  end
 
-rescue LoadError
+    answer = resolve_answer(answer, resolution_type) unless answer.nil?
+    answer = parse_string(default, scope) if answer.nil? and default.is_a?(String)
+    answer = default if answer.nil?
+        
+    CORL::Config.set_property(key, answer) # This is why we override this function!!
+    return answer
+  end
+end
+end
 end

data/lib/core/plugin/provisioner.rb

@@ -225,24 +225,23 @@ class Provisioner < CORL.plugin_class(:base)
   
   def lookup(property, default = nil, options = {})
     # Implement in providers
+    nil
   end
-  
-  #--
-  
-  def import(files, options = {})
-    # Implement in providers
-  end
-  
-  #---
-  
-  def include(resource_name, properties = {}, options = {})
-    # Implement in providers
-  end
-  
+   
   #---
   
   def provision(profiles, options = {})
-    # Implement in providers
+    config  = Config.ensure(options)
+    
+    use_colors               = Util::Console.use_colors
+    Util::Console.use_colors = config.get(:color, true)
+    
+    success = yield(config) if block_given?
+    Config.save_properties(Config.get_options(:corl_log)) if success
+    success
+    
+  ensure
+    Util::Console.use_colors = use_colors  
   end
        
   #-----------------------------------------------------------------------------

data/lib/core/util/puppet.rb

@@ -92,6 +92,13 @@ module Puppet
     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   
     ResourceGroup.new(info, defaults).add(resources, config)
   end
   
@@ -107,15 +114,19 @@ module Puppet
       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(puppet_scope.source.module_name) do |ui|
-        #ui.info("Adding #{type[:name]} #{title} definition")
+      CORL.ui_group(Util::Console.cyan(display_name)) do |ui|
+        rendered_title = Util::Console.blue(title)
+        ui.info("Adding #{type[:name]} #{rendered_title}")
       end
       add_definition(type, title, properties, config)
     when :class
-      CORL.ui_group(puppet_scope.source.module_name) do |ui|
-        #ui.info("Adding #{title} class")
+      CORL.ui_group(Util::Console.cyan(display_name)) do |ui|
+        rendered_title = Util::Console.blue(title)
+        ui.info("Adding class #{rendered_title}")
       end
       add_class(title, properties, config)
     end
@@ -131,7 +142,7 @@ module Puppet
       klass = puppet_scope.find_hostclass(title)
       return unless klass
       
-      #dbg(properties, "class #{title}")
+      debug_resource(config, title, properties)
       klass.ensure_in_catalog(puppet_scope, properties)
       puppet_scope.catalog.add_class(title)
     end  
@@ -140,7 +151,7 @@ module Puppet
   #---
   
   def self.add_definition(type, title, properties, options = {})
-    config       = Config.ensure(options)
+    config = Config.ensure(options)
     
     puppet_scope = config.get(:puppet_scope, nil)    
     return unless puppet_scope
@@ -153,14 +164,16 @@ module Puppet
     
     namevar       = namevar(type[:name], title).to_sym
     resource_name = properties.has_key?(namevar) ? properties[namevar] : title
+    properties    = { :name => resource_name }.merge(properties)
     
-    { :name => resource_name }.merge(properties).each do |key, value|
+    properties.each do |key, value|
       resource.set_parameter(key, value)
     end
     if type[:type] == :define
       type[:resource].instantiate_resource(puppet_scope, resource)
     end
-    #dbg(resource, "definition/type #{type[:type]} #{title}")
+    
+    debug_resource(config, title, properties)
     puppet_scope.compiler.add_resource(puppet_scope, resource)
   end
     
@@ -188,6 +201,8 @@ module Puppet
     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
@@ -198,10 +213,23 @@ module Puppet
       classes = Config.lookup(name, nil, config)
       if classes.is_a?(Array)
         classes.each do |klass|
+          CORL.ui_group(Util::Console.cyan(display_name)) do |ui|
+            ui.info("Including class #{klass}")
+          end
           class_data[klass] = properties
         end
-      else
-        class_data[name.to_s] = properties  
+      end
+    end
+    
+    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))        
+        
+        ui.info(":\n#{dump}")
+        ui.info("\n", { :prefix => false }) 
       end
     end
     
@@ -237,7 +265,11 @@ module Puppet
       base_names = base_names.reverse if reverse_lookup
         
       base_names.each do |base|
-        value = puppet_scope.lookupvar("::#{base}::#{property}")
+        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 Util::Data.undef?(value)  
       end
     end
@@ -245,12 +277,16 @@ module Puppet
       components = property.to_s.split('::')
       
       if components.length > 1
-        components += [ 'default', components.pop ]
-        value = puppet_scope.lookupvar('::' + components.flatten.join('::'))
+        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
     end
     if Util::Data.undef?(value) && search_name
       value = puppet_scope.lookupvar("::#{property}")
+      Config.debug_lookup(config, property, value, "Puppet name lookup")
     end
     
     ::Puppet::Util::Log.level = log_level
@@ -297,6 +333,19 @@ module Puppet
     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))        
+        
+        ui.info(":\n#{dump}")
+        ui.info("\n", { :prefix => false })       
+      end
+    end
   end      
 end
 end

data/lib/core/util/puppet/resource_group.rb

@@ -75,16 +75,12 @@ class ResourceGroup < Core
   #---
   
   def add(resources, options = {})
-    config    = Config.ensure(options)
-    
-    dbg(resources, 'before')
-    dbg(default, 'defaults')
+    config    = Config.ensure(options)    
     resources = normalize(info[:name], resources, config)
      
     unless Data.empty?(resources)
       collection = self.resources
       resources.each do |title, resource|
-        dbg(resource.export, "#{info[:type]} #{info[:name]}: #{title}")
         Puppet.add_resource(info, title, resource.export, config)
         collection[title] = resource
       end

data/lib/facter/custom_facts.rb

@@ -9,7 +9,20 @@ begin
     network        = CORL.network(CORL.sha1(network_config), network_config, :default)
 
     if network && node = network.local_node
-      CORL::Util::Data.hash(node[:facts]).each do |name, value|    
+      Facter.add(:corl_provider) do
+        setcode do
+          node.plugin_provider
+        end  
+      end
+      
+      corl_facts = CORL::Util::Data.merge([ {
+        :corl_identity    => "test",
+        :corl_stage       => "maintain",
+        :corl_type        => "core",
+        :corl_environment => "development"
+      }, node[:facts] ])
+      
+      CORL::Util::Data.hash(corl_facts).each do |name, value|    
         Facter.add(name) do
           confine :kernel => :linux # TODO: Extend this to work with more systems
     

data/lib/puppet/indirector/corl.rb

@@ -1,10 +1,10 @@
 
 require 'puppet/indirector/terminus'
 
-class Puppet::Indirector::CORL < Puppet::Indirector::Terminus
+class Puppet::Indirector::Corl < Puppet::Indirector::Terminus
   
   def initialize(*args)
-    unless CORL::Config.initialized?
+    unless CORL::Config.config_initialized?
       raise "CORL terminus not supported without the CORL library"
     end
     super
@@ -13,15 +13,28 @@ class Puppet::Indirector::CORL < Puppet::Indirector::Terminus
   #---
 
   def find(request)
-    config = CORL::Config.init_flat({}, [ :param, :data_binding ], {
-      :provisioner  => :puppetnode,
-      :hiera_scope  => request.options[:variables],
-      :puppet_scope => request.options[:variables],
-      :search       => 'core::default',
-      :search_name  => false,
-      :force        => true,
-      :merge        => true
-    })    
+    puppet_scope = request.options[:variables]    
+    module_name  = nil
+    module_name  = puppet_scope.source.module_name if puppet_scope.source
+    contexts     = [ :param, :data_binding, request.key ]
+    
+    default_options = {
+      :provisioner     => :puppetnode,
+      :hiera_scope     => puppet_scope,
+      :puppet_scope    => puppet_scope,
+      :search          => 'core::default',
+      :search_name     => false,
+      :force           => true,
+      :merge           => true,
+      :undefined_value => :undef
+    }
+    
+    if module_name
+      config = CORL::Config.init({}, contexts, module_name, default_options)  
+    else
+      config = CORL::Config.init_flat({}, contexts, default_options)
+    end
+          
     value = CORL::Config.lookup(request.key, nil, config)
   end
 end

data/lib/puppet/indirector/data_binding/corl.rb

@@ -1,6 +1,6 @@
 
 require 'puppet/indirector/corl'
 
-class Puppet::DataBinding::CORL < Puppet::Indirector::CORL
+class Puppet::DataBinding::Corl < Puppet::Indirector::Corl
   desc "Retrieve data using CORL lookup methods."
 end

data/lib/puppet/parser/functions/corl_include.rb

@@ -23,17 +23,28 @@ If no value is found in the defined sources, it does not include any classes.
       raise(Puppet::ParseError, "corl_include(): Define at least the variable name " +
         "given (#{args.size} for 1)") if args.size < 1
 
-      var_name   = args[0]
-      parameters = ( args.size > 1 ? args[1] : {} )
-      options    = ( args.size > 2 ? args[2] : {} )
+      var_name    = args[0]
+      parameters  = ( args.size > 1 ? args[1] : {} )
+      options     = ( args.size > 2 ? args[2] : {} )
+      
+      module_name = parent_module_name
+      contexts    = [ :include, var_name ]
+      
+      default_options = {
+        :hiera_scope     => self,
+        :puppet_scope    => self,
+        :search          => 'core::default',
+        :force           => true,
+        :merge           => true,
+        :undefined_value => :undef
+      }
+      
+      if module_name
+        config = CORL::Config.init(options, contexts, module_name, default_options)  
+      else
+        config = CORL::Config.init_flat(options, contexts, default_options)
+      end
       
-      config = CORL::Config.init_flat(options, [ :include ], {
-        :hiera_scope  => self,
-        :puppet_scope => self,
-        :search       => 'core::default',
-        :force        => true,
-        :merge        => true
-      })
       CORL::Util::Puppet.include(var_name, parameters, config)
     end
   end

data/lib/puppet/parser/functions/corl_initialize.rb

@@ -9,7 +9,17 @@ This function initializes the CORL plugin system through Puppet.
     EOS
 ) do |args|    
     CORL.run do
+      # Register all Nucleon plugins defined by Puppet modules.
       CORL::Util::Puppet.register_plugins({ :puppet_scope => self })
+      
+      # Make sure defaults are evaluated first!
+      if compiler.node.classes.is_a?(Hash)
+        compiler.node.classes.each do |name, parameters|
+          if name.match(/::default:?/)            
+            compiler.evaluate_classes({ name => parameters }, self, false)
+          end
+        end
+      end
     end
   end
 end