puppet 0.24.9 → 0.25.0

data/lib/puppet/type/file.rb

@@ -6,17 +6,20 @@ require 'fileutils'
 require 'puppet/network/handler'
 require 'puppet/util/diff'
 require 'puppet/util/checksums'
+require 'puppet/network/client'
+require 'puppet/util/backups'
 
 module Puppet
     newtype(:file) do
         include Puppet::Util::MethodHelper
         include Puppet::Util::Checksums
+        include Puppet::Util::Backups
         @doc = "Manages local files, including setting ownership and
             permissions, creation of both files and directories, and
             retrieving entire files from remote servers.  As Puppet matures, it
             expected that the ``file`` resource will be used less and less to
             manage content, and instead native resources will be used to do so.
-            
+
             If you find that you are often copying files in from a central
             location, rather than using native resources, please contact
             Reductive Labs and we can hopefully work with you to develop a
@@ -28,9 +31,21 @@ module Puppet
 
             validate do |value|
                 unless value =~ /^#{File::SEPARATOR}/
-                    raise Puppet::Error, "File paths must be fully qualified"
+                    raise Puppet::Error, "File paths must be fully qualified, not '%s'" % value
                 end
             end
+
+            # convert the current path in an index into the collection and the last
+            # path name. The aim is to use less storage for all common paths in a hierarchy
+            munge do |value|
+                path, name = File.split(value)
+                { :index => Puppet::FileCollection.collection.index(path), :name => name }
+            end
+
+            # and the reverse
+            unmunge do |value|
+                File.join( Puppet::FileCollection.collection.path(value[:index]), value[:name] )
+            end
         end
 
         newparam(:backup) do
@@ -45,11 +60,11 @@ module Puppet
                 the same directory with that value as the extension of the
                 backup. Setting ``backup => false`` disables all backups of the
                 file in question.
-                
+
                 Puppet automatically creates a local filebucket named ``puppet`` and
                 defaults to backing up there.  To use a server-based filebucket,
                 you must specify one in your configuration::
-                    
+
                     filebucket { main:
                         server => puppet
                     }
@@ -74,39 +89,21 @@ module Puppet
                 filebucketed files.
                 "
 
-            defaultto { "puppet" }
-            
+            defaultto "puppet"
+
             munge do |value|
                 # I don't really know how this is happening.
-                if value.is_a?(Array)
-                    value = value.shift
-                end
+                value = value.shift if value.is_a?(Array)
+
                 case value
-                when false, "false", :false:
+                when false, "false", :false
                     false
-                when true, "true", ".puppet-bak", :true:
+                when true, "true", ".puppet-bak", :true
                     ".puppet-bak"
-                when /^\./
+                when String
                     value
-                when String:
-                    # We can't depend on looking this up right now,
-                    # we have to do it after all of the objects
-                    # have been instantiated.
-                    if bucketobj = Puppet::Type.type(:filebucket)[value]
-                        @resource.bucket = bucketobj.bucket
-                        bucketobj.title
-                    else
-                        # Set it to the string; finish() turns it into a
-                        # filebucket.
-                        @resource.bucket = value
-                        value
-                    end
-                when Puppet::Network::Client.client(:Dipper):
-                    @resource.bucket = value
-                    value.name
                 else
-                    self.fail "Invalid backup type %s" %
-                        value.inspect
+                    self.fail "Invalid backup type %s" % value.inspect
                 end
             end
         end
@@ -115,7 +112,7 @@ module Puppet
             desc "Whether and how deeply to do recursive
                 management."
 
-            newvalues(:true, :false, :inf, /^[0-9]+$/)
+            newvalues(:true, :false, :inf, :remote, /^[0-9]+$/)
 
             # Replace the validation so that we allow numbers in
             # addition to string representations of them.
@@ -125,10 +122,42 @@ module Puppet
                 case newval
                 when :true, :inf: true
                 when :false: false
+                when :remote: :remote
+                when Integer, Fixnum, Bignum:
+                    self.warning "Setting recursion depth with the recurse parameter is now deprecated, please use recurselimit"
+
+                    # recurse == 0 means no recursion
+                    return false if value == 0
+
+                    resource[:recurselimit] = value
+                    true
+                when /^\d+$/:
+                    self.warning "Setting recursion depth with the recurse parameter is now deprecated, please use recurselimit"
+                    value = Integer(value)
+
+                    # recurse == 0 means no recursion
+                    return false if value == 0
+
+                    resource[:recurselimit] = value
+                    true
+                else
+                    raise ArgumentError, "Invalid recurse value %s" % value.inspect
+                end
+            end
+        end
+
+        newparam(:recurselimit) do
+            desc "How deeply to do recursive management."
+
+            newvalues(/^[0-9]+$/)
+
+            munge do |value|
+                newval = super(value)
+                case newval
                 when Integer, Fixnum, Bignum: value
                 when /^\d+$/: Integer(value)
                 else
-                    raise ArgumentError, "Invalid recurse value %s" % value.inspect
+                    raise ArgumentError, "Invalid recurselimit value %s" % value.inspect
                 end
             end
         end
@@ -156,8 +185,6 @@ module Puppet
                 engine, so shell metacharacters are fully supported, e.g. ``[a-z]*``.
                 Matches that would descend into the directory structure are ignored,
                 e.g., ``*/*``."
-       
-            defaultto false
 
             validate do |value|
                 unless value.is_a?(Array) or value.is_a?(String) or value == false
@@ -186,7 +213,7 @@ module Puppet
                 this will destroy data.  Only use this option for generated
                 files unless you really know what you are doing.  This option only
                 makes sense when recursively managing directories.
-                
+
                 Note that when using ``purge`` with ``source``, Puppet will purge any files
                 that are not on the remote system."
 
@@ -207,15 +234,13 @@ module Puppet
 
             newvalues(:first, :all)
         end
-        
-        attr_accessor :bucket
 
         # Autorequire any parent directories.
         autorequire(:file) do
-            if self[:path]
-                File.dirname(self[:path])
+            basedir = File.dirname(self[:path])
+            if basedir != self[:path]
+                basedir
             else
-                Puppet.err "no path for %s, somehow; cannot setup autorequires" % self.ref
                 nil
             end
         end
@@ -235,7 +260,7 @@ module Puppet
                 end
             end
         end
-        
+
         CREATORS = [:content, :source, :target]
 
         validate do
@@ -243,11 +268,22 @@ module Puppet
             CREATORS.each do |param|
                 count += 1 if self.should(param)
             end
+            if @parameters.include?(:source)
+                count += 1
+            end
             if count > 1
                 self.fail "You cannot specify more than one of %s" % CREATORS.collect { |p| p.to_s}.join(", ")
             end
+
+            if !self[:source] and self[:recurse] == :remote
+                self.fail "You cannot specify a remote recursion without a source"
+            end
+
+            if !self[:recurse] and self[:recurselimit]
+                self.warning "Possible error: recurselimit is set but not recurse, no recursion will happen"
+            end
         end
-        
+
         def self.[](path)
             return nil unless path
             super(path.gsub(/\/+/, '/').sub(/\/$/, ''))
@@ -268,7 +304,7 @@ module Puppet
                     obj[:check] = :all
                     files << obj
                 else
-                    files << self.create(
+                    files << self.new(
                         :name => path, :check => :all
                     )
                 end
@@ -278,11 +314,6 @@ module Puppet
 
         @depthfirst = false
 
-
-        def argument?(arg)
-            @arghash.include?(arg)
-        end
-
         # Determine the user to write files as.
         def asuser
             if self.should(:owner) and ! self.should(:owner).is_a?(Symbol)
@@ -301,159 +332,68 @@ module Puppet
             return asuser
         end
 
+        def bucket
+            return @bucket if defined?(@bucket) and @bucket
+
+            backup = self[:backup]
+            return nil unless backup
+            return nil if backup =~ /^\./
+
+            unless catalog or backup == "puppet"
+                fail "Can not find filebucket for backups without a catalog"
+            end
+
+            unless catalog and filebucket = catalog.resource(:filebucket, backup) or backup == "puppet"
+                fail "Could not find filebucket %s specified in backup" % backup
+            end
+
+            return default_bucket unless filebucket
+
+            @bucket = filebucket.bucket
+
+            return @bucket
+        end
+
+        def default_bucket
+            Puppet::Type.type(:filebucket).mkdefaultbucket.bucket
+        end
+
+        # Does the file currently exist?  Just checks for whether
+        # we have a stat
+        def exist?
+            stat ? true : false
+        end
+
         # We have to do some extra finishing, to retrieve our bucket if
         # there is one.
         def finish
-            # Let's cache these values, since there should really only be
-            # a couple of these buckets
-            @@filebuckets ||= {}
-
             # Look up our bucket, if there is one
-            if bucket = self.bucket
-                case bucket
-                when String:
-                    if obj = @@filebuckets[bucket]
-                        # This sets the @value on :backup, too
-                        self.bucket = obj
-                    elsif bucket == "puppet"
-                        obj = Puppet::Network::Client.client(:Dipper).new(
-                            :Path => Puppet[:clientbucketdir]
-                        )
-                        self.bucket = obj
-                        @@filebuckets[bucket] = obj
-                    elsif obj = Puppet::Type.type(:filebucket).bucket(bucket)
-                        @@filebuckets[bucket] = obj
-                        self.bucket = obj
-                    else
-                        self.fail "Could not find filebucket %s" % bucket
-                    end
-                when Puppet::Network::Client.client(:Dipper): # things are hunky-dorey
-                else
-                    self.fail "Invalid bucket type %s" % bucket.class
-                end
-            end
+            bucket()
             super
         end
-        
+
         # Create any children via recursion or whatever.
         def eval_generate
-            recurse()
-        end
+            return [] unless self.recurse?
 
-        # Deal with backups.
-        def handlebackup(file = nil)
-            # let the path be specified
-            file ||= self[:path]
-            # if they specifically don't want a backup, then just say
-            # we're good
-            unless FileTest.exists?(file)
-                return true
-            end
-
-            unless self[:backup]
-                return true
-            end
+            recurse
+            #recurse.reject do |resource|
+            #    catalog.resource(:file, resource[:path])
+            #end.each do |child|
+            #    catalog.add_resource child
+            #    catalog.relationship_graph.add_edge self, child
+            #end
+        end
 
-            case File.stat(file).ftype
-            when "directory":
-                if self[:recurse]
-                    # we don't need to backup directories when recurse is on
-                    return true
-                else
-                    backup = self.bucket || self[:backup]
-                    case backup
-                    when Puppet::Network::Client.client(:Dipper):
-                        notice "Recursively backing up to filebucket"
-                        require 'find'
-                        Find.find(self[:path]) do |f|
-                            if File.file?(f)
-                                sum = backup.backup(f)
-                                self.notice "Filebucketed %s to %s with sum %s" %
-                                    [f, backup.name, sum]
-                            end
-                        end
-
-                        return true
-                    when String:
-                        newfile = file + backup
-                        # Just move it, since it's a directory.
-                        if FileTest.exists?(newfile)
-                            remove_backup(newfile)
-                        end
-                        begin
-                            bfile = file + backup
-
-                            # Ruby 1.8.1 requires the 'preserve' addition, but
-                            # later versions do not appear to require it.
-                            FileUtils.cp_r(file, bfile, :preserve => true)
-                            return true
-                        rescue => detail
-                            # since they said they want a backup, let's error out
-                            # if we couldn't make one
-                            self.fail "Could not back %s up: %s" %
-                                [file, detail.message]
-                        end
-                    else
-                        self.err "Invalid backup type %s" % backup.inspect
-                        return false
-                    end
-                end
-            when "file":
-                backup = self.bucket || self[:backup]
-                case backup
-                when Puppet::Network::Client.client(:Dipper):
-                    sum = backup.backup(file)
-                    self.notice "Filebucketed to %s with sum %s" %
-                        [backup.name, sum]
-                    return true
-                when String:
-                    newfile = file + backup
-                    if FileTest.exists?(newfile)
-                        remove_backup(newfile)
-                    end
-                    begin
-                        # FIXME Shouldn't this just use a Puppet object with
-                        # 'source' specified?
-                        bfile = file + backup
-
-                        # Ruby 1.8.1 requires the 'preserve' addition, but
-                        # later versions do not appear to require it.
-                        FileUtils.cp(file, bfile, :preserve => true)
-                        return true
-                    rescue => detail
-                        # since they said they want a backup, let's error out
-                        # if we couldn't make one
-                        self.fail "Could not back %s up: %s" %
-                            [file, detail.message]
-                    end
-                else
-                    self.err "Invalid backup type %s" % backup.inspect
-                    return false
-                end
-            when "link": return true
-            else
-                self.notice "Cannot backup files of type %s" %
-                    File.stat(file).ftype
-                return false
+        def flush
+            # We want to make sure we retrieve metadata anew on each transaction.
+            @parameters.each do |name, param|
+                param.flush if param.respond_to?(:flush)
             end
+            @stat = nil
         end
-        
-        def handleignore(children)
-            return children unless self[:ignore]
-            self[:ignore].each { |ignore|
-                ignored = []
-                Dir.glob(File.join(self[:path],ignore), File::FNM_DOTMATCH) {
-                    |match| ignored.push(File.basename(match))
-                }
-                children = children - ignored
-            }
-            return children
-        end
-          
-        def initialize(hash)
-            # Store a copy of the arguments for later.
-            tmphash = hash.to_hash
 
+        def initialize(hash)
             # Used for caching clients
             @clients = {}
 
@@ -461,197 +401,42 @@ module Puppet
 
             # Get rid of any duplicate slashes, and remove any trailing slashes.
             @title = @title.gsub(/\/+/, "/")
-            
-            @title.sub!(/\/$/, "") unless @title == "/"
-
-            # Clean out as many references to any file paths as possible.
-            # This was the source of many, many bugs.
-            @arghash = tmphash
-            @arghash.delete(self.class.namevar)
 
-            [:source, :parent].each do |param|
-                if @arghash.include?(param)
-                    @arghash.delete(param)
-                end
-            end
+            @title.sub!(/\/$/, "") unless @title == "/"
 
             @stat = nil
         end
 
-        # Build a recursive map of a link source
-        def linkrecurse(recurse)
-            target = @parameters[:target].should
-
-            method = :lstat
-            if self[:links] == :follow
-                method = :stat
-            end
-
-            targetstat = nil
-            unless FileTest.exist?(target)
-                return
-            end
-            # Now stat our target
-            targetstat = File.send(method, target)
-            unless targetstat.ftype == "directory"
-                return
-            end
-
-            # Now that we know our corresponding target is a directory,
-            # change our type
-            self[:ensure] = :directory
-
-            unless FileTest.readable? target
-                self.notice "Cannot manage %s: permission denied" % self.name
-                return
-            end
-
-            children = Dir.entries(target).reject { |d| d =~ /^\.+$/ }
-         
-            # Get rid of ignored children
-            if @parameters.include?(:ignore)
-                children = handleignore(children)
-            end
-
-            added = []
-            children.each do |file|
-                Dir.chdir(target) do
-                    longname = File.join(target, file)
-
-                    # Files know to create directories when recursion
-                    # is enabled and we're making links
-                    args = {
-                        :recurse => recurse,
-                        :ensure => longname
-                    }
-
-                    if child = self.newchild(file, true, args)
-                        added << child
-                    end
-                end
+        # Configure discovered resources to be purged.
+        def mark_children_for_purging(children)
+            children.each do |name, child|
+                next if child[:source]
+                child[:ensure] = :absent
             end
-            
-            added
         end
 
-        # Build up a recursive map of what's around right now
-        def localrecurse(recurse)
-            unless FileTest.exist?(self[:path]) and self.stat.directory?
-                #self.info "%s is not a directory; not recursing" %
-                #    self[:path]
-                return
-            end
-
-            unless FileTest.readable? self[:path]
-                self.notice "Cannot manage %s: permission denied" % self.name
-                return
-            end
-
-            children = Dir.entries(self[:path])
-         
-            #Get rid of ignored children
-            if @parameters.include?(:ignore)
-                children = handleignore(children)
-            end
-
-            added = []
-            children.each { |file|
-                file = File.basename(file)
-                next if file =~ /^\.\.?$/ # skip . and .. 
-                options = {:recurse => recurse}
-
-                if child = self.newchild(file, true, options)
-                    added << child
-                end
-            }
-            
-            added
-        end
-        
         # Create a new file or directory object as a child to the current
         # object.
-        def newchild(path, local, hash = {})
-            raise(Puppet::DevError, "File recursion cannot happen without a catalog") unless catalog
+        def newchild(path)
+            full_path = File.join(self[:path], path)
 
-            # make local copy of arguments
-            args = symbolize_options(@arghash)
+            # Add some new values to our original arguments -- these are the ones
+            # set at initialization.  We specifically want to exclude any param
+            # values set by the :source property or any default values.
+            # LAK:NOTE This is kind of silly, because the whole point here is that
+            # the values set at initialization should live as long as the resource
+            # but values set by default or by :source should only live for the transaction
+            # or so.  Unfortunately, we don't have a straightforward way to manage
+            # the different lifetimes of this data, so we kludge it like this.
+            # The right-side hash wins in the merge.
+            options = @original_parameters.merge(:path => full_path).reject { |param, value| value.nil? }
 
-            # There's probably a better way to do this, but we don't want
-            # to pass this info on.
-            if v = args[:ensure]
-                v = symbolize(v)
-                args.delete(:ensure)
+            # These should never be passed to our children.
+            [:parent, :ensure, :recurse, :recurselimit, :target, :alias, :source].each do |param|
+                options.delete(param) if options.include?(param)
             end
 
-            if path =~ %r{^#{File::SEPARATOR}}
-                self.devfail(
-                    "Must pass relative paths to PFile#newchild()"
-                )
-            else
-                path = File.join(self[:path], path)
-            end
-
-            args[:path] = path
-
-            unless hash.include?(:recurse)
-                if args.include?(:recurse)
-                    if args[:recurse].is_a?(Integer)
-                        args[:recurse] -= 1 # reduce the level of recursion
-                    end
-                end
-
-            end
-
-            hash.each { |key,value|
-                args[key] = value
-            }
-
-            child = nil
-
-            # The child might already exist because 'localrecurse' runs
-            # before 'sourcerecurse'.  I could push the override stuff into
-            # a separate method or something, but the work is the same other
-            # than this last bit, so it doesn't really make sense.
-            if child = catalog.resource(:file, path)
-                unless child.parent.object_id == self.object_id
-                    self.debug "Not managing more explicit file %s" %
-                        path
-                    return nil
-                end
-
-                # This is only necessary for sourcerecurse, because we might have
-                # created the object with different 'should' values than are
-                # set remotely.
-                unless local
-                    args.each { |var,value|
-                        next if var == :path
-                        next if var == :name
-
-                        # behave idempotently
-                        unless child.should(var) == value
-                            child[var] = value
-                        end
-                    }
-                end
-                return nil
-            else # create it anew
-                #notice "Creating new file with args %s" % args.inspect
-                args[:parent] = self
-                begin
-                    # This method is used by subclasses of :file, so use the class name rather than hard-coding
-                    # :file.
-                    return nil unless child = catalog.create_implicit_resource(self.class.name, args)
-                rescue => detail
-                    self.notice "Cannot manage: %s" % [detail]
-                    return nil
-                end
-            end
-
-            # LAK:FIXME This shouldn't be necessary, but as long as we're
-            # modeling the relationship graph specifically, it is.
-            catalog.relationship_graph.add_edge self, child
-
-            return child
+            return self.class.new(options)
         end
 
         # Files handle paths specially, because they just lengthen their
@@ -675,63 +460,60 @@ module Puppet
                 return [self.ref]
             end
         end
-        
+
         # Should we be purging?
         def purge?
             @parameters.include?(:purge) and (self[:purge] == :true or self[:purge] == "true")
         end
 
-        # Recurse into the directory.  This basically just calls 'localrecurse'
-        # and maybe 'sourcerecurse', returning the collection of generated
-        # files.
+        # Recursively generate a list of file resources, which will
+        # be used to copy remote files, manage local files, and/or make links
+        # to map to another directory.
         def recurse
-            # are we at the end of the recursion?
-            return unless self.recurse?
-
-            recurse = self[:recurse]
-            # we might have a string, rather than a number
-            if recurse.is_a?(String)
-                if recurse =~ /^[0-9]+$/
-                    recurse = Integer(recurse)
-                else # anything else is infinite recursion
-                    recurse = true
-                end
+            children = {}
+            if self[:recurse] != :remote
+                children = recurse_local
             end
 
-            if recurse.is_a?(Integer)
-                recurse -= 1
-            end
-            
-            children = []
-            
-            # We want to do link-recursing before normal recursion so that all
-            # of the target stuff gets copied over correctly.
-            if @parameters.include? :target and ret = self.linkrecurse(recurse)
-                children += ret
-            end
-            if ret = self.localrecurse(recurse)
-                children += ret
+            if self[:target]
+                recurse_link(children)
+            elsif self[:source]
+                recurse_remote(children)
             end
 
-            # These will be files pulled in by the file source
-            sourced = false
-            if @parameters.include?(:source)
-                ret, sourced = self.sourcerecurse(recurse)
-                if ret
-                    children += ret
-                end
-            end
+            # If we're purging resources, then delete any resource that isn't on the
+            # remote system.
+            mark_children_for_purging(children) if self.purge?
 
-            # The purge check needs to happen after all of the other recursion.
-            if self.purge?
-                children.each do |child|
-                    if (sourced and ! sourced.include?(child[:path])) or ! child.managed?
-                        child[:ensure] = :absent
+            result = children.values.sort { |a, b| a[:path] <=> b[:path] }
+            remove_less_specific_files(result)
+        end
+
+        # This is to fix bug #2296, where two files recurse over the same
+        # set of files.  It's a rare case, and when it does happen you're
+        # not likely to have many actual conflicts, which is good, because
+        # this is a pretty inefficient implementation.
+        def remove_less_specific_files(files)
+            # We sort the paths so we can short-circuit some tests.
+            mypath = self[:path]
+            other_paths = catalog.vertices.find_all do |r|
+                r.is_a?(self.class) and r[:path][0..(mypath.length - 1)] == mypath
+            end.collect { |r| r[:path] }.sort { |a, b| a.length <=> b.length } - [self[:path]]
+
+            return files if other_paths.empty?
+
+            remove = []
+            files.each do |file|
+                path = file[:path]
+                other_paths.each do |p|
+                    if path[0..(p.length - 1)] == p
+                        remove << file
+                        break
                     end
                 end
             end
-            
-            children
+
+            files - remove
         end
 
         # A simple method for determining whether we should be recursing.
@@ -740,174 +522,120 @@ module Puppet
 
             val = @parameters[:recurse].value
 
-            if val and (val == true or val > 0)
+            if val and (val == true or val == :remote)
                 return true
             else
                 return false
             end
         end
 
-        # Remove the old backup.
-        def remove_backup(newfile)
-            if self.class.name == :file and self[:links] != :follow
-                method = :lstat
-            else
-                method = :stat
+        # Recurse the target of the link.
+        def recurse_link(children)
+            perform_recursion(self[:target]).each do |meta|
+                if meta.relative_path == "."
+                    self[:ensure] = :directory
+                    next
+                end
+
+                children[meta.relative_path] ||= newchild(meta.relative_path)
+                if meta.ftype == "directory"
+                    children[meta.relative_path][:ensure] = :directory
+                else
+                    children[meta.relative_path][:ensure] = :link
+                    children[meta.relative_path][:target] = meta.full_path
+                end
             end
-            old = File.send(method, newfile).ftype
+            children
+        end
 
-            if old == "directory"
-                raise Puppet::Error,
-                    "Will not remove directory backup %s; use a filebucket" %
-                    newfile
+        # Recurse the file itself, returning a Metadata instance for every found file.
+        def recurse_local
+            result = perform_recursion(self[:path])
+            return {} unless result
+            result.inject({}) do |hash, meta|
+                next hash if meta.relative_path == "."
+
+                hash[meta.relative_path] = newchild(meta.relative_path)
+                hash
             end
+        end
 
-            info "Removing old backup of type %s" %
-                File.send(method, newfile).ftype
+        # Recurse against our remote file.
+        def recurse_remote(children)
+            sourceselect = self[:sourceselect]
 
-            begin
-                File.unlink(newfile)
-            rescue => detail
-                puts detail.backtrace if Puppet[:trace]
-                self.err "Could not remove old backup: %s" % detail
-                return false
+            total = self[:source].collect do |source|
+                next unless result = perform_recursion(source)
+                return if top = result.find { |r| r.relative_path == "." } and top.ftype != "directory"
+                result.each { |data| data.source = "%s/%s" % [source, data.relative_path] }
+                break result if result and ! result.empty? and sourceselect == :first
+                result
+            end.flatten
+
+            # This only happens if we have sourceselect == :all
+            unless sourceselect == :first
+                found = []
+                total.reject! do |data|
+                    result = found.include?(data.relative_path)
+                    found << data.relative_path unless found.include?(data.relative_path)
+                    result
+                end
+            end
+
+            total.each do |meta|
+                if meta.relative_path == "."
+                    parameter(:source).metadata = meta
+                    next
+                end
+                children[meta.relative_path] ||= newchild(meta.relative_path)
+                children[meta.relative_path][:source] = meta.source
+                children[meta.relative_path][:checksum] = :md5 if meta.ftype == "file"
+
+                children[meta.relative_path].parameter(:source).metadata = meta
             end
+
+            children
+        end
+
+        def perform_recursion(path)
+            Puppet::FileServing::Metadata.search(path, :links => self[:links], :recurse => (self[:recurse] == :remote ? true : self[:recurse]), :recurselimit => self[:recurselimit], :ignore => self[:ignore])
         end
 
         # Remove any existing data.  This is only used when dealing with
         # links or directories.
         def remove_existing(should)
-            return unless s = stat(true)
+            return unless s = stat
 
-            self.fail "Could not back up; will not replace" unless handlebackup
+            self.fail "Could not back up; will not replace" unless perform_backup
 
             unless should.to_s == "link"
-                return if s.ftype.to_s == should.to_s 
+                return if s.ftype.to_s == should.to_s
             end
 
             case s.ftype
-            when "directory":
+            when "directory"
                 if self[:force] == :true
                     debug "Removing existing directory for replacement with %s" % should
                     FileUtils.rmtree(self[:path])
                 else
                     notice "Not removing directory; use 'force' to override"
                 end
-            when "link", "file":
+            when "link", "file"
                 debug "Removing existing %s for replacement with %s" %
                     [s.ftype, should]
                 File.unlink(self[:path])
             else
                 self.fail "Could not back up files of type %s" % s.ftype
             end
+            expire
         end
 
         # a wrapper method to make sure the file exists before doing anything
         def retrieve
-            unless stat = self.stat(true)
-                self.debug "File does not exist"
-                # If the file doesn't exist but we have a source, then call
-                # retrieve on that property
-
-                propertyvalues = properties().inject({}) { |hash, property|
-                                     hash[property] = :absent
-                                     hash
-                                  }
-
-                if @parameters.include?(:source)
-                    propertyvalues[:source] = @parameters[:source].retrieve
-                end
-                return propertyvalues
-            end
-
-            return currentpropvalues()
-        end
-
-        # This recurses against the remote source and makes sure the local
-        # and remote structures match.  It's run after 'localrecurse'.  This
-        # method only does anything when its corresponding remote entry is
-        # a directory; in that case, this method creates file objects that
-        # correspond to any contained remote files.
-        def sourcerecurse(recurse)
-            # we'll set this manually as necessary
-            if @arghash.include?(:ensure)
-                @arghash.delete(:ensure)
-            end
-            
-            r = false
-            if recurse
-                unless recurse == 0
-                    r = 1
-                end
+            if source = parameter(:source)
+                source.copy_source_values
             end
-            
-            ignore = self[:ignore]
-
-            result = []
-            found = []
-
-            # Keep track of all the files we found in the source, so we can purge
-            # appropriately.
-            sourced = []
-
-            success = false
-            
-            @parameters[:source].should.each do |source|
-                sourceobj, path = uri2obj(source)
-
-                # okay, we've got our source object; now we need to
-                # build up a local file structure to match the remote
-                # one
-
-                server = sourceobj.server
-
-                desc = server.list(path, self[:links], r, ignore)
-                if desc == "" 
-                    next
-                end
-
-                success = true
-            
-                # Now create a new child for every file returned in the list.
-                result += desc.split("\n").collect { |line|
-                    file, type = line.split("\t")
-                    next if file == "/" # skip the listing object
-                    name = file.sub(/^\//, '')
-
-                    # This makes sure that the first source *always* wins
-                    # for conflicting files.
-                    next if found.include?(name)
-
-                    # For directories, keep all of the sources, so that
-                    # sourceselect still works as planned.
-                    if type == "directory"
-                        newsource = @parameters[:source].should.collect do |tmpsource|
-                            tmpsource + file
-                        end
-                    else
-                        newsource = source + file
-                    end
-                    args = {:source => newsource}
-                    if type == file
-                        args[:recurse] = nil
-                    end
-
-                    found << name
-                    sourced << File.join(self[:path], name)
-
-                    self.newchild(name, false, args)
-                }.reject {|c| c.nil? }
-
-                if self[:sourceselect] == :first
-                    return [result, sourced]
-                end
-            end
-
-            unless success
-                raise Puppet::Error, "None of the provided sources exist"
-            end
-
-            return [result, sourced]
+            super
         end
 
         # Set the checksum, from another property.  There are multiple
@@ -926,11 +654,33 @@ module Puppet
             end
         end
 
+        # Should this thing be a normal file?  This is a relatively complex
+        # way of determining whether we're trying to create a normal file,
+        # and it's here so that the logic isn't visible in the content property.
+        def should_be_file?
+            return true if self[:ensure] == :file
+
+            # I.e., it's set to something like "directory"
+            return false if e = self[:ensure] and e != :present
+
+            # The user doesn't really care, apparently
+            if self[:ensure] == :present
+                return true unless s = stat
+                return true if s.ftype == "file"
+                return false
+            end
+
+            # If we've gotten here, then :ensure isn't set
+            return true if self[:content]
+            return true if stat and stat.ftype == "file"
+            return false
+        end
+
         # Stat our file.  Depending on the value of the 'links' attribute, we
         # use either 'stat' or 'lstat', and we expect the properties to use the
         # resulting stat object accordingly (mostly by testing the 'ftype'
         # value).
-        def stat(refresh = false)
+        cached_attr(:stat) do
             method = :stat
 
             # Files are the only types that support links
@@ -938,23 +688,15 @@ module Puppet
                 method = :lstat
             end
             path = self[:path]
-            # Just skip them when they don't exist at all.
-            unless FileTest.exists?(path) or FileTest.symlink?(path)
-                @stat = nil
-                return @stat
-            end
-            if @stat.nil? or refresh == true
-                begin
-                    @stat = File.send(method, self[:path])
-                rescue Errno::ENOENT => error
-                    @stat = nil
-                rescue Errno::EACCES => error
-                    self.warning "Could not stat; permission denied"
-                    @stat = nil
-                end
-            end
 
-            return @stat
+            begin
+                File.send(method, self[:path])
+            rescue Errno::ENOENT => error
+                return nil
+            rescue Errno::EACCES => error
+                warning "Could not stat; permission denied"
+                return nil
+            end
         end
 
         # We have to hack this just a little bit, because otherwise we'll get
@@ -968,75 +710,6 @@ module Puppet
             obj
         end
 
-        def localfileserver
-            unless defined? @@localfileserver
-                args = {
-                    :Local => true,
-                    :Mount => { "/" => "localhost" },
-                    :Config => false
-                }
-                @@localfileserver = Puppet::Network::Handler.handler(:fileserver).new(args)
-            end
-            @@localfileserver
-        end
-
-        def uri2obj(source)
-            sourceobj = Puppet::Type::File::FileSource.new
-            path = nil
-            unless source
-                devfail "Got a nil source"
-            end
-            if source =~ /^\//
-                source = "file://localhost/%s" % URI.escape(source)
-                sourceobj.mount = "localhost"
-                sourceobj.local = true
-            end
-            begin
-                uri = URI.parse(URI.escape(source))
-            rescue => detail
-                self.fail "Could not understand source %s: %s" %
-                    [source, detail.to_s]
-            end
-
-            case uri.scheme
-            when "file":
-                sourceobj.server = localfileserver
-                path = "/localhost" + uri.path
-            when "puppet":
-                # FIXME: We should cache clients by uri.host + uri.port
-                # not by the full source path
-                unless @clients.include?(source)
-                    host = uri.host
-                    host ||= Puppet[:server] unless Puppet[:name] == "puppet"
-                    if host.nil?
-                        server = localfileserver
-                    else
-                        args = { :Server => host }
-                        if uri.port
-                            args[:Port] = uri.port
-                        end
-                        server = Puppet::Network::Client.file.new(args)
-                    end
-                    @clients[source] = server
-                end
-                sourceobj.server = @clients[source]
-
-                tmp = uri.path
-                if tmp =~ %r{^/(\w+)}
-                    sourceobj.mount = $1
-                    path = tmp
-                    #path = tmp.sub(%r{^/\w+},'') || "/"
-                else
-                    self.fail "Invalid source path %s" % tmp
-                end
-            else
-                self.fail "Got other URL type '%s' from %s" %
-                        [uri.scheme, source]
-            end
-
-            return [sourceobj, path.sub(/\/\//, '/')]
-        end
-
         # Write out the file.  Requires the content to be written,
         # the property name for logging, and the checksum for validation.
         def write(content, property, checksum = nil)
@@ -1049,8 +722,14 @@ module Puppet
             remove_existing(:file)
 
             use_temporary_file = (content.length != 0)
-            path = self[:path]
-            path += ".puppettmp" if use_temporary_file
+            if use_temporary_file
+                path = "#{self[:path]}.puppettmp_#{rand(10000)}"
+                while File.exists?(path) or File.symlink?(path)
+                    path = "#{self[:path]}.puppettmp_#{rand(10000)}"
+                    end
+              else
+                path = self[:path]
+              end
 
             mode = self.should(:mode) # might be nil
             umask = mode ? 000 : 022
@@ -1065,7 +744,7 @@ module Puppet
                     fail_if_checksum_is_wrong(path, checksum) if validate
                     File.rename(path, self[:path])
                 rescue => detail
-                    self.err "Could not rename tmp %s for replacing: %s" % [self[:path], detail]
+                    fail "Could not rename temporary file %s to %s : %s" % [path, self[:path], detail]
                 ensure
                     # Make sure the created file gets removed
                     File.unlink(path) if FileTest.exists?(path)
@@ -1130,20 +809,14 @@ module Puppet
                 next unless [:mode, :owner, :group, :seluser, :selrole, :seltype, :selrange].include?(thing.name)
 
                 # Make sure we get a new stat objct
-                self.stat(true)
+                expire
                 currentvalue = thing.retrieve
                 unless thing.insync?(currentvalue)
                     thing.sync
                 end
             end
         end
-    end # Puppet.type(:pfile)
-
-    # the filesource class can't include the path, because the path
-    # changes for every file instance
-    class ::Puppet::Type::File::FileSource
-        attr_accessor :mount, :root, :server, :local
-    end
+    end # Puppet::Type.type(:pfile)
 
     # We put all of the properties in separate files, because there are so many
     # of them.  The order these are loaded is important, because it determines