puppet 0.9.2 → 0.13.0

data/lib/puppet/type/pfile.rb

@@ -6,264 +6,264 @@ 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
+    newtype(:file) do
+        @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`` element will be used less and less to
+            manage content, and instead native elements will be used to do so.
+            
+            If you find that you are often copying files in from a central
+            location, rather than using native elements, please contact
+            Reductive Labs and we can hopefully work with you to develop a
+            native element to support what you are doing."
+
+        newparam(:path) do
+            desc "The path to the file to manage.  Must be fully qualified."
+            isnamevar
+        end
+
+        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."
 
-            @paramdoc[:linkmaker] = "An internal parameter used by the *symlink*
+            defaultto true
+
+            munge do |value|
+                case value
+                when false, "false":
+                    false
+                when true, "true":
+                    ".puppet-bak"
+                when Array:
+                    case value[0]
+                    when "filebucket":
+                        if bucket = Puppet.type(:filebucket).bucket(value[1])
+                            bucket
+                        else
+                            self.fail "Could not retrieve filebucket %s" %
+                                value[1]
+                        end
+                    else
+                        self.fail "Invalid backup object type %s" %
+                            value[0].inspect
+                    end
+                else
+                    self.fail "Invalid backup type %s" %
+                        value.inspect
+                end
+            end
+        end
+
+        newparam(:linkmaker) do
+            desc "An internal parameter used by the *symlink*
                 type to do recursive link creation."
+        end
 
-            @paramdoc[:recurse] = "Whether and how deeply to do recursive
+        newparam(:recurse) do
+            desc "Whether and how deeply to do recursive
                 management.  **false**/*true*/*inf*/*number*"
 
-            @paramdoc[:ignore] = "A parameter which omits action on files matching
+            munge do |value|
+                value
+            end
+        end
+
+        newparam(:ignore) do
+            desc "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., ``*/*``."
+       
+            defaultto false
 
-          #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
+            validate do |value|
+                unless value.is_a?(Array) or value.is_a?(String) or value == false
+                    self.devfail "Ignore must be a string or an Array"
+                end
+            end
+        end
+
+        autorequire(:file) do
+            cur = []
+            # Skip the nil in the beginning and don't add ourselves as a prereq
+            # either.
+            self.name.split(File::SEPARATOR)[1..-2].collect { |dir|
+                cur << dir
+                "/" + cur.join(File::SEPARATOR)
+            }
+        end
+
+        validate do
+            if self[:content] and self[:source]
+                self.fail "You cannot specify both content and a source"
+            end
+        end
 
-            @depthfirst = false
+        @depthfirst = false
 
-            PINPARAMS = [:mode, :type, :owner, :group, :checksum]
 
+        def argument?(arg)
+            @arghash.include?(arg)
+        end
 
-            def argument?(arg)
-                @arghash.include?(arg)
+        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
 
-            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
+            unless self[:backup]
+                return true
+            end
 
-                case File.stat(file).ftype
-                when "directory":
-                    # we don't need to backup directories
+            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 "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
+                when String:
+                    newfile = file + backup
+                    if FileTest.exists?(newfile)
                         begin
-                            FileUtils.cp(file,
-                                file + backup)
-                            return true
+                            File.unlink(newfile)
                         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])
+                            self.err "Could not remove old backup: %s" %
+                                detail
+                            return false
                         end
-                    else
-                        self.err "Invalid backup type %s" % backup
-                        return false
+                    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
+                        self.fail "Could not back %s up: %s" %
+                            [file, detail.message]
                     end
                 else
-                    self.notice "Cannot backup files of type %s" %
-                        File.stat(file).ftype
+                    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
-            
-            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
+        end
+        
+        def handleignore(children)
+            return children unless self[:ignore]
+            self[:ignore].each { |ignore|
+                ignored = []
+                Dir.glob(File.join(self.name,ignore), File::FNM_DOTMATCH) { |match|
+                    ignored.push(File.basename(match))
                 }
-                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
+                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
             
-            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
+            @arghash = self.argclean(hash)
+            @arghash.delete(self.class.namevar)
 
-            def newchild(path, hash = {})
-                # make local copy of arguments
-                args = @arghash.dup
+            if @arghash.include?(:source)
+                @arghash.delete(:source)
+            end
 
-                if path =~ %r{^#{File::SEPARATOR}}
-                    raise Puppet::DevError.new(
-                        "Must pass relative paths to PFile#newchild()"
-                    )
-                else
-                    path = File.join(self.name, path)
-                end
+            @stat = nil
+
+            # Used for caching clients
+            @clients = {}
+
+            super
+        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
+
+            if path =~ %r{^#{File::SEPARATOR}}
+                self.devfail(
+                    "Must pass relative paths to PFile#newchild()"
+                )
+            else
+                path = File.join(self.name, path)
+            end
 
-                args[:path] = path
+            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
+            unless hash.include?(:recurse)
+                if args.include?(:recurse)
+                    if args[:recurse].is_a?(Integer)
+                        args[:recurse] -= 1 # reduce the level of recursion
                     end
-
                 end
 
-                hash.each { |key,value|
-                    args[key] = value
+            end
+
+            hash.each { |key,value|
+                args[key] = value
+            }
+
+            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)
+
+                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
 
-                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
+            # 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.debug "Not managing more explicit file %s" %
+                        path
+                    return nil
                 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
+                # 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
@@ -272,298 +272,322 @@ module Puppet
                             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
+            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
-                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
+            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
-                        # 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
+                        super
                     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
+                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
 
-                # are we at the end of the recursion?
-                if recurse == 0
-                    self.info "finished recursing"
-                    return
+            return @path.join("/")
+        end
+
+        # Recurse into the directory.  This basically just calls 'localrecurse'
+        # and maybe 'sourcerecurse'.
+        def 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)
+                #elsif recurse =~ /^inf/ # infinite recursion
+                else # anything else is infinite recursion
+                    recurse = true
                 end
+            end
 
-                if recurse.is_a?(Integer)
-                    recurse -= 1
-                end
+            # are we at the end of the recursion?
+            if recurse == 0
+                self.info "finished recursing"
+                return
+            end
 
-                self.localrecurse(recurse)
-                if @states.include?(:source)
-                    self.sourcerecurse(recurse)
-                end
+            if recurse.is_a?(Integer)
+                recurse -= 1
             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
+            self.localrecurse(recurse)
+            if @states.include?(:source)
+                self.sourcerecurse(recurse)
+            end
+        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
+        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
 
-                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
+            unless FileTest.readable? self.name
+                self.notice "Cannot manage %s: permission denied" % self.name
+                return
+            end
 
-                        end
-                        child.retrieve
+            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, true, :recurse => recurse)
+                    unless @children.include?(child)
+                        self.push child
+                        added.push file
                     end
-                }
+                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
+
+            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
 
-            # 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)
+            # 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
 
-                # okay, we've got our source object; now we need to
-                # build up a local file structure to match the remote
-                # one
+            ignore = self[:ignore]
 
-                server = sourceobj.server
-                sum = "md5"
-                if state = self.state(:checksum)
-                    sum = state.checktype
+            #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
-                r = false
-                if recurse
-                    unless recurse == 0
-                        r = 1
-                    end
+                self.newchild(name, false, 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
 
-                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)
+            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 = :absent
                 }
+                return
             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
+            super
+        end
 
-                if @parameters.include?(:recurse)
-                    self.recurse
+        # 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.
+        def setchecksum(sum = nil)
+            if @states.include? :checksum
+                if sum
+                    @states[: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
                 end
+            end
+        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
+        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
-
-                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
 
-                return @stat
+        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
+                self.fail "Could not understand source %s: %s" %
+                    [source, detail.to_s]
             end
 
-            def uri2obj(source)
-                sourceobj = FileSource.new
-                path = nil
-                if source =~ /^\//
-                    source = "file://localhost/%s" % source
-                    sourceobj.mount = "localhost"
-                    sourceobj.local = true
+            case uri.scheme
+            when "file":
+                unless defined? @@localfileserver
+                    @@localfileserver = Puppet::Server::FileServer.new(
+                        :Local => true,
+                        :Mount => { "/" => "localhost" },
+                        :Config => false
+                    )
+                    #@@localfileserver.mount("/", "localhost")
                 end
-                begin
-                    uri = URI.parse(source)
-                rescue => detail
-                    raise Puppet::Error, "Could not understand source %s: %s" %
-                        [source, detail.to_s]
+                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]
 
-                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
+                tmp = uri.path
+                if tmp =~ %r{^/(\w+)}
+                    sourceobj.mount = $1
+                    path = tmp
+                    #path = tmp.sub(%r{^/\w+},'') || "/"
                 else
-                    raise Puppet::Error,
-                        "Got other recursive file proto %s from %s" %
-                            [uri.scheme, source]
+                    self.fail "Invalid source path %s" % tmp
                 end
-
-                return [sourceobj, path.sub(/\/\//, '/')]
+            else
+                self.fail "Got other recursive file proto %s from %s" %
+                        [uri.scheme, source]
             end
-        end # Puppet::Type::PFile
-    end # Puppet::Type
+
+            return [sourceobj, path.sub(/\/\//, '/')]
+        end
+    end # Puppet.type(:pfile)
 
     # 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$
+    # We put all of the states 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.
+    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/ensure'      # can create the file
+    require 'puppet/type/pfile/uid'
+    require 'puppet/type/pfile/group'
+    require 'puppet/type/pfile/mode'
+    require 'puppet/type/pfile/type'
+end
+# $Id: pfile.rb 883 2006-02-08 16:53:34Z luke $