puppet 0.18.4 → 0.22.4

data/lib/puppet/type/pfile.rb

@@ -3,11 +3,12 @@ require 'cgi'
 require 'etc'
 require 'uri'
 require 'fileutils'
-require 'puppet/type/state'
-require 'puppet/server/fileserver'
+require 'puppet/type/property'
+require 'puppet/network/handler'
 
 module Puppet
     newtype(:file) do
+        include Puppet::Util::MethodHelper
         @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
@@ -32,13 +33,20 @@ module Puppet
 
         newparam(:backup) do
             desc "Whether files should be backed up before
-                being replaced.  If a filebucket is specified, files will be
-                backed up there; else, they will be backed up in the same directory
-                with a ``.puppet-bak`` extension,, and no backups
-                will be made if backup is ``false``.
+                being replaced.  The preferred method of backing files up is via
+                a ``filebucket``, which stores files by their MD5 sums and allows
+                easy retrieval without littering directories with backups.  You
+                can specify a local filebucket or a network-accessible
+                server-based filebucket by setting ``backup => bucket-name``.
+                Alternatively, if you specify any value that begins with a ``.``
+                (e.g., ``.puppet-bak``), then Puppet will use copy the file in
+                the same directory with that value as the extension of the
+                backup. Setting ``backup => false`` disables all backups of the
+                file in question.
                 
-                To use filebuckets, you must first create a filebucket in your
-                configuration:
+                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
@@ -47,7 +55,7 @@ module Puppet
                 The ``puppetmasterd`` daemon creates a filebucket by default,
                 so you can usually back up to your main server with this
                 configuration.  Once you've described the bucket in your
-                configuration, you can use it in any file:
+                configuration, you can use it in any file::
 
                     file { \"/my/file\":
                         source => \"/path/in/nfs/or/something\",
@@ -56,7 +64,7 @@ module Puppet
 
                 This will back the file up to the central server.
 
-                At this point, the only benefits to doing so are that you do not
+                At this point, the benefits of using a filebucket are that you do not
                 have backup files lying around on each of your machines, a given
                 version of a file is only backed up once, and you can restore
                 any given file manually, no matter how old.  Eventually,
@@ -64,37 +72,46 @@ module Puppet
                 filebucketed files.
                 "
 
-            attr_reader :bucket
-            defaultto ".puppet-bak"
-
+            defaultto  do
+                # Make sure the default file bucket exists.
+                obj = Puppet::Type.type(:filebucket)["puppet"] ||
+                    Puppet::Type.type(:filebucket).create(:name => "puppet")
+                obj.bucket
+            end
+            
             munge do |value|
+                # I don't really know how this is happening.
+                if value.is_a?(Array)
+                    value = value.shift
+                end
                 case value
                 when false, "false", :false:
                     false
                 when true, "true", ".puppet-bak", :true:
                     ".puppet-bak"
+                when /^\./
+                    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.
-                    @bucket = value
-                    value
+                    if bucketobj = Puppet::Type.type(:filebucket)[value]
+                        @parent.bucket = bucketobj.bucket
+                        bucketobj.title
+                    else
+                        # Set it to the string; finish() turns it into a
+                        # filebucket.
+                        @parent.bucket = value
+                        value
+                    end
+                when Puppet::Network::Client.client(:Dipper):
+                    @parent.bucket = value
+                    value.name
                 else
                     self.fail "Invalid backup type %s" %
                         value.inspect
                 end
             end
-
-            # Provide a straight-through hook for setting the bucket.
-            def bucket=(bucket)
-                @value = bucket
-                @bucket = bucket
-            end
-        end
-
-        newparam(:linkmaker) do
-            desc "An internal parameter used by the *symlink*
-                type to do recursive link creation."
         end
 
         newparam(:recurse) do
@@ -102,17 +119,40 @@ module Puppet
                 management."
 
             newvalues(:true, :false, :inf, /^[0-9]+$/)
+
+            # Replace the validation so that we allow numbers in
+            # addition to string representations of them.
+            validate { |arg| }
             munge do |value|
                 newval = super(value)
                 case newval
                 when :true, :inf: true
                 when :false: false
+                when Integer, Fixnum, Bignum: value
+                when /^\d+$/: Integer(value)
                 else
-                    newval
+                    raise ArgumentError, "Invalid recurse value %s" % value.inspect
                 end
             end
         end
 
+        newparam(:replace, :boolean => true) do
+            desc "Whether or not to replace a file that is
+                sourced but exists.  This is useful for using file sources
+                purely for initialization."
+            newvalues(:true, :false)
+            aliasvalue(:yes, :true)
+            aliasvalue(:no, :false)
+            defaultto :true
+        end
+
+        newparam(:force, :boolean => true) do
+            desc "Force the file operation.  Currently only used when replacing
+                directories with links."
+            newvalues(:true, :false)
+            defaultto false
+        end
+
         newparam(:ignore) do
             desc "A parameter which omits action on files matching
                 specified patterns during recursion.  Uses Ruby's builtin globbing
@@ -145,26 +185,78 @@ module Puppet
             defaultto :ignore
         end
 
-        autorequire(:file) do
-            cur = []
-            pary = self[:path].split(File::SEPARATOR)
-            pary.shift # remove the initial nil
-            pary.pop   # remove us
+        newparam(:purge, :boolean => true) do
+            desc "Whether unmanaged files should be purged.  If you have a filebucket
+                configured the purged files will be uploaded, but if you do not,
+                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."
 
-            pary.inject([""]) do |ary, dir|
-                ary << dir
-                cur << ary.join(File::SEPARATOR)
-                ary
+            defaultto :false
+
+            newvalues(:true, :false)
+        end
+
+        newparam(:sourceselect) do
+            desc "Whether to copy all valid sources, or just the first one.  This parameter
+                is only used in recursive copies; by default, the first valid source is the
+                only one used as a recursive source, but if this parameter is set to ``all``,
+                then all valid sources will have all of their contents copied to the local host,
+                and for sources that have the same file, the source earlier in the list will
+                be used."
+
+            defaultto :first
+
+            newvalues(:first, :all)
+        end
+        
+        attr_accessor :bucket
+
+        # Autorequire any parent directories.
+        autorequire(:file) do
+            if self[:path]
+                File.dirname(self[:path])
+            else
+                Puppet.err "no path for %s, somehow; cannot setup autorequires" % self.ref
+                nil
             end
+        end
 
-            cur
+        # Autorequire the owner and group of the file.
+        {:user => :owner, :group => :group}.each do |type, property|
+            autorequire(type) do
+                if @parameters.include?(property)
+                    # The user/group property automatically converts to IDs
+                    next unless should = @parameters[property].shouldorig
+                    val = should[0]
+                    if val.is_a?(Integer) or val =~ /^\d+$/
+                        nil
+                    else
+                        val
+                    end
+                end
+            end
         end
+        
+        CREATORS = [:content, :source, :target]
 
         validate do
-            if self[:content] and self[:source]
-                self.fail "You cannot specify both content and a source"
+            count = 0
+            CREATORS.each do |param|
+                count += 1 if self.should(param)
+            end
+            if count > 1
+                self.fail "You cannot specify more than one of %s" % CREATORS.collect { |p| p.to_s}.join(", ")
             end
         end
+        
+        def self.[](path)
+            return nil unless path
+            super(path.gsub(/\/+/, '/').sub(/\/$/, ''))
+        end
 
         # List files, but only one level deep.
         def self.list(base = "/")
@@ -199,13 +291,13 @@ module Puppet
         # Determine the user to write files as.
         def asuser
             if self.should(:owner) and ! self.should(:owner).is_a?(Symbol)
-                writeable = Puppet::Util.asuser(self.should(:owner)) {
+                writeable = Puppet::Util::SUIDManager.asuser(self.should(:owner)) {
                     FileTest.writable?(File.dirname(self[:path]))
                 }
 
                 # If the parent directory is writeable, then we execute
                 # as the user in question.  Otherwise we'll rely on
-                # the 'owner' state to do things.
+                # the 'owner' property to do things.
                 if writeable
                     asuser = self.should(:owner)
                 end
@@ -215,32 +307,43 @@ module Puppet
         end
 
         # We have to do some extra finishing, to retrieve our bucket if
-        # there is one
+        # 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 @parameters.include?(:backup) and bucket = @parameters[:backup].bucket
+            if bucket = self.bucket
                 case bucket
                 when String:
                     if obj = @@filebuckets[bucket]
                         # This sets the @value on :backup, too
-                        @parameters[:backup].bucket = obj
-                    elsif obj = Puppet.type(:filebucket).bucket(bucket)
+                        self.bucket = obj
+                    elsif bucket == "puppet"
+                        obj = Puppet::Network::Client.client(:Dipper).new(
+                            :Path => Puppet[:clientbucketdir]
+                        )
+                        self.bucket = obj
                         @@filebuckets[bucket] = obj
-                        @parameters[:backup].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::Client::Dipper: # things are hunky-dorey
+                when Puppet::Network::Client.client(:Dipper): # things are hunky-dorey
                 else
                     self.fail "Invalid bucket type %s" % bucket.class
                 end
             end
             super
         end
+        
+        # Create any children via recursion or whatever.
+        def eval_generate
+            recurse()
+        end
 
         # Deal with backups.
         def handlebackup(file = nil)
@@ -262,9 +365,9 @@ module Puppet
                     # we don't need to backup directories when recurse is on
                     return true
                 else
-                    backup = self[:backup]
+                    backup = self.bucket || self[:backup]
                     case backup
-                    when Puppet::Client::Dipper:
+                    when Puppet::Network::Client.client(:Dipper):
                         notice "Recursively backing up to filebucket"
                         require 'find'
                         Find.find(self[:path]) do |f|
@@ -275,21 +378,12 @@ module Puppet
                             end
                         end
 
-                        require 'fileutils'
-                        FileUtils.rmtree(self[:path])
                         return true
                     when String:
                         newfile = file + backup
                         # Just move it, since it's a directory.
                         if FileTest.exists?(newfile)
-                            begin
-                                File.unlink(newfile)
-                            rescue => detail
-                                puts detail.backtrace
-                                self.err "Could not remove old backup: %s" %
-                                    detail
-                                return false
-                            end
+                            remove_backup(newfile)
                         end
                         begin
                             bfile = file + backup
@@ -310,9 +404,9 @@ module Puppet
                     end
                 end
             when "file":
-                backup = self[:backup]
+                backup = self.bucket || self[:backup]
                 case backup
-                when Puppet::Client::Dipper:
+                when Puppet::Network::Client.client(:Dipper):
                     sum = backup.backup(file)
                     self.info "Filebucketed to %s with sum %s" %
                         [backup.name, sum]
@@ -320,13 +414,7 @@ module Puppet
                 when String:
                     newfile = file + backup
                     if FileTest.exists?(newfile)
-                        begin
-                            File.unlink(newfile)
-                        rescue => detail
-                            self.err "Could not remove old backup: %s" %
-                                detail
-                            return false
-                        end
+                        remove_backup(newfile)
                     end
                     begin
                         # FIXME Shouldn't this just use a Puppet object with
@@ -347,6 +435,7 @@ module Puppet
                     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
@@ -367,28 +456,133 @@ module Puppet
         end
           
         def initialize(hash)
-            # clean out as many references to any file paths as possible
-            # this was the source of many, many bugs
-            @arghash = self.argclean(hash)
+            # Store a copy of the arguments for later.
+            tmphash = hash.to_hash
+
+            # Used for caching clients
+            @clients = {}
+
+            super
+
+            # Get rid of any duplicate slashes, and remove any trailing slashes.
+            @title = @title.gsub(/\/+/, "/").sub(/\/$/, "")
+
+            # 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)
 
-            if @arghash.include?(:source)
-                @arghash.delete(:source)
+            [:source, :parent].each do |param|
+                if @arghash.include?(param)
+                    @arghash.delete(param)
+                end
             end
 
             @stat = nil
+        end
 
-            # Used for caching clients
-            @clients = {}
+        # Build a recursive map of a link source
+        def linkrecurse(recurse)
+            target = @parameters[:target].should
 
-            super
+            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
+            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 = {})
             # make local copy of arguments
-            args = @arghash.dup
+            args = symbolize_options(@arghash)
+
+            # 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)
+            end
 
             if path =~ %r{^#{File::SEPARATOR}}
                 self.devfail(
@@ -414,31 +608,14 @@ module Puppet
             }
 
             child = nil
-            klass = nil
-
-            # We specifically look in @parameters here, because 'linkmaker' isn't
-            # a valid attribute for subclasses, so using 'self[:linkmaker]' throws
-            # an error.
-            if @parameters.include?(:linkmaker) and 
-                args.include?(:source) and ! FileTest.directory?(args[:source])
-                klass = Puppet.type(:symlink)
-
-                # clean up the args a lot for links
-                old = args.dup
-                args = {
-                    :ensure => old[:source],
-                    :path => path
-                }
-            else
-                klass = self.class
-            end
-
+            klass = self.class
+            
             # 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 = klass[path]
-                unless @children.include?(child)
+                unless child.parent.object_id == self.object_id
                     self.debug "Not managing more explicit file %s" %
                         path
                     return nil
@@ -451,12 +628,14 @@ module Puppet
                     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
@@ -467,7 +646,6 @@ module Puppet
                     if child.nil?
                         return nil
                     end
-                    @children << child
                 rescue Puppet::Error => detail
                     self.notice(
                         "Cannot manage: %s" %
@@ -487,74 +665,87 @@ module Puppet
             return child
         end
 
-        # Paths are special for files, because we don't actually want to show
-        # the parent's full path.
-        def path
-            unless defined? @path
-                if defined? @parent
-                    # We only need to behave specially when our parent is also
-                    # a file
-                    if @parent.is_a?(self.class)
-                        # Remove the parent file name
-                        ppath = @parent.path.sub(/\/?file=.+/, '')
-                        @path = []
-                        if ppath != "/" and ppath != ""
-                            @path << ppath
-                        end
-                        @path << self.class.name.to_s + "=" + self.name
-                    else
-                        super
-                    end
+        # Files handle paths specially, because they just lengthen their
+        # path names, rather than including the full parent's title each
+        # time.
+        def pathbuilder
+            if defined? @parent
+                # We only need to behave specially when our parent is also
+                # a file
+                if @parent.is_a?(self.class)
+                    # Remove the parent file name
+                    list = @parent.pathbuilder
+                    list.pop # remove the parent's path info
+                    return list << self.ref
                 else
-                    # The top-level name is always puppet[top], so we don't
-                    # bother with that.  And we don't add the hostname
-                    # here, it gets added in the log server thingy.
-                    if self.name == "puppet[top]"
-                        @path = ["/"]
-                    else
-                        # We assume that if we don't have a parent that we
-                        # should not cache the path
-                        @path = [self.class.name.to_s + "=" + self.name]
-                    end
+                    return super
                 end
+            else
+                return [self.ref]
             end
-
-            return @path.join("/")
+        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'.
+        # and maybe 'sourcerecurse', returning the collection of generated
+        # files.
         def recurse
+            # are we at the end of the recursion?
+            unless self.recurse?
+                return
+            end
+
             recurse = self[:recurse]
             # we might have a string, rather than a number
             if recurse.is_a?(String)
                 if recurse =~ /^[0-9]+$/
                     recurse = Integer(recurse)
-                #elsif recurse =~ /^inf/ # infinite recursion
                 else # anything else is infinite recursion
                     recurse = true
                 end
             end
 
-            # are we at the end of the recursion?
-            #if recurse == 0
-            unless self.recurse?
-                return
-            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
+            end
 
-            self.localrecurse(recurse)
-            if @states.include? :target
-                self.linkrecurse(recurse)
+            # 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 @states.include?(:source)
-                self.sourcerecurse(recurse)
+
+            # 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
+                    end
+                end
             end
+            
+            children
         end
 
+        # A simple method for determining whether we should be recursing.
         def recurse?
             return false unless @parameters.include?(:recurse)
 
@@ -567,222 +758,192 @@ module Puppet
             end
         end
 
-        # Build a recursive map of a link source
-        def linkrecurse(recurse)
-            target = @states[:target].should
-
-            method = :lstat
-            if self[:links] == :follow
+        # Remove the old backup.
+        def remove_backup(newfile)
+            if self.class.name == :file and self[:links] != :follow
+                method = :lstat
+            else
                 method = :stat
             end
+            old = File.send(method, newfile).ftype
 
-            targetstat = nil
-            unless FileTest.exist?(target)
-                #self.info "%s does not exist; not recursing" %
-                #    target
-                return
-            end
-            # Now stat our target
-            targetstat = File.send(method, target)
-            unless targetstat.ftype == "directory"
-                #self.info "%s is not a directory; not recursing" %
-                #    target
-                return
+            if old == "directory"
+                raise Puppet::Error,
+                    "Will not remove directory backup %s; use a filebucket" %
+                    newfile
             end
 
-            # Now that we know our corresponding target is a directory,
-            # change our type
-            self[:ensure] = :directory
+            info "Removing old backup of type %s" %
+                File.send(method, newfile).ftype
 
-            unless FileTest.readable? target
-                self.notice "Cannot manage %s: permission denied" % self.name
-                return
+            begin
+                File.unlink(newfile)
+            rescue => detail
+                if Puppet[:trace]
+                    puts detail.backtrace
+                end
+                self.err "Could not remove old backup: %s" %
+                    detail
+                return false
             end
+        end
 
-            children = Dir.entries(target).reject { |d| d =~ /^\.+$/ }
-         
-            #Get rid of ignored children
-            if @parameters.include?(:ignore)
-                children = handleignore(children)
-            end  
+        # Remove any existing data.  This is only used when dealing with
+        # links or directories.
+        def remove_existing(should)
+            return unless s = stat(true)
 
-            added = []
-            children.each do |file|
-                Dir.chdir(target) do
-                    longname = File.join(target, file)
+            unless handlebackup
+                self.fail "Could not back up; will not replace"
+            end
 
-                    # Files know to create directories when recursion
-                    # is enabled and we're making links
-                    args = {
-                        :recurse => recurse,
-                        :ensure => longname
-                    }
+            unless should.to_s == "link"
+                return if s.ftype.to_s == should.to_s 
+            end
 
-                    if child = self.newchild(file, true, args)
-                        unless @children.include?(child)
-                            self.push child
-                            added.push file
-                        end
-                    end
+            case s.ftype
+            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":
+                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
         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
+        # 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"
+                properties().each { |property|
+                    property.is = :absent
+                }
+                
+                # If the file doesn't exist but we have a source, then call
+                # retrieve on that property
+                if @parameters.include?(:source)
+                    @parameters[:source].retrieve
+                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 .. 
-                if child = self.newchild(file, true, :recurse => recurse)
-                    unless @children.include?(child)
-                        self.push child
-                        added.push file
-                    end
-                end
+            properties().each { |property|
+                property.retrieve
             }
         end
 
         # This recurses against the remote source and makes sure the local
-        # and remote structures match.  It's run after 'localrecurse'.
+        # 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)
-            # FIXME sourcerecurse should support purging non-remote files
-            source = @states[:source].source
-
-            unless ! source.nil? and source !~ /^\s*$/
-                self.notice "source %s does not exist" % @states[:source].should
-                return nil
-            end
-            
-            sourceobj, path = uri2obj(source)
-
             # we'll set this manually as necessary
             if @arghash.include?(:ensure)
                 @arghash.delete(:ensure)
             end
-
-            # 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
-            sum = "md5"
-            if state = self.state(:checksum)
-                sum = state.checktype
-            end
+            
             r = false
             if recurse
                 unless recurse == 0
                     r = 1
                 end
             end
-
-            #ignore = self[:ignore] || false
+            
             ignore = self[:ignore]
 
-            #self.warning "Listing path %s with ignore %s" %
-            #    [path.inspect, ignore.inspect]
-            desc = server.list(path, self[:links], r, ignore)
-           
-            desc.split("\n").each { |line|
-                file, type = line.split("\t")
-                next if file == "/"
-                name = file.sub(/^\//, '')
-                #self.warning "child name is %s" % name
-                args = {:source => source + file}
-                if type == file
-                    args[:recurse] = nil
-                end
-                self.newchild(name, false, args)
-                #self.newchild(hash, source, recurse)
-                #hash2child(hash, source, recurse)
-            }
-        end
+            result = []
+            found = []
 
-        # a wrapper method to make sure the file exists before doing anything
-        def retrieve
-            if @states.include?(:source)
-                # This probably isn't the best place for it, but we need
-                # to make sure that we have a corresponding checksum state.
-                unless @states.include?(:checksum)
-                    self[:checksum] = "md5"
-                end
+            # Keep track of all the files we found in the source, so we can purge
+            # appropriately.
+            sourced = []
+            
+            @parameters[:source].should.each do |source|
+                sourceobj, path = uri2obj(source)
 
-                # We have to retrieve the source info before the recursion happens,
-                # although I'm not exactly clear on why.
-                @states[:source].retrieve
-            end
+                # okay, we've got our source object; now we need to
+                # build up a local file structure to match the remote
+                # one
 
-            if @parameters.include?(:recurse)
-                self.recurse
-            end
+                server = sourceobj.server
 
-            unless stat = self.stat(true)
-                self.debug "File does not exist"
-                @states.each { |name,state|
-                    # We've already retreived the source, and we don't
-                    # want to overwrite whatever it did.  This is a bit
-                    # of a hack, but oh well, source is definitely special.
-                    next if name == :source
-                    state.is = :absent
-                }
+                desc = server.list(path, self[:links], r, ignore)
+                if desc == "" 
+                    next
+                end
+            
+                # 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 |source|
+                            source + file
+                        end
+                    else
+                        newsource = source + file
+                    end
+                    args = {:source => newsource}
+                    if type == file
+                        args[:recurse] = nil
+                    end
 
-                return
-            end
+                    found << name
+                    sourced << File.join(self[:path], name)
 
-            states().each { |state|
-                # We don't want to call 'describe()' twice, so only do a local
-                # retrieve on the source.
-                if state.name == :source
-                    state.retrieve(false)
-                else
-                    state.retrieve
+                    self.newchild(name, false, args)
+                }.reject {|c| c.nil? }
+
+                if self[:sourceselect] == :first
+                    return [result, sourced]
                 end
-            }
+            end
+            return [result, sourced]
         end
 
-        # Set the checksum, from another state.  There are multiple states that
-        # modify the contents of a file, and they need the ability to make sure
-        # that the checksum value is in sync.
+        # Set the checksum, from another property.  There are multiple
+        # properties that modify the contents of a file, and they need the
+        # ability to make sure that the checksum value is in sync.
         def setchecksum(sum = nil)
-            if @states.include? :checksum
+            if @parameters.include? :checksum
                 if sum
-                    @states[:checksum].checksum = sum
+                    @parameters[:checksum].checksum = sum
                 else
                     # If they didn't pass in a sum, then tell checksum to
                     # figure it out.
-                    @states[:checksum].retrieve
-                    @states[:checksum].checksum = @states[:checksum].is
+                    @parameters[:checksum].retrieve
+                    @parameters[:checksum].checksum = @parameters[:checksum].is
                 end
             end
         end
 
-        # Stat our file.  Depending on the value of the 'links' attribute, we use
-        # either 'stat' or 'lstat', and we expect the states to use the resulting
-        # stat object accordingly (mostly by testing the 'ftype' value).
+        # 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)
             method = :stat
 
             # Files are the only types that support links
-            if self.class.name == :file and self[:links] != :follow
+            if (self.class.name == :file and self[:links] != :follow) or self.class.name == :tidy
                 method = :lstat
             end
             path = self[:path]
@@ -805,6 +966,17 @@ module Puppet
             return @stat
         end
 
+        # We have to hack this just a little bit, because otherwise we'll get
+        # an error when the target and the contents are created as properties on
+        # the far side.
+        def to_trans
+            obj = super
+            if obj[:target] == :notlink
+                obj.delete(:target)
+            end
+            obj
+        end
+
         def uri2obj(source)
             sourceobj = FileSource.new
             path = nil
@@ -817,7 +989,7 @@ module Puppet
                 sourceobj.local = true
             end
             begin
-                uri = URI.parse(source)
+                uri = URI.parse(URI.escape(source))
             rescue => detail
                 self.fail "Could not understand source %s: %s" %
                     [source, detail.to_s]
@@ -826,7 +998,7 @@ module Puppet
             case uri.scheme
             when "file":
                 unless defined? @@localfileserver
-                    @@localfileserver = Puppet::Server::FileServer.new(
+                    @@localfileserver = Puppet::Network::Handler.handler(:fileserver).new(
                         :Local => true,
                         :Mount => { "/" => "localhost" },
                         :Config => false
@@ -841,9 +1013,9 @@ module Puppet
                     args[:Port] = uri.port
                 end
                 # FIXME We should cache a copy of this server
-                #sourceobj.server = Puppet::NetworkClient.new(args)
+                #sourceobj.server = Puppet::Network::NetworkClient.new(args)
                 unless @clients.include?(source)
-                    @clients[source] = Puppet::Client::FileClient.new(args)
+                    @clients[source] = Puppet::Network::Client.file.new(args)
                 end
                 sourceobj.server = @clients[source]
 
@@ -869,16 +1041,7 @@ module Puppet
         def write(usetmp = true)
             mode = self.should(:mode)
 
-            #if FileTest.exists?(self[:path])
-            if s = stat(false)
-                # this makes sure we have a copy for posterity
-                @backed = self.handlebackup
-
-                if s.ftype == "link" and self[:links] != :follow
-                    # Remove existing links, since we're writing out a file
-                    File.unlink(self[:path])
-                end
-            end
+            remove_existing(:file)
 
             # The temporary file
             path = nil
@@ -889,7 +1052,7 @@ module Puppet
             end
 
             # As the correct user and group
-            Puppet::Util.asuser(asuser(), self.should(:group)) do
+            write_if_writable(File.dirname(path)) do
                 f = nil
                 # Open our file with the correct modes
                 if mode
@@ -923,10 +1086,68 @@ module Puppet
                 end
             end
 
+            # make sure all of the modes are actually correct
+            property_fix
+
             # And then update our checksum, so the next run doesn't find it.
             # FIXME This is extra work, because it's going to read the whole
             # file back in again.
             self.setchecksum
+            
+        end
+        
+        # Run the block as the specified user if the dir is writeable, else
+        # run it as root (or the current user).
+        def write_if_writable(dir)
+            yield
+            # We're getting different behaviors from different versions of ruby, so...
+            # asroot = true
+            # Puppet::Util::SUIDManager.asuser(asuser(), self.should(:group)) do
+            #     if FileTest.writable?(dir)
+            #         asroot = false
+            #         yield
+            #     end
+            # end
+            # 
+            # if asroot
+            #     yield
+            # end
+        end
+
+        private
+
+        # Override the parent method, because we don't want to generate changes
+        # when the file is missing and there is no 'ensure' state.
+        def propertychanges
+            unless self.stat
+                found = false
+                ([:ensure] + CREATORS).each do |prop|
+                    if @parameters.include?(prop)
+                        found = true
+                        break
+                    end
+                end
+                unless found
+                    return []
+                end
+            end
+            super
+        end
+
+        # There are some cases where all of the work does not get done on
+        # file creation/modification, so we have to do some extra checking.
+        def property_fix
+            self.each do |thing|
+                next unless thing.is_a? Puppet::Property
+                next unless [:mode, :owner, :group].include?(thing.name)
+
+                # Make sure we get a new stat objct
+                self.stat(true)
+                thing.retrieve
+                unless thing.insync?
+                    thing.sync
+                end
+            end
         end
     end # Puppet.type(:pfile)
 
@@ -936,17 +1157,17 @@ module Puppet
         attr_accessor :mount, :root, :server, :local
     end
 
-    # We put all of the states in separate files, because there are so many
+    # 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
-    # the order they are in the state list.
+    # the order they are in the property list.
     require 'puppet/type/pfile/checksum'
     require 'puppet/type/pfile/content'     # can create the file
     require 'puppet/type/pfile/source'      # can create the file
-    require 'puppet/type/pfile/target'
+    require 'puppet/type/pfile/target'      # creates a different type of file
     require 'puppet/type/pfile/ensure'      # can create the file
-    require 'puppet/type/pfile/uid'
+    require 'puppet/type/pfile/owner'
     require 'puppet/type/pfile/group'
     require 'puppet/type/pfile/mode'
     require 'puppet/type/pfile/type'
 end
-# $Id: pfile.rb 1355 2006-07-03 23:15:15Z luke $
+# $Id: pfile.rb 2436 2007-04-30 17:29:02Z luke $