puppet 0.23.2 → 0.24.0

data/lib/puppet/metatype/manager.rb

@@ -111,7 +111,7 @@ module Manager
     def type(name)
         @types ||= {}
 
-        name = symbolize(name)
+        name = name.to_s.downcase.to_sym
 
         if t = @types[name]
             return t
@@ -139,4 +139,3 @@ module Manager
 end
 end
 
-# $Id: manager.rb 2680 2007-07-12 04:27:04Z luke $

data/lib/puppet/metatype/metaparams.rb

@@ -94,7 +94,7 @@ class Puppet::Type
     
     # We've got four relationship metaparameters, so this method is used
     # to reduce code duplication between them.
-    def store_relationship(param, values)
+    def munge_relationship(param, values)
         # We need to support values passed in as an array or as a
         # resource reference.
         result = []
@@ -194,20 +194,24 @@ class Puppet::Type
             unless aliases.is_a?(Array)
                 aliases = [aliases]
             end
-            @resource.info "Adding aliases %s" % aliases.collect { |a|
-                    a.inspect
-            }.join(", ")
+
+            raise(ArgumentError, "Cannot add aliases without a catalog") unless @resource.catalog
+
+            @resource.info "Adding aliases %s" % aliases.collect { |a| a.inspect }.join(", ")
+
             aliases.each do |other|
-                if obj = @resource.class[other]
-                    unless obj == @resource
-                        self.fail(
-                            "%s can not create alias %s: object already exists" %
-                            [@resource.title, other]
-                        )
+                if obj = @resource.catalog.resource(@resource.class.name, other)
+                    unless obj.object_id == @resource.object_id
+                        self.fail("%s can not create alias %s: object already exists" % [@resource.title, other])
                     end
                     next
                 end
+
+                # LAK:FIXME Old-school, add the alias to the class.
                 @resource.class.alias(other, @resource)
+
+                # Newschool, add it to the catalog.
+                @resource.catalog.alias(@resource, other)
             end
         end
     end
@@ -247,7 +251,16 @@ class Puppet::Type
         end
         
         def munge(rels)
-            @resource.store_relationship(self.class.name, rels)
+            @resource.munge_relationship(self.class.name, rels)
+        end
+
+        def validate_relationship
+            @value.each do |value|
+                unless @resource.catalog.resource(*value)
+                    description = self.class.direction == :in ? "dependency" : "dependent"
+                    raise Puppet::Error, "Could not find #{description} %s[%s]" % [value[0].to_s.capitalize, value[1]]
+                end
+            end
         end
         
         # Create edges from each of our relationships.    :in
@@ -263,18 +276,12 @@ class Puppet::Type
                 # we just have a name and a type, and we need to convert it
                 # to an object...
                 tname, name = value
-                object = nil
-                if type = Puppet::Type.type(tname)
-                    object = type[name]
-                else # try to treat it as a component
-                    object = Puppet::Type::Component["#{tname}[#{name}]"]
-                end
+                reference = Puppet::ResourceReference.new(tname, name)
                 
                 # Either of the two retrieval attempts could have returned
                 # nil.
-                unless object
-                    self.fail "Could not retrieve dependency '%s[%s]'" %
-                        [tname.to_s.capitalize, name]
+                unless object = reference.resolve
+                    self.fail "Could not retrieve dependency '%s' of %s" % [reference, @resource.ref]
                 end
 
                 # Are we requiring them, or vice versa?  See the method docs
@@ -414,4 +421,3 @@ class Puppet::Type
     end
 end # Puppet::Type
 
-# $Id: metaparams.rb 2684 2007-07-12 16:39:47Z luke $

data/lib/puppet/metatype/providers.rb

@@ -230,6 +230,9 @@ class Puppet::Type
 
     # Return an array of all of the suitable providers.
     def self.suitableprovider
+        if @providers.empty?
+            providerloader.loadall
+        end
         @providers.find_all { |name, provider|
             provider.suitable?
         }.collect { |name, provider|
@@ -249,5 +252,3 @@ class Puppet::Type
         end
     end
 end
-
-# $Id: providers.rb 2714 2007-07-19 18:12:20Z luke $

data/lib/puppet/metatype/relationships.rb

@@ -40,7 +40,7 @@ class Puppet::Type
                     end
                 end
                 
-                reqs << Puppet::Relationship[dep, self]
+                reqs << Puppet::Relationship.new(dep, self)
             }
         }
         
@@ -113,4 +113,3 @@ class Puppet::Type
     end
 end
 
-# $Id: relationships.rb 2169 2007-02-07 06:47:10Z luke $

data/lib/puppet/metatype/schedules.rb

@@ -31,4 +31,3 @@ class Puppet::Type
     end
 end
 
-# $Id: schedules.rb 2665 2007-07-09 21:32:33Z luke $

data/lib/puppet/metatype/tags.rb

@@ -36,4 +36,3 @@ class Puppet::Type
     end
 end
 
-# $Id: tags.rb 1762 2006-10-10 20:59:10Z luke $

data/lib/puppet/module.rb

@@ -4,14 +4,15 @@ class Puppet::Module
     TEMPLATES = "templates"
     FILES = "files"
     MANIFESTS = "manifests"
-
+    
     # Return an array of paths by splitting the +modulepath+ config
     # parameter. Only consider paths that are absolute and existing
     # directories
-    def self.modulepath
-        dirs = Puppet[:modulepath].split(":")
+    def self.modulepath(environment = nil)
+        dirs = Puppet.settings.value(:modulepath, environment).split(":")
         if ENV["PUPPETLIB"]
             dirs = ENV["PUPPETLIB"].split(":") + dirs
+        else
         end
         dirs.select do |p|
             p =~ /^#{File::SEPARATOR}/ && File::directory?(p)
@@ -21,22 +22,34 @@ class Puppet::Module
     # Find and return the +module+ that +path+ belongs to. If +path+ is
     # absolute, or if there is no module whose name is the first component
     # of +path+, return +nil+
-    def self.find(path)
-        if path =~ %r/^#{File::SEPARATOR}/
+    def self.find(modname, environment = nil)
+        if modname =~ %r/^#{File::SEPARATOR}/
             return nil
         end
 
-        modname, rest = path.split(File::SEPARATOR, 2)
-        return nil if modname.nil? || modname.empty?
-
-        modpath = modulepath.collect { |p|
-            File::join(p, modname)
+        modpath = modulepath(environment).collect { |path|
+            File::join(path, modname)
         }.find { |f| File::directory?(f) }
         return nil unless modpath
 
         return self.new(modname, modpath)
     end
 
+    # Return an array of the full path of every subdirectory in each
+    # directory in the modulepath.
+    def self.all(environment = nil)
+        modulepath(environment).map do |mp|
+            Dir.new(mp).map do |modfile|
+                modpath = File.join(mp, modfile)
+                unless modfile == '.' or modfile == '..' or !File.directory?(modpath)
+                    modpath
+                else
+                    nil
+                end
+            end
+        end.flatten.compact
+    end
+
     # Instance methods
 
     # Find the concrete file denoted by +file+. If +file+ is absolute,
@@ -45,16 +58,25 @@ class Puppet::Module
     # param.
     # In all cases, an absolute path is returned, which does not
     # necessarily refer to an existing file
-    def self.find_template(file)
-        if file =~ /^#{File::SEPARATOR}/
-            return file
+    def self.find_template(template, environment = nil)
+        if template =~ /^#{File::SEPARATOR}/
+            return template
         end
 
-        mod = find(file)
+        path, file = split_path(template)
+
+        # Because templates don't have an assumed template name, like manifests do,
+        # we treat templates with no name as being templates in the main template
+        # directory.
+        if file.nil?
+            mod = nil
+        else
+            mod = find(path, environment)
+        end
         if mod
             return mod.template(file)
         else
-            return File.join(Puppet[:templatedir], file)
+            return File.join(Puppet.settings.value(:templatedir, environment), template)
         end
     end
 
@@ -63,13 +85,13 @@ class Puppet::Module
     # +pat+ does not contain any wildcards and is an existing module, return
     # a list of manifests in that module matching the rest of +pat+
     # Otherwise, try to find manifests matching +pat+ relative to +cwd+
-    def self.find_manifests(pat, cwd = nil)
-        cwd ||= Dir.getwd
-        mod = find(pat)
-        if mod
-            return mod.manifests(pat)
+    def self.find_manifests(start, options = {})
+        cwd = options[:cwd] || Dir.getwd
+        module_name, pattern = split_path(start)
+        if module_name and mod = find(module_name, options[:environment])
+            return mod.manifests(pattern)
         else
-            abspat = File::expand_path(pat, cwd)
+            abspat = File::expand_path(start, cwd)
             files = Dir.glob(abspat).reject { |f| FileTest.directory?(f) }
             if files.size == 0
                 files = Dir.glob(abspat + ".pp").reject { |f| FileTest.directory?(f) }
@@ -78,28 +100,36 @@ class Puppet::Module
         end
     end
 
+    # Split the path into the module and the rest of the path.
+    # This method can and often does return nil, so anyone calling
+    # it needs to handle that.
+    def self.split_path(path)
+        if path =~ %r/^#{File::SEPARATOR}/
+            return nil
+        end
+
+        modname, rest = path.split(File::SEPARATOR, 2)
+        return nil if modname.nil? || modname.empty?
+        return modname, rest
+    end
+
     attr_reader :name, :path
     def initialize(name, path)
         @name = name
         @path = path
     end
 
-    def strip(file)
-        n, rest = file.split(File::SEPARATOR, 2)
-        rest = nil if rest && rest.empty?
-        return rest
-    end
-
     def template(file)
-        return File::join(path, TEMPLATES, strip(file))
+        return File::join(path, TEMPLATES, file)
     end
 
     def files
         return File::join(path, FILES)
     end
 
-    def manifests(pat)
-        rest = strip(pat)
+    # Return the list of manifests matching the given glob pattern,
+    # defaulting to 'init.pp' for empty modules.
+    def manifests(rest)
         rest ||= "init.pp"
         p = File::join(path, MANIFESTS, rest)
         files = Dir.glob(p)
@@ -111,5 +141,3 @@ class Puppet::Module
 
     private :initialize
 end
-
-# $Id: module.rb 2655 2007-07-06 22:22:10Z luke $

data/lib/puppet/network/authconfig.rb

@@ -165,4 +165,3 @@ module Puppet
     end
 end
 
-# $Id: authconfig.rb 2345 2007-03-22 15:40:28Z luke $

data/lib/puppet/network/authorization.rb

@@ -81,4 +81,3 @@ module Puppet::Network
     end
 end
 
-# $Id: authorization.rb 2259 2007-03-06 19:03:05Z luke $

data/lib/puppet/network/authstore.rb

@@ -294,4 +294,3 @@ module Puppet
     end
 end
 
-# $Id: authstore.rb 2673 2007-07-10 19:26:36Z luke $

data/lib/puppet/network/client.rb

@@ -19,6 +19,12 @@ class Net::HTTP
             false
         end
     end
+
+    # JJM: This is a "backport" of sorts to older ruby versions which
+    # do not have this accessor.  See #896 for more information.
+    unless Net::HTTP.instance_methods.include? "enable_post_connection_check"
+        attr_accessor :enable_post_connection_check
+    end
 end
 
 # The base class for all of the clients.  Many clients just directly
@@ -85,8 +91,12 @@ class Puppet::Network::Client
 
             @driver = self.class.xmlrpc_client.new(args)
 
-            if self.read_cert
-                @driver.cert_setup(self)
+            self.read_cert
+
+            # We have to start the HTTP connection manually before we start
+            # sending it requests or keep-alive won't work.
+            if @driver.respond_to? :start
+                @driver.start
             end
 
             @local = false
@@ -114,7 +124,7 @@ class Puppet::Network::Client
     # Make sure we set the driver up when we read the cert in.
     def read_cert
         if super
-            @driver.cert_setup(self) if @driver.respond_to?(:cert_setup)
+            @driver.recycle_connection(self) if @driver.respond_to?(:recycle_connection)
             return true
         else
             return false
@@ -184,4 +194,3 @@ class Puppet::Network::Client
     require 'puppet/network/client/proxy'
 end
 
-# $Id: client.rb 2375 2007-03-30 23:17:40Z luke $

data/lib/puppet/network/client/ca.rb

@@ -14,9 +14,9 @@ class Puppet::Network::Client::CA < Puppet::Network::Client
     end
 
     # This client is really only able to request certificates for the
-    # current host.  It uses the Puppet.config settings to figure everything out.
+    # current host.  It uses the Puppet.settings settings to figure everything out.
     def request_cert
-        Puppet.config.use(:main, :ssl)
+        Puppet.settings.use(:main, :ssl)
 
         if cert = read_cert
             return cert
@@ -49,11 +49,10 @@ class Puppet::Network::Client::CA < Puppet::Network::Client
         end
 
         # Only write the cert out if it passes validating.
-        Puppet.config.write(:hostcert) do |f| f.print cert end
-        Puppet.config.write(:localcacert) do |f| f.print cacert end
+        Puppet.settings.write(:hostcert) do |f| f.print cert end
+        Puppet.settings.write(:localcacert) do |f| f.print cacert end
 
         return @cert
     end
 end
 
-# $Id: ca.rb 2611 2007-06-18 19:33:15Z luke $

data/lib/puppet/network/client/dipper.rb

@@ -78,4 +78,3 @@ class Puppet::Network::Client::Dipper < Puppet::Network::Client
     end
 end
 
-# $Id: dipper.rb 2679 2007-07-11 20:23:49Z luke $

data/lib/puppet/network/client/file.rb

@@ -4,4 +4,3 @@ class Puppet::Network::Client::File < Puppet::Network::Client::ProxyClient
     self.mkmethods
 end
 
-# $Id: file.rb 2259 2007-03-06 19:03:05Z luke $

data/lib/puppet/network/client/master.rb

@@ -7,7 +7,7 @@ class Puppet::Network::Client::Master < Puppet::Network::Client
         @@sync = Sync.new
     end
 
-    attr_accessor :objects
+    attr_accessor :catalog
     attr_reader :compile_time
 
     class << self
@@ -38,61 +38,20 @@ class Puppet::Network::Client::Master < Puppet::Network::Client
         # in their manifests
         facts["clientversion"] = Puppet.version.to_s
 
+        # And add our environment as a fact.
+        facts["environment"] = Puppet[:environment]
+
         facts
     end
 
     # Return the list of dynamic facts as an array of symbols
     def self.dynamic_facts
-        Puppet.config[:dynamicfacts].split(/\s*,\s*/).collect { |fact| fact.downcase }
-    end
-
-    # This method actually applies the configuration.
-    def apply(tags = nil, ignoreschedules = false)
-        unless defined? @objects
-            raise Puppet::Error, "Cannot apply; objects not defined"
-        end
-
-        transaction = @objects.evaluate
-
-        if tags
-            transaction.tags = tags
-        end
-
-        if ignoreschedules
-            transaction.ignoreschedules = true
-        end
-
-        transaction.addtimes :config_retrieval => @configtime
-
-        begin
-            transaction.evaluate
-        rescue Puppet::Error => detail
-            Puppet.err "Could not apply complete configuration: %s" %
-                detail
-        rescue => detail
-            Puppet.err "Got an uncaught exception of type %s: %s" %
-                [detail.class, detail]
-            if Puppet[:trace]
-                puts detail.backtrace
-            end
-        ensure
-            Puppet::Util::Storage.store
-        end
-        
-        if Puppet[:report] or Puppet[:summarize]
-            report(transaction)
-        end
-
-        return transaction
-    ensure
-        if defined? transaction and transaction
-            transaction.cleanup
-        end
+        Puppet.settings[:dynamicfacts].split(/\s*,\s*/).collect { |fact| fact.downcase }
     end
 
     # Cache the config
     def cache(text)
-        Puppet.info "Caching configuration at %s" % self.cachefile
+        Puppet.info "Caching catalog at %s" % self.cachefile
         confdir = ::File.dirname(Puppet[:localconfig])
         ::File.open(self.cachefile + ".tmp", "w", 0660) { |f|
             f.print text
@@ -108,10 +67,10 @@ class Puppet::Network::Client::Master < Puppet::Network::Client
     end
 
     def clear
-        @objects.remove(true) if @objects
+        @catalog.clear(true) if @catalog
         Puppet::Type.allclear
         mkdefault_objects
-        @objects = nil
+        @catalog = nil
     end
 
     # Initialize and load storage
@@ -134,7 +93,7 @@ class Puppet::Network::Client::Master < Puppet::Network::Client
         end
     end
 
-    # Check whether our configuration is up to date
+    # Check whether our catalog is up to date
     def fresh?(facts)
         if Puppet[:ignorecache]
             Puppet.notice "Ignoring cache"
@@ -149,12 +108,12 @@ class Puppet::Network::Client::Master < Puppet::Network::Client
             return false
         end
 
-        # We're willing to give a 2 second drift
         newcompile = @driver.freshness
+        # We're willing to give a 2 second drift
         if newcompile - @compile_time.to_i < 1
             return true
         else
-            Puppet.debug "Server compile time is %s vs %s" % [newcompile, @compile_time]
+            Puppet.debug "Server compile time is %s vs %s" % [newcompile, @compile_time.to_i]
             return false
         end
     end
@@ -165,7 +124,7 @@ class Puppet::Network::Client::Master < Puppet::Network::Client
         lockfile.unlock(:anonymous => true)
     end
 
-    # Stop the daemon from making any configuration runs.
+    # Stop the daemon from making any catalog runs.
     def disable
         lockfile.lock(:anonymous => true)
     end
@@ -180,63 +139,57 @@ class Puppet::Network::Client::Master < Puppet::Network::Client
             facts = self.class.facts
         end
 
-        if self.objects or FileTest.exists?(self.cachefile)
-            if self.fresh?(facts)
-                Puppet.info "Config is up to date"
-                if self.objects
-                    return
-                end
-                if oldtext = self.retrievecache
-                    begin
-                        @objects = YAML.load(oldtext).to_type
-                    rescue => detail
-                        Puppet.warning "Could not load cached configuration: %s" % detail
-                    end
-                    return
-                end
-            end
-        end
-        Puppet.debug("getting config")
+        raise Puppet::Network::ClientError.new("Could not retrieve any facts") unless facts.length > 0
 
         # Retrieve the plugins.
-        if Puppet[:pluginsync]
-            getplugins()
-        end
+        getplugins() if Puppet[:pluginsync]
 
-        unless facts.length > 0
-            raise Puppet::Network::ClientError.new(
-                "Could not retrieve any facts"
-            )
+        if (self.catalog or FileTest.exist?(self.cachefile)) and self.fresh?(facts)
+            Puppet.info "Configuration is up to date"
+            return if use_cached_config
         end
 
-        unless objects = get_actual_config(facts)
-            @objects = nil
+        Puppet.debug("Retrieving catalog")
+
+        # If we can't retrieve the catalog, just return, which will either
+        # fail, or use the in-memory catalog.
+        unless yaml_objects = get_actual_config(facts)
+            use_cached_config(true)
             return
         end
 
-        unless objects.is_a?(Puppet::TransBucket)
-            raise NetworkClientError,
-                "Invalid returned objects of type %s" % objects.class
+        begin
+            objects = YAML.load(yaml_objects)
+        rescue => detail
+            msg = "Configuration could not be translated from yaml"
+            msg += "; using cached catalog" if use_cached_config(true)
+            Puppet.warning msg
+            return
         end
 
         self.setclasses(objects.classes)
 
         # Clear all existing objects, so we can recreate our stack.
-        if self.objects
+        clear() if self.catalog
+
+        # Now convert the objects to a puppet catalog graph.
+        begin
+            @catalog = objects.to_catalog
+        rescue => detail
             clear()
+            puts detail.backtrace if Puppet[:trace]
+            msg = "Configuration could not be instantiated: %s" % detail
+            msg += "; using cached catalog" if use_cached_config(true)
+            Puppet.warning msg
+            return
         end
 
-        # Now convert the objects to real Puppet objects
-        @objects = objects.to_type
-
-        if @objects.nil?
-            raise Puppet::Error, "Configuration could not be processed"
+        if ! @catalog.from_cache
+            self.cache(yaml_objects)
         end
 
-        # and perform any necessary final actions before we evaluate.
-        @objects.finalize
-
-        return @objects
+        # Keep the state database up to date.
+        @catalog.host_config = true
     end
     
     # A simple proxy method, so it's easy to test.
@@ -246,12 +199,9 @@ class Puppet::Network::Client::Master < Puppet::Network::Client
     
     # Just so we can specify that we are "the" instance.
     def initialize(*args)
-        Puppet.config.use(:main, :ssl, :puppetd)
+        Puppet.settings.use(:main, :ssl, :puppetd)
         super
 
-        # This might be nil
-        @configtime = 0
-
         self.class.instance = self
         @running = false
 
@@ -293,30 +243,32 @@ class Puppet::Network::Client::Master < Puppet::Network::Client
         end
     end
 
-    # The code that actually runs the configuration.  
-    def run(tags = nil, ignoreschedules = false)
+    # The code that actually runs the catalog.  
+    # This just passes any options on to the catalog,
+    # which accepts :tags and :ignoreschedules.
+    def run(options = {})
         got_lock = false
         splay
         Puppet::Util.sync(:puppetrun).synchronize(Sync::EX) do
             if !lockfile.lock
-                Puppet.notice "Lock file %s exists; skipping configuration run" %
+                Puppet.notice "Lock file %s exists; skipping catalog run" %
                     lockfile.lockfile
             else
                 got_lock = true
                 begin
-                    @configtime = thinmark do
+                    duration = thinmark do
                         self.getconfig
                     end
                 rescue => detail
-                    Puppet.err "Could not retrieve configuration: %s" % detail
+                    puts detail.backtrace if Puppet[:trace]
+                    Puppet.err "Could not retrieve catalog: %s" % detail
                 end
 
-                if defined? @objects and @objects
-                    unless @local
-                        Puppet.notice "Starting configuration run"
-                    end
-                    benchmark(:notice, "Finished configuration run") do
-                        self.apply(tags, ignoreschedules)
+                if self.catalog
+                    @catalog.retrieval_duration = duration
+                    Puppet.notice "Starting catalog run" unless @local
+                    benchmark(:notice, "Finished catalog run") do
+                        @catalog.apply(options)
                     end
                 end
             end
@@ -363,9 +315,6 @@ class Puppet::Network::Client::Master < Puppet::Network::Client
     # Download files from the remote server, returning a list of all
     # changed files.
     def self.download(args)
-        objects = Puppet::Type.type(:component).create(
-            :name => "#{args[:name]}_collector"
-        )
         hash = {
             :path => args[:dest],
             :recurse => true,
@@ -374,24 +323,30 @@ class Puppet::Network::Client::Master < Puppet::Network::Client
             :owner => Process.uid,
             :group => Process.gid,
             :purge => true,
+            :force => true,
             :backup => false
         }
 
         if args[:ignore]
             hash[:ignore] = args[:ignore].split(/\s+/)
         end
-        objects.push Puppet::Type.type(:file).create(hash)
+        downconfig = Puppet::Node::Catalog.new("downloading")
+        downconfig.add_resource Puppet::Type.type(:file).create(hash)
         
         Puppet.info "Retrieving #{args[:name]}s"
 
         noop = Puppet[:noop]
         Puppet[:noop] = false
 
+        files = []
         begin
-            trans = objects.evaluate
-            trans.ignoretags = true
             Timeout::timeout(self.timeout) do
-                trans.evaluate
+                downconfig.apply do |trans|
+                    trans.changed?.find_all do |resource|
+                        yield resource if block_given?
+                        files << resource[:path]
+                    end
+                end
             end
         rescue Puppet::Error, Timeout::Error => detail
             if Puppet[:debug]
@@ -400,18 +355,10 @@ class Puppet::Network::Client::Master < Puppet::Network::Client
             Puppet.err "Could not retrieve #{args[:name]}s: %s" % detail
         end
 
-        # Now source all of the changed objects, but only source those
-        # that are top-level.
-        files = []
-        trans.changed?.find_all do |object|
-            yield object if block_given?
-            files << object[:path]
-        end
-        trans.cleanup
-
         # Now clean up after ourselves
-        objects.remove
-        files
+        downconfig.clear
+
+        return files
     ensure
         # I can't imagine why this is necessary, but apparently at last one person has had problems with noop
         # being nil here.
@@ -424,21 +371,20 @@ class Puppet::Network::Client::Master < Puppet::Network::Client
 
     # Retrieve facts from the central server.
     def self.getfacts
-        # Clear all existing definitions.
-        Facter.clear
-
         # Download the new facts
         path = Puppet[:factpath].split(":")
         files = []
         download(:dest => Puppet[:factdest], :source => Puppet[:factsource],
-            :ignore => Puppet[:factsignore], :name => "fact") do |object|
-
-            next unless path.include?(::File.dirname(object[:path]))
+            :ignore => Puppet[:factsignore], :name => "fact") do |resource|
 
-            files << object[:path]
+            next unless path.include?(::File.dirname(resource[:path]))
 
+            files << resource[:path]
         end
     ensure
+        # Clear all existing definitions.
+        Facter.clear
+
         # Reload everything.
         if Facter.respond_to? :loadfacts
             Facter.loadfacts
@@ -458,20 +404,20 @@ class Puppet::Network::Client::Master < Puppet::Network::Client
     # changed plugins, because Puppet::Type loads plugins on demand.
     def self.getplugins
         download(:dest => Puppet[:plugindest], :source => Puppet[:pluginsource],
-            :ignore => Puppet[:pluginsignore], :name => "plugin") do |object|
+            :ignore => Puppet[:pluginsignore], :name => "plugin") do |resource|
 
-            next if FileTest.directory?(object[:path])
-            path = object[:path].sub(Puppet[:plugindest], '').sub(/^\/+/, '')
+            next if FileTest.directory?(resource[:path])
+            path = resource[:path].sub(Puppet[:plugindest], '').sub(/^\/+/, '')
             unless Puppet::Util::Autoload.loaded?(path)
                 next
             end
 
             begin
                 Puppet.info "Reloading downloaded file %s" % path
-                load object[:path]
+                load resource[:path]
             rescue => detail
                 Puppet.warning "Could not reload downloaded file %s: %s" %
-                    [object[:path], detail]
+                    [resource[:path], detail]
             end
         end
     end
@@ -514,42 +460,6 @@ class Puppet::Network::Client::Master < Puppet::Network::Client
 
         return timeout
     end
-    
-    # Send off the transaction report.
-    def report(transaction)
-        begin
-            report = transaction.generate_report()
-        rescue => detail
-            Puppet.err "Could not generate report: %s" % detail
-            return
-        end
-
-        if Puppet[:rrdgraph] == true
-            report.graph()
-        end
-
-        if Puppet[:summarize]
-            puts report.summary
-        end
-        
-        if Puppet[:report]
-            begin
-                reportclient().report(report)
-            rescue => detail
-                Puppet.err "Reporting failed: %s" % detail
-            end
-        end
-    end
-
-    def reportclient
-        unless defined? @reportclient
-            @reportclient = Puppet::Network::Client.report.new(
-                :Server => Puppet[:reportserver]
-            )
-        end
-
-        @reportclient
-    end
 
     loadfacts()
 
@@ -579,92 +489,48 @@ class Puppet::Network::Client::Master < Puppet::Network::Client
         end
     end
     
-    # Actually retrieve the configuration, either from the server or from a
+    # Actually retrieve the catalog, either from the server or from a
     # local master.
     def get_actual_config(facts)
-        if @local
-            return get_local_config(facts)
-        else
-            begin
-                Timeout::timeout(self.class.timeout) do
-                    return get_remote_config(facts)
-                end
-            rescue Timeout::Error
-                Puppet.err "Configuration retrieval timed out"
-                return nil
+        begin
+            Timeout::timeout(self.class.timeout) do
+                return get_remote_config(facts)
             end
+        rescue Timeout::Error
+            Puppet.err "Configuration retrieval timed out"
+            return nil
         end
     end
     
-    # Retrieve a configuration from a local master.
-    def get_local_config(facts)
-        # If we're local, we don't have to do any of the conversion
-        # stuff.
-        objects = @driver.getconfig(facts, "yaml")
-        @compile_time = Time.now
-
-        if objects == ""
-            raise Puppet::Error, "Could not retrieve configuration"
-        end
-        
-        return objects
-    end
-    
     # Retrieve a config from a remote master.
     def get_remote_config(facts)
         textobjects = ""
 
         textfacts = CGI.escape(YAML.dump(facts))
 
-        benchmark(:debug, "Retrieved configuration") do
+        benchmark(:debug, "Retrieved catalog") do
             # error handling for this is done in the network client
             begin
                 textobjects = @driver.getconfig(textfacts, "yaml")
                 begin
                     textobjects = CGI.unescape(textobjects)
                 rescue => detail
-                    raise Puppet::Error, "Could not CGI.unescape configuration"
+                    raise Puppet::Error, "Could not CGI.unescape catalog"
                 end
 
             rescue => detail
-                Puppet.err "Could not retrieve configuration: %s" % detail
-
-                unless Puppet[:usecacheonfailure]
-                    @objects = nil
-                    Puppet.warning "Not using cache on failed configuration"
-                    return
-                end
+                Puppet.err "Could not retrieve catalog: %s" % detail
+                return nil
             end
         end
 
-        fromcache = false
-        if textobjects == ""
-            unless textobjects = self.retrievecache
-                raise Puppet::Error.new(
-                    "Cannot connect to server and there is no cached configuration"
-                )
-            end
-            Puppet.warning "Could not get config; using cached copy"
-            fromcache = true
-        else
-            @compile_time = Time.now
-            Puppet::Util::Storage.cache(:configuration)[:facts] = facts
-            Puppet::Util::Storage.cache(:configuration)[:compile_time] = @compile_time
-        end
+        return nil if textobjects == ""
 
-        begin
-            objects = YAML.load(textobjects)
-        rescue => detail
-            raise Puppet::Error,
-                "Could not understand configuration: %s" %
-                detail.to_s
-        end
+        @compile_time = Time.now
+        Puppet::Util::Storage.cache(:configuration)[:facts] = facts
+        Puppet::Util::Storage.cache(:configuration)[:compile_time] = @compile_time
 
-        if @cache and ! fromcache
-            self.cache(textobjects)
-        end
-        
-        return objects
+        return textobjects
     end
 
     def lockfile
@@ -690,6 +556,32 @@ class Puppet::Network::Client::Master < Puppet::Network::Client
         Puppet.info "Sleeping for %s seconds (splay is enabled)" % time
         sleep(time)
     end
-end
 
-# $Id: master.rb 2671 2007-07-10 19:25:32Z luke $
+    private
+
+    # Use our cached config, optionally specifying whether this is
+    # necessary because of a failure.
+    def use_cached_config(because_of_failure = false)
+        return true if self.catalog
+
+        if because_of_failure and ! Puppet[:usecacheonfailure]
+            @catalog = nil
+            Puppet.warning "Not using cache on failed catalog"
+            return false
+        end
+
+        return false unless oldtext = self.retrievecache
+
+        begin
+            @catalog = YAML.load(oldtext).to_catalog
+            @catalog.from_cache = true
+            @catalog.host_config = true
+        rescue => detail
+            puts detail.backtrace if Puppet[:trace]
+            Puppet.warning "Could not load cached catalog: %s" % detail
+            clear
+            return false
+        end
+        return true
+    end
+end