puppet 4.0.0 → 5.0.0

data/lib/puppet/provider/package/urpmi.rb

@@ -23,7 +23,7 @@ Puppet::Type.type(:package).provide :urpmi, :parent => :rpm, :source => :rpm do
     urpmi "--auto", wanted
 
     unless self.query
-      raise Puppet::Error, "Package #{self.name} was not present after trying to install it"
+      raise Puppet::Error, _("Package %{name} was not present after trying to install it") % { name: self.name }
     end
   end
 

data/lib/puppet/provider/package/windows/exe_package.rb

@@ -8,7 +8,7 @@ class Puppet::Provider::Package::Windows
     def self.from_registry(name, values)
       if valid?(name, values)
         ExePackage.new(
-          values['DisplayName'],
+          get_display_name(values),
           values['DisplayVersion'],
           values['UninstallString']
         )
@@ -18,14 +18,15 @@ class Puppet::Provider::Package::Windows
     # Is this a valid executable package we should manage?
     def self.valid?(name, values)
       # See http://community.spiceworks.com/how_to/show/2238
-      !!(values['DisplayName'] and values['DisplayName'].length > 0 and
-         values['UninstallString'] and values['UninstallString'].length > 0 and
-         values['SystemComponent'] != 1 and # DWORD
-         values['WindowsInstaller'] != 1 and # DWORD
-         name !~ /^KB[0-9]{6}/ and
-         values['ParentKeyName'] == nil and
-         values['Security Update'] == nil and
-         values['Update Rollup'] == nil and
+      displayName = get_display_name(values)
+      !!(displayName && displayName.length > 0 &&
+         values['UninstallString'] &&
+         values['UninstallString'].length > 0 &&
+         values['WindowsInstaller'] != 1 && # DWORD
+         name !~ /^KB[0-9]{6}/ &&
+         values['ParentKeyName'] == nil &&
+         values['Security Update'] == nil &&
+         values['Update Rollup'] == nil &&
          values['Hotfix'] == nil)
     end
 

data/lib/puppet/provider/package/windows/msi_package.rb

@@ -20,7 +20,7 @@ class Puppet::Provider::Package::Windows
         inst = installer
 
         if inst.ProductState(name) == INSTALLSTATE_DEFAULT
-          MsiPackage.new(values['DisplayName'],
+          MsiPackage.new(get_display_name(values),
                          values['DisplayVersion'],
                          name, # productcode
                          inst.ProductInfo(name, 'PackageCode'))
@@ -31,9 +31,9 @@ class Puppet::Provider::Package::Windows
     # Is this a valid MSI package we should manage?
     def self.valid?(name, values)
       # See http://community.spiceworks.com/how_to/show/2238
-      !!(values['DisplayName'] and values['DisplayName'].length > 0 and
-         values['SystemComponent'] != 1 and # DWORD
-         values['WindowsInstaller'] == 1 and # DWORD
+      displayName = get_display_name(values)
+      !!(displayName && displayName.length > 0 &&
+         values['WindowsInstaller'] == 1 && # DWORD
          name =~ /\A\{[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\}\Z/i)
     end
 

data/lib/puppet/provider/package/windows/package.rb

@@ -50,7 +50,7 @@ class Puppet::Provider::Package::Windows
 
     # Get the class that knows how to install this resource
     def self.installer_class(resource)
-      fail("The source parameter is required when using the Windows provider.") unless resource[:source]
+      fail(_("The source parameter is required when using the Windows provider.")) unless resource[:source]
 
       case resource[:source]
       when /\.msi"?\Z/i
@@ -58,10 +58,10 @@ class Puppet::Provider::Package::Windows
         # REMIND: what about msp, etc
         MsiPackage
       when /\.exe"?\Z/i
-        fail("The source does not exist: '#{resource[:source]}'") unless Puppet::FileSystem.exist?(resource[:source])
+        fail(_("The source does not exist: '%{source}'") % { source: resource[:source] }) unless Puppet::FileSystem.exist?(resource[:source])
         ExePackage
       else
-        fail("Don't know how to install '#{resource[:source]}'")
+        fail(_("Don't know how to install '%{source}'") % { source: resource[:source] })
       end
     end
 
@@ -71,7 +71,7 @@ class Puppet::Provider::Package::Windows
 
     def self.replace_forward_slashes(value)
       if value.include?('/')
-        value.gsub!('/', "\\") 
+        value.gsub!('/', "\\")
         Puppet.debug('Package source parameter contained /s - replaced with \\s')
       end
       value
@@ -81,6 +81,14 @@ class Puppet::Provider::Package::Windows
       value.include?(' ') ? %Q["#{value.gsub(/"/, '\"')}"] : value
     end
 
+    def self.get_display_name(values)
+      return if values.nil?
+      return values['DisplayName'] if values['DisplayName'] && values['DisplayName'].length > 0
+      return values['QuietDisplayName'] if values['QuietDisplayName'] && values['QuietDisplayName'].length > 0
+
+      ''
+    end
+
     def initialize(name, version)
       @name = name
       @version = version

data/lib/puppet/provider/package/windows.rb

@@ -75,7 +75,7 @@ Puppet::Type.type(:package).provide(:windows, :parent => Puppet::Provider::Packa
     check_result(output.exitstatus)
   end
 
-  # http://msdn.microsoft.com/en-us/library/windows/desktop/aa368542(v=vs.85).aspx
+  # https://msdn.microsoft.com/en-us/library/windows/desktop/aa368542(v=vs.85).aspx
   self::ERROR_SUCCESS                  = 0
   self::ERROR_SUCCESS_REBOOT_INITIATED = 1641
   self::ERROR_SUCCESS_REBOOT_REQUIRED  = 3010
@@ -90,17 +90,17 @@ Puppet::Type.type(:package).provide(:windows, :parent => Puppet::Provider::Packa
     when self.class::ERROR_SUCCESS
       # yeah
     when self.class::ERROR_SUCCESS_REBOOT_INITIATED
-      warning("The package #{operation}ed successfully and the system is rebooting now.")
+      warning(_("The package %{operation}ed successfully and the system is rebooting now.") % { operation: operation })
     when self.class::ERROR_SUCCESS_REBOOT_REQUIRED
-      warning("The package #{operation}ed successfully, but the system must be rebooted.")
+      warning(_("The package %{operation}ed successfully, but the system must be rebooted.") % { operation: operation })
     else
-      raise Puppet::Util::Windows::Error.new("Failed to #{operation}", hr)
+      raise Puppet::Util::Windows::Error.new(_("Failed to %{operation}") % { operation: operation }, hr)
     end
   end
 
   # This only gets called if there is a value to validate, but not if it's absent
   def validate_source(value)
-    fail("The source parameter cannot be empty when using the Windows provider.") if value.empty?
+    fail(_("The source parameter cannot be empty when using the Windows provider.")) if value.empty?
   end
 
   def install_options

data/lib/puppet/provider/package/yum.rb

@@ -11,7 +11,7 @@ Puppet::Type.type(:package).provide :yum, :parent => :rpm, :source => :rpm do
 
   has_feature :install_options, :versionable, :virtual_packages
 
-  commands :yum => "yum", :rpm => "rpm"
+  commands :cmd => "yum", :rpm => "rpm"
 
   if command('rpm')
     confine :true => begin
@@ -26,7 +26,7 @@ Puppet::Type.type(:package).provide :yum, :parent => :rpm, :source => :rpm do
   defaultfor :osfamily => :redhat
 
   def self.prefetch(packages)
-    raise Puppet::Error, "The yum provider can only be used as root" if Process.euid != 0
+    raise Puppet::Error, _("The yum provider can only be used as root") if Process.euid != 0
     super
   end
 
@@ -39,17 +39,17 @@ Puppet::Type.type(:package).provide :yum, :parent => :rpm, :source => :rpm do
   #
   # @api private
   # @param package [String] The name of the package to query
-  # @param enablerepo [Array<String>] A list of repositories to enable for this query
   # @param disablerepo [Array<String>] A list of repositories to disable for this query
+  # @param enablerepo [Array<String>] A list of repositories to enable for this query
   # @param disableexcludes [Array<String>] A list of repository excludes to disable for this query
   # @return [Hash<Symbol, String>]
-  def self.latest_package_version(package, enablerepo, disablerepo, disableexcludes)
+  def self.latest_package_version(package, disablerepo, enablerepo, disableexcludes)
 
-    key = [enablerepo, disablerepo, disableexcludes]
+    key = [disablerepo, enablerepo, disableexcludes]
 
     @latest_versions ||= {}
     if @latest_versions[key].nil?
-      @latest_versions[key] = check_updates(enablerepo, disablerepo, disableexcludes)
+      @latest_versions[key] = check_updates(disablerepo, enablerepo, disableexcludes)
     end
 
     if @latest_versions[key][package]
@@ -61,15 +61,15 @@ Puppet::Type.type(:package).provide :yum, :parent => :rpm, :source => :rpm do
   # combination of repositories to enable and disable.
   #
   # @api private
-  # @param enablerepo [Array<String>] A list of repositories to enable for this query
   # @param disablerepo [Array<String>] A list of repositories to disable for this query
+  # @param enablerepo [Array<String>] A list of repositories to enable for this query
   # @param disableexcludes [Array<String>] A list of repository excludes to disable for this query
   # @return [Hash<String, Array<Hash<String, String>>>] All packages that were
   #   found with a list of found versions for each package.
-  def self.check_updates(enablerepo, disablerepo, disableexcludes)
-    args = [command(:yum), 'check-update']
-    args.concat(enablerepo.map { |repo| ["--enablerepo=#{repo}"] }.flatten)
+  def self.check_updates(disablerepo, enablerepo, disableexcludes)
+    args = [command(:cmd), 'check-update']
     args.concat(disablerepo.map { |repo| ["--disablerepo=#{repo}"] }.flatten)
+    args.concat(enablerepo.map { |repo| ["--enablerepo=#{repo}"] }.flatten)
     args.concat(disableexcludes.map { |repo| ["--disableexcludes=#{repo}"] }.flatten)
 
     output = Puppet::Util::Execution.execute(args, :failonfail => false, :combine => false)
@@ -78,9 +78,9 @@ Puppet::Type.type(:package).provide :yum, :parent => :rpm, :source => :rpm do
     if output.exitstatus == 100
       updates = parse_updates(output)
     elsif output.exitstatus == 0
-      self.debug "yum check-update exited with 0; no package updates available."
+      self.debug "#{command(:cmd)} check-update exited with 0; no package updates available."
     else
-      self.warn "Could not check for updates, 'yum check-update' exited with #{output.exitstatus}"
+      self.warning _("Could not check for updates, '%{cmd} check-update' exited with %{status}") % { cmd: command(:cmd), status: output.exitstatus }
     end
     updates
   end
@@ -91,6 +91,7 @@ Puppet::Type.type(:package).provide :yum, :parent => :rpm, :source => :rpm do
 
     updates = Hash.new { |h, k| h[k] = [] }
     body.split.each_slice(3) do |tuple|
+      break if tuple[0] =~ /^(Obsoleting|Security:|Update)/
       hash = update_to_hash(*tuple[0..1])
       # Create entries for both the package name without a version and a
       # version since yum considers those as mostly interchangeable.
@@ -125,11 +126,29 @@ Puppet::Type.type(:package).provide :yum, :parent => :rpm, :source => :rpm do
     @latest_versions = nil
   end
 
+  def self.error_level
+    '0'
+  end
+
+  def self.update_command
+    # In yum both `upgrade` and `update` can be used to update packages
+    # `yum upgrade` == `yum --obsoletes update`
+    # Quote the DNF docs:
+    # "Yum does this if its obsoletes config option is enabled but
+    # the behavior is not properly documented and can be harmful."
+    # So we'll stick with the safter option
+    # If a user wants to remove obsoletes, they can use { :install_options => '--obsoletes' }
+    # More detail here: https://bugzilla.redhat.com/show_bug.cgi?id=1096506
+    'update'
+  end
+
   def install
     wanted = @resource[:name]
+    error_level = self.class.error_level
+    update_command = self.class.update_command
     # If not allowing virtual packages, do a query to ensure a real package exists
     unless @resource.allow_virtual?
-      yum *['-d', '0', '-e', '0', '-y', install_options, :list, wanted].compact
+      execute([command(:cmd), '-d', '0', '-e', error_level, '-y', install_options, :list, wanted].compact)
     end
 
     should = @resource.should(:ensure)
@@ -137,47 +156,73 @@ Puppet::Type.type(:package).provide :yum, :parent => :rpm, :source => :rpm do
     operation = :install
 
     case should
+    when :latest
+      current_package = self.query
+      if current_package && !current_package[:ensure].to_s.empty?
+        operation = update_command
+        self.debug "Ensuring latest, so using #{operation}"
+      else
+        self.debug "Ensuring latest, but package is absent, so using #{:install}"
+        operation = :install
+      end
+      should = nil
     when true, false, Symbol
       # pass
       should = nil
     else
       # Add the package version
       wanted += "-#{should}"
-      is = self.query
-      if is && yum_compareEVR(yum_parse_evr(should), yum_parse_evr(is[:ensure])) < 0
-        self.debug "Downgrading package #{@resource[:name]} from version #{is[:ensure]} to #{should}"
-        operation = :downgrade
+      if wanted.scan(ARCH_REGEX)
+        self.debug "Detected Arch argument in package! - Moving arch to end of version string"
+        wanted.gsub!(/(.+)(#{ARCH_REGEX})(.+)/,'\1\3\2')
+      end
+
+      current_package = self.query
+      if current_package
+        if rpm_compareEVR(rpm_parse_evr(should), rpm_parse_evr(current_package[:ensure])) < 0
+          self.debug "Downgrading package #{@resource[:name]} from version #{current_package[:ensure]} to #{should}"
+          operation = :downgrade
+        elsif rpm_compareEVR(rpm_parse_evr(should), rpm_parse_evr(current_package[:ensure])) > 0
+          self.debug "Upgrading package #{@resource[:name]} from version #{current_package[:ensure]} to #{should}"
+          operation = update_command
+        end
       end
     end
 
-    args = ["-d", "0", "-e", "0", "-y", install_options, operation, wanted].compact
-    yum *args
+    # Yum on el-4 and el-5 returns exit status 0 when trying to install a package it doesn't recognize;
+    # ensure we capture output to check for errors.
+    no_debug = if Facter.value(:operatingsystemmajrelease).to_i > 5 then ["-d", "0"] else [] end
+    command = [command(:cmd)] + no_debug + ["-e", error_level, "-y", install_options, operation, wanted].compact
+    output = execute(command)
 
+    if output =~ /^No package #{wanted} available\.$/
+      raise Puppet::Error, _("Could not find package %{wanted}") % { wanted: wanted }
+    end
 
     # If a version was specified, query again to see if it is a matching version
     if should
       is = self.query
-      raise Puppet::Error, "Could not find package #{self.name}" unless is
+      raise Puppet::Error, _("Could not find package %{name}") % { name: self.name } unless is
 
       # FIXME: Should we raise an exception even if should == :latest
       # and yum updated us to a version other than @param_hash[:ensure] ?
-      vercmp_result = yum_compareEVR(yum_parse_evr(should), yum_parse_evr(is[:ensure]))
-      raise Puppet::Error, "Failed to update to version #{should}, got version #{is[:ensure]} instead" if vercmp_result != 0
+      vercmp_result = rpm_compareEVR(rpm_parse_evr(should), rpm_parse_evr(is[:ensure]))
+      raise Puppet::Error, _("Failed to update to version %{should}, got version %{version} instead") % { should: should, version: is[:ensure] } if vercmp_result != 0
     end
   end
 
   # What's the latest package version available?
   def latest
-    upd = self.class.latest_package_version(@resource[:name], enablerepo, disablerepo, disableexcludes)
+    upd = self.class.latest_package_version(@resource[:name], disablerepo, enablerepo, disableexcludes)
     unless upd.nil?
       # FIXME: there could be more than one update for a package
       # because of multiarch
       return "#{upd[:epoch]}:#{upd[:version]}-#{upd[:release]}"
     else
-      # Yum didn't find updates, pretend the current
-      # version is the latest
-      raise Puppet::DevError, "Tried to get latest on a missing package" if properties[:ensure] == :absent
-      return properties[:ensure]
+      # Yum didn't find updates, pretend the current version is the latest
+      version = properties[:ensure]
+      raise Puppet::DevError, "Tried to get latest on a missing package" if version == :absent || version == :purged
+      return version
     end
   end
 
@@ -187,73 +232,7 @@ Puppet::Type.type(:package).provide :yum, :parent => :rpm, :source => :rpm do
   end
 
   def purge
-    yum "-y", :erase, @resource[:name]
-  end
-
-  # parse a yum "version" specification
-  # this re-implements yum's
-  # rpmUtils.miscutils.stringToVersion() in ruby
-  def yum_parse_evr(s)
-    ei = s.index(':')
-    if ei
-      e = s[0,ei]
-      s = s[ei+1,s.length]
-    else
-      e = nil
-    end
-    e = String(Bignum(e)) rescue '0'
-    ri = s.index('-')
-    if ri
-      v = s[0,ri]
-      r = s[ri+1,s.length]
-    else
-      v = s
-      r = nil
-    end
-    return { :epoch => e, :version => v, :release => r }
-  end
-
-  # how yum compares two package versions:
-  # rpmUtils.miscutils.compareEVR(), which massages data types and then calls
-  # rpm.labelCompare(), found in rpm.git/python/header-py.c, which
-  # sets epoch to 0 if null, then compares epoch, then ver, then rel
-  # using compare_values() and returns the first non-0 result, else 0.
-  # This function combines the logic of compareEVR() and labelCompare().
-  #
-  # "version_should" can be v, v-r, or e:v-r.
-  # "version_is" will always be at least v-r, can be e:v-r
-  def yum_compareEVR(should_hash, is_hash)
-    # pass on to rpm labelCompare
-    rc = compare_values(should_hash[:epoch], is_hash[:epoch])
-    return rc unless rc == 0
-    rc = compare_values(should_hash[:version], is_hash[:version])
-    return rc unless rc == 0
-
-    # here is our special case, PUP-1244.
-    # if should_hash[:release] is nil (not specified by the user),
-    # and comparisons up to here are equal, return equal. We need to
-    # evaluate to whatever level of detail the user specified, so we
-    # don't end up upgrading or *downgrading* when not intended.
-    #
-    # This should NOT be triggered if we're trying to ensure latest.
-    return 0 if should_hash[:release].nil?
-
-    rc = compare_values(should_hash[:release], is_hash[:release])
-    return rc
-  end
-
-  # this method is a native implementation of the
-  # compare_values function in rpm's python bindings,
-  # found in python/header-py.c, as used by yum.
-  def compare_values(s1, s2)
-    if s1.nil? && s2.nil?
-      return 0
-    elsif ( not s1.nil? ) && s2.nil?
-      return 1
-    elsif s1.nil? && (not s2.nil?)
-      return -1
-    end
-    return rpmvercmp(s1, s2)
+    execute([command(:cmd), "-y", :erase, @resource[:name]])
   end
 
   private

data/lib/puppet/provider/package/zypper.rb

@@ -12,6 +12,37 @@ Puppet::Type.type(:package).provide :zypper, :parent => :rpm do
   defaultfor :operatingsystem => [:suse, :sles, :sled, :opensuse]
   confine    :operatingsystem => [:suse, :sles, :sled, :opensuse]
 
+  # @api private
+  # Reset the latest version hash to nil
+  # needed for spec tests to clear cached value
+  def self.reset!
+    @latest_versions = nil
+  end
+
+  def self.latest_package_version(package)
+    if @latest_versions.nil?
+      @latest_versions = list_updates
+    end
+
+    @latest_versions[package]
+  end
+
+  def self.list_updates
+    output = zypper 'list-updates'
+
+    avail_updates = {}
+
+    # split up columns
+    output.lines.each do |line|
+      pkg_ver = line.split(/\s*\|\s*/)
+      # ignore zypper headers
+      next unless pkg_ver[0] == 'v'
+      avail_updates[pkg_ver[2]] = pkg_ver[4]
+    end
+
+    avail_updates
+  end
+
   #on zypper versions <1.0, the version option returns 1
   #some versions of zypper output on stderr
   def zypper_version
@@ -35,10 +66,9 @@ Puppet::Type.type(:package).provide :zypper, :parent => :rpm do
     end
 
     #This has been tested with following zypper versions
-    #SLE 10.2: 0.6.104
-    #SLE 11.0: 1.0.8
-    #OpenSuse 10.2: 0.6.13
-    #OpenSuse 11.2: 1.2.8
+    #SLE 10.4: 0.6.201
+    #SLE 11.3: 1.6.307
+    #SLE 12.0: 1.11.14
     #Assume that this will work on newer zypper versions
 
     #extract version numbers and convert to integers
@@ -52,40 +82,64 @@ Puppet::Type.type(:package).provide :zypper, :parent => :rpm do
       quiet = '--quiet'
     end
 
-    options = [quiet, :install]
+    inst_opts = []
+    inst_opts = install_options if resource[:install_options]
+
+
+    options = []
+    options << quiet
+    options << '--no-gpg-check' unless inst_opts.delete('--no-gpg-check').nil?
+    options << :install
 
     #zypper 0.6.13 (OpenSuSE 10.2) does not support auto agree with licenses
     options << '--auto-agree-with-licenses' unless major < 1 and minor <= 6 and patch <= 13
     options << '--no-confirm'
-    options << '--name' unless @resource.allow_virtual? || should
-    options += install_options if resource[:install_options]
+    options += inst_opts unless inst_opts.empty?
+
+    # Zypper 0.6.201 doesn't recognize '--name'
+    # It is unclear where this functionality was introduced, but it
+    # is present as early as 1.0.13
+    options << '--name' unless major < 1 || @resource.allow_virtual? || should
     options << wanted
 
     zypper *options
 
     unless self.query
       raise Puppet::ExecutionFailure.new(
-        "Could not find package #{self.name}"
+        _("Could not find package %{name}") % { name: self.name }
       )
     end
   end
 
   # What's the latest package version available?
   def latest
-    #zypper can only get a list of *all* available packages?
-    output = zypper "list-updates"
-
-    if output =~ /#{Regexp.escape @resource[:name]}\s*\|.*?\|\s*([^\s\|]+)/
-      return $1
-    else
+    return self.class.latest_package_version(@resource[:name]) ||
       # zypper didn't find updates, pretend the current
       # version is the latest
-      return @property_hash[:ensure]
-    end
+      @property_hash[:ensure]
   end
 
   def update
     # zypper install can be used for update, too
     self.install
   end
+
+  def uninstall
+    #extract version numbers and convert to integers
+    major, minor, patch = zypper_version.scan(/\d+/).map{ |x| x.to_i }
+
+    if major < 1
+      super
+    else
+      options = [:remove, '--no-confirm']
+      if major == 1 && minor < 6
+          options << '--force-resolution'
+      end
+
+      options << @resource[:name]
+    	
+      zypper *options
+    end
+
+  end
 end

data/lib/puppet/provider/package.rb

@@ -16,8 +16,12 @@ class Puppet::Provider::Package < Puppet::Provider
   # Look up the current status.
   def properties
     if @property_hash.empty?
-      @property_hash = query || {:ensure => :absent}
-      @property_hash[:ensure] = :absent if @property_hash.empty?
+      # For providers that support purging, default to purged; otherwise default to absent
+      # Purged is the "most uninstalled" a package can be, so a purged package will be in-sync with
+      # either `ensure => absent` or `ensure => purged`; an absent package will be out of sync with `ensure => purged`.
+      default_status = self.class.feature?(:purgeable) ? :purged : :absent
+      @property_hash = query || { :ensure => ( default_status )}
+      @property_hash[:ensure] = default_status if @property_hash.empty?
     end
     @property_hash.dup
   end

data/lib/puppet/provider/parsedfile.rb

@@ -109,7 +109,7 @@ class Puppet::Provider::ParsedFile < Puppet::Provider
   # An optional regular expression matched by third party headers.
   #
   # For example, this can be used to filter the vixie cron headers as
-  # erronously exported by older cron versions.
+  # erroneously exported by older cron versions.
   #
   # @api private
   # @abstract Providers based on ParsedFile may implement this to make it
@@ -120,7 +120,7 @@ class Puppet::Provider::ParsedFile < Puppet::Provider
   #   The expression must be tailored to match exactly one third party header.
   # @see drop_native_header
   # @note When specifying regular expressions in multiline mode, avoid
-  #   greedy repititions such as '.*' (use .*? instead). Otherwise, the
+  #   greedy repetitions such as '.*' (use .*? instead). Otherwise, the
   #   provider may drop file content between sparse headers.
   def self.native_header_regex
     nil
@@ -265,7 +265,7 @@ class Puppet::Provider::ParsedFile < Puppet::Provider
       target_records = retrieve(target)
     rescue Puppet::Util::FileType::FileReadError => detail
       puts detail.backtrace if Puppet[:trace]
-      Puppet.err "Could not prefetch #{self.resource_type.name} provider '#{self.name}' target '#{target}': #{detail}. Treating as empty"
+      Puppet.err _("Could not prefetch %{resource} provider '%{name}' target '%{target}': %{detail}. Treating as empty") % { resource: self.resource_type.name, name: self.name, target: target, detail: detail }
       target_records = []
     end