chef 12.10.24-universal-mingw32 → 12.11.18-universal-mingw32

data/lib/chef/provider/package/apt.rb

@@ -17,132 +17,64 @@
 #
 
 require "chef/provider/package"
-require "chef/mixin/command"
-require "chef/resource/package"
+require "chef/resource/apt_package"
 
 class Chef
   class Provider
     class Package
       class Apt < Chef::Provider::Package
+        use_multipackage_api
 
         provides :package, platform_family: "debian"
         provides :apt_package, os: "linux"
 
-        # return [Hash] mapping of package name to Boolean value
-        attr_accessor :is_virtual_package
-
         def initialize(new_resource, run_context)
           super
-          @is_virtual_package = {}
         end
 
         def load_current_resource
-          @current_resource = Chef::Resource::Package.new(@new_resource.name)
-          @current_resource.package_name(@new_resource.package_name)
-          check_all_packages_state(@new_resource.package_name)
-          @current_resource
+          @current_resource = Chef::Resource::AptPackage.new(new_resource.name)
+          current_resource.package_name(new_resource.package_name)
+          current_resource.version(get_current_versions)
+          current_resource
         end
 
         def define_resource_requirements
           super
 
           requirements.assert(:all_actions) do |a|
-            a.assertion { !@new_resource.source }
+            a.assertion { !new_resource.source }
             a.failure_message(Chef::Exceptions::Package, "apt package provider cannot handle source attribute. Use dpkg provider instead")
           end
         end
 
-        def default_release_options
-          # Use apt::Default-Release option only if provider supports it
-          "-o APT::Default-Release=#{@new_resource.default_release}" if @new_resource.respond_to?(:default_release) && @new_resource.default_release
+        def package_data
+          @package_data ||= Hash.new do |hash, key|
+            hash[key] = package_data_for(key)
+          end
         end
 
-        def check_package_state(pkg)
-          is_virtual_package = false
-          installed          = false
-          installed_version  = nil
-          candidate_version  = nil
-
-          shell_out_with_timeout!("apt-cache#{expand_options(default_release_options)} policy #{pkg}").stdout.each_line do |line|
-            case line
-            when /^\s{2}Installed: (.+)$/
-              installed_version = $1
-              if installed_version == "(none)"
-                Chef::Log.debug("#{@new_resource} current version is nil")
-                installed_version = nil
-              else
-                Chef::Log.debug("#{@new_resource} current version is #{installed_version}")
-                installed = true
-              end
-            when /^\s{2}Candidate: (.+)$/
-              candidate_version = $1
-              if candidate_version == "(none)"
-                # This may not be an appropriate assumption, but it shouldn't break anything that already worked -- btm
-                is_virtual_package = true
-                showpkg = shell_out_with_timeout!("apt-cache showpkg #{pkg}").stdout
-                providers = Hash.new
-                showpkg.rpartition(/Reverse Provides: ?#{$/}/)[2].each_line do |line|
-                  provider, version = line.split
-                  providers[provider] = version
-                end
-                # Check if the package providing this virtual package is installed
-                num_providers = providers.length
-                raise Chef::Exceptions::Package, "#{@new_resource.package_name} has no candidate in the apt-cache" if num_providers == 0
-                # apt will only install a virtual package if there is a single providing package
-                raise Chef::Exceptions::Package, "#{@new_resource.package_name} is a virtual package provided by #{num_providers} packages, you must explicitly select one to install" if num_providers > 1
-                # Check if the package providing this virtual package is installed
-                Chef::Log.info("#{@new_resource} is a virtual package, actually acting on package[#{providers.keys.first}]")
-                ret = check_package_state(providers.keys.first)
-                installed = ret[:installed]
-                installed_version = ret[:installed_version]
-              else
-                Chef::Log.debug("#{@new_resource} candidate version is #{$1}")
-              end
-            end
+        def get_current_versions
+          package_name_array.map do |package_name|
+            package_data[package_name][:current_version]
           end
-
-          return {
-            installed_version:   installed_version,
-            installed:           installed,
-            candidate_version:   candidate_version,
-            is_virtual_package:  is_virtual_package,
-          }
         end
 
-        def check_all_packages_state(package)
-          installed_version = {}
-          candidate_version = {}
-          installed = {}
-
-          [package].flatten.each do |pkg|
-            ret = check_package_state(pkg)
-            is_virtual_package[pkg] = ret[:is_virtual_package]
-            installed[pkg]          = ret[:installed]
-            installed_version[pkg]  = ret[:installed_version]
-            candidate_version[pkg]  = ret[:candidate_version]
+        def get_candidate_versions
+          package_name_array.map do |package_name|
+            package_data[package_name][:candidate_version]
           end
+        end
 
-          if package.is_a?(Array)
-            @candidate_version = []
-            final_installed_version = []
-            [package].flatten.each do |pkg|
-              @candidate_version << candidate_version[pkg]
-              final_installed_version << installed_version[pkg]
-            end
-            @current_resource.version(final_installed_version)
-          else
-            @candidate_version = candidate_version[package]
-            @current_resource.version(installed_version[package])
-          end
+        def candidate_version
+          @candidate_version ||= get_candidate_versions
         end
 
         def install_package(name, version)
-          name_array = [ name ].flatten
-          version_array = [ version ].flatten
-          package_name = name_array.zip(version_array).map do |n, v|
-            is_virtual_package[n] ? n : "#{n}=#{v}"
-          end.join(" ")
-          run_noninteractive("apt-get -q -y#{expand_options(default_release_options)}#{expand_options(@new_resource.options)} install #{package_name}")
+          package_name = name.zip(version).map do |n, v|
+            package_data[n][:virtual] ? n : "#{n}=#{v}"
+          end
+          run_noninteractive("apt-get -q -y", default_release_options, new_resource.options, "install", package_name)
         end
 
         def upgrade_package(name, version)
@@ -150,24 +82,27 @@ class Chef
         end
 
         def remove_package(name, version)
-          package_name = [ name ].flatten.join(" ")
-          run_noninteractive("apt-get -q -y#{expand_options(@new_resource.options)} remove #{package_name}")
+          package_name = name.map do |n|
+            package_data[n][:virtual] ? resolve_virtual_package_name(n) : n
+          end
+          run_noninteractive("apt-get -q -y", new_resource.options, "remove", package_name)
         end
 
         def purge_package(name, version)
-          package_name = [ name ].flatten.join(" ")
-          run_noninteractive("apt-get -q -y#{expand_options(@new_resource.options)} purge #{package_name}")
+          package_name = name.map do |n|
+            package_data[n][:virtual] ? resolve_virtual_package_name(n) : n
+          end
+          run_noninteractive("apt-get -q -y", new_resource.options, "purge", package_name)
         end
 
         def preseed_package(preseed_file)
-          Chef::Log.info("#{@new_resource} pre-seeding package installation instructions")
-          run_noninteractive("debconf-set-selections #{preseed_file}")
+          Chef::Log.info("#{new_resource} pre-seeding package installation instructions")
+          run_noninteractive("debconf-set-selections", preseed_file)
         end
 
         def reconfig_package(name, version)
-          package_name = [ name ].flatten.join(" ")
-          Chef::Log.info("#{@new_resource} reconfiguring")
-          run_noninteractive("dpkg-reconfigure #{package_name}")
+          Chef::Log.info("#{new_resource} reconfiguring")
+          run_noninteractive("dpkg-reconfigure", name)
         end
 
         private
@@ -175,8 +110,67 @@ class Chef
         # Runs command via shell_out with magic environment to disable
         # interactive prompts. Command is run with default localization rather
         # than forcing locale to "C", so command output may not be stable.
-        def run_noninteractive(command)
-          shell_out_with_timeout!(command, :env => { "DEBIAN_FRONTEND" => "noninteractive", "LC_ALL" => nil })
+        def run_noninteractive(*args)
+          shell_out_with_timeout!(a_to_s(*args), :env => { "DEBIAN_FRONTEND" => "noninteractive" })
+        end
+
+        def default_release_options
+          # Use apt::Default-Release option only if provider supports it
+          "-o APT::Default-Release=#{new_resource.default_release}" if new_resource.respond_to?(:default_release) && new_resource.default_release
+        end
+
+        def resolve_package_versions(pkg)
+          current_version = nil
+          candidate_version = nil
+          run_noninteractive("apt-cache", default_release_options, "policy", pkg).stdout.each_line do |line|
+            case line
+            when /^\s{2}Installed: (.+)$/
+              current_version = ( $1 != "(none)" ) ? $1 : nil
+              Chef::Log.debug("#{new_resource} installed version for #{pkg} is #{$1}")
+            when /^\s{2}Candidate: (.+)$/
+              candidate_version = ( $1 != "(none)" ) ? $1 : nil
+              Chef::Log.debug("#{new_resource} candidate version for #{pkg} is #{$1}")
+            end
+          end
+          [ current_version, candidate_version ]
+        end
+
+        def resolve_virtual_package_name(pkg)
+          showpkg = run_noninteractive("apt-cache showpkg", pkg).stdout
+          partitions = showpkg.rpartition(/Reverse Provides: ?#{$/}/)
+          return nil if partitions[0] == "" && partitions[1] == "" # not found in output
+          set = partitions[2].lines.each_with_object(Set.new) do |line, acc|
+            # there may be multiple reverse provides for a single package
+            acc.add(line.split[0])
+          end
+          if set.size > 1
+            raise Chef::Exceptions::Package, "#{new_resource.package_name} is a virtual package provided by multiple packages, you must explicitly select one"
+          end
+          return set.to_a.first
+        end
+
+        def package_data_for(pkg)
+          virtual           = false
+          current_version   = nil
+          candidate_version = nil
+
+          current_version, candidate_version = resolve_package_versions(pkg)
+
+          if candidate_version.nil?
+            newpkg = resolve_virtual_package_name(pkg)
+
+            if newpkg
+              virtual = true
+              Chef::Log.info("#{new_resource} is a virtual package, actually acting on package[#{newpkg}]")
+              current_version, candidate_version = resolve_package_versions(newpkg)
+            end
+          end
+
+          return {
+            current_version:    current_version,
+            candidate_version:  candidate_version,
+            virtual:            virtual,
+          }
         end
 
       end

data/lib/chef/provider/package/chocolatey.rb

@@ -229,13 +229,11 @@ EOS
         def available_packages
           @available_packages ||=
             begin
-              cmd = [ "list -ar #{package_name_array.join ' '}" ]
+              cmd = [ "list -r #{package_name_array.join ' '}" ]
               cmd.push( "-source #{new_resource.source}" ) if new_resource.source
-              parse_list_output(*cmd).each_with_object({}) do |name_version, available|
-                name, version = name_version
-                if desired_name_versions[name].nil? || desired_name_versions[name] == version
-                  available[name] = version
-                end
+              raw = parse_list_output(*cmd)
+              raw.keys.each_with_object({}) do |name, available|
+                available[name] = desired_name_versions[name] || raw[name]
               end
             end
         end
@@ -252,14 +250,15 @@ EOS
         # (names are downcased for case-insenstive matching)
         #
         # @param cmd [String] command to run
-        # @return [Array] list output converted to ruby Hash
+        # @return [Hash] list output converted to ruby Hash
         def parse_list_output(*args)
-          list = []
+          hash = {}
           choco_command(*args).stdout.each_line do |line|
+            next if line.start_with?("Chocolatey v")
             name, version = line.split("|")
-            list << [ name.downcase, version.chomp ]
+            hash[name.downcase] = version.chomp
           end
-          list
+          hash
         end
 
         # Helper to downcase all names in an array

data/lib/chef/provider/package/dpkg.rb

@@ -23,9 +23,9 @@ class Chef
   class Provider
     class Package
       class Dpkg < Chef::Provider::Package
-        DPKG_REMOVED = /^Status: deinstall ok config-files/
+        DPKG_REMOVED   = /^Status: deinstall ok config-files/
         DPKG_INSTALLED = /^Status: install ok installed/
-        DPKG_VERSION = /^Version: (.+)$/
+        DPKG_VERSION   = /^Version: (.+)$/
 
         provides :dpkg_package, os: "linux"
 

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

@@ -41,7 +41,7 @@ class Chef
           globsafe_pkg = Chef::Util::PathHelper.escape_glob_dir(pkg)
           possibilities = Dir["/var/db/pkg/#{globsafe_category || "*"}/#{globsafe_pkg}-*"].map { |d| d.sub(%r{/var/db/pkg/}, "") }
           versions = possibilities.map do |entry|
-            if entry =~ %r{[^/]+/#{Regexp.escape(pkg)}\-(\d[\.\d]*((_(alpha|beta|pre|rc|p)\d*)*)?(-r\d+)?)}
+            if entry =~ %r{[^/]+/#{Regexp.escape(pkg)}\-(\d[\.\d]*[a-z]?((_(alpha|beta|pre|rc|p)\d*)*)?(-r\d+)?)}
               [$&, $1]
             end
           end.compact

data/lib/chef/provider/package/rubygems.rb

@@ -482,20 +482,16 @@ class Chef
 
         def candidate_version
           @candidate_version ||= begin
-                                   if target_version_already_installed?(@current_resource.version, @new_resource.version)
-                                     nil
-                                   elsif source_is_remote?
-                                     @gem_env.candidate_version_from_remote(gem_dependency, *gem_sources).to_s
-                                   else
-                                     @gem_env.candidate_version_from_file(gem_dependency, @new_resource.source).to_s
-                                   end
-                                 end
+                                  if source_is_remote?
+                                    @gem_env.candidate_version_from_remote(gem_dependency, *gem_sources).to_s
+                                  else
+                                    @gem_env.candidate_version_from_file(gem_dependency, @new_resource.source).to_s
+                                  end
+                                end
         end
 
-        def target_version_already_installed?(current_version, new_version)
-          return false unless current_version
-          return false if new_version.nil?
-
+        def version_requirement_satisfied?(current_version, new_version)
+          return false unless current_version && new_version
           Gem::Requirement.new(new_version).satisfied_by?(Gem::Version.new(current_version))
         end
 

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

@@ -18,10 +18,10 @@
 
 require "chef/config"
 require "chef/provider/package"
-require "chef/mixin/which"
-require "chef/resource/package"
-require "singleton"
+require "chef/resource/yum_package"
 require "chef/mixin/get_source_from_package"
+require "chef/provider/package/yum/rpm_utils"
+require "chef/provider/package/yum/yum_cache"
 
 class Chef
   class Provider
@@ -31,961 +31,6 @@ class Chef
         provides :package, platform_family: %w{rhel fedora}
         provides :yum_package, os: "linux"
 
-        class RPMUtils
-          class << self
-
-            # RPM::Version version_parse equivalent
-            def version_parse(evr)
-              return if evr.nil?
-
-              epoch = nil
-              # assume this is a version
-              version = evr
-              release = nil
-
-              lead = 0
-              tail = evr.size
-
-              if evr =~ %r{^([\d]+):}
-                epoch = $1.to_i
-                lead = $1.length + 1
-              elsif evr[0].ord == ":".ord
-                epoch = 0
-                lead = 1
-              end
-
-              if evr =~ %r{:?.*-(.*)$}
-                release = $1
-                tail = evr.length - release.length - lead - 1
-
-                if release.empty?
-                  release = nil
-                end
-              end
-
-              version = evr[lead, tail]
-              if version.empty?
-                version = nil
-              end
-
-              [ epoch, version, release ]
-            end
-
-            # verify
-            def isalnum(x)
-              isalpha(x) || isdigit(x)
-            end
-
-            def isalpha(x)
-              v = x.ord
-              (v >= 65 && v <= 90) || (v >= 97 && v <= 122)
-            end
-
-            def isdigit(x)
-              v = x.ord
-              v >= 48 && v <= 57
-            end
-
-            # based on the reference spec in lib/rpmvercmp.c in rpm 4.9.0
-            def rpmvercmp(x, y)
-              # easy! :)
-              return 0 if x == y
-
-              if x.nil?
-                x = ""
-              end
-
-              if y.nil?
-                y = ""
-              end
-
-              # not so easy :(
-              #
-              # takes 2 strings like
-              #
-              # x = "1.20.b18.el5"
-              # y = "1.20.b17.el5"
-              #
-              # breaks into purely alpha and numeric segments and compares them using
-              # some rules
-              #
-              # * 10 > 1
-              # * 1 > a
-              # * z > a
-              # * Z > A
-              # * z > Z
-              # * leading zeros are ignored
-              # * separators (periods, commas) are ignored
-              # * "1.20.b18.el5.extrastuff" > "1.20.b18.el5"
-
-              x_pos = 0                # overall string element reference position
-              x_pos_max = x.length - 1 # number of elements in string, starting from 0
-              x_seg_pos = 0            # segment string element reference position
-              x_comp = nil             # segment to compare
-
-              y_pos = 0
-              y_seg_pos = 0
-              y_pos_max = y.length - 1
-              y_comp = nil
-
-              while x_pos <= x_pos_max && y_pos <= y_pos_max
-                # first we skip over anything non alphanumeric
-                while (x_pos <= x_pos_max) && (isalnum(x[x_pos]) == false)
-                  x_pos += 1 # +1 over pos_max if end of string
-                end
-                while (y_pos <= y_pos_max) && (isalnum(y[y_pos]) == false)
-                  y_pos += 1
-                end
-
-                # if we hit the end of either we are done matching segments
-                if (x_pos == x_pos_max + 1) || (y_pos == y_pos_max + 1)
-                  break
-                end
-
-                # we are now at the start of a alpha or numeric segment
-                x_seg_pos = x_pos
-                y_seg_pos = y_pos
-
-                # grab segment so we can compare them
-                if isdigit(x[x_seg_pos].ord)
-                  x_seg_is_num = true
-
-                  # already know it's a digit
-                  x_seg_pos += 1
-
-                  # gather up our digits
-                  while (x_seg_pos <= x_pos_max) && isdigit(x[x_seg_pos])
-                    x_seg_pos += 1
-                  end
-                  # copy the segment but not the unmatched character that x_seg_pos will
-                  # refer to
-                  x_comp = x[x_pos, x_seg_pos - x_pos]
-
-                  while (y_seg_pos <= y_pos_max) && isdigit(y[y_seg_pos])
-                    y_seg_pos += 1
-                  end
-                  y_comp = y[y_pos, y_seg_pos - y_pos]
-                else
-                  # we are comparing strings
-                  x_seg_is_num = false
-
-                  while (x_seg_pos <= x_pos_max) && isalpha(x[x_seg_pos])
-                    x_seg_pos += 1
-                  end
-                  x_comp = x[x_pos, x_seg_pos - x_pos]
-
-                  while (y_seg_pos <= y_pos_max) && isalpha(y[y_seg_pos])
-                    y_seg_pos += 1
-                  end
-                  y_comp = y[y_pos, y_seg_pos - y_pos]
-                end
-
-                # if y_seg_pos didn't advance in the above loop it means the segments are
-                # different types
-                if y_pos == y_seg_pos
-                  # numbers always win over letters
-                  return x_seg_is_num ? 1 : -1
-                end
-
-                # move the ball forward before we mess with the segments
-                x_pos += x_comp.length # +1 over pos_max if end of string
-                y_pos += y_comp.length
-
-                # we are comparing numbers - simply convert them
-                if x_seg_is_num
-                  x_comp = x_comp.to_i
-                  y_comp = y_comp.to_i
-                end
-
-                # compares ints or strings
-                # don't return if equal - try the next segment
-                if x_comp > y_comp
-                  return 1
-                elsif x_comp < y_comp
-                  return -1
-                end
-
-                # if we've reached here than the segments are the same - try again
-              end
-
-              # we must have reached the end of one or both of the strings and they
-              # matched up until this point
-
-              # segments matched completely but the segment separators were different -
-              # rpm reference code treats these as equal.
-              if (x_pos == x_pos_max + 1) && (y_pos == y_pos_max + 1)
-                return 0
-              end
-
-              # the most unprocessed characters left wins
-              if (x_pos_max - x_pos) > (y_pos_max - y_pos)
-                return 1
-              else
-                return -1
-              end
-            end
-
-          end # self
-        end # RPMUtils
-
-        class RPMVersion
-          include Comparable
-
-          def initialize(*args)
-            if args.size == 1
-              @e, @v, @r = RPMUtils.version_parse(args[0])
-            elsif args.size == 3
-              @e = args[0].to_i
-              @v = args[1]
-              @r = args[2]
-            else
-              raise ArgumentError, "Expecting either 'epoch-version-release' or 'epoch, " +
-                "version, release'"
-            end
-          end
-          attr_reader :e, :v, :r
-          alias :epoch :e
-          alias :version :v
-          alias :release :r
-
-          def self.parse(*args)
-            self.new(*args)
-          end
-
-          def <=>(y)
-            compare_versions(y)
-          end
-
-          def compare(y)
-            compare_versions(y, false)
-          end
-
-          def partial_compare(y)
-            compare_versions(y, true)
-          end
-
-          # RPM::Version rpm_version_to_s equivalent
-          def to_s
-            if @r.nil?
-              @v
-            else
-              "#{@v}-#{@r}"
-            end
-          end
-
-          def evr
-            "#{@e}:#{@v}-#{@r}"
-          end
-
-          private
-
-          # Rough RPM::Version rpm_version_cmp equivalent - except much slower :)
-          #
-          # partial lets epoch and version segment equality be good enough to return equal, eg:
-          #
-          # 2:1.2-1 == 2:1.2
-          # 2:1.2-1 == 2:
-          #
-          def compare_versions(y, partial = false)
-            x = self
-
-            # compare epoch
-            if (x.e.nil? == false && x.e > 0) && y.e.nil?
-              return 1
-            elsif x.e.nil? && (y.e.nil? == false && y.e > 0)
-              return -1
-            elsif x.e.nil? == false && y.e.nil? == false
-              if x.e < y.e
-                return -1
-              elsif x.e > y.e
-                return 1
-              end
-            end
-
-            # compare version
-            if partial && (x.v.nil? || y.v.nil?)
-              return 0
-            elsif x.v.nil? == false && y.v.nil?
-              return 1
-            elsif x.v.nil? && y.v.nil? == false
-              return -1
-            elsif x.v.nil? == false && y.v.nil? == false
-              cmp = RPMUtils.rpmvercmp(x.v, y.v)
-              return cmp if cmp != 0
-            end
-
-            # compare release
-            if partial && (x.r.nil? || y.r.nil?)
-              return 0
-            elsif x.r.nil? == false && y.r.nil?
-              return 1
-            elsif x.r.nil? && y.r.nil? == false
-              return -1
-            elsif x.r.nil? == false && y.r.nil? == false
-              cmp = RPMUtils.rpmvercmp(x.r, y.r)
-              return cmp
-            end
-
-            return 0
-          end
-        end
-
-        class RPMPackage
-          include Comparable
-
-          def initialize(*args)
-            if args.size == 4
-              @n = args[0]
-              @version = RPMVersion.new(args[1])
-              @a = args[2]
-              @provides = args[3]
-            elsif args.size == 6
-              @n = args[0]
-              e = args[1].to_i
-              v = args[2]
-              r = args[3]
-              @version = RPMVersion.new(e, v, r)
-              @a = args[4]
-              @provides = args[5]
-            else
-              raise ArgumentError, "Expecting either 'name, epoch-version-release, arch, provides' " +
-                "or 'name, epoch, version, release, arch, provides'"
-            end
-
-            # We always have one, ourselves!
-            if @provides.empty?
-              @provides = [ RPMProvide.new(@n, @version.evr, :==) ]
-            end
-          end
-          attr_reader :n, :a, :version, :provides
-          alias :name :n
-          alias :arch :a
-
-          def <=>(y)
-            compare(y)
-          end
-
-          def compare(y)
-            x = self
-
-            # easy! :)
-            return 0 if x.nevra == y.nevra
-
-            # compare name
-            if x.n.nil? == false && y.n.nil?
-              return 1
-            elsif x.n.nil? && y.n.nil? == false
-              return -1
-            elsif x.n.nil? == false && y.n.nil? == false
-              if x.n < y.n
-                return -1
-              elsif x.n > y.n
-                return 1
-              end
-            end
-
-            # compare version
-            if x.version > y.version
-              return 1
-            elsif x.version < y.version
-              return -1
-            end
-
-            # compare arch
-            if x.a.nil? == false && y.a.nil?
-              return 1
-            elsif x.a.nil? && y.a.nil? == false
-              return -1
-            elsif x.a.nil? == false && y.a.nil? == false
-              if x.a < y.a
-                return -1
-              elsif x.a > y.a
-                return 1
-              end
-            end
-
-            return 0
-          end
-
-          def to_s
-            nevra
-          end
-
-          def nevra
-            "#{@n}-#{@version.evr}.#{@a}"
-          end
-        end
-
-        # Simple implementation from rpm and ruby-rpm reference code
-        class RPMDependency
-          def initialize(*args)
-            if args.size == 3
-              @name = args[0]
-              @version = RPMVersion.new(args[1])
-              # Our requirement to other dependencies
-              @flag = args[2] || :==
-            elsif args.size == 5
-              @name = args[0]
-              e = args[1].to_i
-              v = args[2]
-              r = args[3]
-              @version = RPMVersion.new(e, v, r)
-              @flag = args[4] || :==
-            else
-              raise ArgumentError, "Expecting either 'name, epoch-version-release, flag' or " +
-                "'name, epoch, version, release, flag'"
-            end
-          end
-          attr_reader :name, :version, :flag
-
-          # Parses 2 forms:
-          #
-          # "mtr >= 2:0.71-3.0"
-          # "mta"
-          def self.parse(string)
-            if string =~ %r{^(\S+)\s+(>|>=|=|==|<=|<)\s+(\S+)$}
-              name = $1
-              if $2 == "="
-                flag = :==
-              else
-                flag = :"#{$2}"
-              end
-              version = $3
-
-              return self.new(name, version, flag)
-            else
-              name = string
-              return self.new(name, nil, nil)
-            end
-          end
-
-          # Test if another RPMDependency satisfies our requirements
-          def satisfy?(y)
-            unless y.kind_of?(RPMDependency)
-              raise ArgumentError, "Expecting an RPMDependency object"
-            end
-
-            x = self
-
-            # Easy!
-            if x.name != y.name
-              return false
-            end
-
-            # Partial compare
-            #
-            # eg: x.version 2.3 == y.version 2.3-1
-            sense = x.version.partial_compare(y.version)
-
-            # Thanks to rpmdsCompare() rpmds.c
-            if (sense < 0) && ((x.flag == :> || x.flag == :>=) || (y.flag == :<= || y.flag == :<))
-              return true
-            elsif (sense > 0) && ((x.flag == :< || x.flag == :<=) || (y.flag == :>= || y.flag == :>))
-              return true
-            elsif sense == 0 && (
-              ((x.flag == :== || x.flag == :<= || x.flag == :>=) && (y.flag == :== || y.flag == :<= || y.flag == :>=)) ||
-              (x.flag == :< && y.flag == :<) ||
-              (x.flag == :> && y.flag == :>)
-            )
-              return true
-            end
-
-            return false
-          end
-        end
-
-        class RPMProvide < RPMDependency; end
-        class RPMRequire < RPMDependency; end
-
-        class RPMDbPackage < RPMPackage
-          # <rpm parts>, installed, available
-          def initialize(*args)
-            @repoid = args.pop
-            # state
-            @available = args.pop
-            @installed = args.pop
-            super(*args)
-          end
-          attr_reader :repoid, :available, :installed
-        end
-
-        # Simple storage for RPMPackage objects - keeps them unique and sorted
-        class RPMDb
-          def initialize
-            # package name => [ RPMPackage, RPMPackage ] of different versions
-            @rpms = Hash.new
-            # package nevra => RPMPackage for lookups
-            @index = Hash.new
-            # provide name (aka feature) => [RPMPackage, RPMPackage] each providing this feature
-            @provides = Hash.new
-            # RPMPackages listed as available
-            @available = Set.new
-            # RPMPackages listed as installed
-            @installed = Set.new
-          end
-
-          def [](package_name)
-            self.lookup(package_name)
-          end
-
-          # Lookup package_name and return a descending array of package objects
-          def lookup(package_name)
-            pkgs = @rpms[package_name]
-            if pkgs
-              return pkgs.sort.reverse
-            else
-              return nil
-            end
-          end
-
-          def lookup_provides(provide_name)
-            @provides[provide_name]
-          end
-
-          # Using the package name as a key, and nevra for an index, keep a unique list of packages.
-          # The available/installed state can be overwritten for existing packages.
-          def push(*args)
-            args.flatten.each do |new_rpm|
-              unless new_rpm.kind_of?(RPMDbPackage)
-                raise ArgumentError, "Expecting an RPMDbPackage object"
-              end
-
-              @rpms[new_rpm.n] ||= Array.new
-
-              # we may already have this one, like when the installed list is refreshed
-              idx = @index[new_rpm.nevra]
-              if idx
-                # grab the existing package if it's not
-                curr_rpm = idx
-              else
-                @rpms[new_rpm.n] << new_rpm
-
-                new_rpm.provides.each do |provide|
-                  @provides[provide.name] ||= Array.new
-                  @provides[provide.name] << new_rpm
-                end
-
-                curr_rpm = new_rpm
-              end
-
-              # Track the nevra -> RPMPackage association to avoid having to compare versions
-              # with @rpms[new_rpm.n] on the next round
-              @index[new_rpm.nevra] = curr_rpm
-
-              # these are overwritten for existing packages
-              if new_rpm.available
-                @available << curr_rpm
-              end
-              if new_rpm.installed
-                @installed << curr_rpm
-              end
-            end
-          end
-
-          def <<(*args)
-            self.push(args)
-          end
-
-          def clear
-            @rpms.clear
-            @index.clear
-            @provides.clear
-            clear_available
-            clear_installed
-          end
-
-          def clear_available
-            @available.clear
-          end
-
-          def clear_installed
-            @installed.clear
-          end
-
-          def size
-            @rpms.size
-          end
-          alias :length :size
-
-          def available_size
-            @available.size
-          end
-
-          def installed_size
-            @installed.size
-          end
-
-          def available?(package)
-            @available.include?(package)
-          end
-
-          def installed?(package)
-            @installed.include?(package)
-          end
-
-          def whatprovides(rpmdep)
-            unless rpmdep.kind_of?(RPMDependency)
-              raise ArgumentError, "Expecting an RPMDependency object"
-            end
-
-            what = []
-
-            packages = lookup_provides(rpmdep.name)
-            if packages
-              packages.each do |pkg|
-                pkg.provides.each do |provide|
-                  if provide.satisfy?(rpmdep)
-                    what << pkg
-                  end
-                end
-              end
-            end
-
-            return what
-          end
-        end
-
-        # Cache for our installed and available packages, pulled in from yum-dump.py
-        class YumCache
-          include Chef::Mixin::Which
-          include Chef::Mixin::ShellOut
-          include Singleton
-
-          attr_accessor :yum_binary
-
-          def initialize
-            @rpmdb = RPMDb.new
-
-            # Next time @rpmdb is accessed:
-            #  :all       - Trigger a run of "yum-dump.py --options --installed-provides", updates
-            #               yum's cache and parses options from /etc/yum.conf. Pulls in Provides
-            #               dependency data for installed packages only - this data is slow to
-            #               gather.
-            #  :provides  - Same as :all but pulls in Provides data for available packages as well.
-            #               Used as a last resort when we can't find a Provides match.
-            #  :installed - Trigger a run of "yum-dump.py --installed", only reads the local rpm
-            #               db. Used between client runs for a quick refresh.
-            #  :none      - Do nothing, a call to one of the reload methods is required.
-            @next_refresh = :all
-
-            @allow_multi_install = []
-
-            @extra_repo_control = nil
-
-            # these are for subsequent runs if we are on an interval
-            Chef::Client.when_run_starts do
-              YumCache.instance.reload
-            end
-          end
-
-          attr_reader :extra_repo_control
-
-          # Cache management
-          #
-
-          def refresh
-            case @next_refresh
-            when :none
-              return nil
-            when :installed
-              reset_installed
-              # fast
-              opts = " --installed"
-            when :all
-              reset
-              # medium
-              opts = " --options --installed-provides"
-            when :provides
-              reset
-              # slow!
-              opts = " --options --all-provides"
-            else
-              raise ArgumentError, "Unexpected value in next_refresh: #{@next_refresh}"
-            end
-
-            if @extra_repo_control
-              opts << " #{@extra_repo_control}"
-            end
-
-            opts << " --yum-lock-timeout #{Chef::Config[:yum_lock_timeout]}"
-
-            one_line = false
-            error = nil
-
-            helper = ::File.join(::File.dirname(__FILE__), "yum-dump.py")
-            status = nil
-
-            begin
-              status = shell_out!("#{python_bin} #{helper}#{opts}", :timeout => Chef::Config[:yum_timeout])
-              status.stdout.each_line do |line|
-                one_line = true
-
-                line.chomp!
-                if line =~ %r{\[option (.*)\] (.*)}
-                  if $1 == "installonlypkgs"
-                    @allow_multi_install = $2.split
-                  else
-                    raise Chef::Exceptions::Package, "Strange, unknown option line '#{line}' from yum-dump.py"
-                  end
-                  next
-                end
-
-                if line =~ %r{^(\S+) ([0-9]+) (\S+) (\S+) (\S+) \[(.*)\] ([i,a,r]) (\S+)$}
-                  name     = $1
-                  epoch    = $2
-                  version  = $3
-                  release  = $4
-                  arch     = $5
-                  provides = parse_provides($6)
-                  type     = $7
-                  repoid   = $8
-                else
-                  Chef::Log.warn("Problem parsing line '#{line}' from yum-dump.py! " +
-                                 "Please check your yum configuration.")
-                  next
-                end
-
-                case type
-                when "i"
-                  # if yum-dump was called with --installed this may not be true, but it's okay
-                  # since we don't touch the @available Set in reload_installed
-                  available = false
-                  installed = true
-                when "a"
-                  available = true
-                  installed = false
-                when "r"
-                  available = true
-                  installed = true
-                end
-
-                pkg = RPMDbPackage.new(name, epoch, version, release, arch, provides, installed, available, repoid)
-                @rpmdb << pkg
-              end
-
-              error = status.stderr
-            rescue Mixlib::ShellOut::CommandTimeout => e
-              Chef::Log.error("#{helper} exceeded timeout #{Chef::Config[:yum_timeout]}")
-              raise(e)
-            end
-
-            if status.exitstatus != 0
-              raise Chef::Exceptions::Package, "Yum failed - #{status.inspect} - returns: #{error}"
-            else
-              unless one_line
-                Chef::Log.warn("Odd, no output from yum-dump.py. Please check " +
-                               "your yum configuration.")
-              end
-            end
-
-            # A reload method must be called before the cache is altered
-            @next_refresh = :none
-          end
-
-          def python_bin
-            yum_executable = which(yum_binary)
-            if yum_executable && shabang?(yum_executable)
-              shabang_or_fallback(extract_interpreter(yum_executable))
-            else
-              Chef::Log.warn("Yum executable not found or doesn't start with #!. Using default python.")
-              "/usr/bin/python"
-            end
-          rescue StandardError => e
-            Chef::Log.warn("An error occurred attempting to determine correct python executable. Using default.")
-            Chef::Log.debug(e)
-            "/usr/bin/python"
-          end
-
-          def extract_interpreter(file)
-            ::File.open(file, "r", &:readline)[2..-1].strip
-          end
-
-          # dnf based systems have a yum shim that has /bin/bash as the interpreter. Don't use this.
-          def shabang_or_fallback(interpreter)
-            if interpreter == "/bin/bash"
-              Chef::Log.warn("Yum executable interpreter is /bin/bash. Falling back to default python.")
-              "/usr/bin/python"
-            else
-              interpreter
-            end
-          end
-
-          def shabang?(file)
-            ::File.open(file, "r") do |f|
-              f.read(2) == '#!'
-            end
-          rescue Errno::ENOENT
-            false
-          end
-
-          def reload
-            @next_refresh = :all
-          end
-
-          def reload_installed
-            @next_refresh = :installed
-          end
-
-          def reload_provides
-            @next_refresh = :provides
-          end
-
-          def reset
-            @rpmdb.clear
-          end
-
-          def reset_installed
-            @rpmdb.clear_installed
-          end
-
-          # Querying the cache
-          #
-
-          # Check for package by name or name+arch
-          def package_available?(package_name)
-            refresh
-
-            if @rpmdb.lookup(package_name)
-              return true
-            else
-              if package_name =~ %r{^(.*)\.(.*)$}
-                pkg_name = $1
-                pkg_arch = $2
-
-                if matches = @rpmdb.lookup(pkg_name)
-                  matches.each do |m|
-                    return true if m.arch == pkg_arch
-                  end
-                end
-              end
-            end
-
-            return false
-          end
-
-          # Returns a array of packages satisfying an RPMDependency
-          def packages_from_require(rpmdep)
-            refresh
-            @rpmdb.whatprovides(rpmdep)
-          end
-
-          # Check if a package-version.arch is available to install
-          def version_available?(package_name, desired_version, arch = nil)
-            version(package_name, arch, true, false) do |v|
-              return true if desired_version == v
-            end
-
-            return false
-          end
-
-          # Return the source repository for a package-version.arch
-          def package_repository(package_name, desired_version, arch = nil)
-            package(package_name, arch, true, false) do |pkg|
-              return pkg.repoid if desired_version == pkg.version.to_s
-            end
-
-            return nil
-          end
-
-          # Return the latest available version for a package.arch
-          def available_version(package_name, arch = nil)
-            version(package_name, arch, true, false)
-          end
-          alias :candidate_version :available_version
-
-          # Return the currently installed version for a package.arch
-          def installed_version(package_name, arch = nil)
-            version(package_name, arch, false, true)
-          end
-
-          # Return an array of packages allowed to be installed multiple times, such as the kernel
-          def allow_multi_install
-            refresh
-            @allow_multi_install
-          end
-
-          def enable_extra_repo_control(arg)
-            # Don't touch cache if it's the same repos as the last load
-            unless @extra_repo_control == arg
-              @extra_repo_control = arg
-              reload
-            end
-          end
-
-          def disable_extra_repo_control
-            # Only force reload when set
-            if @extra_repo_control
-              @extra_repo_control = nil
-              reload
-            end
-          end
-
-          private
-
-          def version(package_name, arch = nil, is_available = false, is_installed = false)
-            package(package_name, arch, is_available, is_installed) do |pkg|
-              if block_given?
-                yield pkg.version.to_s
-              else
-                # first match is latest version
-                return pkg.version.to_s
-              end
-            end
-
-            if block_given?
-              return self
-            else
-              return nil
-            end
-          end
-
-          def package(package_name, arch = nil, is_available = false, is_installed = false)
-            refresh
-            packages = @rpmdb[package_name]
-            if packages
-              packages.each do |pkg|
-                if is_available
-                  next unless @rpmdb.available?(pkg)
-                end
-                if is_installed
-                  next unless @rpmdb.installed?(pkg)
-                end
-                if arch
-                  next unless pkg.arch == arch
-                end
-
-                if block_given?
-                  yield pkg
-                else
-                  # first match is latest version
-                  return pkg
-                end
-              end
-            end
-
-            if block_given?
-              return self
-            else
-              return nil
-            end
-          end
-
-          # Parse provides from yum-dump.py output
-          def parse_provides(string)
-            ret = []
-            # ['atk = 1.12.2-1.fc6', 'libatk-1.0.so.0']
-            string.split(", ").each do |seg|
-              # 'atk = 1.12.2-1.fc6'
-              if seg =~ %r{^'(.*)'$}
-                ret << RPMProvide.parse($1)
-              end
-            end
-
-            return ret
-          end
-
-        end # YumCache
-
         include Chef::Mixin::GetSourceFromPackage
 
         def initialize(new_resource, run_context)
@@ -1126,7 +171,7 @@ class Chef
             end
           end
 
-          @current_resource = Chef::Resource::Package.new(@new_resource.name)
+          @current_resource = Chef::Resource::YumPackage.new(@new_resource.name)
           @current_resource.package_name(@new_resource.package_name)
 
           installed_version = []