puppet 2.7.26 → 3.0.0.rc4

data/lib/puppet/type/scheduled_task.rb

@@ -80,7 +80,7 @@ Puppet::Type.newtype(:scheduled_task) do
   end
 
   newproperty(:trigger, :array_matching => :all) do
-    desc <<-'EOT'
+    desc <<-EOT
       One or more triggers defining when the task should run. A single trigger is
       represented as a hash, and multiple triggers can be specified with an array of
       hashes.

data/lib/puppet/type/service.rb

@@ -198,9 +198,8 @@ module Puppet
     newparam :hasrestart do
       desc "Specify that an init script has a `restart` command.  If this is
         false and you do not specify a command in the `restart` attribute,
-        the init script's `stop` and `start` commands will be used.
-
-        Defaults to false."
+        the init script's `stop` and `start` commands will be used. Defaults
+        to true; note that this is a change from earlier versions of Puppet."
       newvalues(:true, :false)
     end
 

data/lib/puppet/type/tidy.rb

@@ -43,7 +43,7 @@ Puppet::Type.newtype(:tidy) do
   end
 
   newparam(:matches) do
-    desc <<-'EOT'
+    desc <<-EOT
       One or more (shell type) file glob patterns, which restrict
       the list of files to be tidied to those whose basenames match
       at least one of the patterns specified. Multiple patterns can
@@ -101,17 +101,16 @@ Puppet::Type.newtype(:tidy) do
 
       Specifying 0 will remove all files."
 
-    @@ageconvertors = {
+    AgeConvertors = {
       :s => 1,
-      :m => 60
+      :m => 60,
+      :h => 60 * 60,
+      :d => 60 * 60 * 24,
+      :w => 60 * 60 * 24 * 7,
     }
 
-    @@ageconvertors[:h] = @@ageconvertors[:m] * 60
-    @@ageconvertors[:d] = @@ageconvertors[:h] * 24
-    @@ageconvertors[:w] = @@ageconvertors[:d] * 7
-
     def convert(unit, multi)
-      if num = @@ageconvertors[unit]
+      if num = AgeConvertors[unit]
         return num * multi
       else
         self.fail "Invalid age unit '#{unit}'"
@@ -148,16 +147,8 @@ Puppet::Type.newtype(:tidy) do
       Only the first character is significant, so the full word can also
       be used."
 
-    @@sizeconvertors = {
-      :b => 0,
-      :k => 1,
-      :m => 2,
-      :g => 3,
-      :t => 4
-    }
-
     def convert(unit, multi)
-      if num = @@sizeconvertors[unit]
+      if num = { :b => 0, :k => 1, :m => 2, :g => 3, :t => 4 }[unit]
         result = multi
         num.times do result *= 1024 end
         return result

data/lib/puppet/type/yumrepo.rb

@@ -112,11 +112,11 @@ module Puppet
         reposdir.gsub!(/[\n,]/, " ")
         reposdir.split.each do |dir|
           Dir::glob("#{dir}/*.repo").each do |file|
-            @inifile.read(file) if File.file?(file)
+            @inifile.read(file) if ::File.file?(file)
           end
         end
         reposdir.split.each do |dir|
-          if File::directory?(dir) && File::writable?(dir)
+          if ::File.directory?(dir) && ::File.writable?(dir)
             @defaultrepodir = dir
             break
           end
@@ -138,12 +138,12 @@ module Puppet
       reposdir.gsub!(/[\n,]/, " ")
       reposdir.split.each do |dir|
         Dir::glob("#{dir}/*.repo").each do |file|
-          result.read(file) if File.file?(file)
+          result.read(file) if ::File.file?(file)
         end
       end
       if @defaultrepodir.nil?
         reposdir.split.each do |dir|
-          if File::directory?(dir) && File::writable?(dir)
+          if ::File.directory?(dir) && ::File.writable?(dir)
             @defaultrepodir = dir
             break
           end
@@ -159,7 +159,7 @@ module Puppet
       if result.nil?
         # Brand new section
         path = yumconf
-        path = File::join(@defaultrepodir, "#{name}.repo") unless @defaultrepodir.nil?
+        path = ::File.join(@defaultrepodir, "#{name}.repo") unless @defaultrepodir.nil?
         Puppet::info "create new repo #{name} in file #{path}"
         result = inifile.add_section(name, path)
       end
@@ -172,10 +172,10 @@ module Puppet
       unless Puppet[:noop]
         target_mode = 0644 # FIXME: should be configurable
         inifile.each_file do |file|
-          current_mode = File.stat(file).mode & 0777
+          current_mode = ::File.stat(file).mode & 0777
           unless current_mode == target_mode
             Puppet::info "changing mode of #{file} from %03o to %03o" % [current_mode, target_mode]
-            File.chmod(target_mode, file)
+            ::File.chmod(target_mode, file)
           end
         end
       end
@@ -357,5 +357,33 @@ module Puppet
       newvalue(:absent) { self.should = :absent }
       newvalue(/.*/) { }
     end
+
+    newproperty(:sslcacert, :parent => Puppet::IniProperty) do
+      desc "Path to the directory containing the databases of the
+        certificate authorities yum should use to verify SSL certificates.\n#{ABSENT_DOC}"
+      newvalue(:absent) { self.should = :absent }
+      newvalue(/.*/) { }
+    end
+
+    newproperty(:sslverify, :parent => Puppet::IniProperty) do
+      desc "Should yum verify SSL certificates/hosts at all.
+        Possible values are 'True' or 'False'.\n#{ABSENT_DOC}"
+      newvalue(:absent) { self.should = :absent }
+      newvalue(%r(True|False)) { }
+    end
+
+    newproperty(:sslclientcert, :parent => Puppet::IniProperty) do
+      desc "Path  to the SSL client certificate yum should use to connect
+        to repos/remote sites.\n#{ABSENT_DOC}"
+      newvalue(:absent) { self.should = :absent }
+      newvalue(/.*/) { }
+    end
+
+    newproperty(:sslclientkey, :parent => Puppet::IniProperty) do
+      desc "Path to the SSL client key yum should use to connect
+        to repos/remote sites.\n#{ABSENT_DOC}"
+      newvalue(:absent) { self.should = :absent }
+      newvalue(/.*/) { }
+    end
   end
 end

data/lib/puppet/type/zfs.rb

@@ -40,6 +40,10 @@ parent zfs instances, the zfs resource will autorequire them."
       desc "The copies property. Valid values are `1`, `2`, `3`."
     end
 
+    newproperty(:dedup) do
+      desc "The dedup property. Valid values are `on`, `off`."
+    end
+
     newproperty(:devices) do
       desc "The devices property. Valid values are `on`, `off`."
     end

data/lib/puppet/type/zone.rb

@@ -98,11 +98,7 @@ autorequire that directory."
     end
 
     def self.state_name(name)
-      if other = @state_aliases[name]
-        other
-      else
-        name
-      end
+      @state_aliases[name.to_sym] || name.to_sym
     end
 
     newvalue :absent, :down => :destroy
@@ -184,6 +180,15 @@ autorequire that directory."
       current_value = self.retrieve
       self.class.state_index(current_value) < self.class.state_index(self.should)
     end
+
+    # We override the newvalue in the parent class. Thus the values that we get from the
+    # manifest are stored as they are and later compared to the current state of the instance,
+    # which is in symbol form. Hence we have to convert this to symbol here for now.
+    # TODO: fix this so that munging is no longer necessary. see also #15886
+
+    munge do |value|
+      value.intern
+    end
   end
 
   newparam(:name) do
@@ -270,6 +275,29 @@ autorequire that directory."
     end
   end
 
+  newproperty(:path, :parent => ZoneConfigProperty) do
+    desc "The root of the zone's filesystem.  Must be a fully qualified
+      file name.  If you include `%s` in the path, then it will be
+      replaced with the zone's name.  Currently, you cannot use
+      Puppet to move a zone. Consequently this is a readonly property."
+
+    def configtext
+      "set zonepath=#{self.should}"
+    end
+
+    validate do |value|
+      raise ArgumentError, "The zone base must be fully qualified" unless value =~ /^\//
+    end
+
+    munge do |value|
+      if value =~ /%s/
+        value % @resource[:name]
+      else
+        value
+      end
+    end
+  end
+
   newproperty(:pool, :parent => ZoneConfigProperty) do
     desc "The resource pool for this zone."
 
@@ -374,27 +402,6 @@ autorequire that directory."
       so Puppet only checks for it at that time.}
   end
 
-  newparam(:path) do
-    desc "The root of the zone's filesystem.  Must be a fully qualified
-      file name.  If you include `%s` in the path, then it will be
-      replaced with the zone's name.  Currently, you cannot use
-      Puppet to move a zone."
-
-    validate do |value|
-      unless value =~ /^\//
-        raise ArgumentError, "The zone base must be fully qualified"
-      end
-    end
-
-    munge do |value|
-      if value =~ /%s/
-        value % @resource[:name]
-      else
-        value
-      end
-    end
-  end
-
   newparam(:create_args) do
     desc "Arguments to the `zonecfg` create command.  This can be used to create branded zones."
   end
@@ -440,22 +447,25 @@ autorequire that directory."
       self.fail "'#{ip}' is an invalid #{name}"
   end
 
+  def validate_exclusive(interface, address, router)
+    return if !interface.nil? and address.nil?
+    self.fail "only interface may be specified when using exclusive IP stack: #{interface}:#{address}"
+  end
+  def validate_shared(interface, address, router)
+    self.fail "ip must contain interface name and ip address separated by a \":\"" if interface.nil? or address.nil?
+    [address, router].each do |ip|
+      validate_ip(address, "IP address") unless ip.nil?
+    end
+  end
+
   validate do
-    value = self[:ip]
-    interface, address, defrouter = value.split(':')
+    return unless self[:ip]
+    interface, address, router = self[:ip].split(':')
     if self[:iptype] == :shared
-      if (interface && address && defrouter.nil?) ||
-        (interface && address && defrouter)
-        validate_ip(address, "IP address")
-        validate_ip(defrouter, "default router")
-      else
-        self.fail "ip must contain interface name and ip address separated by a \":\""
-      end
+      validate_shared(interface, address, router)
     else
-      self.fail "only interface may be specified when using exclusive IP stack: #{value}" unless interface && address.nil? && defrouter.nil?
+      validate_exclusive(interface, address, router)
     end
-
-    self.fail "zone path is required" unless self[:path]
   end
 
   def retrieve

data/lib/puppet/util.rb

@@ -1,8 +1,8 @@
 # A module to collect utility functions.
 
 require 'English'
-require 'puppet/util/monkey_patches'
 require 'puppet/external/lock'
+require 'puppet/error'
 require 'puppet/util/execution_stub'
 require 'uri'
 require 'sync'
@@ -13,11 +13,8 @@ require 'ostruct'
 require 'puppet/util/platform'
 
 module Puppet
-  # A command failed to execute.
-  require 'puppet/error'
-  class ExecutionFailure < Puppet::Error
-  end
 module Util
+  require 'puppet/util/monkey_patches'
   require 'benchmark'
 
   # These are all for backward compatibility -- these are methods that used
@@ -27,6 +24,7 @@ module Util
 
   @@sync_objects = {}.extend MonitorMixin
 
+
   def self.activerecord_version
     if (defined?(::ActiveRecord) and defined?(::ActiveRecord::VERSION) and defined?(::ActiveRecord::VERSION::MAJOR) and defined?(::ActiveRecord::VERSION::MINOR))
       ([::ActiveRecord::VERSION::MAJOR, ::ActiveRecord::VERSION::MINOR].join('.').to_f)
@@ -35,6 +33,36 @@ module Util
     end
   end
 
+
+  # Run some code with a specific environment.  Resets the environment back to
+  # what it was at the end of the code.
+  def self.withenv(hash)
+    saved = ENV.to_hash
+    hash.each do |name, val|
+      ENV[name.to_s] = val
+    end
+
+    yield
+  ensure
+    ENV.clear
+    saved.each do |name, val|
+      ENV[name] = val
+    end
+  end
+
+
+  # Execute a given chunk of code with a new umask.
+  def self.withumask(mask)
+    cur = File.umask(mask)
+
+    begin
+      yield
+    ensure
+      File.umask(cur)
+    end
+  end
+
+
   def self.synchronize_on(x,type)
     sync_object,users = 0,1
     begin
@@ -122,16 +150,6 @@ module Util
     end
   end
 
-  # Execute a given chunk of code with a new umask.
-  def self.withumask(mask)
-    cur = File.umask(mask)
-
-    begin
-      yield
-    ensure
-      File.umask(cur)
-    end
-  end
 
   def benchmark(*args)
     msg = args.pop
@@ -174,6 +192,21 @@ module Util
       ENV['PATH'].split(File::PATH_SEPARATOR).each do |dir|
         begin
           dest = File.expand_path(File.join(dir, bin))
+        rescue ArgumentError => e
+          # if the user's PATH contains a literal tilde (~) character and HOME is not set, we may get
+          # an ArgumentError here.  Let's check to see if that is the case; if not, re-raise whatever error
+          # was thrown.
+          if e.to_s =~ /HOME/ and (ENV['HOME'].nil? || ENV['HOME'] == "")
+            # if we get here they have a tilde in their PATH.  We'll issue a single warning about this and then
+            # ignore this path element and carry on with our lives.
+            Puppet::Util::Warnings.warnonce("PATH contains a ~ character, and HOME is not set; ignoring PATH element '#{dir}'.")
+          elsif e.to_s =~ /doesn't exist|can't find user/
+            # ...otherwise, we just skip the non-existent entry, and do nothing.
+            Puppet::Util::Warnings.warnonce("Couldn't expand PATH containing a ~ character; ignoring PATH element '#{dir}'.")
+          else
+            raise
+          end
+        else
           if Puppet.features.microsoft_windows? && File.extname(dest).empty?
             exts = ENV['PATHEXT']
             exts = exts ? exts.split(File::PATH_SEPARATOR) : %w[.COM .EXE .BAT .CMD]
@@ -183,9 +216,6 @@ module Util
             end
           end
           return dest if FileTest.file? dest and FileTest.executable? dest
-        rescue ArgumentError => e
-          raise unless e.to_s =~ /doesn't exist|can't find user/
-          # ...otherwise, we just skip the non-existent entry, and do nothing.
         end
       end
     end
@@ -202,17 +232,9 @@ module Util
   AbsolutePathWindows = %r!^(?:(?:[A-Z]:#{slash})|(?:#{slash}#{slash}#{label}#{slash}#{label})|(?:#{slash}#{slash}\?#{slash}#{label}))!io
   AbsolutePathPosix   = %r!^/!
   def absolute_path?(path, platform=nil)
-    # When running an internal subcommand (Application), the app requires puppet
-    # which loads features, which creates an autoloader, which calls this method.
-    # In that case, it isn't necessary to require puppet. When running an external
-    # subcommand or if none was specified, then the CommandLine will call the
-    # `which` method to resolve the external executable, and that requires features.
-    # Rather then moving this require to handle the external subcommand case, or
-    # no subcommand case, I'm undoing the performance change from 20efe94. This
-    # code has been eliminated in 3.x since puppet can be required before loading
-    # the application (since the default vardir/confdir locations are solely
-    # based on user vs. system user, and not the application's run_mode).
-    require 'puppet'
+    # Due to weird load order issues, I was unable to remove this require.
+    # This is fixed in Telly so it can be removed there.
+    require 'puppet' unless defined?(Puppet)
 
     # Ruby only sets File::ALT_SEPARATOR on Windows and the Ruby standard
     # library uses that to test what platform it's on.  Normally in Puppet we
@@ -278,72 +300,6 @@ module Util
   end
   module_function :uri_to_path
 
-  # Execute the provided command with STDIN connected to a pipe, yielding the
-  # pipe object.  That allows data to be fed to that subprocess.
-  #
-  # The command can be a simple string, which is executed as-is, or an Array,
-  # which is treated as a set of command arguments to pass through.#
-  #
-  # In all cases this is passed directly to the shell, and STDOUT and STDERR
-  # are connected together during execution.
-  def execpipe(command, failonfail = true)
-    if respond_to? :debug
-      debug "Executing '#{command}'"
-    else
-      Puppet.debug "Executing '#{command}'"
-    end
-
-    # Paste together an array with spaces.  We used to paste directly
-    # together, no spaces, which made for odd invocations; the user had to
-    # include whitespace between arguments.
-    #
-    # Having two spaces is really not a big drama, since this passes to the
-    # shell anyhow, while no spaces makes for a small developer cost every
-    # time this is invoked. --daniel 2012-02-13
-    command_str = command.respond_to?(:join) ? command.join(' ') : command
-    output = open("| #{command_str} 2>&1") do |pipe|
-      yield pipe
-    end
-
-    if failonfail
-      unless $CHILD_STATUS == 0
-        raise ExecutionFailure, output
-      end
-    end
-
-    output
-  end
-
-  def execfail(command, exception)
-      output = execute(command)
-      return output
-  rescue ExecutionFailure
-      raise exception, output
-  end
-
-  def execute_posix(command, arguments, stdin, stdout, stderr)
-    child_pid = safe_posix_fork(stdin, stdout, stderr) do
-      # We can't just call Array(command), and rely on it returning
-      # things like ['foo'], when passed ['foo'], because
-      # Array(command) will call command.to_a internally, which when
-      # given a string can end up doing Very Bad Things(TM), such as
-      # turning "/tmp/foo;\r\n /bin/echo" into ["/tmp/foo;\r\n", " /bin/echo"]
-      command = [command].flatten
-      Process.setsid
-      begin
-        Puppet::Util::SUIDManager.change_privileges(arguments[:uid], arguments[:gid], true)
-
-        ENV['LANG'] = ENV['LC_ALL'] = ENV['LC_MESSAGES'] = ENV['LANGUAGE'] = 'C'
-        Kernel.exec(*command)
-      rescue => detail
-        puts detail.to_s
-        exit!(1)
-      end
-    end
-    child_pid
-  end
-  module_function :execute_posix
-
   def safe_posix_fork(stdin=$stdin, stdout=$stdout, stderr=$stderr, &block)
     child_pid = Kernel.fork do
       $stdin.reopen(stdin)
@@ -358,105 +314,11 @@ module Util
   end
   module_function :safe_posix_fork
 
-  def execute_windows(command, arguments, stdin, stdout, stderr)
-    command = command.map do |part|
-      part.include?(' ') ? %Q["#{part.gsub(/"/, '\"')}"] : part
-    end.join(" ") if command.is_a?(Array)
-
-    Puppet::Util::Windows::Process.execute(command, arguments, stdin, stdout, stderr)
-  end
-  module_function :execute_windows
-
-  # Execute the desired command, and return the status and output.
-  # def execute(command, failonfail = true, uid = nil, gid = nil)
-  # :combine sets whether or not to combine stdout/stderr in the output
-  # :stdinfile sets a file that can be used for stdin. Passing a string
-  # for stdin is not currently supported.
-  def execute(command, arguments = {:failonfail => true, :combine => true})
-    if command.is_a?(Array)
-      command = command.flatten.map(&:to_s)
-      str = command.join(" ")
-    elsif command.is_a?(String)
-      str = command
-    end
-
-    if respond_to? :debug
-      debug "Executing '#{str}'"
-    else
-      Puppet.debug "Executing '#{str}'"
-    end
-
-    null_file = Puppet.features.microsoft_windows? ? 'NUL' : '/dev/null'
-
-    stdin = File.open(arguments[:stdinfile] || null_file, 'r')
-    stdout = arguments[:squelch] ? File.open(null_file, 'w') : Tempfile.new('puppet')
-    stderr = arguments[:combine] ? stdout : File.open(null_file, 'w')
-
-    exec_args = [command, arguments, stdin, stdout, stderr]
-
-    if execution_stub = Puppet::Util::ExecutionStub.current_value
-      return execution_stub.call(*exec_args)
-    elsif Puppet.features.posix?
-      child_pid = execute_posix(*exec_args)
-      exit_status = Process.waitpid2(child_pid).last.exitstatus
-    elsif Puppet.features.microsoft_windows?
-      process_info = execute_windows(*exec_args)
-      begin
-        exit_status = Puppet::Util::Windows::Process.wait_process(process_info.process_handle)
-      ensure
-        Process.CloseHandle(process_info.process_handle)
-        Process.CloseHandle(process_info.thread_handle)
-      end
-    end
-
-    [stdin, stdout, stderr].each {|io| io.close rescue nil}
-
-    # read output in if required
-    unless arguments[:squelch]
-      output = wait_for_output(stdout)
-      Puppet.warning "Could not get output" unless output
-    end
-
-    if arguments[:failonfail] and exit_status != 0
-      raise ExecutionFailure, "Execution of '#{str}' returned #{exit_status}: #{output}"
-    end
-
-    output
-  end
-
-  module_function :execute
-
-  def wait_for_output(stdout)
-    # Make sure the file's actually been written.  This is basically a race
-    # condition, and is probably a horrible way to handle it, but, well, oh
-    # well.
-    2.times do |try|
-      if File.exists?(stdout.path)
-        stdout.open
-        begin
-          return stdout.read
-        ensure
-          stdout.close
-          stdout.unlink
-        end
-      else
-        time_to_sleep = try / 2.0
-        Puppet.warning "Waiting for output; will sleep #{time_to_sleep} seconds"
-        sleep(time_to_sleep)
-      end
-    end
-    nil
-  end
-  module_function :wait_for_output
-
   # Create an exclusive lock.
   def threadlock(resource, type = Sync::EX)
     Puppet::Util.synchronize_on(resource,type) { yield }
   end
 
-  # Because some modules provide their own version of this method.
-  alias util_execute execute
-
   module_function :benchmark
 
   def memory
@@ -470,38 +332,15 @@ module Util
     end
   end
 
-  def symbolize(value)
-    Puppet.deprecation_warning "symbolize is deprecated. Call the intern method on the object instead."
-    if value.respond_to? :intern
-      value.intern
-    else
-      value
-    end
-  end
-
   def symbolizehash(hash)
     newhash = {}
     hash.each do |name, val|
-      if name.is_a? String
-        newhash[name.intern] = val
-      else
-        newhash[name] = val
-      end
+      name = name.intern if name.respond_to? :intern
+      newhash[name] = val
     end
     newhash
   end
-
-  def symbolizehash!(hash)
-    Puppet.deprecation_warning "symbolizehash! is deprecated. Use the non-destructive symbolizehash method instead."
-    # this is not the most memory-friendly way to accomplish this, but the
-    #  code re-use and clarity seems worthwhile.
-    newhash = symbolizehash(hash)
-    hash.clear
-    hash.merge!(newhash)
-
-    hash
-  end
-  module_function :symbolize, :symbolizehash, :symbolizehash!
+  module_function :symbolizehash
 
   # Just benchmark, with no logging.
   def thinmark
@@ -520,6 +359,36 @@ module Util
   end
   module_function :binread
 
+  # utility method to get the current call stack and format it to a human-readable string (which some IDEs/editors
+  # will recognize as links to the line numbers in the trace)
+  def self.pretty_backtrace(backtrace = caller(1))
+    backtrace.collect do |line|
+      file_path, line_num = line.split(":")
+      file_path = expand_symlinks(File.expand_path(file_path))
+
+      file_path + ":" + line_num
+    end .join("\n")
+
+  end
+
+  # utility method that takes a path as input, checks each component of the path to see if it is a symlink, and expands
+  # it if it is.  returns the expanded path.
+  def self.expand_symlinks(file_path)
+    file_path.split("/").inject do |full_path, next_dir|
+      next_path = full_path + "/" + next_dir
+      if File.symlink?(next_path) then
+        link = File.readlink(next_path)
+        next_path =
+            case link
+              when /^\// then link
+              else
+                File.expand_path(full_path + "/" + link)
+            end
+      end
+      next_path
+    end
+  end
+
   # Replace a file, securely.  This takes a block, and passes it the file
   # handle of a file open for writing.  Write the replacement content inside
   # the block and it will safely replace the target file.
@@ -538,21 +407,9 @@ module Util
   # The default_mode is the mode to use when the target file doesn't already
   # exist; if the file is present we copy the existing mode/owner/group values
   # across.
-
-  DEFAULT_POSIX_MODE = 0644
-  DEFAULT_WINDOWS_MODE = nil
-
   def replace_file(file, default_mode, &block)
     raise Puppet::DevError, "replace_file requires a block" unless block_given?
 
-    unless default_mode
-      if Puppet.features.microsoft_windows?
-        default_mode = DEFAULT_WINDOWS_MODE
-      else
-        default_mode = DEFAULT_POSIX_MODE
-      end
-    end
-
     file     = Pathname(file)
     tempfile = Tempfile.new(file.basename.to_s, file.dirname.to_s)
 
@@ -566,21 +423,16 @@ module Util
     # and specifically handle the platform, which has all sorts of magic.
     # So, unlike Unix, we don't pre-prep security; we use the default "quite
     # secure" tempfile permissions instead.  Magic happens later.
-    if !Puppet.features.microsoft_windows?
+    unless Puppet.features.microsoft_windows?
       # Grab the current file mode, and fall back to the defaults.
-      if file.exist?
-        stat = file.lstat
-        tempfile.chown(stat.uid, stat.gid)
-        effective_mode = stat.mode
-      else
-        effective_mode = default_mode
-      end
+      stat = file.lstat rescue OpenStruct.new(:mode => default_mode,
+                                              :uid  => Process.euid,
+                                              :gid  => Process.egid)
 
-      if effective_mode
-        # We only care about the bottom four slots, which make the real mode,
-        # and not the rest of the platform stat call fluff and stuff.
-        tempfile.chmod(effective_mode & 07777)
-      end
+      # We only care about the bottom four slots, which make the real mode,
+      # and not the rest of the platform stat call fluff and stuff.
+      tempfile.chmod(stat.mode & 07777)
+      tempfile.chown(stat.uid, stat.gid)
     end
 
     # OK, now allow the caller to write the content of the file.
@@ -603,17 +455,41 @@ module Util
     tempfile.close
 
     if Puppet.features.microsoft_windows?
-      # Windows ReplaceFile needs a file to exist, so touch handles this
-      if !file.exist?
-        FileUtils.touch(file.to_s)
-        if default_mode
-          Puppet::Util::Windows::Security.set_mode(default_mode, file.to_s)
+      # This will appropriately clone the file, but only if the file we are
+      # replacing exists.  Which is kind of annoying; thanks Microsoft.
+      #
+      # So, to avoid getting into an infinite loop we will retry once if the
+      # file doesn't exist, but only the once...
+      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.
         end
-      end
-      # Yes, the arguments are reversed compared to the rename in the rest
-      # of the world.
-      Puppet::Util::Windows::File.replace_file(file, tempfile.path)
 
+        # Set the permissions to what we want.
+        Puppet::Util::Windows::Security.set_mode(default_mode, file.to_s)
+
+        # ...and finally retry the operation.
+        retry
+      end
     else
       File.rename(tempfile.path, file)
     end
@@ -625,9 +501,62 @@ module Util
     file
   end
   module_function :replace_file
+
+
+  # Executes a block of code, wrapped with some special exception handling.  Causes the ruby interpreter to
+  #  exit if the block throws an exception.
+  #
+  # @param [String] message a message to log if the block fails
+  # @param [Integer] code the exit code that the ruby interpreter should return if the block fails
+  # @yield
+  def exit_on_fail(message, code = 1)
+    yield
+  # First, we need to check and see if we are catching a SystemExit error.  These will be raised
+  #  when we daemonize/fork, and they do not necessarily indicate a failure case.
+  rescue SystemExit => err
+    raise err
+
+  # Now we need to catch *any* other kind of exception, because we may be calling third-party
+  #  code (e.g. webrick), and we have no idea what they might throw.
+  rescue Exception => err
+    ## NOTE: when debugging spec failures, these two lines can be very useful
+    #puts err.inspect
+    #puts Puppet::Util.pretty_backtrace(err.backtrace)
+    Puppet.log_exception(err, "Could not #{message}: #{err}")
+    Puppet::Util::Log.force_flushqueue()
+    exit(code)
+  end
+  module_function :exit_on_fail
+
+
+
+
+  #######################################################################################################
+  # Deprecated methods relating to process execution; these have been moved to Puppet::Util::Execution
+  #######################################################################################################
+
+  def execpipe(command, failonfail = true, &block)
+    Puppet.deprecation_warning("Puppet::Util.execpipe is deprecated; please use Puppet::Util::Execution.execpipe")
+    Puppet::Util::Execution.execpipe(command, failonfail, &block)
+  end
+  module_function :execpipe
+
+  def execfail(command, exception)
+    Puppet.deprecation_warning("Puppet::Util.execfail is deprecated; please use Puppet::Util::Execution.execfail")
+    Puppet::Util::Execution.execfail(command, exception)
+  end
+  module_function :execfail
+
+  def execute(command, arguments = {})
+    Puppet.deprecation_warning("Puppet::Util.execute is deprecated; please use Puppet::Util::Execution.execute")
+    Puppet::Util::Execution.execute(command, arguments)
+  end
+  module_function :execute
+
 end
 end
 
+
 require 'puppet/util/errors'
 require 'puppet/util/methodhelper'
 require 'puppet/util/metaid'