puppet 0.23.2 → 0.24.0

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

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

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

@@ -28,4 +28,3 @@ class Puppet::Network::Client::Report < Puppet::Network::Client
     end
 end
 
-# $Id: report.rb 2259 2007-03-06 19:03:05Z luke $

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

@@ -49,4 +49,3 @@ class Puppet::Network::Client::Resource < Puppet::Network::Client
     end
 end
 
-# $Id: resource.rb 2259 2007-03-06 19:03:05Z luke $

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

@@ -10,4 +10,3 @@ class Puppet::Network::Client::Runner < Puppet::Network::Client::ProxyClient
     end
 end
 
-# $Id: runner.rb 2259 2007-03-06 19:03:05Z luke $

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

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

data/lib/puppet/network/client_request.rb

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

data/lib/puppet/network/handler.rb

@@ -10,7 +10,7 @@ module Puppet::Network
         # This is so that the handlers can subclass just 'Handler', rather
         # then having to specify the full class path.
         Handler = self
-        attr_accessor :server
+        attr_accessor :server, :local
 
         extend Puppet::Util::SubclassLoader
         extend Puppet::Util
@@ -44,7 +44,10 @@ module Puppet::Network
         # Create an empty init method with the same signature.
         def initialize(hash = {})
         end
+
+        def local?
+            self.local
+        end
     end
 end
 
-# $Id: handler.rb 2479 2007-05-07 22:29:44Z luke $

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

@@ -60,7 +60,7 @@ class Puppet::Network::Handler
         end
 
         def initialize(hash = {})
-            Puppet.config.use(:main, :ssl, :ca)
+            Puppet.settings.use(:main, :ssl, :ca)
             if hash.include? :autosign
                 @autosign = hash[:autosign]
             end
@@ -155,4 +155,3 @@ class Puppet::Network::Handler
     end
 end
 
-# $Id: ca.rb 2612 2007-06-18 19:51:17Z luke $

data/lib/puppet/network/handler/configuration.rb

@@ -0,0 +1,184 @@
+require 'openssl'
+require 'puppet'
+require 'puppet/parser/interpreter'
+require 'puppet/sslcertificates'
+require 'xmlrpc/server'
+require 'yaml'
+
+class Puppet::Network::Handler
+    class Configuration < Handler
+        desc "Puppet's configuration compilation interface.  Passed a node name
+            or other key, retrieves information about the node (using the ``node_source``)
+            and returns a compiled configuration."
+
+        include Puppet::Util
+
+        attr_accessor :local, :classes
+
+        @interface = XMLRPC::Service::Interface.new("configuration") { |iface|
+                iface.add_method("string configuration(string)")
+                iface.add_method("string version()")
+        }
+
+        # Compile a node's configuration.
+        def configuration(key, client = nil, clientip = nil)
+            # If we want to use the cert name as our key
+            if Puppet[:node_name] == 'cert' and client
+                key = client
+            end
+
+            # Note that this is reasonable, because either their node source should actually
+            # know about the node, or they should be using the ``none`` node source, which
+            # will always return data.
+            unless node = Puppet::Node.find_by_any_name(key)
+                raise Puppet::Error, "Could not find node '%s'" % key
+            end
+
+            # Add any external data to the node.
+            add_node_data(node)
+
+            configuration = compile(node)
+
+            return translate(configuration)
+        end
+
+        def initialize(options = {})
+            options.each do |param, value|
+                case param
+                when :Classes: @classes = value
+                when :Local: self.local = value
+                else
+                    raise ArgumentError, "Configuration handler does not accept %s" % param
+                end
+            end
+
+            set_server_facts
+        end
+
+        # Are we running locally, or are our clients networked?
+        def local?
+            self.local
+        end
+
+        # Return the configuration version.
+        def version(client = nil, clientip = nil)
+            if client and node = Puppet::Node.find_by_any_name(client)
+                update_node_check(node)
+                return interpreter.configuration_version(node)
+            else
+                # Just return something that will always result in a recompile, because
+                # this is local.
+                return (Time.now + 1000).to_i
+            end
+        end
+
+        private
+
+        # Add any extra data necessary to the node.
+        def add_node_data(node)
+            # Merge in our server-side facts, so they can be used during compilation.
+            node.merge(@server_facts)
+
+            # Add any specified classes to the node's class list.
+            if @classes
+                @classes.each do |klass|
+                    node.classes << klass
+                end
+            end
+        end
+
+        # Compile the actual configuration.
+        def compile(node)
+            # Pick the benchmark level.
+            if local?
+                level = :none
+            else
+                level = :notice
+            end
+
+            # Ask the interpreter to compile the configuration.
+            str = "Compiled configuration for %s" % node.name
+            if node.environment
+                str += " in environment %s" % node.environment
+            end
+            config = nil
+            benchmark(level, "Compiled configuration for %s" % node.name) do
+                begin
+                    config = interpreter.compile(node)
+                rescue => detail
+                    # If we're local, then we leave it to the local system
+                    # to handle error reporting, but otherwise we do it here
+                    # so the interpreter doesn't need to know if the parser
+                    # is local or not.
+                    Puppet.err(detail.to_s) unless local?
+                    raise
+                end
+            end
+
+            return config
+        end
+
+        # Create our interpreter object.
+        def create_interpreter
+            return Puppet::Parser::Interpreter.new
+        end
+
+        # Create/return our interpreter.
+        def interpreter
+            unless defined?(@interpreter) and @interpreter
+                @interpreter = create_interpreter
+            end
+            @interpreter
+        end
+
+        # Initialize our server fact hash; we add these to each client, and they
+        # won't change while we're running, so it's safe to cache the values.
+        def set_server_facts
+            @server_facts = {}
+
+            # Add our server version to the fact list
+            @server_facts["serverversion"] = Puppet.version.to_s
+
+            # And then add the server name and IP
+            {"servername" => "fqdn",
+                "serverip" => "ipaddress"
+            }.each do |var, fact|
+                if value = Facter.value(fact)
+                    @server_facts[var] = value
+                else
+                    Puppet.warning "Could not retrieve fact %s" % fact
+                end
+            end
+
+            if @server_facts["servername"].nil?
+                host = Facter.value(:hostname)
+                if domain = Facter.value(:domain)
+                    @server_facts["servername"] = [host, domain].join(".")
+                else
+                    @server_facts["servername"] = host
+                end
+            end
+        end
+
+        # Translate our configuration appropriately for sending back to a client.
+        def translate(config)
+            if local?
+                config
+            else
+                CGI.escape(config.to_yaml(:UseBlock => true))
+            end
+        end
+
+        # Mark that the node has checked in. FIXME this needs to be moved into
+        # the Node class, or somewhere that's got abstract backends.
+        def update_node_check(node)
+            if Puppet.features.rails? and Puppet[:storeconfigs]
+                Puppet::Rails.connect
+
+                host = Puppet::Rails::Host.find_or_create_by_name(node.name)
+                host.last_freshcheck = Time.now
+                host.save
+            end
+        end
+    end
+end

data/lib/puppet/network/handler/filebucket.rb

@@ -64,7 +64,7 @@ class Puppet::Network::Handler # :nodoc:
                 end
             end
 
-            Puppet.config.use(:filebucket)
+            Puppet.settings.use(:filebucket)
 
             @name = "Filebucket[#{@path}]"
         end
@@ -180,4 +180,3 @@ class Puppet::Network::Handler # :nodoc:
     end
 end
 
-# $Id: filebucket.rb 2479 2007-05-07 22:29:44Z luke $

data/lib/puppet/network/handler/fileserver.rb

@@ -17,6 +17,7 @@ class Puppet::Network::Handler
 
         # Special filserver module for puppet's module system
         MODULES = "modules"
+        PLUGINS = "plugins"
 
         @interface = XMLRPC::Service::Interface.new("fileserver") { |iface|
             iface.add_method("string describe(string, string)")
@@ -28,6 +29,34 @@ class Puppet::Network::Handler
             CHECKPARAMS.dup
         end
 
+        # If the configuration file exists, then create (if necessary) a LoadedFile
+        # object to manage it; else, return nil.
+        def configuration
+            # Short-circuit the default case.
+            return @configuration if defined?(@configuration)
+
+            config_path = @passed_configuration_path || Puppet[:fileserverconfig]
+            return nil unless FileTest.exist?(config_path)
+
+            # The file exists but we don't have a LoadedFile instance for it.
+            @configuration = Puppet::Util::LoadedFile.new(config_path)
+        end
+
+        # Create our default mounts for modules and plugins.  This is duplicated code,
+        # but I'm not really worried about that.
+        def create_default_mounts
+            @mounts = {}
+            Puppet.debug "No file server configuration file; autocreating #{MODULES} mount with default permissions"
+            mount = Mount.new(MODULES)
+            mount.allow("*")
+            @mounts[MODULES] = mount
+            
+            Puppet.debug "No file server configuration file; autocreating #{PLUGINS} mount with default permissions"
+            mount = PluginMount.new(PLUGINS)
+            mount.allow("*")
+            @mounts[PLUGINS] = mount
+        end
+
         # Describe a given file.  This returns all of the manageable aspects
         # of that file.
         def describe(url, links = :ignore, client = nil, clientip = nil)
@@ -44,7 +73,7 @@ class Puppet::Network::Handler
             end
 
             obj = nil
-            unless obj = mount.getfileobject(path, links)
+            unless obj = mount.getfileobject(path, links, client)
                 return ""
             end
 
@@ -79,13 +108,10 @@ class Puppet::Network::Handler
 
             if hash[:Config] == false
                 @noreadconfig = true
-            else
-                @config = Puppet::Util::LoadedFile.new(
-                    hash[:Config] || Puppet[:fileserverconfig]
-                )
-                @noreadconfig = false
             end
 
+            @passed_configuration_path = hash[:Config]
+
             if hash.include?(:Mount)
                 @passedconfig = true
                 unless hash[:Mount].is_a?(Hash)
@@ -99,9 +125,14 @@ class Puppet::Network::Handler
                     end
                 }
                 self.mount(nil, MODULES)
+                self.mount(nil, PLUGINS)
             else
                 @passedconfig = false
-                readconfig(false) # don't check the file the first time.
+                if configuration
+                    readconfig(false) # don't check the file the first time.
+                else
+                    create_default_mounts()
+                end
             end
         end
 
@@ -114,13 +145,11 @@ class Puppet::Network::Handler
             end
 
             obj = nil
-            unless FileTest.exists?(path)
+            unless mount.path_exists?(path, client)
                 return ""
             end
 
-            # We pass two paths here, but reclist internally changes one
-            # of the arguments when called internally.
-            desc = reclist(mount, path, path, recurse, ignore)
+            desc = mount.list(path, recurse, ignore, client)
 
             if desc.length == 0
                 mount.notice "Got no information on //%s/%s" %
@@ -137,6 +166,11 @@ class Puppet::Network::Handler
             self.local
         end
 
+        # Is a given mount available?
+        def mounted?(name)
+            @mounts.include?(name)
+        end
+
         # Mount a new directory with a name.
         def mount(path, name)
             if @mounts.include?(name)
@@ -167,13 +201,15 @@ class Puppet::Network::Handler
                 mount.info "Sending %s to %s" % [url, client]
             end
 
-            unless FileTest.exists?(path)
+            unless mount.path_exists?(path, client)
+                mount.debug "#{mount} reported that #{path} does not exist"
                 return ""
             end
 
             links = links.intern if links.is_a? String
 
             if links == :ignore and FileTest.symlink?(path)
+                mount.debug "I think that #{path} is a symlink and we're ignoring them"
                 return ""
             end
 
@@ -181,7 +217,7 @@ class Puppet::Network::Handler
             if links == :manage
                 raise Puppet::Error, "Cannot copy links yet."
             else
-                str = File.read(path)
+                str = mount.read_file(path, client)
             end
 
             if @local
@@ -210,6 +246,9 @@ class Puppet::Network::Handler
             end
         end
 
+        # Take a URL and some client info and return a mount and relative
+        # path pair.
+        #
         def convert(url, client, clientip)
             readconfig
 
@@ -219,37 +258,44 @@ class Puppet::Network::Handler
 
             authcheck(url, mount, client, clientip)
 
-            path = nil
-            unless path = mount.subdir(stub, client)
-                mount.notice "Could not find subdirectory %s" %
-                    "//%s/%s" % [mount, stub]
-                return ""
+            return mount, stub
+        end
+
+        # Return the mount for the Puppet modules; allows file copying from
+        # the modules.
+        def modules_mount(module_name, client)
+            # Find our environment, if we have one.
+            unless hostname = (client || Facter.value("hostname"))
+                raise ArgumentError, "Could not find hostname"
+            end
+            if node = Puppet::Node.find(hostname)
+                env = node.environment
+            else
+                env = nil
             end
 
-            return mount, path
+            # And use the environment to look up the module.
+            mod = Puppet::Module::find(module_name, env)
+            if mod
+                return @mounts[MODULES].copy(mod.name, mod.files)
+            else
+                return nil
+            end
         end
 
-        # Deal with ignore parameters.
-        def handleignore(children, path, ignore)            
-            ignore.each { |ignore|                
-                Dir.glob(File.join(path,ignore), File::FNM_DOTMATCH) { |match|
-                    children.delete(File.basename(match))
-                }                
-            }
-            return children
-        end  
-
         # Read the configuration file.
         def readconfig(check = true)
             return if @noreadconfig
 
-            if check and ! @config.changed?
+            return unless configuration
+
+            if check and ! @configuration.changed?
                 return
             end
 
             newmounts = {}
             begin
-                File.open(@config.file) { |f|
+                File.open(@configuration.file) { |f|
                     mount = nil
                     count = 1
                     f.each { |line|
@@ -260,7 +306,7 @@ class Puppet::Network::Handler
                             name = $1
                             if newmounts.include?(name)
                                 raise FileServerError, "%s is already mounted at %s" %
-                                    [newmounts[name], name], count, @config.file
+                                    [newmounts[name], name], count, @configuration.file
                             end
                             mount = Mount.new(name)
                             newmounts[name] = mount
@@ -269,8 +315,12 @@ class Puppet::Network::Handler
                             value = $2
                             case var
                             when "path":
+                                if mount.name == PLUGINS
+                                    Puppet.warning "An explicit 'plugins' mount is deprecated.  Please switch to using modules."
+                                end
+                                
                                 if mount.name == MODULES
-                                    Puppet.warning "The '#{MODULES}' module can not have a path. Ignoring attempt to set it"
+                                    Puppet.warning "The '#{mount.name}' module can not have a path. Ignoring attempt to set it"
                                 else
                                     begin
                                         mount.path = value
@@ -287,7 +337,7 @@ class Puppet::Network::Handler
                                         mount.allow(val)
                                     rescue AuthStoreError => detail
                                         raise FileServerError.new(detail.to_s,
-                                            count, @config.file)
+                                            count, @configuration.file)
                                     end
                                 }
                             when "deny":
@@ -297,115 +347,92 @@ class Puppet::Network::Handler
                                         mount.deny(val)
                                     rescue AuthStoreError => detail
                                         raise FileServerError.new(detail.to_s,
-                                            count, @config.file)
+                                            count, @configuration.file)
                                     end
                                 }
                             else
                                 raise FileServerError.new("Invalid argument '%s'" % var,
-                                    count, @config.file)
+                                    count, @configuration.file)
                             end
                         else
                             raise FileServerError.new("Invalid line '%s'" % line.chomp,
-                                count, @config.file)
+                                count, @configuration.file)
                         end
                         count += 1
                     }
                 }
             rescue Errno::EACCES => detail
-                Puppet.err "FileServer error: Cannot read %s; cannot serve" % @config
-                #raise Puppet::Error, "Cannot read %s" % @config
+                Puppet.err "FileServer error: Cannot read %s; cannot serve" % @configuration
+                #raise Puppet::Error, "Cannot read %s" % @configuration
             rescue Errno::ENOENT => detail
                 Puppet.err "FileServer error: '%s' does not exist; cannot serve" %
-                    @config
-                #raise Puppet::Error, "%s does not exit" % @config
-            #rescue FileServerError => detail
-            #    Puppet.err "FileServer error: %s" % detail
+                    @configuration
             end
 
             unless newmounts[MODULES]
+                Puppet.debug "No #{MODULES} mount given; autocreating with default permissions"
                 mount = Mount.new(MODULES)
                 mount.allow("*")
                 newmounts[MODULES] = mount
             end
-
+            
+            unless newmounts[PLUGINS]
+                Puppet.debug "No #{PLUGINS} mount given; autocreating with default permissions"
+                mount = PluginMount.new(PLUGINS)
+                mount.allow("*")
+                newmounts[PLUGINS] = mount
+            end
+            
+            unless newmounts[PLUGINS].valid?
+                Puppet.debug "No path given for #{PLUGINS} mount; creating a special PluginMount"
+                # We end up here if the user has specified access rules for
+                # the plugins mount, without specifying a path (which means
+                # they want to have the default behaviour for the mount, but
+                # special access control).  So we need to move all the
+                # user-specified access controls into the new PluginMount
+                # object...
+                mount = PluginMount.new(PLUGINS)
+                # Yes, you're allowed to hate me for this.
+                mount.instance_variable_set(:@declarations,
+                                 newmounts[PLUGINS].instance_variable_get(:@declarations)
+                                 )
+                newmounts[PLUGINS] = mount
+            end
+                
             # Verify each of the mounts are valid.
             # We let the check raise an error, so that it can raise an error
             # pointing to the specific problem.
             newmounts.each { |name, mount|
                 unless mount.valid?
-                    raise FileServerError, "No path specified for mount %s" %
+                    raise FileServerError, "Invalid mount %s" %
                         name
                 end
             }
             @mounts = newmounts
         end
 
-        # Recursively list the directory. FIXME This should be using
-        # puppet objects, not directly listing.
-        def reclist(mount, root, path, recurse, ignore)
-            # Take out the root of the path.
-            name = path.sub(root, '')
-            if name == ""
-                name = "/"
-            end
-
-            if name == path
-                raise FileServerError, "Could not match %s in %s" %
-                    [root, path]
-            end
-
-            desc = [name]
-            ftype = File.stat(path).ftype
-
-            desc << ftype
-            if recurse.is_a?(Integer)
-                recurse -= 1
-            end
-
-            ary = [desc]
-            if recurse == true or (recurse.is_a?(Integer) and recurse > -1)
-                if ftype == "directory"
-                    children = Dir.entries(path)
-                    if ignore
-                        children = handleignore(children, path, ignore)
-                    end  
-                    children.each { |child|
-                        next if child =~ /^\.\.?$/
-                        reclist(mount, root, File.join(path, child), recurse, ignore).each { |cobj|
-                            ary << cobj
-                        }
-                    }
-                end
-            end
-
-            return ary.reject { |c| c.nil? }
-        end
-
         # Split the path into the separate mount point and path.
         def splitpath(dir, client)
             # the dir is based on one of the mounts
             # so first retrieve the mount path
             mount = nil
             path = nil
-            if dir =~ %r{/([-\w]+)/?}
-                tmp = $1
-                path = dir.sub(%r{/#{tmp}/?}, '')
+            if dir =~ %r{/([-\w]+)}
+                # Strip off the mount name.
+                mount_name, path = dir.sub(%r{^/}, '').split(File::Separator, 2)
 
-                mod = Puppet::Module::find(tmp)
-                if mod
-                    mount = @mounts[MODULES].copy(mod.name, mod.files)
-                else
-                    unless mount = @mounts[tmp]
-                        raise FileServerError, "Fileserver module '%s' not mounted" % tmp
+                unless mount = modules_mount(mount_name, client)
+                    unless mount = @mounts[mount_name]
+                        raise FileServerError, "Fileserver module '%s' not mounted" % mount_name
                     end
                 end
             else
                 raise FileServerError, "Fileserver error: Invalid path '%s'" % dir
             end
 
-            if path == ""
-                path = nil
-            else
+            if path.nil? or path == ''
+                path = '/'
+            elsif path
                 # Remove any double slashes that might have occurred
                 path = URI.unescape(path.gsub(/\/\//, "/"))
             end
@@ -429,13 +456,13 @@ class Puppet::Network::Handler
 
             Puppet::Util.logmethods(self, true)
 
-            def getfileobject(dir, links)
-                unless FileTest.exists?(dir)
-                    self.notice "File source %s does not exist" % dir
+            def getfileobject(dir, links, client = nil)
+                unless path_exists?(dir, client)
+                    self.debug "File source %s does not exist" % dir
                     return nil
                 end
 
-                return fileobj(dir, links)
+                return fileobj(dir, links, client)
             end
              
             # Run 'retrieve' on a file.  This gets the actual parameters, so
@@ -519,6 +546,19 @@ class Puppet::Network::Handler
                 end
             end
 
+            # Return a fully qualified path, given a short path and
+            # possibly a client name.
+            def file_path(relative_path, node = nil)
+                full_path = path(node)
+
+                raise ArgumentError.new("Mounts without paths are not usable") unless full_path
+
+                # If there's no relative path name, then we're serving the mount itself.
+                return full_path unless relative_path and relative_path != "/"
+
+                return File.join(full_path, relative_path)
+            end
+
             # Create out object.  It must have a name.
             def initialize(name, path = nil)
                 unless name =~ %r{^[-\w]+$}
@@ -535,9 +575,9 @@ class Puppet::Network::Handler
                 super()
             end
 
-            def fileobj(path, links)
+            def fileobj(path, links, client)
                 obj = nil
-                if obj = Puppet.type(:file)[path]
+                if obj = Puppet.type(:file)[file_path(path, client)]
                     # This can only happen in local fileserving, but it's an
                     # important one.  It'd be nice if we didn't just set
                     # the check params every time, but I'm not sure it's worth
@@ -545,7 +585,7 @@ class Puppet::Network::Handler
                     obj[:check] = CHECKPARAMS
                 else
                     obj = Puppet.type(:file).create(
-                        :name => path,
+                        :name => file_path(path, client),
                         :check => CHECKPARAMS
                     )
                 end
@@ -562,6 +602,11 @@ class Puppet::Network::Handler
                 return obj
             end
 
+            # Read the contents of the file at the relative path given.
+            def read_file(relpath, client)
+               File.read(file_path(relpath, client))
+            end
+
             # Cache this manufactured map, since if it's used it's likely
             # to get used a lot.
             def localmap
@@ -607,6 +652,12 @@ class Puppet::Network::Handler
                 @path = path
             end
 
+            # Verify that the path given exists within this mount's subtree.
+            #
+            def path_exists?(relpath, client = nil)
+                File.exists?(file_path(relpath, client))
+            end
+
             # Return the current values for the object.
             def properties(obj)
                 obj.retrieve.inject({}) { |props, ary| props[ary[0].name] = ary[1]; props }
@@ -618,7 +669,7 @@ class Puppet::Network::Handler
                 basedir = self.path(client)
 
                 dirname = if dir
-                    File.join(basedir, dir.split("/").join(File::SEPARATOR))
+                    File.join(basedir, *dir.split("/"))
                 else
                     basedir
                 end
@@ -653,8 +704,129 @@ class Puppet::Network::Handler
                 result.instance_variable_set(:@name, name)
                 return result
             end
+
+            # List the contents of the relative path +relpath+ of this mount.
+            #
+            # +recurse+ is the number of levels to recurse into the tree,
+            # or false to provide no recursion or true if you just want to
+            # go for broke.
+            #
+            # +ignore+ is an array of filenames to ignore when traversing
+            # the list.
+            #
+            # The return value of this method is a complex nest of arrays,
+            # which describes a directory tree.  Each file or directory is
+            # represented by an array, where the first element is the path
+            # of the file (relative to the root of the mount), and the
+            # second element is the type.  A directory is represented by an
+            # array as well, where the first element is a "directory" array,
+            # while the remaining elements are other file or directory
+            # arrays.  Confusing?  Hell yes.  As an added bonus, all names
+            # must start with a slash, because... well, I'm fairly certain
+            # a complete explanation would involve the words "crack pipe"
+            # and "bad batch".
+            #
+            def list(relpath, recurse, ignore, client = nil)
+                reclist(file_path(relpath, client), nil, recurse, ignore)
+            end
+
+            # Recursively list the files in this tree.
+            def reclist(basepath, abspath, recurse, ignore)
+                abspath = basepath if abspath.nil?
+                relpath = abspath.sub(%r{^#{basepath}}, '')
+                relpath = "/#{relpath}" if relpath[0] != ?/  #/
+                
+                return unless FileTest.exists?(abspath)
+                
+                desc = [relpath]
+                
+                ftype = File.stat(abspath).ftype
+
+                desc << ftype
+                if recurse.is_a?(Integer)
+                    recurse -= 1
+                end
+
+                ary = [desc]
+                if recurse == true or (recurse.is_a?(Integer) and recurse > -1)
+                    if ftype == "directory"
+                        children = Dir.entries(abspath)
+                        if ignore
+                            children = handleignore(children, abspath, ignore)
+                        end  
+                        children.each { |child|
+                            next if child =~ /^\.\.?$/
+                            reclist(basepath, File.join(abspath, child), recurse, ignore).each { |cobj|
+                                ary << cobj
+                            }
+                        }
+                    end
+                end
+
+                return ary.compact
+            end
+
+            # Deal with ignore parameters.
+            def handleignore(files, path, ignore_patterns)
+                ignore_patterns.each do |ignore|
+                    files.delete_if do |entry|
+                        File.fnmatch(ignore, entry, File::FNM_DOTMATCH)
+                    end
+                end
+                return files
+            end
+        end  
+
+        # A special mount class specifically for the plugins mount -- just
+        # has some magic to effectively do a union mount of the 'plugins'
+        # directory of all modules.
+        # 
+        class PluginMount < Mount
+            def path(client)
+                ''
+            end
+
+            def mod_path_exists?(mod, relpath, client = nil)
+                File.exists?(File.join(mod, PLUGINS, relpath))
+            end
+
+            def path_exists?(relpath, client = nil)
+               !valid_modules.find { |m| mod_path_exists?(m, relpath, client) }.nil?
+            end
+
+            def valid?
+                true
+            end
+
+            def mod_file_path(mod, relpath, client = nil)
+                File.join(mod, PLUGINS, relpath)
+            end
+            
+            def file_path(relpath, client = nil)
+                mod = valid_modules.map { |m| mod_path_exists?(m, relpath, client) ? m : nil }.compact.first
+                mod_file_path(mod, relpath, client)
+            end
+
+            # create a list of files by merging all modules
+            def list(relpath, recurse, ignore, client = nil)
+                result = []
+                valid_modules.each do |m|
+                    ary = reclist(mod_file_path(m, relpath, client), nil, recurse, ignore)
+                    ary = [] if ary.nil?
+                   result += ary
+                end
+                result
+            end
+
+            private
+            def valid_modules
+               Puppet::Module.all.find_all { |m| File.directory?(File.join(m, PLUGINS)) }
+            end
+            
+            def add_to_filetree(f, filetree)
+               first, rest = f.split(File::SEPARATOR, 2)
+            end
         end
     end
 end
 
-# $Id: fileserver.rb 2653 2007-07-06 00:54:51Z luke $