corl 0.4.0

data/lib/corl/provisioner/puppetnode.rb

@@ -0,0 +1,407 @@
+
+module CORL
+module Provisioner
+class Puppetnode < Plugin::Provisioner
+  
+  #-----------------------------------------------------------------------------
+  # Provisioner plugin interface
+   
+  def normalize
+    super
+    
+    require 'puppet'
+    
+    if CORL.log_level == :debug
+      Puppet.debug = true
+    end
+    Puppet.initialize_settings
+    
+    myself.plugin_name = :default if plugin_name.to_sym == :puppetnode
+       
+    @env      = Puppet::Node::Environment.new
+    @compiler = Puppet::Parser::Compiler.new(node)
+    
+    init_scope
+    register
+  end
+  
+  #---
+  
+  def register
+    # Register Puppet CORL extensions
+    env.modules.each do |mod|
+      lib_dir = File.join(mod.path, 'lib', 'corl')
+      if File.directory?(lib_dir)
+        logger.debug("Registering Puppet module at #{lib_dir}")
+        Manager.connection.register(lib_dir)
+      end
+    end
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Property accessor / modifiers
+ 
+  def env
+    @env
+  end
+  
+  #---
+  
+  def compiler
+    @compiler
+  end
+  
+  #---
+    
+  def init_facts
+    facts = {}
+    
+    unless Puppet[:node_name_value].empty?
+      facts_obj = Puppet::Node::Facts.indirection.find(Puppet[:node_name_value])
+      facts     = facts_obj.values if facts_obj
+    end
+    
+    set(:facts, facts)  
+  end
+  protected :init_facts
+  
+  #---
+  
+  def facts(reset = false)
+    if reset || ! get(:facts)
+      init_facts
+    end
+    get(:facts)
+  end
+  
+  #---
+  
+  def init_node
+    if name
+      name_orig = Puppet[:node_name_value]
+      Puppet[:node_name_value] = name
+    end
+    
+    node = Puppet::Node.indirection.find(Puppet[:node_name_value])
+    
+    if facts = facts(true)
+      node.merge(facts.values)
+    end
+
+    file = Puppet[:classfile]
+    if FileTest.exists?(file)
+      node.classes = File.read(file).split(/[\s\n]+/)
+    end
+    
+    Puppet[:node_name_value] = name_orig if name_orig
+    @node = node
+  end
+  protected :init_node
+  
+  #---
+  
+  def node(reset = false)
+    if reset || ! @node
+      init_node
+    end
+    @node
+  end
+  
+  #---
+  
+  def init_scope
+    @scope       = Puppet::Parser::Scope.new(compiler)
+    scope.source = Puppet::Resource::Type.new(:node, node.name)
+    scope.parent = compiler.topscope  
+  end
+
+  #---
+  
+  def scope
+    @scope
+  end
+  
+  #---
+  
+  def init_catalog
+    node = node(true)
+    
+    starttime = Time.now
+    catalog   = Puppet::Resource::Catalog.indirection.find(node.name, :use_node => node)
+
+    catalog = catalog.to_ral
+    catalog.finalize
+
+    catalog.retrieval_duration = Time.now - starttime
+
+    catalog.write_class_file
+    catalog.write_resource_file
+    
+    @catalog = catalog  
+  end
+  
+  #---
+  
+  def catalog(reset = false)
+    if reset || ! @catalog
+      init_catalog
+    end
+    @catalog
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Resources
+  
+  def resource_types
+    env.known_resource_types
+  end
+  
+  #---
+           
+  def type_info(type_name, reset = false)
+    type_name = type_name.to_s.downcase
+    type_info = 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 = 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 
+      }
+      set(:type_info, type_info)
+    end
+    
+    type_info[type_name]  
+  end
+  
+  #---
+  
+  def find_hostclass(name, options = {})
+    resource_types.find_hostclass(scope.namespaces, name, options)
+  end
+  
+  #---
+
+  def find_definition(name)
+    resource_types.find_definition(scope.namespaces, name)
+  end
+     
+  #-----------------------------------------------------------------------------
+  # Catalog alterations
+  
+  def clear
+    init_catalog
+    myself
+  end
+  
+  #---
+      
+  def add(type_name, resources, defaults = {}, options = {})
+    info = type_info(type_name)
+    PuppetExt::ResourceGroup.new(self, info, defaults).add(resources, options)
+  end
+  
+  #---
+  
+  def add_resource(type, title, properties)
+    if type_name.is_a?(String)
+      type = type_info(type)
+    end
+    
+    case type[:type]
+    when :type, :define
+      add_definition(type, title, properties)
+    when :class
+      add_class(title, properties)
+    end
+  end
+
+  #---
+  
+  def add_class(title, properties)
+    klass = find_hostclass(title)
+    if klass
+      klass.ensure_in_catalog(scope, properties)
+      catalog.add_class(title)
+    end  
+  end
+  protected :add_class
+    
+  #---
+  
+  def add_definition(type, title, properties)    
+    if type_name.is_a?(String)
+      type = type_info(type)
+    end
+    
+    resource          = Puppet::Parser::Resource.new(type[:name], title, :scope => 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(scope, resource)
+    end
+    compiler.add_resource(scope, resource)
+  end
+  protected :add_definition
+
+  #-----------------------------------------------------------------------------
+  # Puppet operations
+  
+  def lookup(property, default = nil, options = {})
+    config = Config.ensure(options)
+    value  = nil
+    
+    puppet_scope = config.get(:puppet_scope, scope)
+    
+    base_names = config.get(:search, nil)
+     
+    search_name    = config.get(:search_name, true)
+    reverse_lookup = config.get(:reverse_lookup, true)
+    
+    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) && search_name
+      value = puppet_scope.lookupvar("::#{property}")
+    end
+    
+    Puppet::Util::Log.level = log_level
+    value      
+  end
+  
+  #--
+  
+  def import(files, base_dir = nil)
+    resource_types.loader.import(file, base_dir + '/')
+  end
+  
+  #---
+  
+  def include(resource_name, properties, options = {})
+    class_data = {}
+    
+    if resource_name.is_a?(Array)
+      resource_name = resource_name.flatten
+    else
+      resource_name = [ resource_name ]
+    end
+      
+    resource_name.each do |name|
+      classes = lookup(name, [], options)
+      if classes.is_a?(Array)
+        classes.each do |klass|
+          class_data[klass] = parameters
+        end
+      end  
+    end
+      
+    klasses = compiler.evaluate_classes(class_data, myself, false)
+    missing = class_data.keys.find_all do |klass|
+      ! klasses.include?(klass)
+    end
+
+    return false unless missing.empty?
+    true
+  end
+  
+  #---
+    
+  def provision(options = {})
+    config = Config.ensure(options)
+    
+    if ! Util::Data.empty?(config[:code])
+      Puppet[:code] = config[:code]
+      
+    elsif ! Util::Data.empty?(config[:manifest])
+      Puppet[:manifest] = config[:manifest]
+    end
+
+    begin
+      return configure(config[:node])
+      
+    rescue => detail
+      Puppet.log_exception(detail)
+    end
+    false
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Utilities
+  
+  def to_name(name)
+    Util::Data.value(name).to_s.gsub(/[\/\\\-\.]/, '_')
+  end
+  
+  #---
+  
+  def type_name(value) # Basically borrowed from Puppet (damn private methods!)
+    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 namevar(type_name, resource_name) # Basically borrowed from Puppet (damn private methods!)
+    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 configure
+    configurer = Puppet::Configurer.new
+    configurer.run(:catalog => catalog, :pluginsync => false)
+  end
+  protected :configure
+end
+end
+end

data/lib/corl/template/environment.rb

@@ -0,0 +1,73 @@
+
+module CORL
+module Template
+class Environment < Plugin::Template
+  
+  #-----------------------------------------------------------------------------
+  # Renderers  
+   
+  def render_processed(data)
+    return super do |output|   
+      case data
+      when Hash
+        data.each do |name, value|
+          output << render_assignment(name, value)
+        end
+      end
+      output          
+    end      
+  end
+  
+  #-----------------------------------------------------------------------------
+  
+  def render_assignment(name, value)
+    name  = render_name(name)
+    value = render_value(value)
+    
+    export      = get(:export, true)
+    export_text = export ? get(:export_text, 'export ') : ''
+    operator    = get(:operator, '=')
+    
+    return "#{export_text}#{name}#{operator}#{value}\n"  
+  end
+  
+  #---
+  
+  def render_name(name)
+    prefix     = get(:name_prefix, '')
+    prefix_sep = prefix.empty? ? '' : get(:name_prefix_sep, '_')
+    
+    suffix     = get(:name_suffix, '')
+    suffix_sep = suffix.empty? ? '' : get(:name_suffix_sep, '')
+    
+    unless prefix.empty?
+      name = "#{prefix}#{prefix_sep}#{name}#{suffix_sep}#{suffix}"
+    end
+    return name
+  end
+  
+  #---
+  
+  def render_value(value)
+    sep          = get(:value_sep, ' ')
+    quote        = get(:quote, true)
+    
+    array_prefix = get(:array_prefix, '(')
+    array_suffix = get(:array_suffix, ')')
+    
+    case value
+    when Array
+      values = []
+      value.each do |item|
+        values << quote ? "'#{item}'" : "#{item}"  
+      end
+      value = "#{array_prefix}#{values.join(sep)}#{array_suffix}"
+            
+    when String
+      value = quote ? "'#{value}'" : "#{value}" 
+    end
+    return value
+  end
+end
+end
+end

data/lib/corl/template/json.rb

@@ -0,0 +1,16 @@
+
+module CORL
+module Template
+class Json < Plugin::Template
+  
+  #-----------------------------------------------------------------------------
+  # Renderers  
+   
+  def render_processed(data)
+    return super do
+      Util::Data.to_json(data)
+    end
+  end
+end
+end
+end

data/lib/corl/template/wrapper.rb

@@ -0,0 +1,16 @@
+
+module CORL
+module Template
+class Wrapper < Plugin::Template
+  
+  #-----------------------------------------------------------------------------
+  # Renderers  
+   
+  def render_processed(data)
+    return super do
+      get(:template_prefix, '') + data.to_s + get(:template_suffix, '')
+    end
+  end
+end
+end
+end

data/lib/corl/template/yaml.rb

@@ -0,0 +1,16 @@
+
+module CORL
+module Template
+class Yaml < Plugin::Template
+  
+  #-----------------------------------------------------------------------------
+  # Renderers  
+   
+  def render_processed(data)
+    return super do
+      Util::Data.to_yaml(data)
+    end    
+  end
+end
+end
+end

data/lib/corl/translator/json.rb

@@ -0,0 +1,27 @@
+
+module CORL
+module Translator
+class Json < Plugin::Translator
+   
+  #-----------------------------------------------------------------------------
+  # Translator operations
+   
+  def parse(json_text)
+    return super do |properties|
+      if json_text && ! json_text.empty?
+        properties = Util::Data.parse_json(json_text)
+      end
+      properties
+    end
+  end
+  
+  #---
+  
+  def generate(properties)
+    return super do
+      Util::Data.to_json(properties, get(:pretty, true))
+    end
+  end
+end
+end
+end

data/lib/corl/translator/yaml.rb

@@ -0,0 +1,27 @@
+
+module CORL
+module Translator
+class Yaml < Plugin::Translator
+   
+  #-----------------------------------------------------------------------------
+  # Translator operations
+   
+  def parse(yaml_text)
+    return super do |properties|
+      if yaml_text && ! yaml_text.empty?
+        properties = Util::Data.parse_yaml(yaml_text)
+      end
+      properties
+    end
+  end
+  
+  #---
+  
+  def generate(properties)
+    return super do
+      Util::Data.to_yaml(properties)
+    end
+  end
+end
+end
+end