corl 0.4.2 → 0.4.3

data/lib/{CORL/provisioner/puppetnode → core/util/puppet}/resource.rb

@@ -1,38 +1,29 @@
 
 module CORL
-module PuppetExt
+module Util
+module Puppet
 class Resource < Core
   
-  extend Mixin::SubConfig
+  include Mixin::SubConfig
    
   #-----------------------------------------------------------------------------
   # Constructor / Destructor
   
-  def initialize(provisioner, info, title, properties = {})
+  def initialize(group, info, title, properties = {})
     super({
-      :title       => string(title),
-      :info        => symbol_map(hash(info)),
-      :provisioner => provisioner,
-      :ready       => false
+      :group => group,
+      :title => string(title),
+      :info  => symbol_map(hash(info)),
+      :ready => false
     })
     import(properties) 
   end
-     
-  #-----------------------------------------------------------------------------
-  # Checks
-
       
   #-----------------------------------------------------------------------------
   # Property accessors / modifiers
   
-  def provisioner(default = nil)
-    return _get(:provisioner, default)
-  end
-  
-  #---
-  
-  def provisioner=provisioner
-    _set(:provisioner, provisioner)
+  def group
+    return _get(:group)
   end
   
   #---
@@ -71,7 +62,6 @@ class Resource < Core
     super(defaults, options)
     
     _set(:ready, false)
-    process(options)
     return self 
   end
 
@@ -81,7 +71,6 @@ class Resource < Core
     super(properties, options)
     
     _set(:ready, false)
-    process(options)
     return self  
   end
       
@@ -100,7 +89,6 @@ class Resource < Core
     config = Config.ensure(options)
     
     tag(config[:tag])
-    
     render(config)
     translate(config)
     
@@ -110,15 +98,21 @@ class Resource < Core
   
   #---
   
-  def tag(tag, append = true)
-    unless Util::Data.empty?(tag)
-      tag           = tag.to_s.split(/\s*,\s*/)
+  def tag(tags, append = true)
+    unless Data.empty?(tags)
+      if tags.is_a?(String)
+        tags = tags.to_s.split(/\s*,\s*/)
+      else
+        tags = tags.flatten
+      end
       resource_tags = get(:tag)
       
       if ! resource_tags || ! append
-        set(:tag, tag)
+        set(:tag, tags)
       else
-        resource_tags << tag
+        tags.each do |tag|
+          resource_tags << tag unless resource_tags.include?(tag)  
+        end
         set(:tag, resource_tags)
       end
     end
@@ -132,13 +126,13 @@ class Resource < Core
     config   = Config.ensure(options)
     
     resource.keys.each do |name|
-      if match = name.match(/^(.+)_template$/)
+      if match = name.to_s.match(/^(.+)_template$/)
         target = match.captures[0]
         
         config.set(:normalize_template, config.get("normalize_#{target}", true))
         config.set(:interpolate_template, config.get("interpolate_#{target}", true))
         
-        resource[target] = CORL.template(resource[name], config).render(resource[target])
+        resource[target] = CORL.template(config, resource[name]).render(resource[target])
         resource.delete(name)         
       end
     end
@@ -149,8 +143,8 @@ class Resource < Core
 
   def render(options = {})
     resource = self.class.render(export, options)
-    clear(options)
-    import(resource, options)    
+    clear
+    import(Config.ensure(resource).export, options)    
     return self
   end
   
@@ -171,7 +165,7 @@ class Resource < Core
   # Utilities
   
   def translate_resource_refs(resource_refs, options = {})
-    return :undef if Util::Data.undef?(resource_refs)
+    return :undef if Data.undef?(resource_refs)
     
     config         = Config.ensure(options)
     resource_names = config.get(:resource_names, {})
@@ -182,12 +176,12 @@ class Resource < Core
     title_flags    = config.get(:title_flags, '')
     title_regexp   = Regexp.new(title_pattern, title_flags.split(''))
     
-    groups         = config.get(:groups, {})
-    
     allow_single   = config.get(:allow_single_return, true)    
     
     type_name      = info[:name].sub(/^\@?\@/, '')
     values         = []
+    
+    composite_resources = group.composite_resources
         
     case resource_refs
     when String
@@ -202,19 +196,19 @@ class Resource < Core
     end
     
     resource_refs.collect! do |value|
-      if value.is_a?(::Puppet::Resource) || ! value.match(title_regexp)
-        value
+      if value.is_a?(::Puppet::Resource) || ! value.to_s.match(title_regexp)
+        value.to_s
           
-      elsif resource_names.has_key?(value)
+      elsif resource_names.has_key?(value.to_s)
         if ! title_prefix.empty?
           "#{title_prefix}_#{value}"
         else
-          value
+          value.to_s
         end
         
-      elsif groups.has_key?(value) && ! groups[value].empty?
+      elsif composite_resources.has_key?(value.to_sym) && ! composite_resources[value.to_sym].empty?
         results = []
-        groups[value].each do |resource_name|
+        composite_resources[value.to_sym].each do |resource_name|
           unless title_prefix.empty?
             resource_name = "#{title_prefix}_#{resource_name}"
           end
@@ -243,3 +237,5 @@ class Resource < Core
 end
 end
 end
+end
+

data/lib/{CORL/provisioner/puppetnode → core/util/puppet}/resource_group.rb

@@ -1,40 +1,30 @@
 
 module CORL
-module PuppetExt
+module Util
+module Puppet
 class ResourceGroup < Core
   
-  extend Mixin::SubConfig
+  include Mixin::SubConfig
    
   #-----------------------------------------------------------------------------
   # Constructor / Destructor
   
-  def initialize(provisioner, type_info, default = {})
+  def initialize(type_info, default = {})
     super({
-      :info        => hash(type_info),
-      :provisioner => provisioner,
-      :default     => symbol_map(hash(default))
+      :info    => hash(type_info),
+      :default => symbol_map(hash(default))
     })
     self.resources = {}
   end
-     
-  #-----------------------------------------------------------------------------
-  # Checks
-
-      
-  #-----------------------------------------------------------------------------
-  # Property accessors / modifiers
-  
-  def provisioner(default = nil)
-    return _get(:provisioner, default)
-  end
   
   #---
   
-  def provisioner=provisioner
-    _set(:provisioner, provisioner)
+  def inspect
+    "#{self.class}#{info.to_s}[#{composite_resources.keys.length}]"
   end
-  
-  #---
+     
+  #-----------------------------------------------------------------------------
+  # Property accessors / modifiers
   
   def info(default = {})
     return hash(_get(:info, default))
@@ -84,21 +74,18 @@ class ResourceGroup < Core
   
   #---
   
-  def clear
-    self.resources = {}
-    return self
-  end
-  
-  #---
-  
   def add(resources, options = {})
     config    = Config.ensure(options)
-    resources = normalize(resources, config)
     
-    unless Util::Data.empty?(resources)
+    dbg(resources, 'before')
+    dbg(default, 'defaults')
+    resources = normalize(info[:name], resources, config)
+     
+    unless Data.empty?(resources)
       collection = self.resources
       resources.each do |title, resource|
-        provisioner.add_resource(info, title, resource.export)
+        dbg(resource.export, "#{info[:type]} #{info[:name]}: #{title}")
+        Puppet.add_resource(info, title, resource.export, config)
         collection[title] = resource
       end
       self.resources = collection
@@ -109,6 +96,7 @@ class ResourceGroup < Core
   #---
   
   def add_composite_resource(name, resource_names)
+    name            = name.to_sym
     composite       = self.composite_resources    
     composite[name] = [] unless composite[name].is_a?(Array)
     
@@ -117,11 +105,12 @@ class ResourceGroup < Core
     end
     
     resource_names.each do |r_name|
+      r_name = r_name.to_sym
+      
       unless composite[name].include?(r_name)
         composite[name] << r_name
       end
     end
-    
     self.composite_resources = composite
   end
   protected :add_composite_resource
@@ -133,19 +122,19 @@ class ResourceGroup < Core
     self.composite_resources = {}
     
     config    = Config.ensure(options)
-    resources = Util::Data.value(resources)
+    resources = Data.value(resources)
     
-    unless Util::Data.empty?(resources)
+    unless Data.empty?(resources)
       resources.keys.each do |name|
-        if ! resources[name] || resources[name].empty? || ! resources[name].is_a?(Hash)        
+        if ! resources[name] || resources[name].empty? || ! resources[name].is_a?(Hash)
           resources.delete(name)
         else
           normalize = true
           
-          namevar = provisioner.namevar(type_name, name)
+          namevar = Puppet.namevar(type_name, name)
           if resources[name].has_key?(namevar)
             value = resources[name][namevar]
-            if Util::Data.empty?(value)
+            if Data.empty?(value)
               resources.delete(name)
               normalize = false
               
@@ -156,7 +145,7 @@ class ResourceGroup < Core
                 new_resource = resources[name].clone
                 new_resource[namevar] = item
                 
-                resources[item_name] = Resource.render(new_resource, config)
+                resources[item_name] = Resource.new(self, info, item_name, new_resource).defaults(default, config)               
                 add_composite_resource(name, item_name)
               end
               resources.delete(name)
@@ -165,13 +154,14 @@ class ResourceGroup < Core
           end
           
           if normalize
-            resource = Resource.new(provisioner, info, name, resources[name])
-            resource.defaults(default, config.import({ :groups => self.composite_resources }))
-            
+            resource = Resource.new(self, info, name, resources[name]).defaults(default, config)
             resources[name] = resource
           end
         end
       end
+      resources.each do |name, resource|
+        resource.process(config)
+      end
     end
     return translate(resources, config)
   end
@@ -203,3 +193,5 @@ class ResourceGroup < Core
 end
 end
 end
+end
+

data/lib/core/util/puppet.rb

@@ -0,0 +1,303 @@
+
+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')
+        if File.directory?(lib_dir)
+          logger.debug("Registering Puppet module at #{lib_dir}")
+          CORL.register(lib_dir)
+          @@register[mod.path] = true
+        end
+      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       
+      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 
+      }
+      config.set(:type_info, type_info)
+    end
+    
+    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)    
+    return unless puppet_scope
+    
+    info = type_info(type_name, options)
+    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)    
+    return unless puppet_scope
+    
+    if type.is_a?(String)
+      type = type_info(type, config)
+    end
+    
+    case type[:type]
+    when :type, :define
+      CORL.ui_group(puppet_scope.source.module_name) do |ui|
+        #ui.info("Adding #{type[:name]} #{title} definition")
+      end
+      add_definition(type, title, properties, config)
+    when :class
+      CORL.ui_group(puppet_scope.source.module_name) do |ui|
+        #ui.info("Adding #{title} class")
+      end
+      add_class(title, properties, config)
+    end
+  end
+
+  #---
+  
+  def self.add_class(title, properties, options = {})
+    config       = Config.ensure(options)    
+    puppet_scope = config.get(:puppet_scope, nil)
+        
+    if puppet_scope
+      klass = puppet_scope.find_hostclass(title)
+      return unless klass
+      
+      #dbg(properties, "class #{title}")
+      klass.ensure_in_catalog(puppet_scope, properties)
+      puppet_scope.catalog.add_class(title)
+    end  
+  end
+    
+  #---
+  
+  def self.add_definition(type, title, properties, options = {})
+    config       = Config.ensure(options)
+    
+    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
+    
+    { :name => resource_name }.merge(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}")
+    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)  
+    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
+    
+    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)
+        classes.each do |klass|
+          class_data[klass] = properties
+        end
+      else
+        class_data[name.to_s] = properties  
+      end
+    end
+    
+    klasses = puppet_scope.compiler.evaluate_classes(class_data, puppet_scope, false)
+    missing = class_data.keys.find_all do |klass|
+      ! klasses.include?(klass)
+    end
+    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)     
+    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|
+        value = puppet_scope.lookupvar("::#{base}::#{property}")
+        break unless Util::Data.undef?(value)  
+      end
+    end
+    if Util::Data.undef?(value)
+      components = property.to_s.split('::')
+      
+      if components.length > 1
+        components += [ 'default', components.pop ]
+        value = puppet_scope.lookupvar('::' + components.flatten.join('::'))
+      end
+    end
+    if Util::Data.undef?(value) && search_name
+      value = puppet_scope.lookupvar("::#{property}")
+    end
+    
+    ::Puppet::Util::Log.level = log_level
+    value      
+  end
+   
+  #-----------------------------------------------------------------------------
+  # Utilities
+  
+  def self.each_module(options = {}, &code)
+    config = Config.ensure(options)
+    values = []
+    
+    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      
+end
+end
+end