diff --git a/lib/puppet/file_serving/configuration.rb b/lib/puppet/file_serving/configuration.rb
index 608924c8b..6092c24e2 100644
--- a/lib/puppet/file_serving/configuration.rb
+++ b/lib/puppet/file_serving/configuration.rb
@@ -1,118 +1,127 @@
 #
 #  Created by Luke Kanies on 2007-10-16.
 #  Copyright (c) 2007. All rights reserved.
 
 require 'puppet'
 require 'puppet/file_serving'
 require 'puppet/file_serving/mount'
 require 'puppet/file_serving/mount/file'
 require 'puppet/file_serving/mount/modules'
 require 'puppet/file_serving/mount/plugins'
 require 'puppet/util/cacher'
 
 class Puppet::FileServing::Configuration
     require 'puppet/file_serving/configuration/parser'
 
     class << self
         include Puppet::Util::Cacher
         cached_attr(:configuration) { new() }
     end
 
     Mount = Puppet::FileServing::Mount
 
     # Create our singleton configuration.
     def self.create
         configuration
     end
 
     private_class_method  :new
 
     attr_reader :mounts
     #private :mounts
 
     # Find the right mount.  Does some shenanigans to support old-style module
     # mounts.
     def find_mount(mount_name, node)
         # Reparse the configuration if necessary.
         readconfig
 
         if mount = mounts[mount_name]
             return mount
         end
 
         if mounts["modules"].environment(node).module(mount_name)
             Puppet.warning "DEPRECATION NOTICE: Found module '%s' without using the 'modules' mount; please prefix path with 'modules/'" % mount_name
             return mounts["modules"]
         end
 
         # This can be nil.
         mounts[mount_name]
     end
 
     def initialize
         @mounts = {}
         @config_file = nil
 
         # We don't check to see if the file is modified the first time,
         # because we always want to parse at first.
         readconfig(false)
     end
 
     # Is a given mount available?
     def mounted?(name)
         @mounts.include?(name)
     end
 
     # Split the path into the separate mount point and path.
     def split_path(request)
         # Reparse the configuration if necessary.
         readconfig
 
         mount_name, path = request.key.split(File::Separator, 2)
 
         raise(ArgumentError, "Cannot find file: Invalid path '%s'" % mount_name) unless mount_name =~ %r{^[-\w]+$}
 
         return nil unless mount = find_mount(mount_name, request.options[:node])
         if mount.name == "modules" and mount_name != "modules"
             # yay backward-compatibility
             path = "%s/%s" % [mount_name, path]
         end
 
         if path == ""
             path = nil
         elsif path
             # Remove any double slashes that might have occurred
             path = path.gsub(/\/+/, "/")
         end
 
         return mount, path
     end
 
     def umount(name)
         @mounts.delete(name) if @mounts.include? name
     end
 
     private
 
+    def mk_default_mounts
+        @mounts["modules"] ||= Mount::Modules.new("modules")
+        @mounts["plugins"] ||= Mount::Plugins.new("plugins")
+    end
+
     # Read the configuration file.
     def readconfig(check = true)
         config = Puppet[:fileserverconfig]
 
         return unless FileTest.exists?(config)
 
         @parser ||= Puppet::FileServing::Configuration::Parser.new(config)
 
         if check and ! @parser.changed?
             return
         end
 
         # Don't assign the mounts hash until we're sure the parsing succeeded.
         begin
             newmounts = @parser.parse
             @mounts = newmounts
         rescue => detail
             puts detail.backtrace if Puppet[:trace]
             Puppet.err "Error parsing fileserver configuration: %s; using old configuration" % detail
         end
+
+    ensure
+        # Make sure we've got our plugins and modules.
+        mk_default_mounts
     end
 end
diff --git a/lib/puppet/file_serving/configuration/parser.rb b/lib/puppet/file_serving/configuration/parser.rb
index c86e00a62..50368fdaf 100644
--- a/lib/puppet/file_serving/configuration/parser.rb
+++ b/lib/puppet/file_serving/configuration/parser.rb
@@ -1,129 +1,121 @@
 require 'puppet/file_serving/configuration'
 require 'puppet/util/loadedfile'
 
 class Puppet::FileServing::Configuration::Parser < Puppet::Util::LoadedFile
     Mount = Puppet::FileServing::Mount
     MODULES = 'modules'
 
     # Parse our configuration file.
     def parse
         raise("File server configuration %s does not exist" % self.file) unless FileTest.exists?(self.file)
         raise("Cannot read file server configuration %s" % self.file) unless FileTest.readable?(self.file)
 
         @mounts = {}
         @count = 0
 
         File.open(self.file) { |f|
             mount = nil
             f.each { |line|
                 # Have the count increment at the top, in case we throw exceptions.
                 @count += 1
 
                 case line
                 when /^\s*#/; next # skip comments
                 when /^\s*$/; next # skip blank lines
                 when /\[([-\w]+)\]/
                     mount = newmount($1)
                 when /^\s*(\w+)\s+(.+)$/
                     var = $1
                     value = $2
                     raise(ArgumentError, "Fileserver configuration file does not use '=' as a separator") if value =~ /^=/
                     case var
                     when "path"
                         path(mount, value)
                     when "allow"
                         allow(mount, value)
                     when "deny"
                         deny(mount, value)
                     else
                         raise ArgumentError.new("Invalid argument '%s'" % var,
                             @count, file)
                     end
                 else
                     raise ArgumentError.new("Invalid line '%s'" % line.chomp,
                         @count, file)
                 end
             }
         }
 
-        mk_default_mounts
-
         validate()
 
         return @mounts
     end
 
     private
 
     # Allow a given pattern access to a mount.
     def allow(mount, value)
         # LAK:NOTE See http://snurl.com/21zf8  [groups_google_com] 
         x = value.split(/\s*,\s*/).each { |val|
             begin
                 mount.info "allowing %s access" % val
                 mount.allow(val)
             rescue AuthStoreError => detail
                 raise ArgumentError.new(detail.to_s,
                     @count, file)
             end
         }
     end
 
     # Deny a given pattern access to a mount.
     def deny(mount, value)
         # LAK:NOTE See http://snurl.com/21zf8  [groups_google_com] 
         x = value.split(/\s*,\s*/).each { |val|
             begin
                 mount.info "denying %s access" % val
                 mount.deny(val)
             rescue AuthStoreError => detail
                 raise ArgumentError.new(detail.to_s,
                     @count, file)
             end
         }
     end
 
-    def mk_default_mounts
-        ["plugins", "modules"].each do |name|
-            newmount(name) unless @mounts[name]
-        end
-    end
-
     # Create a new mount.
     def newmount(name)
         if @mounts.include?(name)
             raise ArgumentError, "%s is already mounted at %s" %
                 [@mounts[name], name], @count, file
         end
         case name
         when "modules"
             mount = Mount::Modules.new(name)
         when "plugins"
             mount = Mount::Plugins.new(name)
         else
             mount = Mount::File.new(name)
         end
         @mounts[name] = mount
         return mount
     end
 
     # Set the path for a mount.
     def path(mount, value)
         if mount.respond_to?(:path=)
             begin
                 mount.path = value
             rescue ArgumentError => detail
                 Puppet.err "Removing mount %s: %s" % [mount.name, detail]
                 @mounts.delete(mount.name)
             end
         else
             Puppet.warning "The '#{mount.name}' module can not have a path. Ignoring attempt to set it"
         end
     end
 
     # Make sure all of our mounts are valid.  We have to do this after the fact
     # because details are added over time as the file is parsed.
     def validate
         @mounts.each { |name, mount| mount.validate }
     end
 end
diff --git a/spec/unit/file_serving/configuration.rb b/spec/unit/file_serving/configuration.rb
index e62423caf..6f5dc115f 100755
--- a/spec/unit/file_serving/configuration.rb
+++ b/spec/unit/file_serving/configuration.rb
@@ -1,208 +1,223 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 require 'puppet/file_serving/configuration'
 
 describe Puppet::FileServing::Configuration do
     it "should make :new a private method" do
         proc { Puppet::FileServing::Configuration.new }.should raise_error
     end
 
     it "should return the same configuration each time :create is called" do
         Puppet::FileServing::Configuration.create.should equal(Puppet::FileServing::Configuration.create)
     end
 
     it "should have a method for removing the current configuration instance" do
         old = Puppet::FileServing::Configuration.create
         Puppet::Util::Cacher.expire
         Puppet::FileServing::Configuration.create.should_not equal(old)
     end
 
     after do
         Puppet::Util::Cacher.expire
     end
 end
 
 describe Puppet::FileServing::Configuration do
 
     before :each do
         @path = "/path/to/configuration/file.conf"
         Puppet.settings.stubs(:value).with(:trace).returns(false)
         Puppet.settings.stubs(:value).with(:fileserverconfig).returns(@path)
     end
 
     after :each do
         Puppet::Util::Cacher.expire
     end
 
     describe "when initializing" do
 
         it "should work without a configuration file" do
             FileTest.stubs(:exists?).with(@path).returns(false)
             proc { Puppet::FileServing::Configuration.create }.should_not raise_error
         end
 
         it "should parse the configuration file if present" do
             FileTest.stubs(:exists?).with(@path).returns(true)
             @parser = mock 'parser'
             @parser.expects(:parse).returns({})
             Puppet::FileServing::Configuration::Parser.stubs(:new).returns(@parser)
             Puppet::FileServing::Configuration.create
         end
 
         it "should determine the path to the configuration file from the Puppet settings" do
             Puppet::FileServing::Configuration.create
         end
     end
 
     describe "when parsing the configuration file" do
 
         before do
             FileTest.stubs(:exists?).with(@path).returns(true)
             @parser = mock 'parser'
             Puppet::FileServing::Configuration::Parser.stubs(:new).returns(@parser)
         end
 
         it "should set the mount list to the results of parsing" do
             @parser.expects(:parse).returns("one" => mock("mount"))
             config = Puppet::FileServing::Configuration.create
             config.mounted?("one").should be_true
         end
 
         it "should not raise exceptions" do
             @parser.expects(:parse).raises(ArgumentError)
             proc { Puppet::FileServing::Configuration.create }.should_not raise_error
         end
 
         it "should replace the existing mount list with the results of reparsing" do
             @parser.expects(:parse).returns("one" => mock("mount"))
             config = Puppet::FileServing::Configuration.create
             config.mounted?("one").should be_true
             # Now parse again
             @parser.expects(:parse).returns("two" => mock('other'))
             config.send(:readconfig, false)
             config.mounted?("one").should be_false
             config.mounted?("two").should be_true
         end
 
         it "should not replace the mount list until the file is entirely parsed successfully" do
             @parser.expects(:parse).returns("one" => mock("mount"))
             @parser.expects(:parse).raises(ArgumentError)
             config = Puppet::FileServing::Configuration.create
             # Now parse again, so the exception gets thrown
             config.send(:readconfig, false)
             config.mounted?("one").should be_true
         end
+
+        it "should add modules and plugins mounts even if the file does not exist" do
+            FileTest.expects(:exists?).returns false # the file doesn't exist
+            config = Puppet::FileServing::Configuration.create
+            config.mounted?("modules").should be_true
+            config.mounted?("plugins").should be_true
+        end
+
+        it "should add modules and plugins mounts even if they are not returned by the parser" do
+            @parser.expects(:parse).returns("one" => mock("mount"))
+            FileTest.expects(:exists?).returns true # the file doesn't exist
+            config = Puppet::FileServing::Configuration.create
+            config.mounted?("modules").should be_true
+            config.mounted?("plugins").should be_true
+        end
     end
 
     describe "when finding the specified mount" do
         it "should choose the named mount if one exists" do
             config = Puppet::FileServing::Configuration.create
             config.expects(:mounts).returns("one" => "foo")
             config.find_mount("one", "mynode").should == "foo"
         end
 
         it "should modules mount's environment to find a matching module if the named module cannot be found" do
             config = Puppet::FileServing::Configuration.create
 
             mod = mock 'module'
             env = mock 'environment'
             env.expects(:module).with("foo").returns mod
             mount = mock 'mount'
             mount.expects(:environment).with("mynode").returns env
 
             config.stubs(:mounts).returns("modules" => mount)
             config.find_mount("foo", "mynode").should equal(mount)
         end
 
         it "should return nil if there is no such named mount and no module with the same name exists" do
             config = Puppet::FileServing::Configuration.create
 
             env = mock 'environment'
             env.expects(:module).with("foo").returns nil
             mount = mock 'mount'
             mount.expects(:environment).with("mynode").returns env
 
             config.stubs(:mounts).returns("modules" => mount)
             config.find_mount("foo", "mynode").should be_nil
         end
     end
 
     describe "when finding the mount name and relative path in a request key" do
         before do
             @config = Puppet::FileServing::Configuration.create
             @config.stubs(:find_mount)
 
             @request = stub 'request', :key => "foo/bar/baz", :options => {}
         end
 
         it "should reread the configuration" do
             @config.expects(:readconfig)
 
             @config.split_path(@request)
         end
 
         it "should treat the first field of the URI path as the mount name" do
             @config.expects(:find_mount).with { |name, node| name == "foo" }
 
             @config.split_path(@request)
         end
 
         it "should fail if the mount name is not alpha-numeric" do
             @request.expects(:key).returns "foo&bar/asdf"
 
             lambda { @config.split_path(@request) }.should raise_error(ArgumentError)
         end
 
         it "should support dashes in the mount name" do
             @request.expects(:key).returns "foo-bar/asdf"
 
             lambda { @config.split_path(@request) }.should_not raise_error(ArgumentError)
         end
 
         it "should use the mount name and node to find the mount" do
             @config.expects(:find_mount).with { |name, node| name == "foo" and node == "mynode" }
             @request.options[:node] = "mynode"
 
             @config.split_path(@request)
         end
 
         it "should return nil if the mount cannot be found" do
             @config.expects(:find_mount).returns nil
 
             @config.split_path(@request).should be_nil
         end
 
         it "should return the mount and the relative path if the mount is found" do
             mount = stub 'mount', :name => "foo"
             @config.expects(:find_mount).returns mount
 
             @config.split_path(@request).should == [mount, "bar/baz"]
         end
 
         it "should remove any double slashes" do
             @request.stubs(:key).returns "foo/bar//baz"
             mount = stub 'mount', :name => "foo"
             @config.expects(:find_mount).returns mount
 
             @config.split_path(@request).should == [mount, "bar/baz"]
         end
 
         it "should return the relative path as nil if it is an empty string" do
             @request.expects(:key).returns "foo"
             mount = stub 'mount', :name => "foo"
             @config.expects(:find_mount).returns mount
 
             @config.split_path(@request).should == [mount, nil]
         end
 
         it "should add 'modules/' to the relative path if the modules mount is used but not specified, for backward compatibility" do
             @request.expects(:key).returns "foo/bar"
             mount = stub 'mount', :name => "modules"
             @config.expects(:find_mount).returns mount
 
             @config.split_path(@request).should == [mount, "foo/bar"]
         end
     end
 end
diff --git a/spec/unit/file_serving/configuration/parser.rb b/spec/unit/file_serving/configuration/parser.rb
index 389e58389..6faf81b4c 100755
--- a/spec/unit/file_serving/configuration/parser.rb
+++ b/spec/unit/file_serving/configuration/parser.rb
@@ -1,193 +1,181 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../../spec_helper'
 
 require 'puppet/file_serving/configuration/parser'
 
 describe Puppet::FileServing::Configuration::Parser do
     it "should subclass the LoadedFile class" do
         Puppet::FileServing::Configuration::Parser.superclass.should equal(Puppet::Util::LoadedFile)
     end
 end
 
 
 module FSConfigurationParserTesting
     def mock_file_content(content)
         # We want an array, but we actually want our carriage returns on all of it.
         lines = content.split("\n").collect { |l| l + "\n" }
         @filehandle.stubs(:each).multiple_yields(*lines)
     end
 end
 
 describe Puppet::FileServing::Configuration::Parser do
     before :each do
         @path = "/my/config.conf"
         FileTest.stubs(:exists?).with(@path).returns(true)
         FileTest.stubs(:readable?).with(@path).returns(true)
         @filehandle = mock 'filehandle'
         File.expects(:open).with(@path).yields(@filehandle)
         @parser = Puppet::FileServing::Configuration::Parser.new(@path)
     end
 
     describe Puppet::FileServing::Configuration::Parser, " when parsing" do
         include FSConfigurationParserTesting
 
-        before do
-            @parser.stubs(:add_modules_mount)
-        end
-
         it "should allow comments" do
             @filehandle.expects(:each).yields("# this is a comment\n")
             proc { @parser.parse }.should_not raise_error
         end
 
         it "should allow blank lines" do
             @filehandle.expects(:each).yields("\n")
             proc { @parser.parse }.should_not raise_error
         end
 
         it "should create a new mount for each section in the configuration" do
             mount1 = mock 'one', :validate => true
             mount2 = mock 'two', :validate => true
             Puppet::FileServing::Mount::File.expects(:new).with("one").returns(mount1)
             Puppet::FileServing::Mount::File.expects(:new).with("two").returns(mount2)
             mock_file_content "[one]\n[two]\n"
             @parser.parse
         end
 
         # This test is almost the exact same as the previous one.
         it "should return a hash of the created mounts" do
             mount1 = mock 'one', :validate => true
             mount2 = mock 'two', :validate => true
             Puppet::FileServing::Mount::File.expects(:new).with("one").returns(mount1)
             Puppet::FileServing::Mount::File.expects(:new).with("two").returns(mount2)
             mock_file_content "[one]\n[two]\n"
 
             result = @parser.parse
             result["one"].should equal(mount1)
             result["two"].should equal(mount2)
         end
 
-        it "should add plugins and modules mounts if they do not exist" do
-            mock_file_content "[one]\npath /foo"
-
-            result = @parser.parse
-            result["plugins"].should_not be_nil
-            result["modules"].should_not be_nil
-        end
-
         it "should only allow mount names that are alphanumeric plus dashes" do
             mock_file_content "[a*b]\n"
             proc { @parser.parse }.should raise_error(ArgumentError)
         end
 
         it "should fail if the value for path/allow/deny starts with an equals sign" do
             mock_file_content "[one]\npath = /testing"
             proc { @parser.parse }.should raise_error(ArgumentError)
         end
 
         it "should validate each created mount" do
             mount1 = mock 'one'
             Puppet::FileServing::Mount::File.expects(:new).with("one").returns(mount1)
             mock_file_content "[one]\n"
 
             mount1.expects(:validate)
 
             @parser.parse
         end
 
         it "should fail if any mount does not pass validation" do
             mount1 = mock 'one'
             Puppet::FileServing::Mount::File.expects(:new).with("one").returns(mount1)
             mock_file_content "[one]\n"
 
             mount1.expects(:validate).raises RuntimeError
 
             lambda { @parser.parse }.should raise_error(RuntimeError)
         end
     end
 
     describe Puppet::FileServing::Configuration::Parser, " when parsing mount attributes" do
         include FSConfigurationParserTesting
 
         before do
             @mount = stub 'testmount', :name => "one", :validate => true
             Puppet::FileServing::Mount::File.expects(:new).with("one").returns(@mount)
             @parser.stubs(:add_modules_mount)
         end
 
         it "should set the mount path to the path attribute from that section" do
             mock_file_content "[one]\npath /some/path\n"
 
             @mount.expects(:path=).with("/some/path")
             @parser.parse
         end
 
         it "should tell the mount to allow any allow values from the section" do
             mock_file_content "[one]\nallow something\n"
 
             @mount.expects(:info)
             @mount.expects(:allow).with("something")
             @parser.parse
         end
 
         it "should tell the mount to deny any deny values from the section" do
             mock_file_content "[one]\ndeny something\n"
 
             @mount.expects(:info)
             @mount.expects(:deny).with("something")
             @parser.parse
         end
 
         it "should fail on any attributes other than path, allow, and deny" do
             mock_file_content "[one]\ndo something\n"
 
             proc { @parser.parse }.should raise_error(ArgumentError)
         end
     end
 
     describe Puppet::FileServing::Configuration::Parser, " when parsing the modules mount" do
         include FSConfigurationParserTesting
 
         before do
             @mount = stub 'modulesmount', :name => "modules", :validate => true
         end
 
         it "should create an instance of the Modules Mount class" do
             mock_file_content "[modules]\n"
 
             Puppet::FileServing::Mount::Modules.expects(:new).with("modules").returns @mount
             @parser.parse
         end
 
         it "should warn if a path is set" do
             mock_file_content "[modules]\npath /some/path\n"
             Puppet::FileServing::Mount::Modules.expects(:new).with("modules").returns(@mount)
 
             Puppet.expects(:warning)
             @parser.parse
         end
     end
 
     describe Puppet::FileServing::Configuration::Parser, " when parsing the plugins mount" do
         include FSConfigurationParserTesting
 
         before do
             @mount = stub 'pluginsmount', :name => "plugins", :validate => true
         end
 
         it "should create an instance of the Plugins Mount class" do
             mock_file_content "[plugins]\n"
 
             Puppet::FileServing::Mount::Plugins.expects(:new).with("plugins").returns @mount
             @parser.parse
         end
 
         it "should warn if a path is set" do
             mock_file_content "[plugins]\npath /some/path\n"
 
             Puppet.expects(:warning)
             @parser.parse
         end
     end
 end