corl 0.4.2 → 0.4.3

data/lib/CORL/provisioner/puppetnode.rb

@@ -3,394 +3,266 @@ module CORL
 module Provisioner
 class Puppetnode < CORL.plugin_class(:provisioner)
   
+  @@puppet_lock = Mutex.new
+  
   #-----------------------------------------------------------------------------
   # Provisioner plugin interface
    
   def normalize(reload)
-    super
-    
-    unless reload
-      require 'puppet'
-    
+    super do
       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)
+      end   
     end
-    
-    init_scope
-    register
   end
   
-  #-----------------------------------------------------------------------------
-  # Property accessor / modifiers
- 
-  def env
-    @env
+  #---
+  
+  def register(options = {})
+    Util::Puppet.register_plugins(Config.ensure(options).defaults({ :puppet_scope => scope }))
   end
   
-  #---
+  #-----------------------------------------------------------------------------
+  # Property accessor / modifiers
   
   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)
+  def scope
+    return compiler.topscope if compiler
+    nil
   end
   
-  #---
-  
-  def init_node
-    if name
-      name_orig = Puppet[:node_name_value]
-      Puppet[:node_name_value] = name
-    end
+  #-----------------------------------------------------------------------------
+  # Puppet initialization
     
-    node = Puppet::Node.indirection.find(Puppet[:node_name_value])
+  def init_puppet(profiles)
+    locations = build_locations
     
-    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
+    # Must be in this order!!
+    Puppet.initialize_settings
+    Puppet::Util::Log.newdestination(:console)
     
-    Puppet[:node_name_value] = name_orig if name_orig
-    @node = node
-  end
-  protected :init_node
-  
-  #---
-  
-  def node(reset = false)
-    if reset || ! @node
-      init_node
+    # TODO: Figure out how to store these damn settings in a specialized
+    # environment without phantom empty environment issues.
+      
+    node = get_node    
+    Puppet[:node_name_value] = id.to_s
+    
+    if manifest = gateway
+      if manifest.match(/^packages\/.*/)
+        manifest = File.join(build_directory, locations[:build], manifest)
+      else
+        manifest = File.join(network.directory, directory, manifest)    
+      end    
+      Puppet[:manifest] = manifest   
     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
+    unless profiles.empty?
+      modulepath = profiles.collect do |profile|
+        File.join(build_directory, locations[:module][profile.to_sym])
+      end
+      Puppet[:modulepath] = array(modulepath).join(File::PATH_SEPARATOR)
+    end
     
-    @catalog = catalog  
+    @compiler = Puppet::Parser::Compiler.new(node)
+    register
+     
+    # Initialize the compiler so we can can lookup and include stuff
+    # This is ugly but seems to be the only way.
+    compiler.compile
   end
+  protected :init_puppet
   
   #---
-  
-  def catalog(reset = false)
-    if reset || ! @catalog
-      init_catalog
+   
+  def get_node
+    node_id = id.to_s
+    node    = Puppet::Node.indirection.find(node_id)
+         
+    if facts = Puppet::Node::Facts.indirection.find(node_id)
+      facts.name = node_id
+      node.merge(facts.values)
     end
-    @catalog
+    node
   end
+  protected :get_node
   
   #-----------------------------------------------------------------------------
-  # Resources
-  
-  def resource_types
-    env.known_resource_types
-  end
+  # Provisioner interface operations
   
-  #---
-           
-  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
+  def build(options = {})
+    super do |locations, package_info, init_location|
+      init_location.call(:modules, nil)
+      
+      init_location.call(:profiles, :pp)
+      init_location.call(:default, :pp)
         
-      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
+      # Build modules
+      
+      locations[:module] = {}
+      
+      init_profile = lambda do |package_name, profile_name, profile_info|
+        package_id     = id(package_name)
+        base_directory = File.join(locations[:modules], package_id.to_s, profile_name.to_s)
         
-      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
+        if profile_info.has_key?(:modules)
+          profile_info[:modules].each do |module_name, module_reference|
+            module_directory = File.join(base_directory, module_name.to_s)
+                
+            module_project = CORL.project(extended_config(:puppet_module, {
+              :directory => File.join(build_directory, module_directory),
+              :url       => module_reference,
+              :create    => true,
+              :pull      => true
+            }))
+            raise unless module_project                
+          end
+          locations[:module][profile_id(package_name, profile_name)] = base_directory
+        end
+      end     
+      
+      hash(package_info.get([ :provisioners, plugin_provider ])).each do |package_name, info|
+        if info.has_key?(:profiles)
+          info[:profiles].each do |profile_name, profile_info|
+            init_profile.call(package_name, profile_name, profile_info)
+          end
         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]  
+      profiles.each do |profile_name, profile_info|
+        init_profile.call(plugin_name, profile_name, profile_info)
+      end
+    end     
   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)
+  def lookup(property, default = nil, options = {})
+    Util::Puppet.lookup(property, default, Config.ensure(options).defaults({ 
+      :provisioner  => :puppetnode,
+      :puppet_scope => scope      
+    }))
   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)
+  def import(files, options = {})
+    Util::Puppet.import(files, Config.ensure(options).defaults({ 
+      :puppet_scope       => scope, 
+      :puppet_import_base => network.directory 
+    }))
   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
+  def include(resource_name, properties = {}, options = {})
+    Util::Puppet.include(resource_name, properties, Config.ensure(options).defaults({
+      :provisioner  => :puppetnode, 
+      :puppet_scope => scope      
+    }))
   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)
+  def add_search_path(type, resource_name)
+    Config.set_options([ :all, type ], { :search => [ resource_name.to_s ] })  
   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)
+  def provision(profiles, options = {})
+    locations = build_locations
+    success   = 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
+    include_location = lambda do |type, add_to_catalog = true, add_search_path = false|      
+      locations[:package].each do |name, package_directory|
+        gateway       = File.join(build_directory, package_directory, "#{type}.pp")
+        resource_name = concatenate([ name, type ])
         
-      base_names.each do |base|
-        value = puppet_scope.lookupvar("::#{base}::#{property}")
-        break unless Util::Data.undef?(value)  
+        add_search_path(type, resource_name) if add_search_path
+        
+        if File.exists?(gateway)
+          import(gateway)
+          include(resource_name, { :before => 'Anchor[gateway_init]' }) if add_to_catalog                   
+        end
+        
+        directory = File.join(build_directory, package_directory, type.to_s)
+        Dir.glob(File.join(directory, '*.pp')).each do |file|
+          resource_name = concatenate([ name, type, File.basename(file).gsub('.pp', '') ])
+          import(file)
+          include(resource_name, { :before => 'Anchor[gateway_init]' }) if add_to_catalog
+        end        
       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
+      gateway       = File.join(build_directory, locations[:build], "#{type}.pp")
+      resource_name = concatenate([ plugin_name, type ])
       
-    resource_name.each do |name|
-      classes = lookup(name, [], options)
-      if classes.is_a?(Array)
-        classes.each do |klass|
-          class_data[klass] = parameters
+      add_search_path(type, resource_name) if add_search_path
+     
+      if File.exists?(gateway)
+        import(gateway)
+        include(resource_name, { :before => 'Anchor[gateway_init]' }) if add_to_catalog                   
+      end
+    
+      if locations.has_key?(type)
+        directory = File.join(build_directory, locations[type])
+        Dir.glob(File.join(directory, '*.pp')).each do |file|
+          resource_name = concatenate([ plugin_name, type, File.basename(file).gsub('.pp', '') ])
+          import(file)
+          include(resource_name, { :before => 'Anchor[gateway_init]' }) if add_to_catalog
         end
-      end  
-    end
-      
-    klasses = compiler.evaluate_classes(class_data, myself, false)
-    missing = class_data.keys.find_all do |klass|
-      ! klasses.include?(klass)
+      end
     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]
+    @@puppet_lock.synchronize do
+      begin
+        start_time = Time.now
+        
+        init_puppet(profiles)
+        
+        # Include defaults
+        include_location.call(:default, true, true)
       
-    elsif ! Util::Data.empty?(config[:manifest])
-      Puppet[:manifest] = config[:manifest]
-    end
-
-    begin
-      return configure(config[:node])
+        # Import and include needed profiles
+        include_location.call(:profiles, false)
       
-    rescue => detail
-      Puppet.log_exception(detail)
-    end
-    false
+        profiles.each do |profile|
+          include(profile, { :require => 'Anchor[gateway_exit]' })
+        end
+        
+        # Start system configuration 
+        catalog = compiler.catalog.to_ral
+        catalog.finalize
+        catalog.retrieval_duration = Time.now - start_time
+        
+        configurer = Puppet::Configurer.new
+        if ! configurer.run(:catalog => catalog, :pluginsync => false)
+          success = false
+        end
+      
+      rescue Exception => error
+        raise error
+        Puppet.log_exception(error)
+      end
+    end    
+    success
   end
   
   #-----------------------------------------------------------------------------
   # Utilities
   
-  def to_name(name)
-    Util::Data.value(name).to_s.gsub(/[\/\\\-\.]/, '_')
+  def profile_id(package_name, profile_name)
+    concatenate([ package_name, 'profile', profile_name ], false)
   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)
+  def concatenate(components, capitalize = false)
+    super(components, capitalize, '::')
   end
-  protected :configure
 end
 end
 end

data/lib/core/mixin/lookup.rb

@@ -8,14 +8,20 @@ module Lookup
   
   def facts
     fact_map = {}
-    Facter.list.each do |name|
-      fact_map[name] = Facter.value(name)
+    
+    CORL.silence do
+      Facter.list.each do |name|
+        fact_map[name] = Facter.value(name)
+      end
     end
+    
     fact_map
   end
   
   def fact(name)
-    Facter.value(name)
+    CORL.silence do
+      Facter.value(name)
+    end
   end
   
   #-----------------------------------------------------------------------------
@@ -26,7 +32,7 @@ module Lookup
   #---
   
   def hiera_config
-    config_file = CORL.value(:hiera_config_file, nil)
+    config_file = CORL.value(:hiera_config_file, File.join(Hiera::Util.config_dir, 'hiera.yaml'))
     config      = {}
 
     if config_file && File.exist?(config_file)
@@ -51,7 +57,7 @@ module Lookup
   def config_initialized?
     ready = false
     if CORL.admin? && hiera && network_path = fact(:corl_network)
-      ready = File.directory?(network_path) && File.directory?(File.join(network_path, 'config')) ? true : false
+      ready = File.directory?(File.join(network_path, 'config')) ? true : false
     end
     ready
   end
@@ -68,7 +74,6 @@ module Lookup
     override    = config.get(:override, nil)
     context     = config.get(:context, :priority)    
     
-    
     return_property = config.get(:return_property, false)
     
     unless properties.is_a?(Array)
@@ -88,12 +93,12 @@ module Lookup
             unless hiera_scope.respond_to?('[]')
               hiera_scope = Hiera::Scope.new(hiera_scope)
             end
-            value = hiera.lookup(property, nil, hiera_scope, override, context)
+            value = hiera.lookup(property.to_s, nil, hiera_scope, override, context)
           end 
     
           if provisioner && Util::Data.undef?(value)
             # Search the provisioner scope (only admins can provision a machine)
-            value = CORL.provisioner(provisioner).lookup(property, default, config)
+            value = CORL.provisioner({ :name => :lookup }, provisioner).lookup(property, default, config)
           end
         end
       end
@@ -102,8 +107,9 @@ module Lookup
     value = Util::Data.value(value)
     
     if ! Config.get_property(first_property) || ! Util::Data.undef?(value)
-      Config.set_property(first_property, value)
+      Config.set_property(first_property.to_s, value)
     end
+    
     return value, first_property if return_property
     value
   end
@@ -113,7 +119,7 @@ module Lookup
   def lookup_array(properties, default = [], options = {})
     config          = Config.ensure(options) 
     value, property = lookup(properties, nil, config.import({ :return_property => true }))
-    
+     
     if Util::Data.undef?(value)
       value = default
         
@@ -126,8 +132,8 @@ module Lookup
     unless value.is_a?(Array)
       value = ( Util::Data.empty?(value) ? [] : [ value ] )
     end
-    
-    Config.set_property(property, value)
+       
+    Config.set_property(property.to_s, value)
     value
   end
     
@@ -150,7 +156,7 @@ module Lookup
       value = ( Util::Data.empty?(value) ? {} : { :value => value } )
     end
     
-    Config.set_property(property, value)
+    Config.set_property(property.to_s, value)
     value
   end
   
@@ -187,8 +193,7 @@ module Lookup
   
     when Hash
       results = data
-    end
-    
+    end    
     results
   end
 end