chef 13.12.14-universal-mingw32 → 14.0.190-universal-mingw32

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

@@ -28,7 +28,7 @@ class Chef
 
         provides :package, platform: "nexentacore"
         provides :package, platform: "solaris2", platform_version: "< 5.11"
-        provides :solaris_package, os: "solaris2"
+        provides :solaris_package
 
         # def initialize(*args)
         #   super
@@ -54,7 +54,7 @@ class Chef
           if new_resource.source
             @package_source_found = ::File.exist?(new_resource.source)
             if @package_source_found
-              Chef::Log.debug("#{new_resource} checking pkg status")
+              logger.trace("#{new_resource} checking pkg status")
               shell_out_compact_timeout("pkginfo", "-l", "-d", new_resource.source, new_resource.package_name).stdout.each_line do |line|
                 case line
                 when /VERSION:\s+(.+)/
@@ -64,12 +64,12 @@ class Chef
             end
           end
 
-          Chef::Log.debug("#{new_resource} checking install state")
+          logger.trace("#{new_resource} checking install state")
           status = shell_out_compact_timeout("pkginfo", "-l", current_resource.package_name)
           status.stdout.each_line do |line|
             case line
             when /VERSION:\s+(.+)/
-              Chef::Log.debug("#{new_resource} version #{$1} is already installed")
+              logger.trace("#{new_resource} version #{$1} is already installed")
               current_resource.version($1)
             end
           end
@@ -89,7 +89,7 @@ class Chef
             when /VERSION:\s+(.+)/
               @candidate_version = $1
               new_resource.version($1)
-              Chef::Log.debug("#{new_resource} setting install candidate version to #{@candidate_version}")
+              logger.trace("#{new_resource} setting install candidate version to #{@candidate_version}")
             end
           end
           unless status.exitstatus == 0
@@ -99,7 +99,7 @@ class Chef
         end
 
         def install_package(name, version)
-          Chef::Log.debug("#{new_resource} package install options: #{options}")
+          logger.trace("#{new_resource} package install options: #{options}")
           if options.nil?
             command = if ::File.directory?(new_resource.source) # CHEF-4469
                         [ "pkgadd", "-n", "-d", new_resource.source, new_resource.package_name ]
@@ -107,7 +107,7 @@ class Chef
                         [ "pkgadd", "-n", "-d", new_resource.source, "all" ]
                       end
             shell_out_compact_timeout!(command)
-            Chef::Log.debug("#{new_resource} installed version #{new_resource.version} from: #{new_resource.source}")
+            logger.trace("#{new_resource} installed version #{new_resource.version} from: #{new_resource.source}")
           else
             command = if ::File.directory?(new_resource.source) # CHEF-4469
                         [ "pkgadd", "-n", options, "-d", new_resource.source, new_resource.package_name ]
@@ -115,7 +115,7 @@ class Chef
                         [ "pkgadd", "-n", options, "-d", new_resource.source, "all" ]
                       end
             shell_out_compact_timeout!(*command)
-            Chef::Log.debug("#{new_resource} installed version #{new_resource.version} from: #{new_resource.source}")
+            logger.trace("#{new_resource} installed version #{new_resource.version} from: #{new_resource.source}")
           end
         end
 
@@ -124,10 +124,10 @@ class Chef
         def remove_package(name, version)
           if options.nil?
             shell_out_compact_timeout!( "pkgrm", "-n", name )
-            Chef::Log.debug("#{new_resource} removed version #{new_resource.version}")
+            logger.trace("#{new_resource} removed version #{new_resource.version}")
           else
             shell_out_compact_timeout!( "pkgrm", "-n", options, name )
-            Chef::Log.debug("#{new_resource} removed version #{new_resource.version}")
+            logger.trace("#{new_resource} removed version #{new_resource.version}")
           end
         end
 

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

@@ -30,7 +30,7 @@ class Chef
         include Chef::Mixin::Checksum
 
         provides :package, os: "windows"
-        provides :windows_package, os: "windows"
+        provides :windows_package
 
         require "chef/provider/package/windows/registry_uninstall_entry.rb"
 
@@ -39,21 +39,13 @@ class Chef
             a.assertion { new_resource.source || msi? }
             a.failure_message Chef::Exceptions::NoWindowsPackageSource, "Source for package #{new_resource.name} must be specified in the resource's source property for package to be installed because the package_name property is used to test for the package installation state for this package type."
           end
-
-          unless uri_scheme?(new_resource.source)
-            requirements.assert(:install) do |a|
-              a.assertion { ::File.exist?(new_resource.source) }
-              a.failure_message Chef::Exceptions::Package, "Source for package #{new_resource.name} does not exist"
-              a.whyrun "Assuming source file #{new_resource.source} would have been created."
-            end
-          end
         end
 
         # load_current_resource is run in Chef::Provider#run_action when not in whyrun_mode?
         def load_current_resource
           @current_resource = Chef::Resource::WindowsPackage.new(new_resource.name)
           if downloadable_file_missing?
-            Chef::Log.debug("We do not know the version of #{new_resource.source} because the file is not downloaded")
+            logger.trace("We do not know the version of #{new_resource.source} because the file is not downloaded")
             current_resource.version(:unknown.to_s)
           else
             current_resource.version(package_provider.installed_version)
@@ -67,11 +59,11 @@ class Chef
           @package_provider ||= begin
             case installer_type
             when :msi
-              Chef::Log.debug("#{new_resource} is MSI")
+              logger.trace("#{new_resource} is MSI")
               require "chef/provider/package/windows/msi"
               Chef::Provider::Package::Windows::MSI.new(resource_for_provider, uninstall_registry_entries)
             else
-              Chef::Log.debug("#{new_resource} is EXE with type '#{installer_type}'")
+              logger.trace("#{new_resource} is EXE with type '#{installer_type}'")
               require "chef/provider/package/windows/exe"
               Chef::Provider::Package::Windows::Exe.new(resource_for_provider, installer_type, uninstall_registry_entries)
             end
@@ -177,7 +169,7 @@ class Chef
         end
 
         def version_equals?(current_version, new_version)
-          Chef::Log.debug("Checking if #{new_resource} version '#{new_version}' is already installed. #{current_version} is currently installed")
+          logger.trace("Checking if #{new_resource} version '#{new_version}' is already installed. #{current_version} is currently installed")
           if current_version.is_a?(Array)
             current_version.include?(new_version)
           else
@@ -229,13 +221,12 @@ class Chef
             r.timeout(new_resource.timeout)
             r.returns(new_resource.returns)
             r.options(new_resource.options)
-            r.sensitive(new_resource.sensitive)
           end
         end
 
         def download_source_file
           source_resource.run_action(:create)
-          Chef::Log.debug("#{new_resource} fetched source file to #{source_resource.path}")
+          logger.trace("#{new_resource} fetched source file to #{source_resource.path}")
         end
 
         def source_resource

data/lib/chef/provider/package/windows/exe.rb

@@ -28,11 +28,13 @@ class Chef
 
           def initialize(resource, installer_type, uninstall_entries)
             @new_resource = resource
+            @logger = new_resource.logger
             @installer_type = installer_type
             @uninstall_entries = uninstall_entries
           end
 
           attr_reader :new_resource
+          attr_reader :logger
           attr_reader :installer_type
           attr_reader :uninstall_entries
 
@@ -43,7 +45,7 @@ class Chef
 
           # Returns a version if the package is installed or nil if it is not.
           def installed_version
-            Chef::Log.debug("#{new_resource} checking package version")
+            logger.trace("#{new_resource} checking package version")
             current_installed_version
           end
 
@@ -52,7 +54,7 @@ class Chef
           end
 
           def install_package
-            Chef::Log.debug("#{new_resource} installing #{new_resource.installer_type} package '#{new_resource.source}'")
+            logger.trace("#{new_resource} installing #{new_resource.installer_type} package '#{new_resource.source}'")
             shell_out!(
               [
                 "start",
@@ -62,7 +64,7 @@ class Chef
                 unattended_flags,
                 expand_options(new_resource.options),
                 "& exit %%%%ERRORLEVEL%%%%",
-              ].join(" "), timeout: new_resource.timeout, returns: new_resource.returns, sensitive: new_resource.sensitive
+              ].join(" "), timeout: new_resource.timeout, returns: new_resource.returns
             )
           end
 
@@ -70,7 +72,7 @@ class Chef
             uninstall_version = new_resource.version || current_installed_version
             uninstall_entries.select { |entry| [uninstall_version].flatten.include?(entry.display_version) }
                              .map(&:uninstall_string).uniq.each do |uninstall_string|
-              Chef::Log.debug("Registry provided uninstall string for #{new_resource} is '#{uninstall_string}'")
+              logger.trace("Registry provided uninstall string for #{new_resource} is '#{uninstall_string}'")
               shell_out!(uninstall_command(uninstall_string), timeout: new_resource.timeout, returns: new_resource.returns)
             end
           end

data/lib/chef/provider/package/windows/msi.rb

@@ -31,10 +31,12 @@ class Chef
 
           def initialize(resource, uninstall_entries)
             @new_resource = resource
+            @logger = new_resource.logger
             @uninstall_entries = uninstall_entries
           end
 
           attr_reader :new_resource
+          attr_reader :logger
           attr_reader :uninstall_entries
 
           # From Chef::Provider::Package
@@ -45,9 +47,9 @@ class Chef
           # Returns a version if the package is installed or nil if it is not.
           def installed_version
             if !new_resource.source.nil? && ::File.exist?(new_resource.source)
-              Chef::Log.debug("#{new_resource} getting product code for package at #{new_resource.source}")
+              logger.trace("#{new_resource} getting product code for package at #{new_resource.source}")
               product_code = get_product_property(new_resource.source, "ProductCode")
-              Chef::Log.debug("#{new_resource} checking package status and version for #{product_code}")
+              logger.trace("#{new_resource} checking package status and version for #{product_code}")
               get_installed_version(product_code)
             else
               if uninstall_entries.count != 0
@@ -59,21 +61,21 @@ class Chef
           def package_version
             return new_resource.version if new_resource.version
             if !new_resource.source.nil? && ::File.exist?(new_resource.source)
-              Chef::Log.debug("#{new_resource} getting product version for package at #{new_resource.source}")
+              logger.trace("#{new_resource} getting product version for package at #{new_resource.source}")
               get_product_property(new_resource.source, "ProductVersion")
             end
           end
 
           def install_package
             # We could use MsiConfigureProduct here, but we'll start off with msiexec
-            Chef::Log.debug("#{new_resource} installing MSI package '#{new_resource.source}'")
+            logger.trace("#{new_resource} installing MSI package '#{new_resource.source}'")
             shell_out!("msiexec /qn /i \"#{new_resource.source}\" #{expand_options(new_resource.options)}", timeout: new_resource.timeout, returns: new_resource.returns)
           end
 
           def remove_package
             # We could use MsiConfigureProduct here, but we'll start off with msiexec
             if !new_resource.source.nil? && ::File.exist?(new_resource.source)
-              Chef::Log.debug("#{new_resource} removing MSI package '#{new_resource.source}'")
+              logger.trace("#{new_resource} removing MSI package '#{new_resource.source}'")
               shell_out!("msiexec /qn /x \"#{new_resource.source}\" #{expand_options(new_resource.options)}", timeout: new_resource.timeout, returns: new_resource.returns)
             else
               uninstall_version = new_resource.version || installed_version
@@ -82,7 +84,7 @@ class Chef
                 uninstall_string = "msiexec /x #{uninstall_string.match(/{.*}/)}"
                 uninstall_string += expand_options(new_resource.options)
                 uninstall_string += " /q" unless uninstall_string.downcase =~ / \/q/
-                Chef::Log.debug("#{new_resource} removing MSI package version using '#{uninstall_string}'")
+                logger.trace("#{new_resource} removing MSI package version using '#{uninstall_string}'")
                 shell_out!(uninstall_string, timeout: new_resource.timeout, returns: new_resource.returns)
               end
             end

data/lib/chef/provider/package/windows/registry_uninstall_entry.rb

@@ -26,7 +26,7 @@ class Chef
         class RegistryUninstallEntry
 
           def self.find_entries(package_name)
-            Chef::Log.debug("Finding uninstall entries for #{package_name}")
+            logger.trace("Finding uninstall entries for #{package_name}")
             entries = []
             [
               [::Win32::Registry::HKEY_LOCAL_MACHINE, (::Win32::Registry::Constants::KEY_READ | 0x0100)],
@@ -45,12 +45,12 @@ class Chef
                         entries.push(quiet_uninstall_string_key?(quiet_uninstall_string, hkey, key, entry))
                       end
                     rescue ::Win32::Registry::Error => ex
-                      Chef::Log.debug("Registry error opening key '#{key}' on node #{desired}: #{ex}")
+                      logger.trace("Registry error opening key '#{key}' on node #{desired}: #{ex}")
                     end
                   end
                 end
               rescue ::Win32::Registry::Error => ex
-                Chef::Log.debug("Registry error opening hive '#{hkey[0]}' :: #{desired}: #{ex}")
+                logger.trace("Registry error opening hive '#{hkey[0]}' :: #{desired}: #{ex}")
               end
             end
             entries
@@ -63,13 +63,18 @@ class Chef
 
           def self.read_registry_property(data, property)
             data[property]
-          rescue ::Win32::Registry::Error => ex
-            Chef::Log.debug("Failure to read property '#{property}'")
+          rescue ::Win32::Registry::Error
+            logger.trace("Failure to read property '#{property}'")
             nil
           end
 
+          def self.logger
+            Chef::Log
+          end
+
           def initialize(hive, key, registry_data, uninstall_key = "UninstallString")
-            Chef::Log.debug("Creating uninstall entry for #{hive}::#{key}")
+            @logger = Chef::Log.with_child({ subsystem: "registry_uninstall_entry" })
+            logger.trace("Creating uninstall entry for #{hive}::#{key}")
             @hive = hive
             @key = key
             @data = registry_data
@@ -84,6 +89,7 @@ class Chef
           attr_reader :display_version
           attr_reader :uninstall_string
           attr_reader :data
+          attr_reader :logger
 
           UNINSTALL_SUBKEY = 'Software\Microsoft\Windows\CurrentVersion\Uninstall'.freeze
         end

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

@@ -1,6 +1,5 @@
-
-# Author:: Adam Jacob (<adam@chef.io>)
-# Copyright:: Copyright 2008-2017, Chef Software Inc.
+#
+# Copyright:: Copyright 2016-2018, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,487 +15,264 @@
 # limitations under the License.
 #
 
-require "chef/config"
 require "chef/provider/package"
 require "chef/resource/yum_package"
+require "chef/mixin/which"
+require "chef/mixin/shell_out"
 require "chef/mixin/get_source_from_package"
-require "chef/provider/package/yum/rpm_utils"
+require "chef/provider/package/yum/python_helper"
+require "chef/provider/package/yum/version"
+# the stubs in the YumCache class are still an external API
 require "chef/provider/package/yum/yum_cache"
 
 class Chef
   class Provider
     class Package
       class Yum < Chef::Provider::Package
+        extend Chef::Mixin::Which
+        extend Chef::Mixin::ShellOut
         include Chef::Mixin::GetSourceFromPackage
 
-        provides :package, platform_family: %w{rhel fedora amazon}
-        provides :yum_package, os: "linux"
-
-        # Multipackage API
         allow_nils
         use_multipackage_api
         use_package_name_for_source
 
-        # Overload the Package provider to keep track of the YumCache
-        def initialize(new_resource, run_context)
-          super
+        provides :package, platform_family: %w{fedora amazon rhel}
+
+        provides :yum_package
 
-          @yum = YumCache.instance
-          @yum.yum_binary = yum_binary
+        #
+        # Most of the magic in this class happens in the python helper script.  The ruby side of this
+        # provider knows only enough to translate Chef-style new_resource name+package+version into
+        # a request to the python side.  The python side is then responsible for knowing everything
+        # about RPMs and what is installed and what is available.  The ruby side of this class should
+        # remain a lightweight translation layer to translate Chef requests into RPC requests to
+        # python.  This class knows nothing about how to compare RPM versions, and does not maintain
+        # any cached state of installed/available versions and should be kept that way.
+        #
+        def python_helper
+          @python_helper ||= PythonHelper.instance
         end
 
-        # @see Chef::Provider::Package#check_resource_semantics!
-        def check_resource_semantics!
-          super
+        def load_current_resource
+          flushcache if new_resource.flush_cache[:before]
 
-          if !new_resource.version.nil? && package_name_array.length != new_version_array.length
-            raise Chef::Exceptions::InvalidResourceSpecification, "Please provide a version for each package. Use `nil` for default version."
-          end
+          @current_resource = Chef::Resource::YumPackage.new(new_resource.name)
+          current_resource.package_name(new_resource.package_name)
+          current_resource.version(get_current_versions)
 
-          if !new_resource.arch.nil? && package_name_array.length != safe_arch_array.length
-            raise Chef::Exceptions::InvalidResourceSpecification, "Please provide an architecture for each package. Use `nil` for default architecture."
-          end
+          current_resource
         end
 
-        # @see Chef::Provider#define_resource_requirements
         def define_resource_requirements
-          super
-
-          # Ensure that the source file (if specified) is present on the file system
           requirements.assert(:install, :upgrade, :remove, :purge) do |a|
             a.assertion { !new_resource.source || ::File.exist?(new_resource.source) }
             a.failure_message Chef::Exceptions::Package, "Package #{new_resource.package_name} not found: #{new_resource.source}"
             a.whyrun "assuming #{new_resource.source} would have previously been created"
           end
-        end
-
-        # @see Chef::Provider#load_current_resource
-        def load_current_resource
-          @yum.reload if flush_cache[:before]
-          manage_extra_repo_control
-
-          if new_resource.source
-            query_source_file
-          else
-            # At this point package_name could be:
-            #
-            # 1) a package name, eg: "foo"
-            # 2) a package name.arch, eg: "foo.i386"
-            # 3) or a dependency, eg: "foo >= 1.1"
-            #
-            # In the third case, we want to convert those dependency strings into
-            # packages that we can actually install
-            convert_dependency_strings_into_packages
-
-            # Fill out the rest of the details by querying the Yum Cache
-            query_yum_cache
-          end
 
-          @current_resource = Chef::Resource::YumPackage.new(new_resource.name)
-          current_resource.package_name(new_resource.package_name)
-          current_resource.version(@installed_version)
-          current_resource
+          super
         end
 
-        # @see Chef::Provider::Package#package_locked
-        def package_locked(name, version)
-          islocked = false
-          locked = shell_out_with_timeout!("yum versionlock")
-          locked.stdout.each_line do |line|
-            line_package = line.sub(/-[^-]*-[^-]*$/, "").split(":").last.strip
-            if line_package == name
-              islocked = true
-            end
+        def candidate_version
+          package_name_array.each_with_index.map do |pkg, i|
+            available_version(i).version_with_arch
           end
-          islocked
         end
 
-        #
-        # Package Action Classes
-        #
-
-        # @see Chef::Provider::Package#install_package
-        def install_package(name, version)
-          if new_resource.source
-            yum_command("-d0 -e0 -y#{expand_options(new_resource.options)} localinstall #{new_resource.source}")
-          else
-            install_remote_package(name, version)
+        def get_current_versions
+          package_name_array.each_with_index.map do |pkg, i|
+            installed_version(i).version_with_arch
           end
-
-          flush_cache[:after] ? @yum.reload : @yum.reload_installed
         end
 
-        # @see Chef::Provider::Package#upgrade_package
-        def upgrade_package(name, version)
-          install_package(name, version)
-        end
+        def install_package(names, versions)
+          method = nil
+          methods = []
+          names.each_with_index do |n, i|
+            next if n.nil?
 
-        # @see Chef::Provider::Package#remove_package
-        def remove_package(name, version)
-          remove_str = full_package_name(name, version).join(" ")
-          yum_command("-d0 -e0 -y#{expand_options(new_resource.options)} remove #{remove_str}")
+            av = available_version(i)
 
-          flush_cache[:after] ? @yum.reload : @yum.reload_installed
-        end
+            name = av.name # resolve the name via the available/candidate version
 
-        # @see Chef::Provider::Package#purge_package
-        def purge_package(name, version)
-          remove_package(name, version)
-        end
+            iv = python_helper.package_query(:whatinstalled, name)
 
-        # @see Chef::Provider::Package#lock_package
-        def lock_package(name, version)
-          lock_str = full_package_name(name, as_array(name).map { nil }).join(" ")
-          yum_command("-d0 -e0 -y#{expand_options(new_resource.options)} versionlock add #{lock_str}")
-        end
-
-        # @see Chef::Provider::Package#unlock_package
-        def unlock_package(name, version)
-          unlock_str = full_package_name(name, as_array(name).map { nil }).join(" ")
-          yum_command("-d0 -e0 -y#{expand_options(new_resource.options)} versionlock delete #{unlock_str}")
-        end
-
-        private
+            method = "install"
 
-        #
-        # System Level Yum Operations
-        #
-
-        def yum_binary
-          @yum_binary ||=
-            begin
-              yum_binary = new_resource.yum_binary if new_resource.is_a?(Chef::Resource::YumPackage)
-              yum_binary ||= ::File.exist?("/usr/bin/yum-deprecated") ? "yum-deprecated" : "yum"
+            # If this is a package like the kernel that can be installed multiple times, we'll skip over this logic
+            if new_resource.allow_downgrade && version_gt?(iv.version_with_arch, av.version_with_arch) && !python_helper.install_only_packages(name)
+              # We allow downgrading only in the evenit of single-package
+              # rules where the user explicitly allowed it
+              method = "downgrade"
             end
-        end
 
-        def version_compare(v1, v2)
-          RPMVersion.parse(v1) <=> RPMVersion.parse(v2)
-        end
+            methods << method
+          end
 
-        # Enable or disable YumCache extra_repo_control
-        def manage_extra_repo_control
-          if new_resource.options
-            repo_control = []
-            new_resource.options.each do |opt|
-              repo_control << opt if opt =~ /--(enable|disable)repo=.+/
-            end
+          # We could split this up into two commands if we wanted to, but
+          # for now, just don't support this.
+          if methods.uniq.length > 1
+            raise Chef::Exceptions::Package, "Multipackage rule has a mix of upgrade and downgrade packages. Cannot proceed."
+          end
 
-            if !repo_control.empty?
-              @yum.enable_extra_repo_control(repo_control.join(" "))
-            else
-              @yum.disable_extra_repo_control
-            end
+          if new_resource.source
+            yum(options, "-y #{method}", new_resource.source)
           else
-            @yum.disable_extra_repo_control
+            resolved_names = names.each_with_index.map { |name, i| available_version(i).to_s unless name.nil? }
+            yum(options, "-y #{method}", resolved_names)
           end
+          flushcache
         end
 
-        # Query the Yum cache for information about potential packages
-        def query_yum_cache
-          installed_versions = []
-          candidate_versions = []
-
-          package_name_array.each_with_index do |n, idx|
-            pkg_name, eval_pkg_arch = parse_arch(n)
+        # yum upgrade does not work on uninstalled packaged, while install will upgrade
+        alias upgrade_package install_package
 
-            # Defer to the arch property for the desired package architecture
-            pkg_arch = safe_arch_array[idx] || eval_pkg_arch
-            set_package_name(idx, pkg_name)
-            set_package_arch(idx, pkg_arch)
+        def remove_package(names, versions)
+          resolved_names = names.each_with_index.map { |name, i| installed_version(i).to_s unless name.nil? }
+          yum(options, "-y remove", resolved_names)
+          flushcache
+        end
 
-            Chef::Log.debug("#{new_resource} checking yum info for #{yum_syntax(n, nil, pkg_arch)}")
-            installed_versions << iv = @yum.installed_version(pkg_name, pkg_arch)
-            candidate_versions << cv = @yum.candidate_version(pkg_name, pkg_arch)
+        alias purge_package remove_package
 
-            Chef::Log.debug("Found Yum package: #{pkg_name} installed version: #{iv || '(none)'} candidate version: #{cv || '(none)'}")
-          end
+        action :flush_cache do
+          flushcache
+        end
 
-          @installed_version = installed_versions.length > 1 ? installed_versions : installed_versions[0]
-          @candidate_version = candidate_versions.length > 1 ? candidate_versions : candidate_versions[0]
+        # NB: the yum_package provider manages individual single packages, please do not submit issues or PRs to try to add wildcard
+        # support to lock / unlock.  The best solution is to write an execute resource which does a not_if `yum versionlock | grep '^pattern`` kind of approach
+        def lock_package(names, versions)
+          yum("-d0 -e0 -y", options, "versionlock add", resolved_package_lock_names(names))
         end
 
-        # Query the provided source file for the package name and version
-        def query_source_file
-          Chef::Log.debug("#{new_resource} checking rpm status")
-          shell_out_with_timeout!("rpm -qp --queryformat '%{NAME} %{VERSION}-%{RELEASE} %{ARCH}\n' #{new_resource.source}", timeout: Chef::Config[:yum_timeout]).stdout.each_line do |line|
-            case line
-            when /^(\S+)\s(\S+)\s(\S+)$/
-              n = $1
-              v = $2
-              a = $3
-
-              unless new_resource.package_name == n
-                Chef::Log.debug("#{new_resource} updating package_name from #{new_resource.package_name} to #{n} (per #{new_resource.source})")
-                new_resource.package_name(n)
-              end
+        # NB: the yum_package provider manages individual single packages, please do not submit issues or PRs to try to add wildcard
+        # support to lock / unlock.  The best solution is to write an execute resource which does a only_if `yum versionlock | grep '^pattern`` kind of approach
+        def unlock_package(names, versions)
+          # yum versionlock delete on rhel6 needs the glob nonsense in the following command
+          yum("-d0 -e0 -y", options, "versionlock delete", resolved_package_lock_names(names).map { |n| "'*:#{n}-*'" })
+        end
 
-              unless new_resource.version == v
-                Chef::Log.debug("#{new_resource} updating version from #{new_resource.version} to #{v} (per #{new_resource.source})")
-                new_resource.version(v)
-              end
+        private
 
-              unless new_resource.arch == a
-                Chef::Log.debug("#{new_resource} updating architecture from #{new_resource.arch} to #{a} (per #{new_resource.source})")
-                new_resource.arch(a)
+        # this will resolve things like `/usr/bin/perl` or virtual packages like `mysql` -- it will not work (well? at all?) with globs that match multiple packages
+        def resolved_package_lock_names(names)
+          names.each_with_index.map do |name, i|
+            if !name.nil?
+              if installed_version(i).version.nil?
+                available_version(i).name
+              else
+                installed_version(i).name
               end
             end
           end
-
-          @installed_version = @yum.installed_version(new_resource.package_name, new_resource.arch)
-          @candidate_version = new_resource.version
         end
 
-        def yum_command(command)
-          command = "#{yum_binary} #{command}"
-          Chef::Log.debug("#{new_resource}: yum command: \"#{command}\"")
-          status = shell_out_with_timeout(command, timeout: Chef::Config[:yum_timeout])
-
-          # This is fun: rpm can encounter errors in the %post/%postun scripts which aren't
-          # considered fatal - meaning the rpm is still successfully installed. These issue
-          # cause yum to emit a non fatal warning but still exit(1). As there's currently no
-          # way to suppress this behavior and an exit(1) will break a Chef run we make an
-          # effort to trap these and re-run the same install command - it will either fail a
-          # second time or succeed.
-          #
-          # A cleaner solution would have to be done in python and better hook into
-          # yum/rpm to handle exceptions as we see fit.
-          if status.exitstatus == 1
-            status.stdout.each_line do |l|
-              # rpm-4.4.2.3 lib/psm.c line 2182
-              next unless l =~ /^error: %(post|postun)\(.*\) scriptlet failed, exit status \d+$/
-              Chef::Log.warn("#{new_resource} caught non-fatal scriptlet issue: \"#{l}\". Can't trust yum exit status " \
-                             "so running install again to verify.")
-              status = shell_out_with_timeout(command, timeout: Chef::Config[:yum_timeout])
-              break
+        def locked_packages
+          @locked_packages ||=
+            begin
+              locked = shell_out_with_timeout!("yum versionlock list")
+              locked.stdout.each_line.map do |line|
+                line.sub(/-[^-]*-[^-]*$/, "").split(":").last.strip
+              end
             end
-          end
-
-          if status.exitstatus > 0
-            command_output = "STDOUT: #{status.stdout}\nSTDERR: #{status.stderr}"
-            raise Chef::Exceptions::Exec, "#{command} returned #{status.exitstatus}:\n#{command_output}"
-          end
         end
 
-        def install_remote_package(name, version)
-          # Work around yum not exiting with an error if a package doesn't exist for CHEF-2062.
-          all_avail = as_array(name).zip(as_array(version), safe_arch_array).any? do |n, v, a|
-            @yum.version_available?(n, v, a)
-          end
-
-          method = log_method = nil
-          methods = []
-          if all_avail
-            # More Yum fun:
-            #
-            # yum install of an old name+version will exit(1)
-            # yum install of an old name+version+arch will exit(0) for some reason
-            #
-            # Some packages can be installed multiple times like the kernel
-            as_array(name).zip(current_version_array, as_array(version), safe_arch_array).each do |n, cv, v, a|
-              next if n.nil?
-
-              method = "install"
-              log_method = "installing"
-
-              unless @yum.allow_multi_install.include?(n)
-                if RPMVersion.parse(cv) > RPMVersion.parse(v)
-                  # We allow downgrading only in the evenit of single-package
-                  # rules where the user explicitly allowed it
-                  if allow_downgrade
-                    method = "downgrade"
-                    log_method = "downgrading"
-                  else
-                    # we bail like yum when the package is older
-                    raise Chef::Exceptions::Package, "Installed package #{yum_syntax(n, cv, a)} is newer " \
-                      "than candidate package #{yum_syntax(n, v, a)}"
-                  end
-                end
-              end
-              # methods don't count for packages we won't be touching
-              next if RPMVersion.parse(cv) == RPMVersion.parse(v)
-              methods << method
-            end
+        def packages_all_locked?(names, versions)
+          resolved_package_lock_names(names).all? { |n| locked_packages.include? n }
+        end
 
-            # We could split this up into two commands if we wanted to, but
-            # for now, just don't support this.
-            if methods.uniq.length > 1
-              raise Chef::Exceptions::Package, "Multipackage rule #{name} has a mix of upgrade and downgrade packages. Cannot proceed."
-            end
+        def packages_all_unlocked?(names, versions)
+          !resolved_package_lock_names(names).any? { |n| locked_packages.include? n }
+        end
 
-            repos = []
-            pkg_string_bits = []
-            as_array(name).zip(current_version_array, as_array(version), safe_arch_array).each do |n, cv, v, a|
-              next if n.nil?
-              next if v == cv
-              s = yum_syntax(n, v, a)
-              repo = @yum.package_repository(n, v, a)
-              repos << "#{s} from #{repo} repository"
-              pkg_string_bits << s
-            end
-            pkg_string = pkg_string_bits.join(" ")
-            Chef::Log.info("#{new_resource} #{log_method} #{repos.join(' ')}")
-            yum_command("-d0 -e0 -y#{expand_options(new_resource.options)} #{method} #{pkg_string}")
-          else
-            raise Chef::Exceptions::Package, "Version #{version} of #{name} not found. Did you specify both version " \
-              "and release? (version-release, e.g. 1.84-10.fc6)"
-          end
+        def version_gt?(v1, v2)
+          return false if v1.nil? || v2.nil?
+          python_helper.compare_versions(v1, v2) == 1
         end
 
-        # Allow for foo.x86_64 style package_name like yum uses in it's output
-        def parse_arch(package_name)
-          if package_name =~ /^(.*)\.(.*)$/
-            new_package_name = $1
-            new_arch = $2
-            # foo.i386 and foo.beta1 are both valid package names or expressions of an arch.
-            # Ensure we don't have an existing package matching package_name, then ensure we at
-            # least have a match for the new_package+new_arch before we overwrite. If neither
-            # then fall through to standard package handling.
-            old_installed = @yum.installed_version(package_name)
-            old_candidate = @yum.candidate_version(package_name)
-            new_installed = @yum.installed_version(new_package_name, new_arch)
-            new_candidate = @yum.candidate_version(new_package_name, new_arch)
-            if (old_installed.nil? && old_candidate.nil?) && (new_installed || new_candidate)
-              Chef::Log.debug("Parsed out arch #{new_arch}, new package name is #{new_package_name}")
-              return new_package_name, new_arch
-            end
-          end
-          [package_name, nil]
+        def version_equals?(v1, v2)
+          return false if v1.nil? || v2.nil?
+          python_helper.compare_versions(v1, v2) == 0
         end
 
-        #
-        # Dependency String Handling
-        #
+        def version_compare(v1, v2)
+          return false if v1.nil? || v2.nil?
+          python_helper.compare_versions(v1, v2)
+        end
 
-        # Iterate through the list of package_names given to us by the user and
-        # see if any of them are in the depenency format ("foo >= 1.1"). Modify
-        # the list of packages and versions to incorporate those values.
-        def convert_dependency_strings_into_packages
-          package_name_array.each_with_index do |n, index|
-            next if @yum.package_available?(n)
-            # If they aren't in the installed packages they could be a dependency.
-            dep = parse_dependency(n, new_version_array[index])
-            if dep
-              if new_resource.package_name.is_a?(Array)
-                new_resource.package_name(package_name_array - [n] + [dep.first])
-                new_resource.version(new_version_array - [new_version_array[index]] + [dep.last]) if dep.last
-              else
-                new_resource.package_name(dep.first)
-                new_resource.version(dep.last) if dep.last
-              end
-            end
-          end
+        # Generate the yum syntax for the package
+        def yum_syntax(name, version, arch)
+          s = name
+          s += "-#{version}" if version
+          s += ".#{arch}" if arch
+          s
         end
 
-        # If we don't have the package we could have been passed a 'whatprovides' feature
-        #
-        # eg: yum install "perl(Config)"
-        #     yum install "mtr = 2:0.71-3.1"
-        #     yum install "mtr > 2:0.71"
-        #
-        # We support resolving these out of the Provides data imported from yum-dump.py and
-        # matching them up with an actual package so the standard resource handling can apply.
-        #
-        # There is currently no support for filename matching.
-        #
-        # Note: This was largely left alone during the multipackage refactor
-        def parse_dependency(name, version)
-          # Transform the package_name into a requirement
-
-          # If we are passed a version or a version constraint we have to assume it's a requirement first. If it can't be
-          # parsed only yum_require.name will be set and new_resource.version will be left intact
-          require_string = if version
-                             "#{name} #{version}"
-                           else
-                             # Transform the package_name into a requirement, might contain a version, could just be
-                             # a match for virtual provides
-                             name
-                           end
-          yum_require = RPMRequire.parse(require_string)
-          # and gather all the packages that have a Provides feature satisfying the requirement.
-          # It could be multiple be we can only manage one
-          packages = @yum.packages_from_require(yum_require)
-
-          if packages.empty?
-            # Don't bother if we are just ensuring a package is removed - we don't need Provides data
-            actions = Array(new_resource.action)
-            unless actions.size == 1 && (actions[0] == :remove || actions[0] == :purge)
-              Chef::Log.debug("#{new_resource} couldn't match #{new_resource.package_name} in " \
-                            "installed Provides, loading available Provides - this may take a moment")
-              @yum.reload_provides
-              packages = @yum.packages_from_require(yum_require)
+        def resolve_source_to_version_obj
+          shell_out_with_timeout!("rpm -qp --queryformat '%{NAME} %{EPOCH} %{VERSION} %{RELEASE} %{ARCH}\n' #{new_resource.source}").stdout.each_line do |line|
+            # this is another case of committing the sin of doing some lightweight mangling of RPM versions in ruby -- but the output of the rpm command
+            # does not match what the yum library accepts.
+            case line
+              when /^(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)$/
+                return Version.new($1, "#{$2 == '(none)' ? '0' : $2}:#{$3}-#{$4}", $5)
             end
           end
+        end
 
-          unless packages.empty?
-            new_package_name = packages.first.name
-            new_package_version = packages.first.version.to_s
-            debug_msg = "#{name}: Unable to match package '#{name}' but matched #{packages.size} "
-            debug_msg << (packages.size == 1 ? "package" : "packages")
-            debug_msg << ", selected '#{new_package_name}' version '#{new_package_version}'"
-            Chef::Log.debug(debug_msg)
-
-            # Ensure it's not the same package under a different architecture
-            unique_names = []
-            packages.each do |pkg|
-              unique_names << "#{pkg.name}-#{pkg.version.evr}"
-            end
-            unique_names.uniq!
+        # @returns Array<Version>
+        def available_version(index)
+          @available_version ||= []
 
-            if unique_names.size > 1
-              Chef::Log.warn("#{new_resource} matched multiple Provides for #{new_resource.package_name} " \
-                             "but we can only use the first match: #{new_package_name}. Please use a more " \
-                             "specific version.")
-            end
+          @available_version[index] ||= if new_resource.source
+                                          resolve_source_to_version_obj
+                                        else
+                                          python_helper.package_query(:whatavailable, package_name_array[index], version: safe_version_array[index], arch: safe_arch_array[index], options: options)
+                                        end
 
-            if yum_require.version.to_s.nil?
-              new_package_version = nil
-            end
-
-            [new_package_name, new_package_version]
-          end
+          @available_version[index]
         end
 
-        #
-        # Misc Helpers
-        #
+        # @returns Array<Version>
+        def installed_version(index)
+          @installed_version ||= []
+          @installed_version[index] ||= if new_resource.source
+                                          python_helper.package_query(:whatinstalled, available_version(index).name, version: safe_version_array[index], arch: safe_arch_array[index])
+                                        else
+                                          python_helper.package_query(:whatinstalled, package_name_array[index], version: safe_version_array[index], arch: safe_arch_array[index])
+                                        end
+          @installed_version[index]
+        end
 
-        # Given an list of names and versions, generate the full yum syntax package name
-        def full_package_name(name, version)
-          as_array(name).zip(as_array(version), safe_arch_array).map do |n, v, a|
-            yum_syntax(n, v, a)
-          end
+        # cache flushing is accomplished by simply restarting the python helper.  this produces a roughly
+        # 15% hit to the runtime of installing/removing/upgrading packages.  correctly using multipackage
+        # array installs (and the multipackage cookbook) can produce 600% improvements in runtime.
+        def flushcache
+          python_helper.restart
         end
 
-        # Generate the yum syntax for the package
-        def yum_syntax(name, version, arch)
-          s = name
-          s += "-#{version}" if version
-          s += ".#{arch}" if arch
-          s
+        def yum_binary
+          @yum_binary ||=
+            begin
+              yum_binary = new_resource.yum_binary if new_resource.is_a?(Chef::Resource::YumPackage)
+              yum_binary ||= ::File.exist?("/usr/bin/yum-deprecated") ? "yum-deprecated" : "yum"
+            end
         end
 
-        # Set the package name correctly based on whether it is a String or Array
-        def set_package_name(idx, name)
-          if new_resource.package_name.is_a?(String)
-            new_resource.package_name(name)
-          else
-            new_resource.package_name[idx] = name
-          end
+        def yum(*args)
+          shell_out_with_timeout!(a_to_s(yum_binary, *args))
         end
 
-        # Set the architecture correcly based on whether it is a String or Array
-        def set_package_arch(idx, arch)
-          if new_resource.package_name.is_a?(String)
-            new_resource.arch(arch) unless arch.nil?
+        def safe_version_array
+          if new_resource.version.is_a?(Array)
+            new_resource.version
+          elsif new_resource.version.nil?
+            package_name_array.map { nil }
           else
-            new_resource.arch ||= []
-            new_resource.arch[idx] = arch
+            [ new_resource.version ]
           end
         end
 
-        # A cousin of package_name_array, return a list of the architectures
-        # defined in the resource.
         def safe_arch_array
           if new_resource.arch.is_a?(Array)
             new_resource.arch
@@ -507,13 +283,6 @@ class Chef
           end
         end
 
-        def flush_cache
-          if new_resource.respond_to?("flush_cache")
-            new_resource.flush_cache
-          else
-            { before: false, after: false }
-          end
-        end
       end
     end
   end