corl 0.4.0

data/lib/corl/provisioner/puppetnode/resource.rb

@@ -0,0 +1,245 @@
+
+module CORL
+module PuppetExt
+class Resource < Core
+  
+  extend Mixin::SubConfig
+   
+  #-----------------------------------------------------------------------------
+  # Constructor / Destructor
+  
+  def initialize(provisioner, info, title, properties = {})
+    super({
+      :title       => string(title),
+      :info        => symbol_map(hash(info)),
+      :provisioner => provisioner,
+      :ready       => false
+    })
+    import(properties) 
+  end
+     
+  #-----------------------------------------------------------------------------
+  # Checks
+
+      
+  #-----------------------------------------------------------------------------
+  # Property accessors / modifiers
+  
+  def provisioner(default = nil)
+    return _get(:provisioner, default)
+  end
+  
+  #---
+  
+  def provisioner=provisioner
+    _set(:provisioner, provisioner)
+  end
+  
+  #---
+  
+  def info(default = {})
+    return hash(_get(:info, default))
+  end
+  
+  #---
+  
+  def info=info
+    _set(:info, hash(info))
+  end
+  
+  #---
+  
+  def title(default = '')
+    return string(_get(:title, default))
+  end
+  
+  #---
+  
+  def title=info
+    _set(:title, string(info))
+  end
+  
+  #---
+  
+  def ready(default = false)
+    return test(_get(:ready, default))
+  end
+ 
+  #---
+  
+  def defaults(defaults, options = {})
+    super(defaults, options)
+    
+    _set(:ready, false)
+    process(options)
+    return self 
+  end
+
+  #---
+  
+  def import(properties, options = {})
+    super(properties, options)
+    
+    _set(:ready, false)
+    process(options)
+    return self  
+  end
+      
+  #-----------------------------------------------------------------------------
+  # Resource operations
+  
+  def ensure_ready(options = {})
+    unless ready
+      process(options)
+    end
+  end
+  
+  #---
+  
+  def process(options = {})
+    config = Config.ensure(options)
+    
+    tag(config[:tag])
+    
+    render(config)
+    translate(config)
+    
+    _set(:ready, true) # Ready for resource creation
+    return self
+  end
+  
+  #---
+  
+  def tag(tag, append = true)
+    unless Util::Data.empty?(tag)
+      tag           = tag.to_s.split(/\s*,\s*/)
+      resource_tags = get(:tag)
+      
+      if ! resource_tags || ! append
+        set(:tag, tag)
+      else
+        resource_tags << tag
+        set(:tag, resource_tags)
+      end
+    end
+    return self
+  end
+  
+  #---
+  
+  def self.render(resource_info, options = {})
+    resource = string_map(resource_info)
+    config   = Config.ensure(options)
+    
+    resource.keys.each do |name|
+      if match = name.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.delete(name)         
+      end
+    end
+    return resource 
+  end
+  
+  #---
+
+  def render(options = {})
+    resource = self.class.render(export, options)
+    clear(options)
+    import(resource, options)    
+    return self
+  end
+  
+  #---
+  
+  def translate(options = {})
+    config = Config.ensure(options)
+    
+    set(:before, translate_resource_refs(get(:before), config)) if get(:before)
+    set(:notify, translate_resource_refs(get(:notify), config)) if get(:notify)
+    set(:require, translate_resource_refs(get(:require), config)) if get(:require)       
+    set(:subscribe, translate_resource_refs(get(:subscribe), config)) if get(:subscribe)
+    
+    return self
+  end
+
+  #-----------------------------------------------------------------------------
+  # Utilities
+  
+  def translate_resource_refs(resource_refs, options = {})
+    return :undef if Util::Data.undef?(resource_refs)
+    
+    config         = Config.ensure(options)
+    resource_names = config.get(:resource_names, {})
+    title_prefix   = config.get(:title_prefix, '')
+    
+    title_pattern  = config.get(:title_pattern, '^\s*([^\[\]]+)\s*$')
+    title_group    = config.get(:title_var_group, 1)
+    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         = []
+        
+    case resource_refs
+    when String
+      if resource_refs.empty?
+        return :undef 
+      else
+        resource_refs = resource_refs.split(/\s*,\s*/)
+      end
+        
+    when ::Puppet::Resource
+      resource_refs = [ resource_refs ]  
+    end
+    
+    resource_refs.collect! do |value|
+      if value.is_a?(::Puppet::Resource) || ! value.match(title_regexp)
+        value
+          
+      elsif resource_names.has_key?(value)
+        if ! title_prefix.empty?
+          "#{title_prefix}_#{value}"
+        else
+          value
+        end
+        
+      elsif groups.has_key?(value) && ! groups[value].empty?
+        results = []
+        groups[value].each do |resource_name|
+          unless title_prefix.empty?
+            resource_name = "#{title_prefix}_#{resource_name}"
+          end
+          results << resource_name        
+        end
+        results
+        
+      else
+        nil
+      end           
+    end
+    
+    resource_refs.flatten.each do |ref|
+      unless ref.nil?        
+        unless ref.is_a?(::Puppet::Resource)
+          ref = ref.match(title_regexp) ? ::Puppet::Resource.new(type_name, ref) : ::Puppet::Resource.new(ref)
+        end
+        values << ref unless ref.nil?
+      end
+    end
+    
+    return values[0] if allow_single && values.length == 1
+    return values
+  end
+  protected :translate_resource_refs
+end
+end
+end

data/lib/corl/provisioner/puppetnode/resource_group.rb

@@ -0,0 +1,205 @@
+
+module CORL
+module PuppetExt
+class ResourceGroup < Core
+  
+  extend Mixin::SubConfig
+   
+  #-----------------------------------------------------------------------------
+  # Constructor / Destructor
+  
+  def initialize(provisioner, type_info, default = {})
+    super({
+      :info        => hash(type_info),
+      :provisioner => provisioner,
+      :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)
+  end
+  
+  #---
+  
+  def info(default = {})
+    return hash(_get(:info, default))
+  end
+  
+  #---
+  
+  def info=info
+    _set(:info, hash(info))
+  end
+  
+  #---
+  
+  def default(default = {})
+    return hash(_get(:default, default))
+  end
+  
+  #---
+  
+  def default=default
+    _set(:default, symbol_map(hash(default)))
+  end
+ 
+  #---
+  
+  def resources(default = {})
+    return hash(_get(:resources, default))
+  end
+  
+  #---
+  
+  def resources=resources
+    _set(:resources, symbol_map(hash(resources)))
+  end
+ 
+  #---
+  
+  def composite_resources(default = {})
+    return hash(_get(:composite_resources, default))
+  end
+  
+  #---
+  
+  def composite_resources=resources
+    _set(:composite_resources, symbol_map(hash(resources)))
+  end
+  
+  #---
+  
+  def clear
+    self.resources = {}
+    return self
+  end
+  
+  #---
+  
+  def add(resources, options = {})
+    config    = Config.ensure(options)
+    resources = normalize(resources, config)
+    
+    unless Util::Data.empty?(resources)
+      collection = self.resources
+      resources.each do |title, resource|
+        provisioner.add_resource(info, title, resource.export)
+        collection[title] = resource
+      end
+      self.resources = collection
+    end
+    return self
+  end
+  
+  #---
+  
+  def add_composite_resource(name, resource_names)
+    composite       = self.composite_resources    
+    composite[name] = [] unless composite[name].is_a?(Array)
+    
+    unless resource_names.is_a?(Array)
+      resource_names = [ resource_names ]
+    end
+    
+    resource_names.each do |r_name|
+      unless composite[name].include?(r_name)
+        composite[name] << r_name
+      end
+    end
+    
+    self.composite_resources = composite
+  end
+  protected :add_composite_resource
+
+  #-----------------------------------------------------------------------------
+  # Resource operations
+  
+  def normalize(type_name, resources, options = {})
+    self.composite_resources = {}
+    
+    config    = Config.ensure(options)
+    resources = Util::Data.value(resources)
+    
+    unless Util::Data.empty?(resources)
+      resources.keys.each do |name|
+        if ! resources[name] || resources[name].empty? || ! resources[name].is_a?(Hash)        
+          resources.delete(name)
+        else
+          normalize = true
+          
+          namevar = provisioner.namevar(type_name, name)
+          if resources[name].has_key?(namevar)
+            value = resources[name][namevar]
+            if Util::Data.empty?(value)
+              resources.delete(name)
+              normalize = false
+              
+            elsif value.is_a?(Array)
+              value.each do |item|
+                item_name = "#{name}_#{item}".gsub(/\-/, '_')
+                
+                new_resource = resources[name].clone
+                new_resource[namevar] = item
+                
+                resources[item_name] = Resource.render(new_resource, config)
+                add_composite_resource(name, item_name)
+              end
+              resources.delete(name)
+              normalize = false
+            end  
+          end
+          
+          if normalize
+            resource = Resource.new(provisioner, info, name, resources[name])
+            resource.defaults(default, config.import({ :groups => self.composite_resources }))
+            
+            resources[name] = resource
+          end
+        end
+      end
+    end
+    return translate(resources, config)
+  end
+  protected :normalize
+  
+  #---
+  
+  def translate(resources, options = {})
+    config  = Config.ensure(options)
+    results = {}
+        
+    prefix   = config.get(:resource_prefix, '')    
+    name_map = {}
+    
+    resources.keys.each do |name|
+      name_map[name] = true
+    end
+    config[:resource_names] = name_map
+    
+    resources.each do |name, resource|
+      unless prefix.empty?
+        name = "#{prefix}_#{name}"
+      end
+      results[name] = resource
+    end
+    return results
+  end
+  protected :translate
+end
+end
+end