diff --git a/lib/puppet/type/file/mode.rb b/lib/puppet/type/file/mode.rb
index 96d6644cf..631327697 100755
--- a/lib/puppet/type/file/mode.rb
+++ b/lib/puppet/type/file/mode.rb
@@ -1,78 +1,77 @@
 # Manage file modes.  This state should support different formats
 # for specification (e.g., u+rwx, or -0011), but for now only supports
 # specifying the full mode.
 module Puppet
   Puppet::Type.type(:file).newproperty(:mode) do
     desc "Mode the file should be.  Currently relatively limited:
       you must specify the exact mode the file should be.
 
       Note that when you set the mode of a directory, Puppet always
       sets the search/traverse (1) bit anywhere the read (4) bit is set.
       This is almost always what you want: read allows you to list the
       entries in a directory, and search/traverse allows you to access
       (read/write/execute) those entries.)  Because of this feature, you
       can recursively make a directory and all of the files in it
       world-readable by setting e.g.:
 
           file { '/some/dir':
             mode    => 644,
             recurse => true,
           }
 
       In this case all of the files underneath `/some/dir` will have
       mode 644, and all of the directories will have mode 755."
 
     validate do |value|
       if value.is_a?(String) and value !~ /^[0-7]+$/
         raise Puppet::Error, "File modes can only be octal numbers, not #{should.inspect}"
       end
     end
 
     munge do |should|
       if should.is_a?(String)
         should.to_i(8).to_s(8)
       else
         should.to_s(8)
       end
     end
 
     # If we're a directory, we need to be executable for all cases
     # that are readable.  This should probably be selectable, but eh.
     def dirmask(value)
       if FileTest.directory?(resource[:path])
         value = value.to_i(8)
         value |= 0100 if value & 0400 != 0
         value |= 010 if value & 040 != 0
         value |= 01 if value & 04 != 0
         value = value.to_s(8)
       end
 
       value
     end
 
     # If we're not following links and we're a link, then we just turn
     # off mode management entirely.
     def insync?(currentvalue)
       if stat = @resource.stat and stat.ftype == "link" and @resource[:links] != :follow
         self.debug "Not managing symlink mode"
         return true
       else
         return super(currentvalue)
       end
     end
 
     # Ideally, dirmask'ing could be done at munge time, but we don't know if 'ensure'
     # will eventually be a directory or something else. And unfortunately, that logic
     # depends on the ensure, source, and target properties. So rather than duplicate
     # that logic, and get it wrong, we do dirmask during retrieve, after 'ensure' has
     # been synced.
     def retrieve
       if @resource.stat
         @should &&= @should.collect { |s| self.dirmask(s) }
       end
 
       super
     end
   end
 end
-
diff --git a/lib/puppet/util/settings/file_setting.rb b/lib/puppet/util/settings/file_setting.rb
index f02a0c547..9bc931108 100644
--- a/lib/puppet/util/settings/file_setting.rb
+++ b/lib/puppet/util/settings/file_setting.rb
@@ -1,125 +1,137 @@
 require 'puppet/util/settings/setting'
 
 # A file.
 class Puppet::Util::Settings::FileSetting < Puppet::Util::Settings::Setting
   AllowedOwners = %w{root service}
   AllowedGroups = %w{root service}
 
   class SettingError < StandardError; end
 
   attr_accessor :mode, :create
 
   # Should we create files, rather than just directories?
   def create_files?
     create
   end
 
   def group=(value)
     unless AllowedGroups.include?(value)
       identifying_fields = [desc,name,default].compact.join(': ')
       raise SettingError, "Internal error: The :group setting for #{identifying_fields} must be 'service', not '#{value}'"
     end
     @group = value
   end
 
   def group
     return unless @group
     @settings[:group]
   end
 
   def owner=(value)
     unless AllowedOwners.include?(value)
       identifying_fields = [desc,name,default].compact.join(': ')
       raise SettingError, "Internal error: The :owner setting for #{identifying_fields} must be either 'root' or 'service', not '#{value}'"
     end
     @owner = value
   end
 
   def owner
     return unless @owner
     return "root" if @owner == "root" or ! use_service_user?
     @settings[:user]
   end
 
   def use_service_user?
     @settings[:mkusers] or @settings.service_user_available?
   end
 
   # Set the type appropriately.  Yep, a hack.  This supports either naming
   # the variable 'dir', or adding a slash at the end.
   def munge(value)
     # If it's not a fully qualified path...
     if value.is_a?(String) and value !~ /^\$/ and value != 'false'
       # Make it one
       value = File.expand_path(value)
     end
     if value.to_s =~ /\/$/
       @type = :directory
       return value.sub(/\/$/, '')
     end
     value
   end
 
   # Return the appropriate type.
   def type
     value = @settings.value(self.name)
     if @name.to_s =~ /dir/
       return :directory
     elsif value.to_s =~ /\/$/
       return :directory
     elsif value.is_a? String
       return :file
     else
       return nil
     end
   end
 
   # Turn our setting thing into a Puppet::Resource instance.
   def to_resource
     return nil unless type = self.type
 
     path = self.value
 
     return nil unless path.is_a?(String)
 
     # Make sure the paths are fully qualified.
     path = File.expand_path(path)
 
     return nil unless type == :directory or create_files? or File.exist?(path)
     return nil if path =~ /^\/dev/ or path =~ /^[A-Z]:\/dev/i
 
     resource = Puppet::Resource.new(:file, path)
 
     if Puppet[:manage_internal_file_permissions]
-      resource[:mode] = self.mode if self.mode
+      if self.mode
+        # This ends up mimicking the munge method of the mode
+        # parameter to make sure that we're always passing the string
+        # version of the octal number.  If we were setting the
+        # 'should' value for mode rather than the 'is', then the munge
+        # method would be called for us automatically.  Normally, one
+        # wouldn't need to call the munge method manually, since
+        # 'should' gets set by the provider and it should be able to
+        # provide the data in the appropriate format.
+        mode = self.mode
+        mode = mode.to_i(8) if mode.is_a?(String)
+        mode = mode.to_s(8)
+        resource[:mode] = mode
+      end
 
       # REMIND fails on Windows because chown/chgrp functionality not supported yet
       if Puppet.features.root? and !Puppet.features.microsoft_windows?
         resource[:owner] = self.owner if self.owner
         resource[:group] = self.group if self.group
       end
     end
 
     resource[:ensure] = type
     resource[:loglevel] = :debug
     resource[:links] = :follow
     resource[:backup] = false
 
     resource.tag(self.section, self.name, "settings")
 
     resource
   end
 
   # Make sure any provided variables look up to something.
   def validate(value)
     return true unless value.is_a? String
     value.scan(/\$(\w+)/) { |name|
       name = $1
       unless @settings.include?(name)
         raise ArgumentError,
           "Settings parameter '#{name}' is undefined"
       end
     }
   end
 end
-
diff --git a/spec/unit/util/settings/file_setting_spec.rb b/spec/unit/util/settings/file_setting_spec.rb
index 6344cf1b5..74d5090cb 100755
--- a/spec/unit/util/settings/file_setting_spec.rb
+++ b/spec/unit/util/settings/file_setting_spec.rb
@@ -1,284 +1,290 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/util/settings'
 require 'puppet/util/settings/file_setting'
 
 describe Puppet::Util::Settings::FileSetting do
   FileSetting = Puppet::Util::Settings::FileSetting
 
   include PuppetSpec::Files
 
   before do
     @basepath = make_absolute("/somepath")
   end
 
   describe "when determining whether the service user should be used" do
     before do
       @settings = mock 'settings'
       @settings.stubs(:[]).with(:mkusers).returns false
       @settings.stubs(:service_user_available?).returns true
     end
 
     it "should be true if the service user is available" do
       @settings.expects(:service_user_available?).returns true
       setting = FileSetting.new(:settings => @settings, :owner => "root", :desc => "a setting")
       setting.should be_use_service_user
     end
 
     it "should be true if 'mkusers' is set" do
       @settings.expects(:[]).with(:mkusers).returns true
       setting = FileSetting.new(:settings => @settings, :owner => "root", :desc => "a setting")
       setting.should be_use_service_user
     end
 
     it "should be false if the service user is not available and 'mkusers' is unset" do
       setting = FileSetting.new(:settings => @settings, :owner => "root", :desc => "a setting")
       setting.should be_use_service_user
     end
   end
 
   describe "when setting the owner" do
     it "should allow the file to be owned by root" do
       root_owner = lambda { FileSetting.new(:settings => mock("settings"), :owner => "root", :desc => "a setting") }
       root_owner.should_not raise_error
     end
 
     it "should allow the file to be owned by the service user" do
       service_owner = lambda { FileSetting.new(:settings => mock("settings"), :owner => "service", :desc => "a setting") }
       service_owner.should_not raise_error
     end
 
     it "should allow the ownership of the file to be unspecified" do
       no_owner = lambda { FileSetting.new(:settings => mock("settings"), :desc => "a setting") }
       no_owner.should_not raise_error
     end
 
     it "should not allow other owners" do
       invalid_owner = lambda { FileSetting.new(:settings => mock("settings"), :owner => "invalid", :desc => "a setting") }
       invalid_owner.should raise_error(FileSetting::SettingError)
     end
   end
 
   describe "when reading the owner" do
     it "should be root when the setting specifies root" do
       setting = FileSetting.new(:settings => mock("settings"), :owner => "root", :desc => "a setting")
       setting.owner.should == "root"
     end
 
     it "should be the owner of the service when the setting specifies service and the service user should be used" do
       settings = mock("settings")
       settings.stubs(:[]).returns "the_service"
 
       setting = FileSetting.new(:settings => settings, :owner => "service", :desc => "a setting")
       setting.expects(:use_service_user?).returns true
       setting.owner.should == "the_service"
     end
 
     it "should be the root when the setting specifies service and the service user should not be used" do
       settings = mock("settings")
       settings.stubs(:[]).returns "the_service"
 
       setting = FileSetting.new(:settings => settings, :owner => "service", :desc => "a setting")
       setting.expects(:use_service_user?).returns false
       setting.owner.should == "root"
     end
 
     it "should be nil when the owner is unspecified" do
       FileSetting.new(:settings => mock("settings"), :desc => "a setting").owner.should be_nil
     end
   end
 
   describe "when setting the group" do
     it "should allow the group to be service" do
       service_group = lambda { FileSetting.new(:settings => mock("settings"), :group => "service", :desc => "a setting") }
       service_group.should_not raise_error
     end
 
     it "should allow the group to be unspecified" do
       no_group = lambda { FileSetting.new(:settings => mock("settings"), :desc => "a setting") }
       no_group.should_not raise_error
     end
 
     it "should not allow invalid groups" do
       invalid_group = lambda { FileSetting.new(:settings => mock("settings"), :group => "invalid", :desc => "a setting") }
       invalid_group.should raise_error(FileSetting::SettingError)
     end
   end
 
   describe "when reading the group" do
     it "should be service when the setting specifies service" do
       setting = FileSetting.new(:settings => mock("settings", :[] => "the_service"), :group => "service", :desc => "a setting")
       setting.group.should == "the_service"
     end
 
     it "should be nil when the group is unspecified" do
       FileSetting.new(:settings => mock("settings"), :desc => "a setting").group.should be_nil
     end
   end
 
   it "should be able to be converted into a resource" do
     FileSetting.new(:settings => mock("settings"), :desc => "eh").should respond_to(:to_resource)
   end
 
   describe "when being converted to a resource" do
     before do
       @settings = mock 'settings'
       @file = Puppet::Util::Settings::FileSetting.new(:settings => @settings, :desc => "eh", :name => :mydir, :section => "mysect")
       @settings.stubs(:value).with(:mydir).returns @basepath
     end
 
     it "should skip files that cannot determine their types" do
       @file.expects(:type).returns nil
       @file.to_resource.should be_nil
     end
 
     it "should skip non-existent files if 'create_files' is not enabled" do
       @file.expects(:create_files?).returns false
       @file.expects(:type).returns :file
       File.expects(:exist?).with(@basepath).returns false
       @file.to_resource.should be_nil
     end
 
     it "should manage existent files even if 'create_files' is not enabled" do
       @file.expects(:create_files?).returns false
       @file.expects(:type).returns :file
       File.expects(:exist?).with(@basepath).returns true
       @file.to_resource.should be_instance_of(Puppet::Resource)
     end
 
     describe "on POSIX systems", :if => Puppet.features.posix? do
       it "should skip files in /dev" do
         @settings.stubs(:value).with(:mydir).returns "/dev/file"
         @file.to_resource.should be_nil
       end
     end
 
     it "should skip files whose paths are not strings" do
       @settings.stubs(:value).with(:mydir).returns :foo
       @file.to_resource.should be_nil
     end
 
     it "should return a file resource with the path set appropriately" do
       resource = @file.to_resource
       resource.type.should == "File"
       resource.title.should == @basepath
     end
 
     it "should fully qualified returned files if necessary (#795)" do
       @settings.stubs(:value).with(:mydir).returns "myfile"
       path = File.join(Dir.getwd, "myfile")
       # Dir.getwd can return windows paths with backslashes, so we normalize them using expand_path
       path = File.expand_path(path) if Puppet.features.microsoft_windows?
       @file.to_resource.title.should == path
     end
 
-    it "should set the mode on the file if a mode is provided" do
+    it "should set the mode on the file if a mode is provided as an octal number" do
       @file.mode = 0755
 
-      @file.to_resource[:mode].should == 0755
+      @file.to_resource[:mode].should == '755'
+    end
+
+    it "should set the mode on the file if a mode is provided as a string" do
+      @file.mode = '0755'
+
+      @file.to_resource[:mode].should == '755'
     end
 
     it "should not set the mode on a the file if manage_internal_file_permissions is disabled" do
       Puppet[:manage_internal_file_permissions] = false
 
       @file.stubs(:mode).returns(0755)
 
       @file.to_resource[:mode].should == nil
     end
 
     it "should set the owner if running as root and the owner is provided" do
       Puppet.features.expects(:root?).returns true
       Puppet.features.stubs(:microsoft_windows?).returns false
 
       @file.stubs(:owner).returns "foo"
       @file.to_resource[:owner].should == "foo"
     end
 
     it "should not set the owner if manage_internal_file_permissions is disabled" do
       Puppet[:manage_internal_file_permissions] = false
       Puppet.features.stubs(:root?).returns true
       @file.stubs(:owner).returns "foo"
 
       @file.to_resource[:owner].should == nil
     end
 
     it "should set the group if running as root and the group is provided" do
       Puppet.features.expects(:root?).returns true
       Puppet.features.stubs(:microsoft_windows?).returns false
 
       @file.stubs(:group).returns "foo"
       @file.to_resource[:group].should == "foo"
     end
 
     it "should not set the group if manage_internal_file_permissions is disabled" do
       Puppet[:manage_internal_file_permissions] = false
       Puppet.features.stubs(:root?).returns true
       @file.stubs(:group).returns "foo"
 
       @file.to_resource[:group].should == nil
     end
 
 
     it "should not set owner if not running as root" do
       Puppet.features.expects(:root?).returns false
       Puppet.features.stubs(:microsoft_windows?).returns false
       @file.stubs(:owner).returns "foo"
       @file.to_resource[:owner].should be_nil
     end
 
     it "should not set group if not running as root" do
       Puppet.features.expects(:root?).returns false
       Puppet.features.stubs(:microsoft_windows?).returns false
       @file.stubs(:group).returns "foo"
       @file.to_resource[:group].should be_nil
     end
 
     describe "on Microsoft Windows systems" do
       before :each do
         Puppet.features.stubs(:microsoft_windows?).returns true
       end
 
       it "should not set owner" do
         @file.stubs(:owner).returns "foo"
         @file.to_resource[:owner].should be_nil
       end
 
       it "should not set group" do
         @file.stubs(:group).returns "foo"
         @file.to_resource[:group].should be_nil
       end
     end
 
     it "should set :ensure to the file type" do
       @file.expects(:type).returns :directory
       @file.to_resource[:ensure].should == :directory
     end
 
     it "should set the loglevel to :debug" do
       @file.to_resource[:loglevel].should == :debug
     end
 
     it "should set the backup to false" do
       @file.to_resource[:backup].should be_false
     end
 
     it "should tag the resource with the settings section" do
       @file.expects(:section).returns "mysect"
       @file.to_resource.should be_tagged("mysect")
     end
 
     it "should tag the resource with the setting name" do
       @file.to_resource.should be_tagged("mydir")
     end
 
     it "should tag the resource with 'settings'" do
       @file.to_resource.should be_tagged("settings")
     end
 
     it "should set links to 'follow'" do
       @file.to_resource[:links].should == :follow
     end
   end
 end