puppet 3.8.7 → 4.0.0.rc1

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

@@ -3,7 +3,6 @@
 
 require 'puppet/provider/package'
 require 'xmlrpc/client'
-require 'puppet/util/http_proxy'
 
 Puppet::Type.type(:package).provide :pip,
   :parent => ::Puppet::Provider::Package do
@@ -57,16 +56,7 @@ Puppet::Type.type(:package).provide :pip,
   # cache of PyPI's package list so this operation will always have to
   # ask the web service.
   def latest
-    http_proxy_host = Puppet::Util::HttpProxy.http_proxy_host
-    http_proxy_port = Puppet::Util::HttpProxy.http_proxy_port
-    if http_proxy_host && http_proxy_port
-      proxy = "#{http_proxy_host}:#{http_proxy_port}"
-    else
-      # nil is acceptable
-      proxy = http_proxy_host
-    end
-
-    client = XMLRPC::Client.new2("http://pypi.python.org/pypi", proxy)
+    client = XMLRPC::Client.new2("http://pypi.python.org/pypi")
     client.http_header_extra = {"Content-Type" => "text/xml"}
     client.timeout = 10
     result = client.call("package_releases", @resource[:name])

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

@@ -26,7 +26,7 @@ Puppet::Type.type(:package).provide :pkg, :parent => Puppet::Provider::Package d
   defaultfor :osfamily => :solaris, :kernelrelease => '5.11'
 
   def self.instances
-    pkg(:list, '-H').split("\n").map{|l| new(parse_line(l))}
+    pkg(:list, '-Hv').split("\n").map{|l| new(parse_line(l))}
   end
 
   # The IFO flag field is just what it names, the first field can have ether
@@ -90,23 +90,15 @@ Puppet::Type.type(:package).provide :pkg, :parent => Puppet::Provider::Package d
   # formats of output for different pkg versions.
   def self.parse_line(line)
     (case line.chomp
-    # NAME (PUBLISHER)            VERSION           IFO  (new:630e1ffc7a19)
-    # system/core-os              0.5.11-0.169      i--
-    when /^(\S+) +(\S+) +(...)$/
-      {:name => $1, :ensure => $2}.merge ifo_flag($3)
+    # FMRI                                                                         IFO
+    # pkg://omnios/SUNWcs@0.5.11,5.11-0.151008:20131204T022241Z                    ---
+    when %r'^pkg://([^/]+)/([^@]+)@(\S+) +(...)$'
+      {:publisher => $1, :name => $2, :ensure => $3}.merge ifo_flag($4)
 
-    # x11/wm/fvwm (fvwm.org)      2.6.1-3           i--
-    when /^(\S+) \((.+)\) +(\S+) +(...)$/
-      {:name => $1, :publisher => $2, :ensure => $3}.merge ifo_flag($4)
-
-    # NAME (PUBLISHER)                  VERSION          STATE      UFOXI (dvd:052adf36c3f4)
-    # SUNWcs                            0.5.11-0.126     installed  -----
-    when /^(\S+) +(\S+) +(\S+) +(.....)$/
-      {:name => $1, :ensure => $2}.merge pkg_state($3).merge(ufoxi_flag($4))
-
-    # web/firefox/plugin/flash (extra)  10.0.32.18-0.111 installed  -----
-    when /^(\S+) \((.+)\) +(\S+) +(\S+) +(.....)$/
-      {:name => $1, :publisher => $2, :ensure => $3}.merge pkg_state($4).merge(ufoxi_flag($5))
+    # FMRI                                                             STATE      UFOXI
+    # pkg://solaris/SUNWcs@0.5.11,5.11-0.151.0.1:20101105T001108Z      installed  u----
+    when %r'^pkg://([^/]+)/([^@]+)@(\S+) +(\S+) +(.....)$'
+      {:publisher => $1, :name => $2, :ensure => $3}.merge pkg_state($4).merge(ufoxi_flag($5))
 
     else
       raise ArgumentError, 'Unknown line format %s: %s' % [self.name, line]
@@ -122,19 +114,69 @@ Puppet::Type.type(:package).provide :pkg, :parent => Puppet::Provider::Package d
     raise Puppet::Error, "Unable to unfreeze #{r[:out]}" unless [0,4].include? r[:exit]
   end
 
+  def insync?(is)
+    # this is called after the generic version matching logic (insync? for the
+    # type), so we only get here if should != is, and 'should' is a version
+    # number. 'is' might not be, though.
+    should = @resource[:ensure]
+    # NB: it is apparently possible for repository administrators to publish
+    # packages which do not include build or branch versions, but component
+    # version must always be present, and the timestamp is added by pkgsend
+    # publish.
+    if /^[0-9.]+(,[0-9.]+)?(-[0-9.]+)?:[0-9]+T[0-9]+Z$/ !~ should
+      # We have a less-than-explicit version string, which we must accept for
+      # backward compatibility. We can find the real version this would match
+      # by asking pkg for the all matching versions, and selecting the first
+      # installable one [0]; this can change over time when remote repositories
+      # are updated, but the principle of least astonishment should still hold:
+      # if we allow users to specify less-than-explicit versions, the
+      # functionality should match that of the package manager.
+      #
+      # [0]: we could simply get the newest matching version with 'pkg list
+      # -n', but that isn't always correct, since it might not be installable.
+      # If that were the case we could potentially end up returning false for
+      # insync? here but not actually changing the package version in install
+      # (ie. if the currently installed version is the latest matching version
+      # that is installable, we would falsely conclude here that since the
+      # installed version is not the latest matching version, we're not in
+      # sync).  'pkg list -a' instead of '-n' would solve this, but
+      # unfortunately it doesn't consider downgrades 'available' (eg. with
+      # installed foo@1.0, list -a foo@0.9 would fail).
+      name = @resource[:name]
+      potential_matches = pkg(:list, '-Hvfa', "#{name}@#{should}").split("\n").map{|l|self.class.parse_line(l)}
+      n = potential_matches.length
+      if n > 1
+        warning("Implicit version #{should} has #{n} possible matches")
+      end
+      potential_matches.each{ |p|
+        command = is == :absent ? 'install' : 'update'
+        status = exec_cmd(command(:pkg), command, '-n', "#{name}@#{p[:ensure]}")[:exit]
+        case status
+        when 4
+          # if the first installable match would cause no changes, we're in sync
+          return true
+        when 0
+          warning("Selecting version '#{p[:ensure]}' for implicit '#{should}'")
+          @resource[:ensure] = p[:ensure]
+          return false
+        end
+      }
+      raise Puppet::DevError, "No version of #{name} matching #{should} is installable, even though the package is currently installed"
+    end
+
+    false
+  end
+
   # Return the version of the package. Note that the bug
   # http://defect.opensolaris.org/bz/show_bug.cgi?id=19159%
   # notes that we can't use -Ha for the same even though the manual page reads that way.
   def latest
-    lines = pkg(:list, "-Hn", @resource[:name]).split("\n")
+    lines = pkg(:list, "-Hvn", @resource[:name]).split("\n")
 
     # remove certificate expiration warnings from the output, but report them
-    # Note: we'd like to use select! here to modify the lines array and avoid
-    #       the second select further down. But Solaris 11 comes with ruby 1.8.7
-    #       which doesn't support select!, so do this as two selects.
     cert_warnings = lines.select { |line| line =~ /^Certificate/ }
-    if cert_warnings
-      Puppet.warning("pkg warning: #{cert_warnings}")
+    unless cert_warnings.empty?
+      Puppet.warning("pkg warning: #{cert_warnings.join(', ')}")
     end
 
     lst = lines.select { |line| line !~ /^Certificate/ }.map { |line| self.class.parse_line(line) }
@@ -155,14 +197,16 @@ Puppet::Type.type(:package).provide :pkg, :parent => Puppet::Provider::Package d
     should = @resource[:ensure]
     # always unhold if explicitly told to install/update
     self.unhold
+    is = self.query
+    if is[:ensure].to_sym == :absent
+      command = 'install'
+    else
+      command = 'update'
+    end
     unless should.is_a? Symbol
       name += "@#{should}"
-      is = self.query
-      unless is[:ensure].to_sym == :absent
-        self.uninstall if Puppet::Util::Package.versioncmp(should, is[:ensure]) < 0
-      end
     end
-    r = exec_cmd(command(:pkg), 'install', '--accept', name)
+    r = exec_cmd(command(:pkg), command, '--accept', name)
     return r if nofail
     raise Puppet::Error, "Unable to update #{r[:out]}" if r[:exit] != 0
   end
@@ -189,7 +233,7 @@ Puppet::Type.type(:package).provide :pkg, :parent => Puppet::Provider::Package d
 
   # list a specific package
   def query
-    r = exec_cmd(command(:pkg), 'list', '-H', @resource[:name])
+    r = exec_cmd(command(:pkg), 'list', '-Hv', @resource[:name])
     return {:ensure => :absent, :name => @resource[:name]} if r[:exit] != 0
     self.class.parse_line(r[:out])
   end

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

@@ -81,7 +81,7 @@ Puppet::Type.type(:package).provide :pkgdmg, :parent => Puppet::Provider::Packag
     begin
       if %r{\A[A-Za-z][A-Za-z0-9+\-\.]*://} =~ cached_source
         cached_source = File.join(tmpdir, "#{name}#{ext}")
-        args = [ "-o", cached_source, "-C", "-", "-k", "-L", "-s", "--fail", "--url", source ]
+        args = [ "-o", cached_source, "-C", "-", "-L", "-s", "--fail", "--url", source ]
         if http_proxy_host and http_proxy_port
           args << "--proxy" << "#{http_proxy_host}:#{http_proxy_port}"
         elsif http_proxy_host and not http_proxy_port
@@ -89,7 +89,7 @@ Puppet::Type.type(:package).provide :pkgdmg, :parent => Puppet::Provider::Packag
         end
       begin
         curl *args
-          Puppet.debug "Success: curl transfered [#{name}] (via: curl #{args.join(" ")})"
+          Puppet.debug "Success: curl transferred [#{name}] (via: curl #{args.join(" ")})"
         rescue Puppet::ExecutionFailure
           Puppet.debug "curl #{args.join(" ")} did not transfer [#{name}].  Falling back to local file." # This used to fall back to open-uri. -NF
           cached_source = source

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

@@ -75,7 +75,7 @@ Puppet::Type.type(:package).provide :pkgin, :parent => Puppet::Provider::Package
   end
 
   def latest
-    package = parse_pkgsearch_line.detect{ |package| package[:status] == '<' }
+    package = parse_pkgsearch_line.detect{ |p| p[:status] == '<' }
     return properties[:ensure] if not package
     return package[:ensure]
   end

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

@@ -4,7 +4,7 @@ require 'fileutils'
 Puppet::Type.type(:package).provide :portage, :parent => Puppet::Provider::Package do
   desc "Provides packaging support for Gentoo's portage system."
 
-  has_feature :versionable
+  has_features :versionable, :reinstallable
 
   {
     :emerge => "/usr/bin/emerge",
@@ -73,6 +73,10 @@ Puppet::Type.type(:package).provide :portage, :parent => Puppet::Provider::Packa
     emerge "--unmerge", package_name
   end
 
+  def reinstall
+    self.install
+  end
+
   def update
     self.install
   end

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

@@ -46,7 +46,6 @@ Puppet::Type.type(:package).provide :portupgrade, :parent => Puppet::Provider::P
       output = portinfo(*cmdline)
     rescue Puppet::ExecutionFailure
       raise Puppet::Error.new(output, $!)
-      return nil
     end
 
     # split output and match it and populate temp hash
@@ -162,7 +161,6 @@ 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}"
-    return nil
   end
 
   ###### Query subcommand - return a hash of details if exists, or nil if it doesn't.

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

@@ -165,6 +165,115 @@ Puppet::Type.type(:package).provide :rpm, :source => :rpm, :parent => Puppet::Pr
     join_options(resource[:uninstall_options])
   end
 
+  # This is an attempt at implementing RPM's
+  # lib/rpmvercmp.c rpmvercmp(a, b) in Ruby.
+  #
+  # Some of the things in here look REALLY
+  # UGLY and/or arbitrary. Our goal is to
+  # match how RPM compares versions, quirks
+  # and all.
+  #
+  # I've kept a lot of C-like string processing
+  # in an effort to keep this as identical to RPM
+  # as possible.
+  #
+  # returns 1 if str1 is newer than str2,
+  #         0 if they are identical
+  #        -1 if str1 is older than str2
+  def rpmvercmp(str1, str2)
+    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
+      str1 = str1.gsub(front_strip_re, '')
+      str2 = str2.gsub(front_strip_re, '')
+
+      # "handle the tilde separator, it sorts before everything else"
+      if /^~/.match(str1) && /^~/.match(str2)
+        # if they both have ~, strip it
+        str1 = str1[1..-1]
+        str2 = str2[1..-1]
+      elsif /^~/.match(str1)
+        return -1
+      elsif /^~/.match(str2)
+        return 1
+      end
+
+      break if str1.length == 0 or str2.length == 0
+
+      # "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 str1 =~ /^[0-9]+/
+          segment1 = $~.to_s
+          str1 = $~.post_match
+        else
+          segment1 = ''
+        end
+        if str2 =~ /^[0-9]+/
+          segment2 = $~.to_s
+          str2 = $~.post_match
+        else
+          segment2 = ''
+        end
+        isnum = true
+      # else grab the chunk of continuous alphas from each string (which may be '')
+      else
+        if str1 =~ /^[A-Za-z]+/
+          segment1 = $~.to_s
+          str1 = $~.post_match
+        else
+          segment1 = ''
+        end
+        if str2 =~ /^[A-Za-z]+/
+          segment2 = $~.to_s
+          str2 = $~.post_match
+        else
+          segment2 = ''
+        end
+      end
+
+      # if the segments we just grabbed from the strings are different types (i.e. one numeric one alpha),
+      # where alpha also includes ''; "numeric segments are always newer than alpha segments"
+      if segment2.length == 0
+        return 1 if isnum
+        return -1
+      end
+
+      if isnum
+        # "throw away any leading zeros - it's a number, right?"
+        segment1 = segment1.gsub(/^0+/, '')
+        segment2 = segment2.gsub(/^0+/, '')
+        # "whichever number has more digits wins"
+        return 1 if segment1.length > segment2.length
+        return -1 if segment1.length < segment2.length
+      end
+
+      # "strcmp will return which one is greater - even if the two segments are alpha
+      # or if they are numeric. don't return if they are equal because there might
+      # be more segments to compare"
+      rc = segment1 <=> segment2
+      return rc if rc != 0
+    end #end while loop
+
+    # if we haven't returned anything yet, "whichever version still has characters left over wins"
+    if str1.length > str2.length
+      return 1
+    elsif str1.length < str2.length
+      return -1
+    else
+      return 0
+    end
+  end
+
   private
   # @param line [String] one line of rpm package query information
   # @return [Hash] of NEVRA_FIELDS strings parsed from package info

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

@@ -5,7 +5,6 @@ Puppet::Type.type(:package).provide :rug, :parent => :rpm do
 
   commands :rug => "/usr/bin/rug"
   commands :rpm => "rpm"
-  defaultfor :operatingsystem => [:suse, :sles]
   confine    :operatingsystem => [:suse, :sles]
 
   # Install a package using 'rug'.

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

@@ -35,7 +35,7 @@ class Puppet::Provider::Package::Windows
           mode |= KEY_READ
           begin
             open(hive, 'Software\Microsoft\Windows\CurrentVersion\Uninstall', mode) do |uninstall|
-              uninstall.each_key do |name, wtime|
+              each_key(uninstall) do |name, wtime|
                 open(hive, "#{uninstall.keyname}\\#{name}", mode) do |key|
                   yield key, values(key)
                 end

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

@@ -1,5 +1,3 @@
-require 'puppet/util/package'
-
 Puppet::Type.type(:package).provide :yum, :parent => :rpm, :source => :rpm do
   desc "Support via `yum`.
 
@@ -13,9 +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", :python => "python"
-
-  self::YUMHELPER = File::join(File::dirname(__FILE__), "yumhelper.py")
+  commands :yum => "yum", :rpm => "rpm"
 
   if command('rpm')
     confine :true => begin
@@ -45,14 +41,15 @@ Puppet::Type.type(:package).provide :yum, :parent => :rpm, :source => :rpm do
   # @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 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)
+  def self.latest_package_version(package, enablerepo, disablerepo, disableexcludes)
 
-    key = [enablerepo, disablerepo]
+    key = [enablerepo, disablerepo, disableexcludes]
 
     @latest_versions ||= {}
     if @latest_versions[key].nil?
-      @latest_versions[key] = fetch_latest_versions(enablerepo, disablerepo)
+      @latest_versions[key] = check_updates(enablerepo, disablerepo, disableexcludes)
     end
 
     if @latest_versions[key][package]
@@ -66,27 +63,62 @@ Puppet::Type.type(:package).provide :yum, :parent => :rpm, :source => :rpm do
   # @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 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.fetch_latest_versions(enablerepo, disablerepo)
-    latest_versions = Hash.new {|h, k| h[k] = []}
-
-    args = [self::YUMHELPER]
-    args.concat(enablerepo.map { |repo| ['-e', repo] }.flatten)
-    args.concat(disablerepo.map { |repo| ['-d', repo] }.flatten)
+  def self.check_updates(enablerepo, disablerepo, disableexcludes)
+    args = [command(:yum), 'check-update']
+    args.concat(enablerepo.map { |repo| ["--enablerepo=#{repo}"] }.flatten)
+    args.concat(disablerepo.map { |repo| ["--disablerepo=#{repo}"] }.flatten)
+    args.concat(disableexcludes.map { |repo| ["--disableexcludes=#{repo}"] }.flatten)
+
+    output = Puppet::Util::Execution.execute(args, :failonfail => false, :combine => false)
+
+    updates = {}
+    if output.exitstatus == 100
+      updates = parse_updates(output)
+    elsif output.exitstatus == 0
+      self.debug "yum check-update exited with 0; no package updates available."
+    else
+      self.warn "Could not check for updates, 'yum check-update' exited with #{output.exitstatus}"
+    end
+    updates
+  end
 
-    python(args).scan(/^_pkg (.*)$/) do |match|
-      hash = nevra_to_hash(match[0])
+  def self.parse_updates(str)
+    # Strip off all content before the first blank line
+    body = str.partition(/^\s*\n/m).last
 
+    updates = Hash.new { |h, k| h[k] = [] }
+    body.split.each_slice(3) do |tuple|
+      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.
       short_name = hash[:name]
       long_name  = "#{hash[:name]}.#{hash[:arch]}"
 
-      latest_versions[short_name] << hash
-      latest_versions[long_name]  << hash
+      updates[short_name] << hash
+      updates[long_name] << hash
     end
-    latest_versions
+
+    updates
+  end
+
+  def self.update_to_hash(pkgname, pkgversion)
+    name, arch = pkgname.split('.')
+
+    match = pkgversion.match(/^(?:(\d+):)?(\S+)-(\S+)$/)
+    epoch = match[1] || '0'
+    version = match[2]
+    release = match[3]
+
+    {
+      :name => name,
+      :epoch => epoch,
+      :version => version,
+      :release => release,
+      :arch    => arch,
+    }
   end
 
   def self.clear
@@ -112,7 +144,7 @@ Puppet::Type.type(:package).provide :yum, :parent => :rpm, :source => :rpm do
       # Add the package version
       wanted += "-#{should}"
       is = self.query
-      if is && Puppet::Util::Package.versioncmp(should, is[:ensure]) < 0
+      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
       end
@@ -129,13 +161,14 @@ Puppet::Type.type(:package).provide :yum, :parent => :rpm, :source => :rpm do
 
       # FIXME: Should we raise an exception even if should == :latest
       # and yum updated us to a version other than @param_hash[:ensure] ?
-      raise Puppet::Error, "Failed to update to version #{should}, got version #{is[:ensure]} instead" if should != is[: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
     end
   end
 
   # What's the latest package version available?
   def latest
-    upd = self.class.latest_package_version(@resource[:name], enablerepo, disablerepo)
+    upd = self.class.latest_package_version(@resource[:name], enablerepo, disablerepo, disableexcludes)
     unless upd.nil?
       # FIXME: there could be more than one update for a package
       # because of multiarch
@@ -157,16 +190,70 @@ Puppet::Type.type(:package).provide :yum, :parent => :rpm, :source => :rpm do
     yum "-y", :erase, @resource[:name]
   end
 
-  # @deprecated
-  def latest_info
-    Puppet.deprecation_warning("#{self.class}##{__method__} is deprecated and is no longer used.")
-    @latest_info
+  # 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
 
-  # @deprecated
-  def latest_info=(latest)
-    Puppet.deprecation_warning("#{self.class}##{__method__} is deprecated and is no longer used.")
-    @latest_info = latest
+  # 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)
   end
 
   private
@@ -179,6 +266,10 @@ Puppet::Type.type(:package).provide :yum, :parent => :rpm, :source => :rpm do
     scan_options(resource[:install_options], '--disablerepo')
   end
 
+  def disableexcludes
+    scan_options(resource[:install_options], '--disableexcludes')
+  end
+
   # Scan a structure that looks like the package type 'install_options'
   # structure for all hashes that have a specific key.
   #