puppet 6.0.5-x64-mingw32 → 8.8.1-x64-mingw32

data/lib/puppet/util.rb

@@ -1,135 +1,93 @@
+# frozen_string_literal: true
+
 # A module to collect utility functions.
 
 require 'English'
-require 'puppet/error'
-require 'puppet/util/execution_stub'
+require_relative '../puppet/error'
+require_relative 'util/execution_stub'
 require 'uri'
 require 'pathname'
 require 'ostruct'
-require 'puppet/util/platform'
-require 'puppet/util/symbolic_file_mode'
-require 'puppet/file_system/uniquefile'
+require_relative 'util/platform'
+require_relative 'util/windows'
+require_relative 'util/symbolic_file_mode'
+require_relative '../puppet/file_system/uniquefile'
 require 'securerandom'
-require 'puppet/util/character_encoding'
+require_relative 'util/character_encoding'
 
 module Puppet
 module Util
-  require 'puppet/util/monkey_patches'
+  require_relative 'util/monkey_patches'
   require 'benchmark'
 
   # These are all for backward compatibility -- these are methods that used
   # to be in Puppet::Util but have been moved into external modules.
-  require 'puppet/util/posix'
+  require_relative 'util/posix'
   extend Puppet::Util::POSIX
 
-  require 'puppet/util/windows/process' if Puppet::Util::Platform.windows?
+  require_relative 'util/windows/process' if Puppet::Util::Platform.windows?
 
   extend Puppet::Util::SymbolicFileMode
 
   def default_env
-    Puppet::Util::Platform.windows? ?
+    Puppet.features.microsoft_windows? ?
       :windows :
       :posix
   end
   module_function :default_env
 
-  # @param name [String] The name of the environment variable to retrieve
-  # @param mode [Symbol] Which operating system mode to use e.g. :posix or :windows.  Use nil to autodetect
-  # @return [String] Value of the specified environment variable.  nil if it does not exist
+  def create_erb(content)
+    ERB.new(content, trim_mode: '-')
+  end
+  module_function :create_erb
+
+  # @deprecated Use ENV instead
   # @api private
   def get_env(name, mode = default_env)
-    if mode == :windows
-      Puppet::Util::Windows::Process.get_environment_strings.each do |key, value |
-        if name.casecmp(key) == 0 then
-          return value
-        end
-      end
-      return nil
-    else
-      ENV[name]
-    end
+    ENV.fetch(name, nil)
   end
   module_function :get_env
 
-  # @param mode [Symbol] Which operating system mode to use e.g. :posix or :windows.  Use nil to autodetect
-  # @return [Hash] A hashtable of all environment variables
+  # @deprecated Use ENV instead
   # @api private
   def get_environment(mode = default_env)
-    case mode
-      when :posix
-        ENV.to_hash
-      when :windows
-        Puppet::Util::Windows::Process.get_environment_strings
-      else
-        raise _("Unable to retrieve the environment for mode %{mode}") % { mode: mode }
-    end
+    ENV.to_hash
   end
   module_function :get_environment
 
-  # Removes all environment variables
-  # @param mode [Symbol] Which operating system mode to use e.g. :posix or :windows.  Use nil to autodetect
+  # @deprecated Use ENV instead
   # @api private
   def clear_environment(mode = default_env)
-    case mode
-      when :posix
-        ENV.clear
-      when :windows
-        Puppet::Util::Windows::Process.get_environment_strings.each do |key, _|
-          Puppet::Util::Windows::Process.set_environment_variable(key, nil)
-        end
-      else
-        raise _("Unable to clear the environment for mode %{mode}") % { mode: mode }
-    end
+    ENV.clear
   end
   module_function :clear_environment
 
-  # @param name [String] The name of the environment variable to set
-  # @param value [String] The value to set the variable to.  nil deletes the environment variable
-  # @param mode [Symbol] Which operating system mode to use e.g. :posix or :windows.  Use nil to autodetect
+  # @deprecated Use ENV instead
   # @api private
   def set_env(name, value = nil, mode = default_env)
-    case mode
-      when :posix
-        ENV[name] = value
-      when :windows
-        Puppet::Util::Windows::Process.set_environment_variable(name,value)
-      else
-        raise _("Unable to set the environment variable %{name} for mode %{mode}") % { name: name, mode: mode }
-    end
+    ENV[name] = value
   end
   module_function :set_env
 
-  # @param name [Hash] Environment variables to merge into the existing environment.  nil values will remove the variable
-  # @param mode [Symbol] Which operating system mode to use e.g. :posix or :windows.  Use nil to autodetect
+  # @deprecated Use ENV instead
   # @api private
   def merge_environment(env_hash, mode = default_env)
-    case mode
-      when :posix
-        env_hash.each { |name, val| ENV[name.to_s] = val }
-      when :windows
-        env_hash.each do |name, val|
-          Puppet::Util::Windows::Process.set_environment_variable(name.to_s, val)
-        end
-      else
-        raise _("Unable to merge given values into the current environment for mode %{mode}") % { mode: mode }
-    end
+    ENV.merge!(hash.transform_keys(&:to_s))
   end
   module_function :merge_environment
 
   # Run some code with a specific environment.  Resets the environment back to
   # what it was at the end of the code.
-  # Windows can store Unicode chars in the environment as keys or values, but
-  # Ruby's ENV tries to roundtrip them through the local codepage, which can
-  # cause encoding problems - underlying helpers use Windows APIs on Windows
-  # see https://bugs.ruby-lang.org/issues/8822
+  #
+  # @param hash [Hash{String,Symbol => String}] Environment variables to override the current environment.
+  # @param mode [Symbol] ignored
   def withenv(hash, mode = :posix)
-    saved = get_environment(mode)
-    merge_environment(hash, mode)
-    yield
-  ensure
-    if saved
-      clear_environment(mode)
-      merge_environment(saved, mode)
+    saved = ENV.to_hash
+    begin
+      ENV.merge!(hash.transform_keys(&:to_s))
+      yield
+    ensure
+      ENV.replace(saved)
     end
   end
   module_function :withenv
@@ -145,10 +103,10 @@ module Util
     end
   end
 
-
   # Change the process to a different user
   def self.chuser
-    if group = Puppet[:group]
+    group = Puppet[:group]
+    if group
       begin
         Puppet::Util::SUIDManager.change_group(group, true)
       rescue => detail
@@ -157,11 +115,12 @@ module Util
 
         # Don't exit on failed group changes, since it's
         # not fatal
-        #exit(74)
+        # exit(74)
       end
     end
 
-    if user = Puppet[:user]
+    user = Puppet[:user]
+    if user
       begin
         Puppet::Util::SUIDManager.change_user(user, true)
       rescue => detail
@@ -218,7 +177,7 @@ module Util
                args.pop
              end
 
-    #TRANSLATORS 'benchmark' is a method name and should not be translated
+    # TRANSLATORS 'benchmark' is a method name and should not be translated
     raise Puppet::DevError, _("Failed to provide level to benchmark") unless level
 
     unless level == :none or object.respond_to? level
@@ -231,7 +190,7 @@ module Util
         yield
       }
       object.send(level, msg % { seconds: "%0.2f" % seconds })
-      return seconds
+      seconds
     else
       yield
     end
@@ -249,36 +208,34 @@ module Util
     if absolute_path?(bin)
       return bin if FileTest.file? bin and FileTest.executable? bin
     else
-      exts = Puppet::Util.get_env('PATHEXT')
+      exts = ENV.fetch('PATHEXT', nil)
       exts = exts ? exts.split(File::PATH_SEPARATOR) : %w[.COM .EXE .BAT .CMD]
-      Puppet::Util.get_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 (Puppet::Util.get_env('HOME').nil? || Puppet::Util.get_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.
-            #TRANSLATORS PATH and HOME are environment variables and should not be translated
-            Puppet::Util::Warnings.warnonce(_("PATH contains a ~ character, and HOME is not set; ignoring PATH element '%{dir}'.") % { dir: dir })
-          elsif e.to_s =~ /doesn't exist|can't find user/
-            # ...otherwise, we just skip the non-existent entry, and do nothing.
-            #TRANSLATORS PATH is an environment variable and should not be translated
-            Puppet::Util::Warnings.warnonce(_("Couldn't expand PATH containing a ~ character; ignoring PATH element '%{dir}'.") % { dir: dir })
-          else
-            raise
-          end
+      ENV.fetch('PATH').split(File::PATH_SEPARATOR).each do |dir|
+        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.fetch('HOME', nil) == "")
+          # 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.
+          # TRANSLATORS PATH and HOME are environment variables and should not be translated
+          Puppet::Util::Warnings.warnonce(_("PATH contains a ~ character, and HOME is not set; ignoring PATH element '%{dir}'.") % { dir: dir })
+        elsif e.to_s =~ /doesn't exist|can't find user/
+          # ...otherwise, we just skip the non-existent entry, and do nothing.
+          # TRANSLATORS PATH is an environment variable and should not be translated
+          Puppet::Util::Warnings.warnonce(_("Couldn't expand PATH containing a ~ character; ignoring PATH element '%{dir}'.") % { dir: dir })
         else
-          if Puppet::Util::Platform.windows? && File.extname(dest).empty?
-            exts.each do |ext|
-              destext = File.expand_path(dest + ext)
-              return destext if FileTest.file? destext and FileTest.executable? destext
-            end
+          raise
+        end
+      else
+        if Puppet::Util::Platform.windows? && File.extname(dest).empty?
+          exts.each do |ext|
+            destext = File.expand_path(dest + ext)
+            return destext if FileTest.file? destext and FileTest.executable? destext
           end
-          return dest if FileTest.file? dest and FileTest.executable? dest
         end
+        return dest if FileTest.file? dest and FileTest.executable? dest
       end
     end
     nil
@@ -291,9 +248,14 @@ module Util
   # Escape once for the string literal, and once for the regex.
   slash = '[\\\\/]'
   label = '[^\\\\/]+'
-  AbsolutePathWindows = %r!^(?:(?:[A-Z]:#{slash})|(?:#{slash}#{slash}#{label}#{slash}#{label})|(?:#{slash}#{slash}\?#{slash}#{label}))!io
-  AbsolutePathPosix   = %r!^/!
-  def absolute_path?(path, platform=nil)
+  AbsolutePathWindows = /^(?:(?:[A-Z]:#{slash})|(?:#{slash}#{slash}#{label}#{slash}#{label})|(?:#{slash}#{slash}\?#{slash}#{label}))/io
+  AbsolutePathPosix   = %r{^/}
+  def absolute_path?(path, platform = nil)
+    unless path.is_a?(String)
+      Puppet.warning("Cannot check if #{path} is an absolute path because it is a '#{path.class}' and not a String'")
+      return false
+    end
+
     # 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
     # would use Puppet.features.microsoft_windows?, but this method needs to
@@ -311,7 +273,7 @@ module Util
               raise Puppet::DevError, _("unknown platform %{platform} in absolute_path") % { platform: platform }
             end
 
-    !! (path =~ regex)
+    !!(path =~ regex)
   end
   module_function :absolute_path?
 
@@ -322,12 +284,13 @@ module Util
     params = { :scheme => 'file' }
 
     if Puppet::Util::Platform.windows?
-      path = path.gsub(/\\/, '/')
+      path = path.tr('\\', '/')
 
-      if unc = /^\/\/([^\/]+)(\/.+)/.match(path)
+      unc = %r{^//([^/]+)(/.+)}.match(path)
+      if unc
         params[:host] = unc[1]
         path = unc[2]
-      elsif path =~ /^[a-z]:\//i
+      elsif path =~ %r{^[a-z]:/}i
         path = '/' + path
       end
     end
@@ -353,13 +316,13 @@ module Util
 
     # CGI.unescape doesn't handle space rules properly in uri paths
     # URI.unescape does, but returns strings in their original encoding
-    path = URI.unescape(uri.path.encode(Encoding::UTF_8))
+    path = uri_unescape(uri.path.encode(Encoding::UTF_8))
 
     if Puppet::Util::Platform.windows? && uri.scheme == 'file'
-      if uri.host
+      if uri.host && !uri.host.empty?
         path = "//#{uri.host}" + path # UNC
       else
-        path.sub!(/^\//, '')
+        path.sub!(%r{^/}, '')
       end
     end
 
@@ -367,7 +330,7 @@ module Util
   end
   module_function :uri_to_path
 
-  RFC_3986_URI_REGEX = /^(?<scheme>([^:\/?#]+):)?(?<authority>\/\/([^\/?#]*))?(?<path>[^?#]*)(\?(?<query>[^#]*))?(#(?<fragment>.*))?$/
+  RFC_3986_URI_REGEX = %r{^(?<scheme>(?:[^:/?#]+):)?(?<authority>//(?:[^/?#]*))?(?<path>[^?#]*)(?:\?(?<query>[^#]*))?(?:#(?<fragment>.*))?$}
 
   # Percent-encodes a URI query parameter per RFC3986 - https://tools.ietf.org/html/rfc3986
   #
@@ -442,10 +405,9 @@ module Util
   #   query will encode + as %2B and space as %20
   #   fragment behaves like query
   def uri_encode(path, opts = { :allow_fragment => false })
-    raise ArgumentError.new(_('path may not be nil')) if path.nil?
+    raise ArgumentError, _('path may not be nil') if path.nil?
 
-    # ensure string starts as UTF-8 for the sake of Ruby 1.9.3
-    encoded = ''.encode!(Encoding::UTF_8)
+    encoded = ''.dup
 
     # parse uri into named matches, then reassemble properly encoded
     parts = path.match(RFC_3986_URI_REGEX)
@@ -457,10 +419,11 @@ module Util
     # + should be left unencoded
     # URI::parse and URI::Generic.build don't like paths encoded with CGI.escape
     # URI.escape does not change / to %2F and : to %3A like CGI.escape
-    encoded += URI.escape(parts[:path]) unless parts[:path].nil?
+    #
+    encoded += rfc2396_escape(parts[:path]) unless parts[:path].nil?
 
     # each query parameter
-    if !parts[:query].nil?
+    unless parts[:query].nil?
       query_string = parts[:query].split('&').map do |pair|
         # can optionally be separated by an =
         pair.split('=').map do |v|
@@ -476,8 +439,36 @@ module Util
   end
   module_function :uri_encode
 
-  def safe_posix_fork(stdin=$stdin, stdout=$stdout, stderr=$stderr, &block)
-    child_pid = Kernel.fork do
+  # From https://github.com/ruby/ruby/blob/v2_7_3/lib/uri/rfc2396_parser.rb#L24-L46
+  ALPHA = "a-zA-Z"
+  ALNUM = "#{ALPHA}\\d"
+  UNRESERVED = "\\-_.!~*'()#{ALNUM}"
+  RESERVED = ";/?:@&=+$,\\[\\]"
+  UNSAFE = Regexp.new("[^#{UNRESERVED}#{RESERVED}]").freeze
+
+  HEX = "a-fA-F\\d"
+  ESCAPED = Regexp.new("%[#{HEX}]{2}").freeze
+
+  def rfc2396_escape(str)
+    str.gsub(UNSAFE) do |match|
+      tmp = ''.dup
+      match.each_byte do |uc|
+        tmp << sprintf('%%%02X', uc)
+      end
+      tmp
+    end.force_encoding(Encoding::US_ASCII)
+  end
+  module_function :rfc2396_escape
+
+  def uri_unescape(str)
+    enc = str.encoding
+    enc = Encoding::UTF_8 if enc == Encoding::US_ASCII
+    str.gsub(ESCAPED) { [::Regexp.last_match(0)[1, 2]].pack('H2').force_encoding(enc) }
+  end
+  module_function :uri_unescape
+
+  def safe_posix_fork(stdin = $stdin, stdout = $stdout, stderr = $stderr, &block)
+    Kernel.fork do
       STDIN.reopen(stdin)
       STDOUT.reopen(stdout)
       STDERR.reopen(stderr)
@@ -489,16 +480,25 @@ module Util
       begin
         Dir.foreach('/proc/self/fd') do |f|
           if f != '.' && f != '..' && f.to_i >= 3
-            IO::new(f.to_i).close rescue nil
+            begin
+              IO.new(f.to_i).close
+            rescue
+              nil
+            end
           end
         end
-      rescue Errno::ENOENT # /proc/self/fd not found
-        3.upto(256){|fd| IO::new(fd).close rescue nil}
+      rescue Errno::ENOENT, Errno::ENOTDIR # /proc/self/fd not found, /proc/self not a dir
+        3.upto(256) { |fd|
+          begin
+            IO.new(fd).close
+          rescue
+            nil
+          end
+        }
       end
 
       block.call if block
     end
-    child_pid
   end
   module_function :safe_posix_fork
 
@@ -514,30 +514,55 @@ module Util
 
   # Just benchmark, with no logging.
   def thinmark
-    seconds = Benchmark.realtime {
+    Benchmark.realtime {
       yield
     }
-
-    seconds
   end
 
   module_function :thinmark
 
+  PUPPET_STACK_INSERTION_FRAME = /.*puppet_stack\.rb.*in.*`stack'/
+
   # 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|
-      _, path, rest = /^(.*):(\d+.*)$/.match(line).to_a
-      # If the path doesn't exist - like in one test, and like could happen in
-      # the world - we should just tolerate it and carry on. --daniel 2012-09-05
-      # Also, if we don't match, just include the whole line.
-      if path
-        path = Pathname(path).realpath rescue path
-        "#{path}:#{rest}"
+  def self.pretty_backtrace(backtrace = caller(1), puppetstack = [])
+    format_backtrace_array(backtrace, puppetstack).join("\n")
+  end
+
+  # arguments may be a Ruby stack, with an optional Puppet stack argument,
+  # or just a Puppet stack.
+  # stacks may be an Array of Strings "/foo.rb:0 in `blah'" or
+  # an Array of Arrays that represent a frame: ["/foo.pp", 0]
+  def self.format_backtrace_array(primary_stack, puppetstack = [])
+    primary_stack.flat_map do |frame|
+      frame = format_puppetstack_frame(frame) if frame.is_a?(Array)
+      primary_frame = resolve_stackframe(frame)
+
+      if primary_frame =~ PUPPET_STACK_INSERTION_FRAME && !puppetstack.empty?
+        [resolve_stackframe(format_puppetstack_frame(puppetstack.shift)),
+         primary_frame]
       else
-        line
+        primary_frame
+      end
+    end
+  end
+
+  def self.resolve_stackframe(frame)
+    _, path, rest = /^(.*):(\d+.*)$/.match(frame).to_a
+    if path
+      path = begin
+        Pathname(path).realpath
+      rescue
+        path
       end
-    end.join("\n")
+      "#{path}:#{rest}"
+    else
+      frame
+    end
+  end
+
+  def self.format_puppetstack_frame(file_and_lineno)
+    file_and_lineno.join(':')
   end
 
   # Replace a file, securely.  This takes a block, and passes it the file
@@ -551,7 +576,7 @@ module Util
   # preserved.  This works hard to avoid loss of any metadata, but will result
   # in an inode change for the file.
   #
-  # Arguments: `filename`, `default_mode`
+  # Arguments: `filename`, `default_mode`, `staging_location`
   #
   # The filename is the file we are going to replace.
   #
@@ -559,11 +584,14 @@ module Util
   # exist; if the file is present we copy the existing mode/owner/group values
   # across. The default_mode can be expressed as an octal integer, a numeric string (ie '0664')
   # or a symbolic file mode.
+  #
+  # The staging_location is a location to render the temporary file before
+  # moving the file to it's final location.
 
-  DEFAULT_POSIX_MODE = 0644
+  DEFAULT_POSIX_MODE = 0o644
   DEFAULT_WINDOWS_MODE = nil
 
-  def replace_file(file, default_mode, &block)
+  def replace_file(file, default_mode, staging_location: nil, validate_callback: nil, &block)
     raise Puppet::DevError, _("replace_file requires a block") unless block_given?
 
     if default_mode
@@ -572,31 +600,34 @@ module Util
       end
 
       mode = symbolic_mode_to_int(normalize_symbolic_mode(default_mode))
+    elsif Puppet::Util::Platform.windows?
+      mode = DEFAULT_WINDOWS_MODE
     else
-      if Puppet::Util::Platform.windows?
-        mode = DEFAULT_WINDOWS_MODE
-      else
-        mode = DEFAULT_POSIX_MODE
-      end
+      mode = DEFAULT_POSIX_MODE
     end
 
     begin
-      file     = Puppet::FileSystem.pathname(file)
+      file = Puppet::FileSystem.pathname(file)
+
       # encoding for Uniquefile is not important here because the caller writes to it as it sees fit
-      tempfile = Puppet::FileSystem::Uniquefile.new(Puppet::FileSystem.basename_string(file), Puppet::FileSystem.dir_string(file))
+      if staging_location
+        tempfile = Puppet::FileSystem::Uniquefile.new(Puppet::FileSystem.basename_string(file), staging_location)
+      else
+        tempfile = Puppet::FileSystem::Uniquefile.new(Puppet::FileSystem.basename_string(file), Puppet::FileSystem.dir_string(file))
+      end
 
       effective_mode =
-      if !Puppet::Util::Platform.windows?
-        # Grab the current file mode, and fall back to the defaults.
+        unless Puppet::Util::Platform.windows?
+          # Grab the current file mode, and fall back to the defaults.
 
-        if Puppet::FileSystem.exist?(file)
-          stat = Puppet::FileSystem.lstat(file)
-          tempfile.chown(stat.uid, stat.gid)
-          stat.mode
-        else
-          mode
+          if Puppet::FileSystem.exist?(file)
+            stat = Puppet::FileSystem.lstat(file)
+            tempfile.chown(stat.uid, stat.gid)
+            stat.mode
+          else
+            mode
+          end
         end
-      end
 
       # OK, now allow the caller to write the content of the file.
       yield tempfile
@@ -604,7 +635,7 @@ module Util
       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)
+        tempfile.chmod(effective_mode & 0o7777)
       end
 
       # Now, make sure the data (which includes the mode) is safe on disk.
@@ -623,9 +654,13 @@ module Util
 
       tempfile.close
 
+      if validate_callback
+        validate_callback.call(tempfile.path)
+      end
+
       if Puppet::Util::Platform.windows?
         # Windows ReplaceFile needs a file to exist, so touch handles this
-        if !Puppet::FileSystem.exist?(file)
+        unless Puppet::FileSystem.exist?(file)
           Puppet::FileSystem.touch(file)
           if mode
             Puppet::Util::Windows::Security.set_mode(mode, Puppet::FileSystem.path_string(file))
@@ -641,6 +676,7 @@ module Util
         if Puppet::FileSystem.exist?(file) && Puppet::FileSystem.directory?(file)
           raise Errno::EISDIR, _("Is a directory: %{directory}") % { directory: file }
         end
+
         File.rename(tempfile.path, Puppet::FileSystem.path_string(file))
       end
     ensure
@@ -651,7 +687,6 @@ module Util
       end
     end
 
-
     # Ideally, we would now fsync the directory as well, but Ruby doesn't
     # have support for that, and it doesn't matter /that/ much...
 
@@ -678,32 +713,45 @@ module Util
   #  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)
+    # puts err.inspect
+    # puts Puppet::Util.pretty_backtrace(err.backtrace)
     Puppet.log_exception(err, "#{message}: #{err}")
     Puppet::Util::Log.force_flushqueue()
     exit(code)
   end
   module_function :exit_on_fail
 
-  def deterministic_rand(seed,max)
+  def deterministic_rand(seed, max)
     deterministic_rand_int(seed, max).to_s
   end
   module_function :deterministic_rand
 
-  def deterministic_rand_int(seed,max)
+  def deterministic_rand_int(seed, max)
     Random.new(seed).rand(max)
   end
   module_function :deterministic_rand_int
+
+  # Executes a block of code, wrapped around Facter.load_external(false) and
+  # Facter.load_external(true) which will cause Facter to not evaluate external facts.
+  def skip_external_facts
+    return yield unless Puppet.runtime[:facter].load_external?
+
+    begin
+      Puppet.runtime[:facter].load_external(false)
+      yield
+    ensure
+      Puppet.runtime[:facter].load_external(true)
+    end
+  end
+  module_function :skip_external_facts
 end
 end
 
-
-require 'puppet/util/errors'
-require 'puppet/util/metaid'
-require 'puppet/util/classgen'
-require 'puppet/util/docs'
-require 'puppet/util/execution'
-require 'puppet/util/logging'
-require 'puppet/util/package'
-require 'puppet/util/warnings'
+require_relative 'util/errors'
+require_relative 'util/metaid'
+require_relative 'util/classgen'
+require_relative 'util/docs'
+require_relative 'util/execution'
+require_relative 'util/logging'
+require_relative 'util/package'
+require_relative 'util/warnings'