puppet 0.9.2

data/lib/puppet/type/package/dpkg.rb

@@ -0,0 +1,108 @@
+module Puppet
+    module PackagingType
+        # The packaging system for Debian systems.
+        module DPKG
+            def query
+                packages = []
+
+                # dpkg only prints as many columns as you have available
+                # which means we don't get all of the info
+                # stupid stupid
+                oldcol = ENV["COLUMNS"]
+                ENV["COLUMNS"] = "500"
+                fields = [:desired, :status, :error, :name, :version, :description]
+
+                hash = {}
+                # list out our specific package
+                open("| dpkg -l %s 2>/dev/null" % self.name) { |process|
+                    # our regex for matching dpkg output
+                    regex = %r{^(.)(.)(.)\s(\S+)\s+(\S+)\s+(.+)$}
+
+                    # we only want the last line
+                    lines = process.readlines
+                    # we've got four header lines, so we should expect all of those
+                    # plus our output
+                    if lines.length < 5
+                        return nil
+                    end
+
+                    line = lines[-1]
+
+                    if match = regex.match(line)
+                        fields.zip(match.captures) { |field,value|
+                            hash[field] = value
+                        }
+                        #packages.push Puppet::Type::Package.installedpkg(hash)
+                    else
+                        raise Puppet::DevError,
+                            "failed to match dpkg line %s" % line
+                    end
+                }
+                ENV["COLUMNS"] = oldcol
+
+                if hash[:error] != " "
+                    raise Puppet::PackageError.new(
+                        "Package %s, version %s is in error state: %s" %
+                            [hash[:name], hash[:install], hash[:error]]
+                    )
+                end
+
+                if hash[:status] == "i"
+                    hash[:install] = hash[:version]
+                else
+                    hash[:install] = :notinstalled
+                end
+
+                return hash
+            end
+
+            def list
+                packages = []
+
+                # dpkg only prints as many columns as you have available
+                # which means we don't get all of the info
+                # stupid stupid
+                oldcol = ENV["COLUMNS"]
+                ENV["COLUMNS"] = "500"
+
+                # list out all of the packages
+                open("| dpkg -l") { |process|
+                    # our regex for matching dpkg output
+                    regex = %r{^(\S+)\s+(\S+)\s+(\S+)\s+(.+)$}
+                    fields = [:status, :name, :install, :description]
+                    hash = {}
+
+                    5.times { process.gets } # throw away the header
+
+                    # now turn each returned line into a package object
+                    process.each { |line|
+                        if match = regex.match(line)
+                            hash.clear
+
+                            fields.zip(match.captures) { |field,value|
+                                hash[field] = value
+                            }
+                            packages.push Puppet::Type::Package.installedpkg(hash)
+                        else
+                            raise Puppet::DevError,
+                                "Failed to match dpkg line %s" % line
+                        end
+                    }
+                }
+                ENV["COLUMNS"] = oldcol
+
+                return packages
+            end
+
+            def remove
+                cmd = "dpkg -r %s" % self.name
+                output = %x{#{cmd} 2>&1}
+                if $? != 0
+                    raise Puppet::PackageError.new(output)
+                end
+            end
+        end
+    end
+end
+
+# $Id: dpkg.rb 707 2005-09-27 19:59:36Z luke $

data/lib/puppet/type/package/rpm.rb

@@ -0,0 +1,81 @@
+module Puppet
+    module PackagingType
+        module RPM
+            def query
+                fields = {
+                    :name => "NAME",
+                    :install => "VERSION",
+                    :description => "DESCRIPTION"
+                }
+
+                cmd = "rpm -q #{self.name} --qf '%s\n'" %
+                    "%{NAME} %{VERSION}-%{RELEASE}"
+
+                # list out all of the packages
+                output = %x{#{cmd} 2>/dev/null}.chomp
+
+                if $? != 0
+                    return nil
+                end
+
+                regex = %r{^(\S+)\s+(\S+)}
+                #fields = [:name, :install, :description]
+                fields = [:name, :install]
+                hash = {}
+                if match = regex.match(output)
+                    fields.zip(match.captures) { |field,value|
+                        hash[field] = value
+                    }
+                else
+                    raise Puppet::DevError,
+                        "Failed to match rpm output '%s'" %
+                        output
+                end
+
+                return hash
+            end
+
+            def list
+                packages = []
+
+                # list out all of the packages
+                open("| rpm -q -a --qf '%{NAME} %{VERSION}\n'") { |process|
+                    # our regex for matching dpkg output
+                    regex = %r{^(\S+)\s+(\S+)}
+                    fields = [:name, :install]
+                    hash = {}
+
+                    # now turn each returned line into a package object
+                    process.each { |line|
+                        if match = regex.match(line)
+                            hash.clear
+
+                            fields.zip(match.captures) { |field,value|
+                                hash[field] = value
+                            }
+                            packages.push Puppet::Type::Package.installedpkg(hash)
+                        else
+                            raise "failed to match rpm line %s" % line
+                        end
+                    }
+                }
+
+                return packages
+            end
+
+            # we need package retrieval mechanisms before we can have package
+            # installation mechanisms...
+            #type.install = proc { |pkg|
+            #    raise "installation not implemented yet"
+            #}
+
+            def remove
+                cmd = "rpm -e %s" % self.name
+                output = %x{#{cmd}}
+                if $? != 0
+                    raise output
+                end
+            end
+        end
+    end
+end

data/lib/puppet/type/package/sun.rb

@@ -0,0 +1,117 @@
+module Puppet
+    module PackagingType
+        module Sun
+            def query
+                names = {
+                    "PKGINST" => :name,
+                    "NAME" => nil,
+                    "CATEGORY" => :category,
+                    "ARCH" => :platform,
+                    "VERSION" => :install,
+                    "BASEDIR" => :root,
+                    "HOTLINE" => nil,
+                    "EMAIL" => nil,
+                    "VENDOR" => :vendor,
+                    "DESC" => :description,
+                    "PSTAMP" => nil,
+                    "INSTDATE" => nil,
+                    "STATUS" => nil,
+                    "FILES" => nil
+                }
+
+                hash = {}
+
+                # list out all of the packages
+                open("| pkginfo -l %s 2>/dev/null" % self.name) { |process|
+                    # we're using the long listing, so each line is a separate
+                    # piece of information
+                    process.each { |line|
+                        case line
+                        when /^$/:  # ignore
+                        when /\s*([A-Z]+):\s+(.+)/:
+                            name = $1
+                            value = $2
+                            if names.include?(name)
+                                unless names[name].nil?
+                                    hash[names[name]] = value
+                                end
+                            else
+                                self.err "'pkginfo' returned invalid name %s" %
+                                    name
+                            end
+                        when /\s+\d+.+/:
+                            # nothing; we're ignoring the FILES info
+                        end
+                    }
+                }
+
+                if hash.empty?
+                    return nil
+                else
+                    return hash
+                end
+            end
+
+            def list
+                packages = []
+                hash = {}
+                names = {
+                    "PKGINST" => :name,
+                    "NAME" => nil,
+                    "CATEGORY" => :category,
+                    "ARCH" => :platform,
+                    "VERSION" => :install,
+                    "BASEDIR" => :root,
+                    "HOTLINE" => nil,
+                    "EMAIL" => nil,
+                    "VENDOR" => :vendor,
+                    "DESC" => :description,
+                    "PSTAMP" => nil,
+                    "INSTDATE" => nil,
+                    "STATUS" => nil,
+                    "FILES" => nil
+                }
+
+                # list out all of the packages
+                open("| pkginfo -l") { |process|
+                    # we're using the long listing, so each line is a separate
+                    # piece of information
+                    process.each { |line|
+                        case line
+                        when /^$/:
+                            packages.push Puppet::Type::Package.installedpkg(hash)
+                            hash.clear
+                        when /\s*(\w+):\s+(.+)/:
+                            name = $1
+                            value = $2
+                            if names.include?(name)
+                                unless names[name].nil?
+                                    hash[names[name]] = value
+                                end
+                            else
+                                raise "Could not find %s" % name
+                            end
+                        when /\s+\d+.+/:
+                            # nothing; we're ignoring the FILES info
+                        end
+                    }
+                }
+                return packages
+            end
+
+            # we need package retrieval mechanisms before we can have package
+            # installation mechanisms...
+            #type.install = proc { |pkg|
+            #    raise "installation not implemented yet"
+            #}
+
+            def remove
+                cmd = "pkgrm -n %s" % self.name
+                output = %x{#{cmd}}
+                if $? != 0
+                    raise output
+                end
+            end
+        end
+    end
+end

data/lib/puppet/type/package/yum.rb

@@ -0,0 +1,58 @@
+module Puppet
+    module PackagingType
+        # A derivative of DPKG; this is how most people actually manage
+        # Debian boxes, and the only thing that differs is that it can
+        # install packages from remote sites.
+        module Yum
+            include RPM
+
+            # Install a package using 'apt-get'.
+            def install
+                cmd = "yum -y install %s" % self.name
+
+                self.info "Executing %s" % cmd.inspect
+                output = %x{#{cmd} 2>&1}
+
+                unless $? == 0
+                    raise Puppet::PackageError.new(output)
+                end
+            end
+
+            # What's the latest package version available?
+            def latest
+                cmd = "yum list %s" % self.name 
+                output = %x{#{cmd} 2>&1}
+
+                unless $? == 0
+                    raise Puppet::PackageError.new(output)
+                end
+
+                if output =~ /#{self.name}\S+\s+(\S+)\s/
+                    return $1
+                else
+                    self.debug "No version"
+                    if Puppet[:debug]
+                        print output
+                    end
+
+                    return nil
+                end
+            end
+
+            def update
+                cmd = "yum -y update %s" % self.name
+
+                self.info "Executing %s" % cmd.inspect
+                output = %x{#{cmd} 2>&1}
+
+                unless $? == 0
+                    raise Puppet::PackageError.new(output)
+                end
+            end
+
+            def versionable?
+                false
+            end
+        end
+    end
+end

data/lib/puppet/type/pfile.rb

@@ -0,0 +1,569 @@
+require 'digest/md5'
+require 'cgi'
+require 'etc'
+require 'uri'
+require 'fileutils'
+require 'puppet/type/state'
+require 'puppet/server/fileserver'
+
+# We put all of the states in separate files, because there are so many
+# of them.
+require 'puppet/type/pfile/type'
+require 'puppet/type/pfile/create'
+require 'puppet/type/pfile/checksum'
+require 'puppet/type/pfile/uid'
+require 'puppet/type/pfile/mode'
+require 'puppet/type/pfile/group'
+require 'puppet/type/pfile/source'
+
+module Puppet
+    class Type
+        class PFile < Type
+            @doc = "Manages local files, including setting ownership and
+                permissions, and allowing creation of both files and directories."
+
+            @states = [
+                Puppet::State::PFileCreate,
+                Puppet::State::PFileChecksum,
+                Puppet::State::PFileSource,
+                Puppet::State::PFileUID,
+                Puppet::State::PFileGroup,
+                Puppet::State::PFileMode,
+                Puppet::State::PFileType
+            ]
+
+            @parameters = [
+                :path,
+                :backup,
+                :linkmaker,
+                :recurse,
+                :ignore
+            ]
+
+            @paramdoc[:path] = "The path to the file to manage.  Must be fully
+                qualified."
+
+            @paramdoc[:backup] = "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."
+
+            @paramdoc[:linkmaker] = "An internal parameter used by the *symlink*
+                type to do recursive link creation."
+
+            @paramdoc[:recurse] = "Whether and how deeply to do recursive
+                management.  **false**/*true*/*inf*/*number*"
+
+            @paramdoc[:ignore] = "A parameter which omits action on files matching
+                specified patterns during recursion.  Uses Ruby's builtin globbing
+                engine, so shell metacharacters are fully supported, e.g. ``[a-z]*``.
+                Matches that would descend into the directory structure are ignored,
+                e.g., ``*/*``."
+
+          #no longer a parameter
+           # @paramdoc[:source] = "Where to retrieve the contents of the files.
+           #     Currently only supports local copying, but will eventually
+           #     support multiple protocols for copying.  Arguments are specified
+           #     using either a full local path or using a URI (currently only
+           #     *file* is supported as a protocol)."
+
+            
+
+            @name = :file
+            @namevar = :path
+
+            @depthfirst = false
+
+            PINPARAMS = [:mode, :type, :owner, :group, :checksum]
+
+
+            def argument?(arg)
+                @arghash.include?(arg)
+            end
+
+            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
+
+                case File.stat(file).ftype
+                when "directory":
+                    # we don't need to backup directories
+                    return true
+                when "file":
+                    backup = self[:backup]
+                    case backup
+                    when Puppet::Client::Dipper:
+                        sum = backup.backup(file)
+                        self.info "Filebucketed %s with sum %s" %
+                            [file, sum]
+                        return true
+                    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
+                        end
+                        begin
+                            FileUtils.cp(file,
+                                file + backup)
+                            return true
+                        rescue => detail
+                            # since they said they want a backup, let's error out
+                            # if we couldn't make one
+                            raise Puppet::Error.new("Could not back %s up: %s" %
+                                [file, detail.message])
+                        end
+                    else
+                        self.err "Invalid backup type %s" % backup
+                        return false
+                    end
+                else
+                    self.notice "Cannot backup files of type %s" %
+                        File.stat(file).ftype
+                    return false
+                end
+            end
+            
+            def handleignore(children)
+                @parameters[:ignore].each { |ignore|
+                    ignored = []
+                    Dir.glob(File.join(self.name,ignore), File::FNM_DOTMATCH) { |match|
+                        ignored.push(File.basename(match))
+                    }
+                    children = children - ignored
+                }
+                return children
+            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)
+                @arghash.delete(self.class.namevar)
+
+                if @arghash.include?(:source)
+                    @arghash.delete(:source)
+                end
+
+                @stat = nil
+                @parameters = Hash.new(false)
+
+                # default to true
+                self[:backup] = true
+
+                # Used for caching clients
+                @clients = {}
+
+                super
+            end
+            
+            def parambackup=(value)
+                case value
+                when false, "false":
+                    @parameters[:backup] = false
+                when true, "true":
+                    @parameters[:backup] = ".puppet-bak"
+                when Array:
+                    case value[0]
+                    when "filebucket":
+                        if bucket = Puppet::Type::PFileBucket.bucket(value[1])
+                            @parameters[:backup] = bucket
+                        else
+                            @parameters[:backup] = ".puppet-bak"
+                            raise Puppet::Error,
+                                "Could not retrieve filebucket %s" %
+                                value[1]
+                        end
+                    else
+                        raise Puppet::Error, "Invalid backup object type %s" %
+                            value[0].inspect
+                    end
+                else
+                    raise Puppet::Error, "Invalid backup type %s" %
+                        value.inspect
+                end
+            end
+            
+            def paramignore=(value)
+           
+                #Make sure the value of ignore is in correct type    
+                unless value.is_a?(Array) or value.is_a?(String)
+                    raise Puppet::DevError.new("Ignore must be a string or an Array")
+                end
+            
+                @parameters[:ignore] = value
+            end
+
+            def newchild(path, hash = {})
+                # make local copy of arguments
+                args = @arghash.dup
+
+                if path =~ %r{^#{File::SEPARATOR}}
+                    raise Puppet::DevError.new(
+                        "Must pass relative paths to PFile#newchild()"
+                    )
+                else
+                    path = File.join(self.name, path)
+                end
+
+                args[:path] = path
+
+                unless hash.include?(:recurse)
+                    if args.include?(:recurse)
+                        if args[:recurse].is_a?(Integer)
+                            self.notice "Decrementing recurse on %s" % path
+                            args[:recurse] -= 1 # reduce the level of recursion
+                        end
+                    end
+
+                end
+
+                hash.each { |key,value|
+                    args[key] = value
+                }
+
+                child = nil
+                klass = nil
+                if @parameters[:linkmaker] and args.include?(:source) and
+                    ! FileTest.directory?(args[:source])
+                    klass = Puppet::Type::Symlink
+
+                    self.debug "%s is a link" % path
+                    # clean up the args a lot for links
+                    old = args.dup
+                    args = {
+                        :target => old[:source],
+                        :path => path
+                    }
+                else
+                    klass = self.class
+                end
+
+                # 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)
+                        self.notice "Not managing more explicit file %s" %
+                            path
+                        return nil
+                    end
+                    args.each { |var,value|
+                        next if var == :path
+                        next if var == :name
+                        # behave idempotently
+                        unless child.should(var) == value
+                            child[var] = value
+                        end
+                    }
+                else # create it anew
+                    #notice "Creating new file with args %s" % args.inspect
+                    args[:parent] = self
+                    begin
+                        child = klass.implicitcreate(args)
+                        
+                        # implicit creation can return nil
+                        if child.nil?
+                            return nil
+                        end
+                        @children << child
+                    rescue Puppet::Error => detail
+                        self.notice(
+                            "Cannot manage: %s" %
+                                [detail.message]
+                        )
+                        self.debug args.inspect
+                        child = nil
+                    rescue => detail
+                        self.notice(
+                            "Cannot manage: %s" %
+                                [detail]
+                        )
+                        self.debug args.inspect
+                        child = nil
+                    end
+                end
+                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
+                    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
+                    end
+                end
+
+                return @path.join("/")
+            end
+
+            # Recurse into the directory.  This basically just calls 'localrecurse'
+            # and maybe 'sourcerecurse'.
+            def recurse
+                recurse = @parameters[: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
+                    self.info "finished recursing"
+                    return
+                end
+
+                if recurse.is_a?(Integer)
+                    recurse -= 1
+                end
+
+                self.localrecurse(recurse)
+                if @states.include?(:source)
+                    self.sourcerecurse(recurse)
+                end
+            end
+
+            def localrecurse(recurse)
+                unless FileTest.exist?(self.name) and self.stat.directory?
+                    #self.info "%s is not a directory; not recursing" %
+                    #    self.name
+                    return
+                end
+
+                unless FileTest.directory? self.name
+                    raise Puppet::Error.new(
+                        "Uh, somehow trying to manage non-dir %s" % self.name
+                    )
+                end
+                unless FileTest.readable? self.name
+                    self.notice "Cannot manage %s: permission denied" % self.name
+                    return
+                end
+
+                children = Dir.entries(self.name)
+             
+                #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, :recurse => recurse)
+                        unless @children.include?(child)
+                            self.push child
+                            added.push file
+
+                        end
+                        child.retrieve
+                    end
+                }
+            end
+
+            # This recurses against the remote source and makes sure the local
+            # and remote structures match.  It's run after 'localrecurse'.
+            def sourcerecurse(recurse)
+                # FIXME sourcerecurse should support purging non-remote files
+                source = @states[:source].source
+                
+                sourceobj, path = uri2obj(source)
+
+                # we'll set this manually as necessary
+                if @arghash.include?(:create)
+                    @arghash.delete(:create)
+                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 = @parameters[:ignore]
+               
+                #self.warning "Listing path %s" % path.inspect
+                desc = server.list(path, 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, args)
+                    #self.newchild(hash, source, recurse)
+                    #hash2child(hash, source, recurse)
+                }
+            end
+
+            # 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
+                    @states[:source].retrieve
+                end
+
+                if @parameters.include?(:recurse)
+                    self.recurse
+                end
+
+                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 = :notfound
+                    }
+                    return
+                end
+
+                super
+            end
+
+            def stat(refresh = false)
+                if @stat.nil? or refresh == true
+                    begin
+                        @stat = File.lstat(self.name)
+                    rescue Errno::ENOENT => error
+                        @stat = nil
+                    rescue => error
+                        self.debug "Failed to stat %s: %s" %
+                            [self.name,error]
+                        @stat = nil
+                    end
+                end
+
+                return @stat
+            end
+
+            def uri2obj(source)
+                sourceobj = FileSource.new
+                path = nil
+                if source =~ /^\//
+                    source = "file://localhost/%s" % source
+                    sourceobj.mount = "localhost"
+                    sourceobj.local = true
+                end
+                begin
+                    uri = URI.parse(source)
+                rescue => detail
+                    raise Puppet::Error, "Could not understand source %s: %s" %
+                        [source, detail.to_s]
+                end
+
+                case uri.scheme
+                when "file":
+                    unless defined? @@localfileserver
+                        @@localfileserver = Puppet::Server::FileServer.new(
+                            :Local => true,
+                            :Mount => { "/" => "localhost" },
+                            :Config => false
+                        )
+                        #@@localfileserver.mount("/", "localhost")
+                    end
+                    sourceobj.server = @@localfileserver
+                    path = "/localhost" + uri.path
+                when "puppet":
+                    args = { :Server => uri.host }
+                    if uri.port
+                        args[:Port] = uri.port
+                    end
+                    # FIXME We should cache a copy of this server
+                    #sourceobj.server = Puppet::NetworkClient.new(args)
+                    unless @clients.include?(source)
+                        @clients[source] = Puppet::Client::FileClient.new(args)
+                    end
+                    sourceobj.server = @clients[source]
+
+                    tmp = uri.path
+                    if tmp =~ %r{^/(\w+)}
+                        sourceobj.mount = $1
+                        path = tmp
+                        #path = tmp.sub(%r{^/\w+},'') || "/"
+                    else
+                        raise Puppet::Error, "Invalid source path %s" % tmp
+                    end
+                else
+                    raise Puppet::Error,
+                        "Got other recursive file proto %s from %s" %
+                            [uri.scheme, source]
+                end
+
+                return [sourceobj, path.sub(/\/\//, '/')]
+            end
+        end # Puppet::Type::PFile
+    end # Puppet::Type
+
+    # the filesource class can't include the path, because the path
+    # changes for every file instance
+    class FileSource
+        attr_accessor :mount, :root, :server, :local
+    end
+end
+
+# $Id$