diff --git a/lib/puppet/type/file/source.rb b/lib/puppet/type/file/source.rb
index 6dda7957c..6ebec51fe 100755
--- a/lib/puppet/type/file/source.rb
+++ b/lib/puppet/type/file/source.rb
@@ -1,182 +1,183 @@
 
 require 'puppet/file_serving/content'
 require 'puppet/file_serving/metadata'
 
 module Puppet
   # Copy files from a local or remote source.  This state *only* does any work
   # when the remote file is an actual file; in that case, this state copies
   # the file down.  If the remote file is a dir or a link or whatever, then
   # this state, during retrieval, modifies the appropriate other states
   # so that things get taken care of appropriately.
   Puppet::Type.type(:file).newparam(:source) do
     include Puppet::Util::Diff
 
     attr_accessor :source, :local
     desc "Copy a file over the current file.  Uses `checksum` to
       determine when a file should be copied.  Valid values are either
       fully qualified paths to files, or URIs.  Currently supported URI
       types are *puppet* and *file*.
 
       This is one of the primary mechanisms for getting content into
       applications that Puppet does not directly support and is very
       useful for those configuration files that don't change much across
       sytems.  For instance:
 
           class sendmail {
             file { \"/etc/mail/sendmail.cf\":
               source => \"puppet://server/modules/module_name/sendmail.cf\"
             }
           }
 
       You can also leave out the server name, in which case `puppet agent`
       will fill in the name of its configuration server and `puppet apply`
       will use the local filesystem.  This makes it easy to use the same
       configuration in both local and centralized forms.
 
       Currently, only the `puppet` scheme is supported for source
       URL's. Puppet will connect to the file server running on
       `server` to retrieve the contents of the file. If the
       `server` part is empty, the behavior of the command-line
       interpreter (`puppet apply`) and the client demon (`puppet agent`) differs
       slightly: `apply` will look such a file up on the module path
       on the local host, whereas `agent` will connect to the
       puppet server that it received the manifest from.
 
       See the [fileserver configuration documentation](http://projects.puppetlabs.com/projects/puppet/wiki/File_Serving_Configuration) for information on how to configure
       and use file services within Puppet.
 
       If you specify multiple file sources for a file, then the first
       source that exists will be used.  This allows you to specify
       what amount to search paths for files:
 
           file { \"/path/to/my/file\":
             source => [
               \"/modules/nfs/files/file.$host\",
               \"/modules/nfs/files/file.$operatingsystem\",
               \"/modules/nfs/files/file\"
             ]
           }
 
       This will use the first found file as the source.
 
       You cannot currently copy links using this mechanism; set `links`
       to `follow` if any remote sources are links.
       "
 
     validate do |sources|
       sources = [sources] unless sources.is_a?(Array)
       sources.each do |source|
         begin
           uri = URI.parse(URI.escape(source))
         rescue => detail
           self.fail "Could not understand source #{source}: #{detail}"
         end
 
         self.fail "Cannot use URLs of type '#{uri.scheme}' as source for fileserving" unless uri.scheme.nil? or %w{file puppet}.include?(uri.scheme)
       end
     end
 
     munge do |sources|
       sources = [sources] unless sources.is_a?(Array)
       sources.collect { |source| source.sub(/\/$/, '') }
     end
 
     def change_to_s(currentvalue, newvalue)
       # newvalue = "{md5}#{@metadata.checksum}"
       if @resource.property(:ensure).retrieve == :absent
         return "creating from source #{metadata.source} with contents #{metadata.checksum}"
       else
         return "replacing from source #{metadata.source} with contents #{metadata.checksum}"
       end
     end
 
     def checksum
       metadata && metadata.checksum
     end
 
     # Look up (if necessary) and return remote content.
     cached_attr(:content) do
       raise Puppet::DevError, "No source for content was stored with the metadata" unless metadata.source
 
       unless tmp = Puppet::FileServing::Content.find(metadata.source)
         fail "Could not find any content at %s" % metadata.source
       end
       tmp.content
     end
 
     # Copy the values from the source to the resource.  Yay.
     def copy_source_values
       devfail "Somehow got asked to copy source values without any metadata" unless metadata
 
       # Take each of the stats and set them as states on the local file
       # if a value has not already been provided.
       [:owner, :mode, :group, :checksum].each do |metadata_method|
         param_name = (metadata_method == :checksum) ? :content : metadata_method
         next if metadata_method == :owner and !Puppet.features.root?
         next if metadata_method == :checksum and metadata.ftype == "directory"
+        next if metadata_method == :checksum and metadata.ftype == "link" and metadata.links == :manage
 
         if resource[param_name].nil? or resource[param_name] == :absent
           resource[param_name] = metadata.send(metadata_method)
         end
       end
 
       if resource[:ensure] == :absent
         # We know all we need to
       elsif metadata.ftype != "link"
         resource[:ensure] = metadata.ftype
       elsif @resource[:links] == :follow
         resource[:ensure] = :present
       else
         resource[:ensure] = "link"
         resource[:target] = metadata.destination
       end
     end
 
     def found?
       ! (metadata.nil? or metadata.ftype.nil?)
     end
 
     # Provide, and retrieve if necessary, the metadata for this file.  Fail
     # if we can't find data about this host, and fail if there are any
     # problems in our query.
     cached_attr(:metadata) do
       return nil unless value
       result = nil
       value.each do |source|
         begin
           if data = Puppet::FileServing::Metadata.find(source)
             result = data
             result.source = source
             break
           end
         rescue => detail
           fail detail, "Could not retrieve file metadata for #{source}: #{detail}"
         end
       end
       fail "Could not retrieve information from source(s) #{value.join(", ")}" unless result
       result
     end
 
     def local?
       found? and uri and (uri.scheme || "file") == "file"
     end
 
     def full_path
       URI.unescape(uri.path) if found? and uri
     end
 
     def server
       (uri and uri.host) or Puppet.settings[:server]
     end
 
     def port
       (uri and uri.port) or Puppet.settings[:masterport]
     end
 
     private
 
     def uri
       @uri ||= URI.parse(URI.escape(metadata.source))
     end
   end
 end
diff --git a/spec/unit/type/file/source_spec.rb b/spec/unit/type/file/source_spec.rb
index 00cc2f235..6e04fa2a5 100755
--- a/spec/unit/type/file/source_spec.rb
+++ b/spec/unit/type/file/source_spec.rb
@@ -1,272 +1,273 @@
 #!/usr/bin/env ruby
 
 Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
 
 source = Puppet::Type.type(:file).attrclass(:source)
 describe Puppet::Type.type(:file).attrclass(:source) do
   before do
     # Wow that's a messy interface to the resource.
     @resource = stub 'resource', :[]= => nil, :property => nil, :catalog => stub("catalog", :dependent_data_expired? => false), :line => 0, :file => ''
   end
 
   it "should be a subclass of Parameter" do
     source.superclass.must == Puppet::Parameter
   end
 
   describe "when initializing" do
     it "should fail if the set values are not URLs" do
       s = source.new(:resource => @resource)
       URI.expects(:parse).with('foo').raises RuntimeError
 
       lambda { s.value = %w{foo} }.must raise_error(Puppet::Error)
     end
 
     it "should fail if the URI is not a local file, file URI, or puppet URI" do
       s = source.new(:resource => @resource)
 
       lambda { s.value = %w{http://foo/bar} }.must raise_error(Puppet::Error)
     end
   end
 
   it "should have a method for retrieving its metadata" do
     source.new(:resource => @resource).must respond_to(:metadata)
   end
 
   it "should have a method for setting its metadata" do
     source.new(:resource => @resource).must respond_to(:metadata=)
   end
 
   describe "when returning the metadata" do
     before do
       @metadata = stub 'metadata', :source= => nil
     end
 
     it "should return already-available metadata" do
       @source = source.new(:resource => @resource)
       @source.metadata = "foo"
       @source.metadata.should == "foo"
     end
 
     it "should return nil if no @should value is set and no metadata is available" do
       @source = source.new(:resource => @resource)
       @source.metadata.should be_nil
     end
 
     it "should collect its metadata using the Metadata class if it is not already set" do
       @source = source.new(:resource => @resource, :value => "/foo/bar")
       Puppet::FileServing::Metadata.expects(:find).with("/foo/bar").returns @metadata
       @source.metadata
     end
 
     it "should use the metadata from the first found source" do
       metadata = stub 'metadata', :source= => nil
       @source = source.new(:resource => @resource, :value => ["/foo/bar", "/fee/booz"])
       Puppet::FileServing::Metadata.expects(:find).with("/foo/bar").returns nil
       Puppet::FileServing::Metadata.expects(:find).with("/fee/booz").returns metadata
       @source.metadata.should equal(metadata)
     end
 
     it "should store the found source as the metadata's source" do
       metadata = mock 'metadata'
       @source = source.new(:resource => @resource, :value => "/foo/bar")
       Puppet::FileServing::Metadata.expects(:find).with("/foo/bar").returns metadata
 
       metadata.expects(:source=).with("/foo/bar")
       @source.metadata
     end
 
     it "should fail intelligently if an exception is encountered while querying for metadata" do
       @source = source.new(:resource => @resource, :value => "/foo/bar")
       Puppet::FileServing::Metadata.expects(:find).with("/foo/bar").raises RuntimeError
 
       @source.expects(:fail).raises ArgumentError
       lambda { @source.metadata }.should raise_error(ArgumentError)
     end
 
     it "should fail if no specified sources can be found" do
       @source = source.new(:resource => @resource, :value => "/foo/bar")
       Puppet::FileServing::Metadata.expects(:find).with("/foo/bar").returns nil
 
       @source.expects(:fail).raises RuntimeError
 
       lambda { @source.metadata }.should raise_error(RuntimeError)
     end
 
     it "should expire the metadata appropriately" do
       expirer = stub 'expired', :dependent_data_expired? => true
 
       metadata = stub 'metadata', :source= => nil
       Puppet::FileServing::Metadata.expects(:find).with("/fee/booz").returns metadata
 
       @source = source.new(:resource => @resource, :value => ["/fee/booz"])
       @source.metadata = "foo"
 
       @source.stubs(:expirer).returns expirer
 
       @source.metadata.should_not == "foo"
     end
   end
 
   it "should have a method for setting the desired values on the resource" do
     source.new(:resource => @resource).must respond_to(:copy_source_values)
   end
 
   describe "when copying the source values" do
     before do
 
       @resource = Puppet::Type.type(:file).new :path => "/foo/bar"
 
       @source = source.new(:resource => @resource)
       @metadata = stub 'metadata', :owner => 100, :group => 200, :mode => 123, :checksum => "{md5}asdfasdf", :ftype => "file"
       @source.stubs(:metadata).returns @metadata
     end
 
     it "should fail if there is no metadata" do
       @source.stubs(:metadata).returns nil
       @source.expects(:devfail).raises ArgumentError
       lambda { @source.copy_source_values }.should raise_error(ArgumentError)
     end
 
     it "should set :ensure to the file type" do
       @metadata.stubs(:ftype).returns "file"
 
       @source.copy_source_values
       @resource[:ensure].must == :file
     end
 
     it "should not set 'ensure' if it is already set to 'absent'" do
       @metadata.stubs(:ftype).returns "file"
 
       @resource[:ensure] = :absent
       @source.copy_source_values
       @resource[:ensure].must == :absent
     end
 
     describe "and the source is a file" do
       before do
         @metadata.stubs(:ftype).returns "file"
       end
 
       it "should copy the metadata's owner, group, checksum, and mode to the resource if they are not set on the resource" do
         Puppet.features.expects(:root?).returns true
 
         @source.copy_source_values
 
         @resource[:owner].must == 100
         @resource[:group].must == 200
         @resource[:mode].must == "173"
 
         # Metadata calls it checksum, we call it content.
         @resource[:content].must == @metadata.checksum
       end
 
       it "should not copy the metadata's owner to the resource if it is already set" do
         @resource[:owner] = 1
         @resource[:group] = 2
         @resource[:mode] = 3
         @resource[:content] = "foobar"
 
         @source.copy_source_values
 
         @resource[:owner].must == 1
         @resource[:group].must == 2
         @resource[:mode].must == "3"
         @resource[:content].should_not == @metadata.checksum
       end
 
       describe "and puppet is not running as root" do
         it "should not try to set the owner" do
           Puppet.features.expects(:root?).returns false
 
           @source.copy_source_values
           @resource[:owner].should be_nil
         end
       end
     end
 
     describe "and the source is a link" do
       it "should set the target to the link destination" do
         @metadata.stubs(:ftype).returns "link"
+        @metadata.stubs(:links).returns "manage"
         @resource.stubs(:[])
         @resource.stubs(:[]=)
 
         @metadata.expects(:destination).returns "/path/to/symlink"
 
         @resource.expects(:[]=).with(:target, "/path/to/symlink")
         @source.copy_source_values
       end
     end
   end
 
   it "should have a local? method" do
     source.new(:resource => @resource).must be_respond_to(:local?)
   end
 
   context "when accessing source properties" do
     before(:each) do
       @source = source.new(:resource => @resource)
       @metadata = stub_everything
       @source.stubs(:metadata).returns(@metadata)
     end
 
     describe "for local sources" do
       before(:each) do
         @metadata.stubs(:ftype).returns "file"
         @metadata.stubs(:source).returns("file:///path/to/source")
       end
 
       it "should be local" do
         @source.must be_local
       end
 
       it "should be local if there is no scheme" do
         @metadata.stubs(:source).returns("/path/to/source")
         @source.must be_local
       end
 
       it "should be able to return the metadata source full path" do
         @source.full_path.should == "/path/to/source"
       end
     end
 
     describe "for remote sources" do
       before(:each) do
         @metadata.stubs(:ftype).returns "file"
         @metadata.stubs(:source).returns("puppet://server:8192/path/to/source")
       end
 
       it "should not be local" do
         @source.should_not be_local
       end
 
       it "should be able to return the metadata source full path" do
         @source.full_path.should == "/path/to/source"
       end
 
       it "should be able to return the source server" do
         @source.server.should == "server"
       end
 
       it "should be able to return the source port" do
         @source.port.should == 8192
       end
 
       describe "which don't specify server or port" do
         before(:each) do
           @metadata.stubs(:source).returns("puppet:///path/to/source")
         end
 
         it "should return the default source server" do
           Puppet.settings.expects(:[]).with(:server).returns("myserver")
           @source.server.should == "myserver"
         end
 
         it "should return the default source port" do
           Puppet.settings.expects(:[]).with(:masterport).returns(1234)
           @source.port.should == 1234
         end
       end
     end
   end
 
 end