chef 12.18.31 → 13.0.118

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

@@ -17,7 +17,6 @@
 #
 #
 require "chef/provider/package"
-require "chef/mixin/command"
 require "chef/resource/package"
 require "chef/mixin/get_source_from_package"
 
@@ -34,48 +33,45 @@ class Chef
         def define_resource_requirements
           super
           requirements.assert(:install) do |a|
-            a.assertion { @new_resource.source }
-            a.failure_message Chef::Exceptions::Package, "Source for package #{@new_resource.name} required for action install"
+            a.assertion { new_resource.source }
+            a.failure_message Chef::Exceptions::Package, "Source for package #{new_resource.name} required for action install"
           end
           requirements.assert(:all_actions) do |a|
-            a.assertion { !@new_resource.source || @package_source_found }
-            a.failure_message Chef::Exceptions::Package, "Package #{@new_resource.name} not found: #{@new_resource.source}"
-            a.whyrun "would assume #{@new_resource.source} would be have previously been made available"
+            a.assertion { !new_resource.source || package_source_found? }
+            a.failure_message Chef::Exceptions::Package, "Package #{new_resource.name} not found: #{new_resource.source}"
+            a.whyrun "would assume #{new_resource.source} would be have previously been made available"
           end
         end
 
         def load_current_resource
-          @current_resource = Chef::Resource::Package.new(@new_resource.name)
-          @current_resource.package_name(@new_resource.package_name)
+          @current_resource = Chef::Resource::Package.new(new_resource.name)
+          current_resource.package_name(new_resource.package_name)
 
-          if @new_resource.source
-            @package_source_found = ::File.exists?(@new_resource.source)
-            if @package_source_found
-              Chef::Log.debug("#{@new_resource} checking pkg status")
-              ret = shell_out_with_timeout("installp -L -d #{@new_resource.source}")
-              ret.stdout.each_line do |line|
-                case line
-                when /:#{@new_resource.package_name}:/
-                  fields = line.split(":")
-                  @new_resource.version(fields[2])
-                when /^#{@new_resource.package_name}:/
-                  Chef::Log.warn("You are installing a bff package by product name. For idempotent installs, please install individual filesets")
-                  fields = line.split(":")
-                  @new_resource.version(fields[2])
-                end
+          if package_source_found?
+            Chef::Log.debug("#{new_resource} checking pkg status")
+            ret = shell_out_compact_timeout("installp", "-L", "-d", new_resource.source)
+            ret.stdout.each_line do |line|
+              case line
+              when /:#{new_resource.package_name}:/
+                fields = line.split(":")
+                new_resource.version(fields[2])
+              when /^#{new_resource.package_name}:/
+                Chef::Log.warn("You are installing a bff package by product name. For idempotent installs, please install individual filesets")
+                fields = line.split(":")
+                new_resource.version(fields[2])
               end
-              raise Chef::Exceptions::Package, "package source #{@new_resource.source} does not provide package #{@new_resource.package_name}" unless @new_resource.version
             end
+            raise Chef::Exceptions::Package, "package source #{new_resource.source} does not provide package #{new_resource.package_name}" unless new_resource.version
           end
 
-          Chef::Log.debug("#{@new_resource} checking install state")
-          ret = shell_out_with_timeout("lslpp -lcq #{@current_resource.package_name}")
+          Chef::Log.debug("#{new_resource} checking install state")
+          ret = shell_out_compact_timeout("lslpp", "-lcq", current_resource.package_name)
           ret.stdout.each_line do |line|
             case line
-            when /#{@current_resource.package_name}/
+            when /#{current_resource.package_name}/
               fields = line.split(":")
-              Chef::Log.debug("#{@new_resource} version #{fields[2]} is already installed")
-              @current_resource.version(fields[2])
+              Chef::Log.debug("#{new_resource} version #{fields[2]} is already installed")
+              current_resource.version(fields[2])
             end
           end
 
@@ -83,23 +79,25 @@ class Chef
             raise Chef::Exceptions::Package, "lslpp failed - #{ret.format_for_exception}!"
           end
 
-          @current_resource
+          current_resource
         end
 
         def candidate_version
           return @candidate_version if @candidate_version
-          ret = shell_out_with_timeout("installp -L -d #{@new_resource.source}")
-          ret.stdout.each_line do |line|
-            case line
-            when /\w:#{Regexp.escape(@new_resource.package_name)}:(.*)/
-              fields = line.split(":")
-              @candidate_version = fields[2]
-              @new_resource.version(fields[2])
-              Chef::Log.debug("#{@new_resource} setting install candidate version to #{@candidate_version}")
+          if package_source_found?
+            ret = shell_out_compact_timeout("installp", "-L", "-d", new_resource.source)
+            ret.stdout.each_line do |line|
+              case line
+              when /\w:#{Regexp.escape(new_resource.package_name)}:(.*)/
+                fields = line.split(":")
+                @candidate_version = fields[2]
+                new_resource.version(fields[2])
+                Chef::Log.debug("#{new_resource} setting install candidate version to #{@candidate_version}")
+              end
+            end
+            unless ret.exitstatus == 0
+              raise Chef::Exceptions::Package, "installp -L -d #{new_resource.source} - #{ret.format_for_exception}!"
             end
-          end
-          unless ret.exitstatus == 0
-            raise Chef::Exceptions::Package, "installp -L -d #{@new_resource.source} - #{ret.format_for_exception}!"
           end
           @candidate_version
         end
@@ -112,28 +110,32 @@ class Chef
         # So far, the code has been tested only with standalone packages.
         #
         def install_package(name, version)
-          Chef::Log.debug("#{@new_resource} package install options: #{@new_resource.options}")
-          if @new_resource.options.nil?
-            shell_out_with_timeout!( "installp -aYF -d #{@new_resource.source} #{@new_resource.package_name}" )
-            Chef::Log.debug("#{@new_resource} installed version #{@new_resource.version} from: #{@new_resource.source}")
+          Chef::Log.debug("#{new_resource} package install options: #{options}")
+          if options.nil?
+            shell_out_compact_timeout!("installp", "-aYF", "-d", new_resource.source, new_resource.package_name)
+            Chef::Log.debug("#{new_resource} installed version #{new_resource.version} from: #{new_resource.source}")
           else
-            shell_out_with_timeout!( "installp -aYF #{expand_options(@new_resource.options)} -d #{@new_resource.source} #{@new_resource.package_name}" )
-            Chef::Log.debug("#{@new_resource} installed version #{@new_resource.version} from: #{@new_resource.source}")
+            shell_out_compact_timeout!("installp", "-aYF", options, "-d", new_resource.source, new_resource.package_name)
+            Chef::Log.debug("#{new_resource} installed version #{new_resource.version} from: #{new_resource.source}")
           end
         end
 
-        alias_method :upgrade_package, :install_package
+        alias upgrade_package install_package
 
         def remove_package(name, version)
-          if @new_resource.options.nil?
-            shell_out_with_timeout!( "installp -u #{name}" )
-            Chef::Log.debug("#{@new_resource} removed version #{@new_resource.version}")
+          if options.nil?
+            shell_out_compact_timeout!("installp", "-u", name)
+            Chef::Log.debug("#{new_resource} removed version #{new_resource.version}")
           else
-            shell_out_with_timeout!( "installp -u #{expand_options(@new_resource.options)} #{name}" )
-            Chef::Log.debug("#{@new_resource} removed version #{@new_resource.version}")
+            shell_out_compact_timeout!("installp", "-u", options, name)
+            Chef::Log.debug("#{new_resource} removed version #{new_resource.version}")
           end
         end
 
+        def package_source_found?
+          @package_source_found ||= new_resource.source && ::File.exist?(new_resource.source)
+        end
+
       end
     end
   end

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

@@ -1,6 +1,6 @@
 #
 # Author:: Adam Jacob (<adam@chef.io>)
-# Copyright:: Copyright 2008-2016, Chef Software Inc.
+# Copyright:: Copyright 2008-2017, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -72,21 +72,21 @@ class Chef
 
         def package_locked(name, version)
           islocked = false
-          locked = shell_out_with_timeout!("apt-mark showhold")
+          locked = shell_out_compact_timeout!("apt-mark", "showhold")
           locked.stdout.each_line do |line|
             line_package = line.strip
             if line_package == name
               islocked = true
             end
           end
-          return islocked
+          islocked
         end
 
         def install_package(name, version)
           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)
+          run_noninteractive("apt-get", "-q", "-y", default_release_options, options, "install", package_name)
         end
 
         def upgrade_package(name, version)
@@ -97,14 +97,14 @@ class Chef
           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)
+          run_noninteractive("apt-get", "-q", "-y", options, "remove", package_name)
         end
 
         def purge_package(name, version)
           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)
+          run_noninteractive("apt-get", "-q", "-y", options, "purge", package_name)
         end
 
         def preseed_package(preseed_file)
@@ -118,11 +118,11 @@ class Chef
         end
 
         def lock_package(name, version)
-          run_noninteractive("apt-mark", new_resource.options, "hold", name)
+          run_noninteractive("apt-mark", options, "hold", name)
         end
 
         def unlock_package(name, version)
-          run_noninteractive("apt-mark", new_resource.options, "unhold", name)
+          run_noninteractive("apt-mark", options, "unhold", name)
         end
 
         private
@@ -131,12 +131,14 @@ class Chef
         # interactive prompts. Command is run with default localization rather
         # than forcing locale to "C", so command output may not be stable.
         def run_noninteractive(*args)
-          shell_out_with_timeout!(a_to_s(*args), :env => { "DEBIAN_FRONTEND" => "noninteractive" })
+          shell_out_compact_timeout!(*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
+          if new_resource.respond_to?(:default_release) && new_resource.default_release
+            [ "-o", "APT::Default-Release=#{new_resource.default_release}" ]
+          end
         end
 
         def resolve_package_versions(pkg)
@@ -156,7 +158,7 @@ class Chef
         end
 
         def resolve_virtual_package_name(pkg)
-          showpkg = run_noninteractive("apt-cache showpkg", pkg).stdout
+          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|
@@ -166,7 +168,7 @@ class Chef
           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
+          set.to_a.first
         end
 
         def package_data_for(pkg)
@@ -186,7 +188,7 @@ class Chef
             end
           end
 
-          return {
+          {
             current_version:    current_version,
             candidate_version:  candidate_version,
             virtual:            virtual,

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

@@ -19,50 +19,79 @@
 require "chef/provider/package"
 require "chef/resource/cab_package"
 require "chef/mixin/shell_out"
+require "chef/mixin/uris"
+require "chef/mixin/checksum"
 
 class Chef
   class Provider
     class Package
       class Cab < Chef::Provider::Package
         include Chef::Mixin::ShellOut
+        include Chef::Mixin::Uris
+        include Chef::Mixin::Checksum
 
         provides :cab_package, os: "windows"
 
         def load_current_resource
           @current_resource = Chef::Resource::CabPackage.new(new_resource.name)
-          current_resource.source(new_resource.source)
+          current_resource.source(cab_file_source)
           new_resource.version(package_version)
           current_resource.version(installed_version)
           current_resource
         end
 
+        def cab_file_source
+          @cab_file_source ||= uri_scheme?(new_resource.source) ? download_source_file : new_resource.source
+        end
+
+        def download_source_file
+          source_resource.run_action(:create)
+          Chef::Log.debug("#{new_resource} fetched source file to #{source_resource.path}")
+          source_resource.path
+        end
+
+        def source_resource
+          @source_resource ||= declare_resource(:remote_file, new_resource.name) do
+            path default_download_cache_path
+            source new_resource.source
+            backup false
+          end
+        end
+
+        def default_download_cache_path
+          uri = ::URI.parse(new_resource.source)
+          filename = ::File.basename(::URI.unescape(uri.path))
+          file_cache_dir = Chef::FileCache.create_cache_path("package/")
+          Chef::Util::PathHelper.cleanpath("#{file_cache_dir}/#{filename}")
+        end
+
         def install_package(name, version)
-          dism_command("/Add-Package /PackagePath:\"#{@new_resource.source}\"")
+          dism_command("/Add-Package /PackagePath:\"#{cab_file_source}\"")
         end
 
         def remove_package(name, version)
-          dism_command("/Remove-Package /PackagePath:\"#{@new_resource.source}\"")
+          dism_command("/Remove-Package /PackagePath:\"#{cab_file_source}\"")
         end
 
         def dism_command(command)
-          shellout = Mixlib::ShellOut.new("dism.exe /Online /English #{command} /NoRestart", { :timeout => @new_resource.timeout })
+          shellout = Mixlib::ShellOut.new("dism.exe /Online /English #{command} /NoRestart", timeout: new_resource.timeout)
           with_os_architecture(nil) do
             shellout.run_command
           end
         end
 
         def installed_version
-          stdout = dism_command("/Get-PackageInfo /PackagePath:\"#{@new_resource.source}\"").stdout
+          stdout = dism_command("/Get-PackageInfo /PackagePath:\"#{cab_file_source}\"").stdout
           package_info = parse_dism_get_package_info(stdout)
           # e.g. Package_for_KB2975719~31bf3856ad364e35~amd64~~6.3.1.8
           package = split_package_identity(package_info["package_information"]["package_identity"])
           # Search for just the package name to catch a different version being installed
-          Chef::Log.debug("#{@new_resource} searching for installed package #{package['name']}")
+          Chef::Log.debug("#{new_resource} searching for installed package #{package['name']}")
           found_packages = installed_packages.select { |p| p["package_identity"] =~ /^#{package['name']}~/ }
-          if found_packages.length == 0
+          if found_packages.empty?
             nil
           elsif found_packages.length == 1
-            stdout = dism_command("/Get-PackageInfo /PackageName:\"#{found_packages.first["package_identity"]}\"").stdout
+            stdout = dism_command("/Get-PackageInfo /PackageName:\"#{found_packages.first['package_identity']}\"").stdout
             find_version(stdout)
           else
             # Presuming this won't happen, otherwise we need to handle it
@@ -71,8 +100,8 @@ class Chef
         end
 
         def package_version
-          Chef::Log.debug("#{@new_resource} getting product version for package at #{@new_resource.source}")
-          stdout = dism_command("/Get-PackageInfo /PackagePath:\"#{@new_resource.source}\"").stdout
+          Chef::Log.debug("#{new_resource} getting product version for package at #{cab_file_source}")
+          stdout = dism_command("/Get-PackageInfo /PackagePath:\"#{cab_file_source}\"").stdout
           find_version(stdout)
         end
 
@@ -85,22 +114,21 @@ class Chef
         # returns a hash of package state information given the output of dism /get-packages
         # expected keys: package_identity
         def parse_dism_get_packages(text)
-          packages = Array.new
+          packages = []
           text.each_line do |line|
             key, value = line.split(":") if line.start_with?("Package Identity")
-            unless key.nil? || value.nil?
-              package = Hash.new
-              package[key.downcase.strip.tr(" ", "_")] = value.strip.chomp
-              packages << package
-            end
+            next if key.nil? || value.nil?
+            package = {}
+            package[key.downcase.strip.tr(" ", "_")] = value.strip.chomp
+            packages << package
           end
           packages
         end
 
         # returns a hash of package information given the output of dism /get-packageinfo
         def parse_dism_get_package_info(text)
-          package_data = Hash.new
-          errors = Array.new
+          package_data = {}
+          errors = []
           in_section = false
           section_headers = [ "Package information", "Custom Properties", "Features" ]
           text.each_line do |line|
@@ -112,7 +140,7 @@ class Chef
               v = $2 # has to be first or the gsub below replaces this variable
               k = $1.downcase.strip.tr(" ", "_")
               if in_section
-                package_data[in_section] = Hash.new unless package_data[in_section]
+                package_data[in_section] = {} unless package_data[in_section]
                 package_data[in_section][k] = v
               else
                 package_data[k] = v
@@ -132,7 +160,7 @@ class Chef
         end
 
         def split_package_identity(identity)
-          data = Hash.new
+          data = {}
           data["name"], data["publisher"], data["arch"], data["resource_id"], data["version"] = identity.split("~")
           data
         end

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

@@ -30,8 +30,8 @@ class Chef
         # Declare that our arguments should be arrays
         use_multipackage_api
 
-        PATHFINDING_POWERSHELL_COMMAND = "[System.Environment]::GetEnvironmentVariable('ChocolateyInstall', 'MACHINE')"
-        CHOCO_MISSING_MSG = <<-EOS
+        PATHFINDING_POWERSHELL_COMMAND = "[System.Environment]::GetEnvironmentVariable('ChocolateyInstall', 'MACHINE')".freeze
+        CHOCO_MISSING_MSG = <<-EOS.freeze
 Could not locate your Chocolatey install. To install chocolatey, we recommend
 the 'chocolatey' cookbook (https://github.com/chocolatey/chocolatey-cookbook).
 If Chocolatey is installed, ensure that the 'ChocolateyInstall' environment
@@ -59,8 +59,8 @@ EOS
           # so we want to assert candidates exist for the alternate source
           requirements.assert(:upgrade, :install) do |a|
             a.assertion { candidates_exist_for_all_uninstalled? }
-            a.failure_message(Chef::Exceptions::Package, "No candidate version available for #{packages_missing_candidates.join(", ")}")
-            a.whyrun("Assuming a repository that offers #{packages_missing_candidates.join(", ")} would have been configured")
+            a.failure_message(Chef::Exceptions::Package, "No candidate version available for #{packages_missing_candidates.join(', ')}")
+            a.whyrun("Assuming a repository that offers #{packages_missing_candidates.join(', ')} would have been configured")
           end
         end
 
@@ -133,12 +133,11 @@ EOS
         end
 
         # Choco does not have dpkg's distinction between purge and remove
-        alias_method :purge_package, :remove_package
+        alias purge_package remove_package
 
         # Override the superclass check.  The semantics for our new_resource.source is not files to
         # install from, but like the rubygem provider's sources which are more like repos.
-        def check_resource_semantics!
-        end
+        def check_resource_semantics!; end
 
         private
 
@@ -160,7 +159,7 @@ EOS
         def choco_install_path
           @choco_install_path ||= powershell_out!(
             PATHFINDING_POWERSHELL_COMMAND
-            ).stdout.chomp
+          ).stdout.chomp
         end
 
         # Helper to dispatch a choco command through shell_out using the timeout
@@ -169,7 +168,7 @@ EOS
         # @param args [String] variable number of string arguments
         # @return [Mixlib::ShellOut] object returned from shell_out!
         def choco_command(*args)
-          shell_out_with_timeout!(args_to_string(choco_exe, *args), { :returns => new_resource.returns })
+          shell_out_with_timeout!(args_to_string(choco_exe, *args), returns: new_resource.returns)
         end
 
         # Use the available_packages Hash helper to create an array suitable for
@@ -268,7 +267,7 @@ EOS
         # @param names [Array] original mixed case names
         # @return [Array] same names in lower case
         def lowercase_names(names)
-          names.map { |name| name.downcase }
+          names.map(&:downcase)
         end
       end
     end

data/lib/chef/provider/package/dnf/dnf_helper.py

@@ -53,7 +53,7 @@ def query(command):
     if len(archq.run()) > 0:
         q = archq
 
-    pkgs = dnf.query.latest_limit_pkgs(q, 1)
+    pkgs = q.latest(1).run()
 
     if not pkgs:
         sys.stdout.write('{} nil nil\n'.format(command['provides'].split().pop(0)))

data/lib/chef/provider/package/dnf/python_helper.rb

@@ -1,5 +1,5 @@
 #
-# Copyright:: Copyright 2016, Chef Software, Inc.
+# Copyright:: Copyright 2016-2017, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -15,6 +15,8 @@
 # limitations under the License.
 #
 
+require "chef/mixin/which"
+require "chef/mixin/shell_out"
 require "chef/provider/package/dnf/version"
 require "timeout"
 
@@ -24,7 +26,8 @@ class Chef
       class Dnf < Chef::Provider::Package
         class PythonHelper
           include Singleton
-          extend Chef::Mixin::Which
+          include Chef::Mixin::Which
+          include Chef::Mixin::ShellOut
 
           attr_accessor :stdin
           attr_accessor :stdout
@@ -32,11 +35,16 @@ class Chef
           attr_accessor :wait_thr
 
           DNF_HELPER = ::File.expand_path(::File.join(::File.dirname(__FILE__), "dnf_helper.py")).freeze
-          DNF_COMMAND = "#{which("python3")} #{DNF_HELPER}"
+
+          def dnf_command
+            @dnf_command ||= which("python", "python3", "python2", "python2.7") do |f|
+              shell_out("#{f} -c 'import dnf'").exitstatus == 0
+            end + " #{DNF_HELPER}"
+          end
 
           def start
             ENV["PYTHONUNBUFFERED"] = "1"
-            @stdin, @stdout, @stderr, @wait_thr = Open3.popen3(DNF_COMMAND)
+            @stdin, @stdout, @stderr, @wait_thr = Open3.popen3(dnf_command)
           end
 
           def reap
@@ -53,6 +61,27 @@ class Chef
             start if stdin.nil?
           end
 
+          # @returns Array<Version>
+          def query(action, provides, version = nil, arch = nil)
+            with_helper do
+              json = build_query(action, provides, version, arch)
+              Chef::Log.debug "sending '#{json}' to python helper"
+              stdin.syswrite json + "\n"
+              output = stdout.sysread(4096).chomp
+              Chef::Log.debug "got '#{output}' from python helper"
+              version = parse_response(output)
+              Chef::Log.debug "parsed #{version} from python helper"
+              version
+            end
+          end
+
+          def restart
+            reap
+            start
+          end
+
+          private
+
           # i couldn't figure out how to decompose an evr on the python side, it seems reasonably
           # painless to do it in ruby (generally massaging nevras in the ruby side is HIGHLY
           # discouraged -- this is an "every rule has an exception" exception -- any additional
@@ -60,10 +89,12 @@ class Chef
           def add_version(hash, version)
             epoch = nil
             if version =~ /(\S+):(\S+)/
-              epoch, version = $1, $2
+              epoch = $1
+              version = $2
             end
             if version =~ /(\S+)-(\S+)/
-              version, release = $1, $2
+              version = $1
+              release = $2
             end
             hash["epoch"] = epoch unless epoch.nil?
             hash["release"] = release unless release.nil?
@@ -83,35 +114,41 @@ class Chef
             array.each_slice(3).map { |x| Version.new(*x) }.first
           end
 
-          # @returns Array<Version>
-          def query(action, provides, version = nil, arch = nil)
-            with_helper do
-              json = build_query(action, provides, version, arch)
-              Chef::Log.debug "sending '#{json}' to python helper"
-              stdin.syswrite json + "\n"
-              output = stdout.sysread(4096).chomp
-              Chef::Log.debug "got '#{output}' from python helper"
-              version = parse_response(output)
-              Chef::Log.debug "parsed #{version} from python helper"
-              version
+          def drain_stderr
+            output = ""
+            until IO.select([stderr], nil, nil, 0).nil?
+              output += stderr.sysread(4096).chomp
             end
-          end
-
-          def restart
-            reap
-            start
+            output
+          rescue
+            # we must rescue EOFError, and we don't much care about errors on stderr anyway
+            output
           end
 
           def with_helper
             max_retries ||= 5
+            ret = nil
             Timeout.timeout(600) do
               check
-              yield
+              ret = yield
             end
+            output = drain_stderr
+            unless output.empty?
+              Chef::Log.debug "discarding output on stderr from python helper: #{output}"
+            end
+            ret
           rescue EOFError, Errno::EPIPE, Timeout::Error, Errno::ESRCH => e
-            raise e unless ( max_retries -= 1 ) > 0
-            restart
-            retry
+            output = drain_stderr
+            if ( max_retries -= 1 ) > 0
+              unless output.empty?
+                Chef::Log.debug "discarding output on stderr from python helper: #{output}"
+              end
+              restart
+              retry
+            else
+              raise e if output.empty?
+              raise "dnf-helper.py had stderr output:\n\n#{output}"
+            end
           end
         end
       end

data/lib/chef/provider/package/dnf/version.rb

@@ -48,7 +48,7 @@ class Chef
             name == other.name && version == other.version && arch == other.arch
           end
 
-          alias_method :eql?, :==
+          alias eql? ==
         end
       end
     end