use_temporary_file = write_temporary_file?

    assumed_default_mode = 0644

    if use_temporary_file

      path = "#{self[:path]}.puppettmp_#{rand(10000)}"

      path = "#{self[:path]}.puppettmp_#{rand(10000)}" while ::File.exists?(path) or ::File.symlink?(path)

    else

      path = self[:path]

    end

    umask = mode ? 000 : 022

    mode_int = mode ? symbolic_mode_to_int(mode, assumed_default_mode) : nil

    mode_int = mode ? symbolic_mode_to_int(mode, 0644) : nil

    if write_temporary_file?

    content_checksum = Puppet::Util.withumask(umask) { ::File.open(path, 'wb', mode_int ) { |f| write_content(f) } }

      Puppet::Util.replace_file(self[:path], mode_int) do |file|

        file.binmode

    # And put our new file in place

        content_checksum = write_content(file)

    if use_temporary_file # This is only not true when our file is empty.

        file.flush

      begin

        fail_if_checksum_is_wrong(file.path, content_checksum) if validate_checksum?

        fail_if_checksum_is_wrong(path, content_checksum) if validate_checksum?

        ::File.rename(path, self[:path])

      rescue => detail

        fail "Could not rename temporary file #{path} to #{self[:path]}: #{detail}"

      ensure

        # Make sure the created file gets removed

        ::File.unlink(path) if FileTest.exists?(path)

    unless Puppet.features.microsoft_windows?

    if !Puppet.features.microsoft_windows?

      stat = file.lstat rescue OpenStruct.new(:mode => default_mode,

      if file.exist?

                                              :uid  => Process.euid,

        stat = file.lstat

                                              :gid  => Process.egid)

        tempfile.chown(stat.uid, stat.gid)

        effective_mode = stat.mode

      else

        effective_mode = default_mode

      end

      # We only care about the bottom four slots, which make the real mode,

      if effective_mode

      # and not the rest of the platform stat call fluff and stuff.

        # We only care about the bottom four slots, which make the real mode,

      tempfile.chmod(stat.mode & 07777)

        # and not the rest of the platform stat call fluff and stuff.

      tempfile.chown(stat.uid, stat.gid)

        tempfile.chmod(effective_mode & 07777)

      end

      # This will appropriately clone the file, but only if the file we are

      # Windows ReplaceFile needs a file to exist, so touch handles this

      # replacing exists.  Which is kind of annoying; thanks Microsoft.

      if !file.exist?

      #

        FileUtils.touch(file.to_s)

      # So, to avoid getting into an infinite loop we will retry once if the

        if default_mode

      # file doesn't exist, but only the once...

          Puppet::Util::Windows::Security.set_mode(default_mode, file.to_s)

      have_retried = false

      begin

        # Yes, the arguments are reversed compared to the rename in the rest

        # of the world.

        Puppet::Util::Windows::File.replace_file(file, tempfile.path)

      rescue Puppet::Util::Windows::Error => e

        # This might race, but there are enough possible cases that there

        # isn't a good, solid "better" way to do this, and the next call

        # should fail in the same way anyhow.

        raise if have_retried or File.exist?(file)

        have_retried = true

        # OK, so, we can't replace a file that doesn't exist, so let us put

        # one in place and set the permissions.  Then we can retry and the

        # magic makes this all work.

        #

        # This is the least-worst option for handling Windows, as far as we

        # can determine.

        File.open(file, 'a') do |fh|

          # this space deliberately left empty for auto-close behaviour,

          # append mode, and not actually changing any of the content.