puppet 4.0.0 → 5.0.0

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

@@ -2,14 +2,19 @@ require 'puppet/provider/package'
 require 'fileutils'
 
 Puppet::Type.type(:package).provide :portage, :parent => Puppet::Provider::Package do
-  desc "Provides packaging support for Gentoo's portage system."
+  desc "Provides packaging support for Gentoo's portage system.
 
-  has_features :versionable, :reinstallable
+    This provider supports the `install_options` and `uninstall_options` attributes, which allows command-line
+    flags to be passed to emerge.  These options should be specified as a string (e.g. '--flag'), a hash
+    (e.g. {'--flag' => 'value'}), or an array where each element is either a string or a hash."
+
+  has_features :install_options, :purgeable, :reinstallable, :uninstall_options, :versionable, :virtual_packages
 
   {
-    :emerge => "/usr/bin/emerge",
-    :eix => "/usr/bin/eix",
-    :update_eix => "/usr/bin/eix-update",
+    :emerge => '/usr/bin/emerge',
+    :eix => '/usr/bin/eix',
+    :qatom_bin => '/usr/bin/qatom',
+    :update_eix => '/usr/bin/eix-update',
   }.each_pair do |name, path|
     has_command(name, path) do
       environment :HOME => '/'
@@ -24,14 +29,18 @@ Puppet::Type.type(:package).provide :portage, :parent => Puppet::Provider::Packa
     result_format = self.eix_result_format
     result_fields = self.eix_result_fields
 
+    limit = self.eix_limit
     version_format = self.eix_version_format
+    slot_versions_format = self.eix_slot_versions_format
+    installed_versions_format = self.eix_installed_versions_format
+    installable_versions_format = self.eix_install_versions_format
     begin
-      eix_file = File.directory?("/var/cache/eix") ? "/var/cache/eix/portage.eix" : "/var/cache/eix"
+      eix_file = File.directory?('/var/cache/eix') ? '/var/cache/eix/portage.eix' : '/var/cache/eix'
       update_eix if !FileUtils.uptodate?(eix_file, %w{/usr/bin/eix /usr/portage/metadata/timestamp})
 
       search_output = nil
-      Puppet::Util.withenv :LASTVERSION => version_format do
-        search_output = eix *(self.eix_search_arguments + ["--installed"])
+      Puppet::Util.withenv :EIX_LIMIT => limit, :LASTVERSION => version_format, :LASTSLOTVERSIONS => slot_versions_format, :INSTALLEDVERSIONS => installed_versions_format, :STABLEVERSIONS => installable_versions_format do
+        search_output = eix *(self.eix_search_arguments + ['--installed'])
       end
 
       packages = []
@@ -56,21 +65,35 @@ Puppet::Type.type(:package).provide :portage, :parent => Puppet::Provider::Packa
 
   def install
     should = @resource.should(:ensure)
-    name = package_name
-    unless should == :present or should == :latest
-      # We must install a specific version
-      name = "=#{name}-#{should}"
-    end
-    emerge name
-  end
-
-  # The common package name format.
-  def package_name
-    @resource[:category] ? "#{@resource[:category]}/#{@resource[:name]}" : @resource[:name]
+    cmd = %w{}
+    name = qatom[:category] ? "#{qatom[:category]}/#{qatom[:pn]}" : qatom[:pn]
+    name = qatom[:pfx] + name if qatom[:pfx]
+    name = name + '-' + qatom[:pv] if qatom[:pv]
+    name = name + '-' + qatom[:pr] if qatom[:pr]
+    name = name + qatom[:slot] if qatom[:slot]
+    cmd << '--update' if [:latest].include?(should)
+    cmd += install_options if @resource[:install_options]
+    cmd << name
+    emerge *cmd
   end
 
   def uninstall
-    emerge "--unmerge", package_name
+    should = @resource.should(:ensure)
+    cmd = %w{--rage-clean}
+    name = qatom[:category] ? "#{qatom[:category]}/#{qatom[:pn]}" : qatom[:pn]
+    name = qatom[:pfx] + name if qatom[:pfx]
+    name = name + '-' + qatom[:pv] if qatom[:pv]
+    name = name + '-' + qatom[:pr] if qatom[:pr]
+    name = name + qatom[:slot] if qatom[:slot]
+    cmd += uninstall_options if @resource[:uninstall_options]
+    cmd << name
+    if [:purged].include?(should)
+      Puppet::Util.withenv :CONFIG_PROTECT => "-*" do
+        emerge *cmd
+      end
+    else
+      emerge *cmd
+    end
   end
 
   def reinstall
@@ -81,21 +104,84 @@ Puppet::Type.type(:package).provide :portage, :parent => Puppet::Provider::Packa
     self.install
   end
 
+  def qatom
+    output_format = self.qatom_output_format
+    result_format = self.qatom_result_format
+    result_fields = self.qatom_result_fields
+    @atom ||= begin
+      search_output = nil
+      package_info = {}
+      # do the search
+      search_output = qatom_bin *([@resource[:name], '--format', output_format])
+      # verify if the search found anything
+      match = result_format.match(search_output)
+      if match
+        result_fields.zip(match.captures) do |field, value|
+          # some fields can be empty or (null) (if we are not passed a category in the package name for instance)
+          if value == '(null)'
+            package_info[field] = nil
+          elsif !value or value.empty?
+            package_info[field] = nil
+          else
+            package_info[field] = value
+          end
+        end
+      end
+      @atom = package_info
+    rescue Puppet::ExecutionFailure => detail
+      raise Puppet::Error.new(detail)
+    end
+  end
+
+  def qatom_output_format
+    '"[%{CATEGORY}] [%{PN}] [%{PV}] [%[PR]] [%[SLOT]] [%[pfx]] [%[sfx]]"'
+  end
+
+  def qatom_result_format
+    /^\"\[(\S*)\]\s+\[(\S*)\]\s+\[(\S*)\]\s+\[(\S*)\]\s+\[(\S*)\]\s+\[(\S*)\]\s+\[(\S*)\](.*)\"$/
+  end
+
+  def qatom_result_fields
+    [:category, :pn, :pv, :pr, :slot, :pfx, :sfx]
+  end
+
+  def self.get_sets
+    @sets ||= begin
+      @sets = emerge *(['--list-sets'])
+    end
+  end
+
   def query
+    limit = self.class.eix_limit
     result_format = self.class.eix_result_format
     result_fields = self.class.eix_result_fields
 
     version_format = self.class.eix_version_format
-    search_field = package_name.count('/') > 0 ? "--category-name" : "--name"
-    search_value = package_name
+    slot_versions_format = self.class.eix_slot_versions_format
+    installed_versions_format = self.class.eix_installed_versions_format
+    installable_versions_format = self.class.eix_install_versions_format
+    search_field = qatom[:category] ? '--category-name' : '--name'
+    search_value = qatom[:category] ? "#{qatom[:category]}/#{qatom[:pn]}" : qatom[:pn]
 
-    begin
-      eix_file = File.directory?("/var/cache/eix") ? "/var/cache/eix/portage.eix" : "/var/cache/eix"
+    @eix_result ||= begin
+      # package sets
+      package_sets = []
+      self.class.get_sets.each_line do |package_set|
+        package_sets << package_set.to_s.strip
+      end
+
+      if @resource[:name].match(/^@/)
+         if package_sets.include?(@resource[:name][1..-1].to_s)
+           return({:name => "#{@resource[:name]}", :ensure => '9999', :version_available => nil, :installed_versions => nil, :installable_versions => "9999,"})
+        end
+      end
+
+      eix_file = File.directory?('/var/cache/eix') ? '/var/cache/eix/portage.eix' : '/var/cache/eix'
       update_eix if !FileUtils.uptodate?(eix_file, %w{/usr/bin/eix /usr/portage/metadata/timestamp})
 
       search_output = nil
-      Puppet::Util.withenv :LASTVERSION => version_format do
-        search_output = eix *(self.class.eix_search_arguments + ["--exact",search_field,search_value])
+      Puppet::Util.withenv :EIX_LIMIT => limit, :LASTVERSION => version_format, :LASTSLOTVERSIONS => slot_versions_format, :INSTALLEDVERSIONS => installed_versions_format, :STABLEVERSIONS => installable_versions_format do
+        search_output = eix *(self.class.eix_search_arguments + ['--exact',search_field,search_value])
       end
 
       packages = []
@@ -107,6 +193,19 @@ Puppet::Type.type(:package).provide :portage, :parent => Puppet::Provider::Packa
           result_fields.zip(match.captures) do |field, value|
             package[field] = value unless !value or value.empty?
           end
+          # dev-lang python [3.4.5] [3.5.2] [2.7.12:2.7,3.4.5:3.4] [2.7.12:2.7,3.4.5:3.4,3.5.2:3.5] https://www.python.org/ An interpreted, interactive, object-oriented programming language
+          # version_available is what we CAN install / update to
+          # ensure is what is currently installed
+          # This DOES NOT choose to install/upgrade or not, just provides current info
+          # prefer checking versions to slots as versions are finer grained
+          if qatom[:pv]
+            package[:version_available] = eix_get_version_for_versions(package[:installable_versions], qatom[:pv])
+            package[:ensure] = eix_get_version_for_versions(package[:installed_versions], qatom[:pv])
+          elsif qatom[:slot]
+            package[:version_available] = eix_get_version_for_slot(package[:slot_versions_available], qatom[:slot])
+            package[:ensure] = eix_get_version_for_slot(package[:installed_slots], qatom[:slot])
+          end
+
           package[:ensure] = package[:ensure] ? package[:ensure] : :absent
           packages << package
         end
@@ -114,12 +213,11 @@ Puppet::Type.type(:package).provide :portage, :parent => Puppet::Provider::Packa
 
       case packages.size
         when 0
-          not_found_value = "#{@resource[:category] ? @resource[:category] : "<unspecified category>"}/#{@resource[:name]}"
-          raise Puppet::Error.new("No package found with the specified name [#{not_found_value}]")
+          raise Puppet::Error.new(_("No package found with the specified name [%{name}]") % { name: @resource[:name] })
         when 1
-          return packages[0]
+          @eix_result = packages[0]
         else
-          raise Puppet::Error.new("More than one package with the specified name [#{search_value}], please use the category parameter to disambiguate")
+          raise Puppet::Error.new(_("More than one package with the specified name [%{search_value}], please use the category parameter to disambiguate") % { search_value: search_value })
       end
     rescue Puppet::ExecutionFailure => detail
       raise Puppet::Error.new(detail)
@@ -131,23 +229,73 @@ Puppet::Type.type(:package).provide :portage, :parent => Puppet::Provider::Packa
   end
 
   private
+  def eix_get_version_for_versions(versions, target)
+    # [2.7.10-r1,2.7.12,3.4.3-r1,3.4.5,3.5.2] 3.5.2
+    return nil if versions.nil?
+    versions = versions.split(',')
+    # [2.7.10-r1 2.7.12 3.4.3-r1 3.4.5 3.5.2]
+    versions.find { |version| version == target }
+    # 3.5.2
+  end
+
+  private
+  def eix_get_version_for_slot(versions_and_slots, slot)
+    # [2.7.12:2.7 3.4.5:3.4 3.5.2:3.5] 3.5
+    return nil if versions_and_slots.nil?
+    versions_and_slots = versions_and_slots.split(',')
+    # [2.7.12:2.7 3.4.5:3.4 3.5.2:3.5]
+    versions_and_slots.map! { |version_and_slot| version_and_slot.split(':') }
+    # [2.7.12: 2.7
+    #  3.4.5:  3.4
+    #  3.5.2:  3.5]
+    version_for_slot = versions_and_slots.find { |version_and_slot| version_and_slot.last == slot[1..-1] }
+    # [3.5.2:  3.5]
+    version_for_slot.first if version_for_slot
+    # 3.5.2
+  end
+
   def self.eix_search_format
-    "'<category> <name> [<installedversions:LASTVERSION>] [<bestversion:LASTVERSION>] <homepage> <description>'"
+    "'<category> <name> [<installedversions:LASTVERSION>] [<bestversion:LASTVERSION>] [<installedversions:LASTSLOTVERSIONS>] [<installedversions:INSTALLEDVERSIONS>] [<availableversions:STABLEVERSIONS>] [<bestslotversions:LASTSLOTVERSIONS>] <homepage> <description>\n'"
   end
 
   def self.eix_result_format
-    /^(\S+)\s+(\S+)\s+\[(\S*)\]\s+\[(\S*)\]\s+(\S+)\s+(.*)$/
+    /^(\S+)\s+(\S+)\s+\[(\S*)\]\s+\[(\S*)\]\s+\[(\S*)\]\s+\[(\S*)\]\s+\[(\S*)\]\s+\[(\S*)\]\s+(\S+)\s+(.*)$/
   end
 
   def self.eix_result_fields
-    [:category, :name, :ensure, :version_available, :vendor, :description]
+    # ensure:[3.4.5], version_available:[3.5.2], installed_slots:[2.7.12:2.7,3.4.5:3.4], installable_versions:[2.7.10-r1,2.7.12,3.4.3-r1,3.4.5,3.5.2] slot_versions_available:[2.7.12:2.7,3.4.5:3.4,3.5.2:3.5]
+    [:category, :name, :ensure, :version_available, :installed_slots, :installed_versions, :installable_versions, :slot_versions_available, :vendor, :description]
   end
 
   def self.eix_version_format
-    "{last}<version>{}"
+    '{last}<version>{}'
+  end
+
+  def self.eix_slot_versions_format
+    '{!first},{}<version>:<slot>'
+  end
+
+  def self.eix_installed_versions_format
+    '{!first},{}<version>'
+  end
+
+  def self.eix_install_versions_format
+    '{!first}{!last},{}{}{isstable}<version>{}'
+  end
+
+  def self.eix_limit
+    '0'
   end
 
   def self.eix_search_arguments
-    ["--nocolor", "--pure-packages", "--format",self.eix_search_format]
+    ['--nocolor', '--pure-packages', '--format', self.eix_search_format]
+  end
+
+  def install_options
+    join_options(@resource[:install_options])
+  end
+
+  def uninstall_options
+    join_options(@resource[:uninstall_options])
   end
 end

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

@@ -6,9 +6,6 @@ Puppet::Type.type(:package).provide :ports, :parent => :freebsd, :source => :fre
     :portuninstall => "/usr/local/sbin/pkg_deinstall",
     :portinfo => "/usr/sbin/pkg_info"
 
-  defaultfor :operatingsystem => :freebsd
-
-  # I hate ports
   %w{INTERACTIVE UNAME}.each do |var|
     ENV.delete(var) if ENV.include?(var)
   end
@@ -20,7 +17,7 @@ Puppet::Type.type(:package).provide :ports, :parent => :freebsd, :source => :fre
 
     output = portupgrade(*cmd)
     if output =~ /\*\* No such /
-      raise Puppet::ExecutionFailure, "Could not find package #{@resource[:name]}"
+      raise Puppet::ExecutionFailure, _("Could not find package %{name}") % { name: @resource[:name] }
     end
   end
 
@@ -46,7 +43,7 @@ Puppet::Type.type(:package).provide :ports, :parent => :freebsd, :source => :fre
 
     unless pkgstuff =~ /^\S+-([^-\s]+)$/
       raise Puppet::Error,
-        "Could not match package info '#{pkgstuff}'"
+        _("Could not match package info '%{pkgstuff}'") % { pkgstuff: pkgstuff }
     end
 
     version = $1
@@ -60,7 +57,7 @@ Puppet::Type.type(:package).provide :ports, :parent => :freebsd, :source => :fre
 
     unless info =~ /\((\w+) has (.+)\)/
       raise Puppet::Error,
-        "Could not match version info '#{info}'"
+        _("Could not match version info '%{info}'") % { info: info }
     end
 
     source, newversion = $1, $2

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

@@ -90,7 +90,7 @@ Puppet::Type.type(:package).provide :portupgrade, :parent => Puppet::Provider::P
     end
 
     if output =~ /\*\* No such /
-      raise Puppet::ExecutionFailure, "Could not find package #{@resource[:name]}"
+      raise Puppet::ExecutionFailure, _("Could not find package %{name}") % { name: @resource[:name] }
     end
 
     # No return code required, so do nil to be clean
@@ -148,10 +148,10 @@ Puppet::Type.type(:package).provide :portupgrade, :parent => Puppet::Provider::P
       # Seriously - this section should never be called in a perfect world.
       # as verification that the port is installed has already happened in query.
       if output =~ /^\*\* No matching package /
-        raise Puppet::ExecutionFailure, "Could not find package #{@resource[:name]}"
+        raise Puppet::ExecutionFailure, _("Could not find package %{name}") % { name: @resource[:name] }
       else
         # Any other error (dump output to log)
-        raise Puppet::ExecutionFailure, "Unexpected output from portversion: #{output}"
+        raise Puppet::ExecutionFailure, _("Unexpected output from portversion: %{output}") % { output: output }
       end
 
       # Just in case we still are running, return nil
@@ -160,7 +160,7 @@ Puppet::Type.type(:package).provide :portupgrade, :parent => Puppet::Provider::P
 
     # At this point normal operation has finished and we shouldn't have been called.
     # Error out and let the admin deal with it.
-    raise Puppet::Error, "portversion.latest() - fatal error with portversion: #{output}"
+    raise Puppet::Error, _("portversion.latest() - fatal error with portversion: %{output}") % { output: output }
   end
 
   ###### Query subcommand - return a hash of details if exists, or nil if it doesn't.

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

@@ -19,9 +19,34 @@ Puppet::Type.type(:package).provide :rpm, :source => :rpm, :parent => Puppet::Pr
   # eventually become this Puppet::Type::Package::ProviderRpm class.
   # The query format by which we identify installed packages
   self::NEVRA_FORMAT = %Q{%{NAME} %|EPOCH?{%{EPOCH}}:{0}| %{VERSION} %{RELEASE} %{ARCH}\\n}
-  self::NEVRA_REGEX  = %r{^(\S+) (\S+) (\S+) (\S+) (\S+)$}
+  self::NEVRA_REGEX  = %r{^'?(\S+) (\S+) (\S+) (\S+) (\S+)$}
   self::NEVRA_FIELDS = [:name, :epoch, :version, :release, :arch]
 
+  ARCH_LIST = [
+    'noarch',
+    'i386',
+    'i686',
+    'ppc',
+    'ppc64',
+    'armv3l',
+    'armv4b',
+    'armv4l',
+    'armv4tl',
+    'armv5tel',
+    'armv5tejl',
+    'armv6l',
+    'armv7l',
+    'm68kmint',
+    's390',
+    's390x',
+    'ia64',
+    'x86_64',
+    'sh3',
+    'sh4',
+  ]
+
+  ARCH_REGEX = Regexp.new(ARCH_LIST.join('|\.'))
+
   commands :rpm => "rpm"
 
   if command('rpm')
@@ -63,7 +88,7 @@ Puppet::Type.type(:package).provide :rpm, :source => :rpm, :parent => Puppet::Pr
         }
       }
     rescue Puppet::ExecutionFailure
-      raise Puppet::Error, "Failed to list packages", $!.backtrace
+      raise Puppet::Error, _("Failed to list packages"), $!.backtrace
     end
 
     packages
@@ -76,7 +101,7 @@ Puppet::Type.type(:package).provide :rpm, :source => :rpm, :parent => Puppet::Pr
     #NOTE: Prior to a fix for issue 1243, this method potentially returned a cached value
     #IF YOU CALL THIS METHOD, IT WILL CALL RPM
     #Use get(:property) to check if cached values are available
-    cmd = ["-q",  @resource[:name], "#{self.class.nosignature}", "#{self.class.nodigest}", "--qf", self.class::NEVRA_FORMAT]
+    cmd = ["-q",  @resource[:name], "#{self.class.nosignature}", "#{self.class.nodigest}", "--qf", "'#{self.class::NEVRA_FORMAT}'"]
 
     begin
       output = rpm(*cmd)
@@ -103,27 +128,28 @@ Puppet::Type.type(:package).provide :rpm, :source => :rpm, :parent => Puppet::Pr
   # Here we just retrieve the version from the file specified in the source.
   def latest
     unless source = @resource[:source]
-      @resource.fail "RPMs must specify a package source"
+      @resource.fail _("RPMs must specify a package source")
     end
 
-    cmd = [command(:rpm), "-q", "--qf", self.class::NEVRA_FORMAT, "-p", source]
-    h = self.class.nevra_to_hash(execfail(cmd, Puppet::Error))
+    cmd = [command(:rpm), "-q", "--qf", "'#{self.class::NEVRA_FORMAT}'", "-p", source]
+    h = self.class.nevra_to_hash(execute(cmd))
     h[:ensure]
+  rescue Puppet::ExecutionFailure => e
+    raise Puppet::Error, e.message, e.backtrace
   end
 
   def install
     unless source = @resource[:source]
-      @resource.fail "RPMs must specify a package source"
-    end
-    # RPM gets pissy if you try to install an already
-    # installed package
-    if @resource.should(:ensure) == @property_hash[:ensure] or
-      @resource.should(:ensure) == :latest && @property_hash[:ensure] == latest
-      return
+      @resource.fail _("RPMs must specify a package source")
     end
 
+    version =  @property_hash[:ensure]
+
+    # RPM gets upset if you try to install an already installed package
+    return if @resource.should(:ensure) == version || (@resource.should(:ensure) == :latest && version == latest)
+
     flag = ["-i"]
-    flag = ["-U", "--oldpackage"] if @property_hash[:ensure] and @property_hash[:ensure] != :absent
+    flag = ["-U", "--oldpackage"] if version && (version != :absent && version != :purged)
     flag += install_options if resource[:install_options]
     rpm flag, source
   end
@@ -184,14 +210,9 @@ Puppet::Type.type(:package).provide :rpm, :source => :rpm, :parent => Puppet::Pr
     return 0 if str1 == str2
 
     front_strip_re = /^[^A-Za-z0-9~]+/
-    segment_re = /^[A-Za-z0-9]/
-    # these represent RPM rpmio/rpmstring.c functions
-    risalnum = /[A-Za-z0-9]/
-    risdigit = /^[0-9]+/
-    risalpha = /[A-Za-z]/
 
     while str1.length > 0 or str2.length > 0
-      # trim anything that's !risalnum() and != '~' off the beginning of each string
+      # trim anything that's in front_strip_re and != '~' off the beginning of each string
       str1 = str1.gsub(front_strip_re, '')
       str2 = str2.gsub(front_strip_re, '')
 
@@ -200,6 +221,7 @@ Puppet::Type.type(:package).provide :rpm, :source => :rpm, :parent => Puppet::Pr
         # if they both have ~, strip it
         str1 = str1[1..-1]
         str2 = str2[1..-1]
+        next
       elsif /^~/.match(str1)
         return -1
       elsif /^~/.match(str2)
@@ -211,7 +233,7 @@ Puppet::Type.type(:package).provide :rpm, :source => :rpm, :parent => Puppet::Pr
       # "grab first completely alpha or completely numeric segment"
       isnum = false
       # if the first char of str1 is a digit, grab the chunk of continuous digits from each string
-      if risdigit.match(str1)
+      if /^[0-9]+/.match(str1)
         if str1 =~ /^[0-9]+/
           segment1 = $~.to_s
           str1 = $~.post_match
@@ -274,6 +296,92 @@ Puppet::Type.type(:package).provide :rpm, :source => :rpm, :parent => Puppet::Pr
     end
   end
 
+  def insync?(is)
+    return false if [:purged, :absent].include?(is)
+    should = resource[:ensure]
+    0 == rpm_compareEVR(rpm_parse_evr(should), rpm_parse_evr(is))
+  end
+
+  # parse a rpm "version" specification
+  # this re-implements rpm's
+  # rpmUtils.miscutils.stringToVersion() in ruby
+  def rpm_parse_evr(s)
+    ei = s.index(':')
+    if ei
+      e = s[0,ei]
+      s = s[ei+1,s.length]
+    else
+      e = nil
+    end
+    begin
+      e = String(Integer(e))
+    rescue
+      # If there are non-digits in the epoch field, default to nil
+      e = nil
+    end
+    ri = s.index('-')
+    if ri
+      v = s[0,ri]
+      r = s[ri+1,s.length]
+      if arch = r.scan(ARCH_REGEX)[0]
+        a = arch.gsub(/\./, '')
+	r.gsub!(ARCH_REGEX, '')
+      end
+    else
+      v = s
+      r = nil
+    end
+    return { :epoch => e, :version => v, :release => r, :arch => a }
+  end
+
+  # how rpm 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 rpm_compareEVR(should_hash, is_hash)
+    # pass on to rpm labelCompare
+
+    if !should_hash[:epoch].nil?
+      rc = compare_values(should_hash[:epoch], is_hash[:epoch])
+      return rc unless rc == 0
+    end
+
+    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 rpm.
+  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)
+  end
+
   private
   # @param line [String] one line of rpm package query information
   # @return [Hash] of NEVRA_FIELDS strings parsed from package info
@@ -287,6 +395,7 @@ Puppet::Type.type(:package).provide :rpm, :source => :rpm, :parent => Puppet::Pr
       self::NEVRA_FIELDS.zip(match.captures) { |f, v| hash[f] = v }
       hash[:provider] = self.name
       hash[:ensure] = "#{hash[:version]}-#{hash[:release]}"
+      hash[:ensure].prepend("#{hash[:epoch]}:") if hash[:epoch] != '0'
     else
       Puppet.debug("Failed to match rpm line #{line}")
     end

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

@@ -25,7 +25,7 @@ Puppet::Type.type(:package).provide :rug, :parent => :rpm do
 
     unless self.query
       raise Puppet::ExecutionFailure.new(
-        "Could not find package #{self.name}"
+        _("Could not find package %{name}") % { name: self.name }
       )
     end
   end

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

@@ -75,8 +75,8 @@ Puppet::Type.type(:package).provide :sun, :parent => Puppet::Provider::Package d
       end
       return self.class.namemap(pkgs[0]) if errmsg.nil?
       # according to commit 41356a7 some errors do not raise an exception
-      # so eventhough pkginfo passed, we have to check the actual output
-      raise Puppet::Error, "Unable to get information about package #{@resource[:name]} because of: #{errmsg}"
+      # so even though pkginfo passed, we have to check the actual output
+      raise Puppet::Error, _("Unable to get information about package %{name} because of: %{errmsg}") % { name: @resource[:name], errmsg: errmsg }
     rescue Puppet::ExecutionFailure
       return {:ensure => :absent}
     end
@@ -93,7 +93,8 @@ Puppet::Type.type(:package).provide :sun, :parent => Puppet::Provider::Package d
 
   # only looking for -G now
   def install
-    raise Puppet::Error, "Sun packages must specify a package source" unless @resource[:source]
+    #TRANSLATORS Sun refers to the company name, do not translate
+    raise Puppet::Error, _("Sun packages must specify a package source") unless @resource[:source]
     options = {
       :adminfile    => @resource[:adminfile],
       :responsefile => @resource[:responsefile],

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

@@ -0,0 +1,28 @@
+Puppet::Type.type(:package).provide :tdnf, :parent => :dnf do
+  desc "Support via `tdnf`.
+
+  This provider supports the `install_options` attribute, which allows command-line flags to be passed to tdnf.
+  These options should be spcified as a string (e.g. '--flag'), a hash (e.g. {'--flag' => 'value'}), or an
+  array where each element is either a string or a hash."
+
+  has_feature :install_options, :versionable, :virtual_packages
+
+  commands :cmd => "tdnf", :rpm => "rpm"
+
+  # Note: this confine was borrowed from the Yum provider. The
+  # original purpose (from way back in 2007) was to make sure we
+  # never try to use RPM on a machine without it. We think this
+  # has probably become obsolete with the way `commands` work, so
+  # we should investigate removing it at some point.
+  if command('rpm')
+    confine :true => begin
+      rpm('--version')
+      rescue Puppet::ExecutionFailure
+        false
+      else
+        true
+      end
+  end
+
+  defaultfor :operatingsystem => "PhotonOS" 
+end

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

@@ -14,7 +14,7 @@ Puppet::Type.type(:package).provide :up2date, :parent => :rpm, :source => :rpm d
 
     unless self.query
       raise Puppet::ExecutionFailure.new(
-        "Could not find package #{self.name}"
+        _("Could not find package %{name}") % { name: self.name }
       )
     end
   end