chef 14.15.6 → 18.1.0

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

@@ -1,6 +1,6 @@
 #
 # Author:: Bryan McLellan <btm@loftninjas.org>
-# Copyright:: Copyright 2014-2018, Chef Software Inc.
+# Copyright:: Copyright (c) Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,11 +16,12 @@
 # limitations under the License.
 #
 
-require "chef/mixin/uris"
-require "chef/resource/windows_package"
-require "chef/provider/package"
-require "chef/util/path_helper"
-require "chef/mixin/checksum"
+require_relative "../../mixin/uris"
+require_relative "../../resource/windows_package"
+require_relative "../package"
+require_relative "../../util/path_helper"
+require_relative "../../mixin/checksum"
+autoload :CGI, "cgi"
 
 class Chef
   class Provider
@@ -32,9 +33,16 @@ class Chef
         provides :package, os: "windows"
         provides :windows_package
 
-        require "chef/provider/package/windows/registry_uninstall_entry.rb"
+        autoload :RegistryUninstallEntry, ::File.expand_path("windows/registry_uninstall_entry.rb", __dir__)
 
         def define_resource_requirements
+          if new_resource.checksum
+            requirements.assert(:install) do |a|
+              a.assertion { checksum_match?(new_resource.checksum, checksum(source_location)) }
+              a.failure_message Chef::Exceptions::Package, "Checksum on resource (#{short_cksum(new_resource.checksum)}) does not match checksum on content (#{short_cksum(source_location)})"
+            end
+          end
+
           requirements.assert(:install) do |a|
             a.assertion { new_resource.source || msi? }
             a.failure_message Chef::Exceptions::NoWindowsPackageSource, "Source for package #{new_resource.package_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."
@@ -49,43 +57,29 @@ class Chef
           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?
-            logger.trace("We do not know the version of #{new_resource.source} because the file is not downloaded")
-            # FIXME: this label should not be used.  It could be set to nil.  Probably what should happen is that
-            # if the file hasn't been downloaded then load_current_resource must download the file here, and then
-            # the else clause to set current_resource.version can always be run.  Relying on a side-effect here
-            # produces at least less readable code, if not outright buggy...  (and I'm assuming that this isn't
-            # wholly just a bug -- since if we only need the package_name to determine if its installed then we
-            # need this, so I'm assuming we need to download the file to pull out the name in order to check
-            # the registry -- which it still feels like we get wrong in the sense we're forcing always downloading
-            # and then always installing(?) which violates idempotency -- and I'm having to think way too hard
-            # about this and would need to go surfing around the code to determine what actually happens, probably
-            # in every different package_provider...)
-            current_resource.version(:unknown.to_s)
-          else
-            current_resource.version(package_provider.installed_version)
-            new_resource.version(package_provider.package_version) if package_provider.package_version
+          if uri_scheme?(new_resource.source) && action == :install
+            download_source_file
           end
 
+          @current_resource = Chef::Resource::WindowsPackage.new(new_resource.name)
+          current_resource.version(package_provider.installed_version)
+          new_resource.version(package_provider.package_version) if package_provider.package_version
+
           current_resource
         end
 
         def package_provider
-          @package_provider ||= begin
-            case installer_type
+          @package_provider ||= case installer_type
             when :msi
               logger.trace("#{new_resource} is MSI")
-              require "chef/provider/package/windows/msi"
+              require_relative "windows/msi"
               Chef::Provider::Package::Windows::MSI.new(resource_for_provider, uninstall_registry_entries)
             else
               logger.trace("#{new_resource} is EXE with type '#{installer_type}'")
-              require "chef/provider/package/windows/exe"
+              require_relative "windows/exe"
               Chef::Provider::Package::Windows::Exe.new(resource_for_provider, installer_type, uninstall_registry_entries)
-            end
-          end
+                                end
         end
 
         def installer_type
@@ -138,17 +132,6 @@ class Chef
           end
         end
 
-        def action_install
-          if uri_scheme?(new_resource.source)
-            download_source_file
-            load_current_resource
-          else
-            validate_content!
-          end
-
-          super
-        end
-
         # Chef::Provider::Package action_install + action_remove call install_package + remove_package
         # Pass those calls to the correct sub-provider
         def install_package(name, version)
@@ -184,7 +167,7 @@ class Chef
         # is not multipackage.  The existing implementation of package_provider.installed_version should probably
         # be what `uninstall_version_array` is, and then that list should be sorted and last/first'd into the
         # current_resource.version.  The current_version_array method was not intended to be overwritten by
-        # sublasses (but ruby provides no feature to block doing so -- it is already marked as private).
+        # subclasses (but ruby provides no feature to block doing so -- it is already marked as private).
         #
         def current_version_array
           [ current_resource.version ]
@@ -244,6 +227,7 @@ class Chef
         end
 
         def resource_for_provider
+          # XXX: this is crazy
           @resource_for_provider = Chef::Resource::WindowsPackage.new(new_resource.name).tap do |r|
             r.source(Chef::Util::PathHelper.validate_path(source_location)) unless source_location.nil?
             r.cookbook_name = new_resource.cookbook_name
@@ -257,19 +241,23 @@ class Chef
 
         def download_source_file
           source_resource.run_action(:create)
-          logger.trace("#{new_resource} fetched source file to #{source_resource.path}")
+          logger.trace("#{new_resource} fetched source file to #{default_download_cache_path}")
         end
 
         def source_resource
-          @source_resource ||= Chef::Resource::RemoteFile.new(default_download_cache_path, run_context).tap do |r|
-            r.source(new_resource.source)
-            r.cookbook_name = new_resource.cookbook_name
-            r.checksum(new_resource.checksum)
-            r.backup(false)
-
+          # It seems correct that this is a build_resource rather than declare_resource/DSL use since updating should not trigger a notification
+          # unless the downloaded file is actually installed.  The case where the remote_file downloads the package but the package is already
+          # installed on the target should not trigger a notification since the running state did not change.
+          @source_resource ||= build_resource(:remote_file, default_download_cache_path) do
+            source(new_resource.source)
+            cookbook_name = new_resource.cookbook_name
+            checksum(new_resource.checksum)
+            backup(false)
+
+            # since the source_resource can mutate here, we save off the @source_resource so we can inspect the actual state later
             if new_resource.remote_file_attributes
               new_resource.remote_file_attributes.each do |(k, v)|
-                r.send(k.to_sym, v)
+                send(k.to_sym, v)
               end
             end
           end
@@ -277,7 +265,7 @@ class Chef
 
         def default_download_cache_path
           uri = ::URI.parse(new_resource.source)
-          filename = ::File.basename(::URI.unescape(uri.path))
+          filename = ::File.basename(::CGI.unescape(uri.path))
           file_cache_dir = Chef::FileCache.create_cache_path("package/")
           Chef::Util::PathHelper.cleanpath("#{file_cache_dir}/#{filename}")
         end
@@ -293,15 +281,6 @@ class Chef
           end
         end
 
-        def validate_content!
-          if new_resource.checksum
-            source_checksum = checksum(source_location)
-            if new_resource.checksum.downcase != source_checksum
-              raise Chef::Exceptions::ChecksumMismatch.new(short_cksum(new_resource.checksum), short_cksum(source_checksum))
-            end
-          end
-        end
-
         def msi?
           return true if new_resource.installer_type == :msi
 

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

@@ -1,5 +1,5 @@
 #
-# Copyright:: Copyright 2016-2018, Chef Software Inc.
+# Copyright:: Copyright (c) Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -15,11 +15,11 @@
 # limitations under the License.
 #
 
-require "chef/mixin/which"
-require "chef/mixin/shell_out"
-require "chef/provider/package/yum/version"
-require "singleton"
-require "timeout"
+require_relative "../../../mixin/which"
+require_relative "../../../mixin/shell_out"
+require_relative "version"
+require "singleton" unless defined?(Singleton)
+require "timeout" unless defined?(Timeout)
 
 class Chef
   class Provider
@@ -40,13 +40,17 @@ class Chef
           YUM_HELPER = ::File.expand_path(::File.join(::File.dirname(__FILE__), "yum_helper.py")).freeze
 
           def yum_command
-            @yum_command ||= which("python", "python2", "python2.7") do |f|
-              shell_out("#{f} -c 'import yum'").exitstatus == 0
-            end + " #{YUM_HELPER}"
+            @yum_command ||= begin
+              cmd = which("platform-python", "python", "python2", "python2.7", extra_path: "/usr/libexec") do |f|
+                shell_out("#{f} -c 'import yum'").exitstatus == 0
+              end
+              raise Chef::Exceptions::Package, "cannot find yum libraries, you may need to use dnf_package" unless cmd
+
+              "#{cmd} #{YUM_HELPER}"
+            end
           end
 
           def start
-            ENV["PYTHONUNBUFFERED"] = "1"
             @inpipe, inpipe_write = IO.pipe
             outpipe_read, @outpipe = IO.pipe
             @stdin, @stdout, @stderr, @wait_thr = Open3.popen3("#{yum_command} #{outpipe_read.fileno} #{inpipe_write.fileno}", outpipe_read.fileno => outpipe_read, inpipe_write.fileno => inpipe_write, close_others: false)
@@ -69,6 +73,7 @@ class Chef
               stderr.close unless stderr.nil?
               inpipe.close unless inpipe.nil?
               outpipe.close unless outpipe.nil?
+              @stdin = @stdout = @stderr = @inpipe = @outpipe = @wait_thr = nil
             end
           end
 
@@ -76,6 +81,10 @@ class Chef
             start if stdin.nil?
           end
 
+          def close_rpmdb
+            query("close_rpmdb", {})
+          end
+
           def compare_versions(version1, version2)
             query("versioncompare", { "versions" => [version1, version2] }).to_i
           end
@@ -83,9 +92,9 @@ class Chef
           def install_only_packages(name)
             query_output = query("installonlypkgs", { "package" => name })
             if query_output == "False"
-              return false
+              false
             elsif query_output == "True"
-              return true
+              true
             end
           end
 
@@ -106,18 +115,111 @@ class Chef
             end
           end
 
+          def is_arch?(arch)
+            # cspell:disable-next
+            arches = %w{aarch64 alpha alphaev4 alphaev45 alphaev5 alphaev56 alphaev6 alphaev67 alphaev68 alphaev7 alphapca56 armv5tejl armv5tel armv5tl armv6l armv7l armv8l armv6hl armv7hl armv7hnl armv8hl i386 athlon geode i386 i486 i586 i686 ia64 mips mipsel mips64 mips64el noarch ppc ppc64 ppc64iseries ppc64p7 ppc64pseries ppc64le riscv32 riscv64 riscv128 s390 s390x sh3 sh4 sh4a sparc sparc64 sparc64v sparcv8 sparcv9 sparcv9v x86_64 amd64 ia32e}
+            arches.include?(arch)
+          end
+
+          # We have a provides line with an epoch in it and yum cannot parse that, so we
+          # need to deconstruct the args.  This doesn't support splats which is why we
+          # only do it for this particularly narrow use case.
+          #
+          # name-epoch:version
+          # name-epoch:version.arch
+          # name-epoch:version-release
+          # name-epoch:version-release.arch
+          #
+          # @api private
+          def deconstruct_args(provides)
+            raise "provides must have an epoch in the version to deconstruct" unless provides =~ /^(\S+)-(\d+):(\S+)/
+
+            name = $1
+            epoch = $2
+            other = $3
+            ret = { "provides" => name, "epoch" => epoch }
+            maybe_arch = other.rpartition(".").last
+            arch = if is_arch?(maybe_arch)
+                     other.delete_suffix!(".#{maybe_arch}")
+                     maybe_arch
+                   end
+            ret.merge!({ "arch" => arch }) if arch
+            (version, _, release) = other.rpartition("-")
+            if version.empty?
+              ret.merge!({ "version" => release }) # yeah, rpartition is just weird
+            else
+              ret.merge!({ "version" => version, "release" => release })
+            end
+          end
+
+          # In the default case for the yum provider we now do terrible things with ruby
+          # to concatenate all the properties together to form a single string to feed to
+          # the python which favors using returnPackages/searchProvides over the
+          # searchNevra API.  That means that these two different ways of constructing the
+          # resource are now perfectly identical:
+          #
+          # yum_package "zabbix-agent-4.0.15-1.fc31.x86_64"
+          #
+          # yum_package "zabbix-agent" do
+          #   version "4.0.15-1.fc31"
+          #   arch "x86_64"
+          # end
+          #
+          # This function handles turning the second form into the first form.
+          #
+          # In the case where the epoch is given in the version and we do not have any glob
+          # patterns that is handled by going the other way and calling deconstruct_args due
+          # to the yum libraries not supporting that calling pattern other than by searchNevra.
+          #
+          # NOTE: This is an ugly hack and should NOT be considered an endorsement of this approach
+          # towards any kind of features or bugfixes in the DNF provider.  I'm doing this
+          # because YUM is sunsetting at this point and its very difficult to fight with the
+          # libraries on the python side of things.
+          #
+          # @api private
+          def combine_args(provides, version, arch)
+            provides = provides.to_s.strip
+            version = if !version.nil? && !version.empty?
+                        version.to_s.strip
+                      end
+            arch = if !arch.nil? && !arch.empty?
+                     arch.to_s.strip
+                   end
+            if version =~ /^[><=]/
+              if arch
+                return { "provides" => "#{provides}.#{arch} #{version}" }
+              else
+                return { "provides" => "#{provides} #{version}" }
+              end
+            end
+            maybe_arch = provides.rpartition(".").last
+            if is_arch?(maybe_arch)
+              arch = maybe_arch
+              provides.delete_suffix!(".#{arch}")
+            end
+            provides = "#{provides}-#{version}" if version
+            provides = "#{provides}.#{arch}" if arch
+            # yum (on rhel7) can't handle an epoch in provides, but
+            # deconstructing the args can't handle dealing with globs
+            if provides =~ /-\d+:/ && provides !~ /[\*\?]/
+              deconstruct_args(provides)
+            else
+              { "provides" => provides }
+            end
+          end
+
           # @return Array<Version>
           # NB: "options" here is the yum_package options hash and is deliberately not **opts
           def package_query(action, provides, version: nil, arch: nil, options: {})
-            parameters = { "provides" => provides, "version" => version, "arch" => arch }
+            parameters = combine_args(provides, version, arch)
             repo_opts = options_params(options || {})
             parameters.merge!(repo_opts)
-            # XXX: for now we restart before and after every query with an enablerepo/disablerepo to clean the helpers internal state
-            restart unless repo_opts.empty?
+            # XXX: for now we close the rpmdb before and after every query with an enablerepo/disablerepo to clean the helpers internal state
+            close_rpmdb unless repo_opts.empty?
             query_output = query(action, parameters)
             version = parse_response(query_output.lines.last)
             Chef::Log.trace "parsed #{version} from python helper"
-            restart unless repo_opts.empty?
+            close_rpmdb unless repo_opts.empty?
             version
           end
 
@@ -128,33 +230,15 @@ class Chef
 
           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
-          # functionality should probably trigger moving this regexp logic into python)
-          def add_version(hash, version)
-            epoch = nil
-            if version =~ /(\S+):(\S+)/
-              epoch = $1
-              version = $2
-            end
-            if version =~ /(\S+)-(\S+)/
-              version = $1
-              release = $2
-            end
-            hash["epoch"] = epoch unless epoch.nil?
-            hash["release"] = release unless release.nil?
-            hash["version"] = version
-          end
-
           def query(action, parameters)
             with_helper do
               json = build_query(action, parameters)
               Chef::Log.trace "sending '#{json}' to python helper"
-              outpipe.syswrite json + "\n"
-              output = inpipe.sysread(4096).chomp
+              outpipe.puts json
+              outpipe.flush
+              output = inpipe.readline.chomp
               Chef::Log.trace "got '#{output}' from python helper"
-              return output
+              output
             end
           end
 
@@ -164,11 +248,6 @@ class Chef
               hash[param_name] = param_value unless param_value.nil?
             end
 
-            # Special handling for certain action / param combos
-            if [:whatinstalled, :whatavailable].include?(action)
-              add_version(hash, parameters["version"]) unless parameters["version"].nil?
-            end
-
             FFI_Yajl::Encoder.encode(hash)
           end
 
@@ -202,16 +281,17 @@ class Chef
               Chef::Log.trace "discarding output on stderr/stdout from python helper: #{output}"
             end
             ret
-          rescue EOFError, Errno::EPIPE, Timeout::Error, Errno::ESRCH => e
+          rescue => e
             output = drain_fds
-            if ( max_retries -= 1 ) > 0
+            restart
+            if ( max_retries -= 1 ) > 0 && !ENV["YUM_HELPER_NO_RETRIES"]
               unless output.empty?
                 Chef::Log.trace "discarding output on stderr/stdout from python helper: #{output}"
               end
-              restart
               retry
             else
               raise e if output.empty?
+
               raise "yum-helper.py had stderr/stdout output:\n\n#{output}"
             end
           end

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

@@ -1,6 +1,6 @@
 
 # Author:: Adam Jacob (<adam@chef.io>)
-# Copyright:: Copyright 2008-2018, Chef Software Inc.
+# Copyright:: Copyright (c) Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,11 +16,11 @@
 # limitations under the License.
 #
 
-require "chef/provider/package"
+require_relative "../../package"
 
 #
 # BUGGY AND DEPRECATED:  This ruby code is known to not match the python implementation for version comparisons.
-# The APIs here should probably be converted to talk to the PythonHelper or just abandonded completely.
+# The APIs here should probably be converted to talk to the PythonHelper or just abandoned completely.
 #
 # e.g. this should just use Chef::Provider::Package::Yum::PythonHelper.instance.compare_versions(x,y)
 #
@@ -46,7 +46,7 @@ class Chef
               lead = 0
               tail = evr.size
 
-              if /^([\d]+):/.match(evr) # rubocop:disable Performance/RedundantMatch
+              if /^(\d+):/.match(evr) # rubocop:disable Performance/RedundantMatch
                 epoch = $1.to_i
                 lead = $1.length + 1
               elsif evr[0].ord == ":".ord
@@ -133,9 +133,7 @@ class Chef
                 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
+                y_pos += 1 while (y_pos <= y_pos_max) && (isalnum(y[y_pos]) == false)
 
                 # 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)
@@ -154,29 +152,21 @@ class Chef
                   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
+                  x_seg_pos += 1 while (x_seg_pos <= x_pos_max) && isdigit(x[x_seg_pos])
                   # 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_seg_pos += 1 while (y_seg_pos <= y_pos_max) && isdigit(y[y_seg_pos])
                   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_seg_pos += 1 while (x_seg_pos <= x_pos_max) && isalpha(x[x_seg_pos])
                   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_seg_pos += 1 while (y_seg_pos <= y_pos_max) && isalpha(y[y_seg_pos])
                   y_comp = y[y_pos, y_seg_pos - y_pos]
                 end
 
@@ -219,9 +209,9 @@ class Chef
 
               # the most unprocessed characters left wins
               if (x_pos_max - x_pos) > (y_pos_max - y_pos)
-                return 1
+                1
               else
-                return -1
+                -1
               end
             end
 
@@ -532,9 +522,9 @@ class Chef
           def lookup(package_name)
             pkgs = @rpms[package_name]
             if pkgs
-              return pkgs.sort.reverse
+              pkgs.sort.reverse
             else
-              return nil
+              nil
             end
           end
 

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

@@ -1,5 +1,5 @@
 #
-# Copyright:: Copyright 2016-2018, Chef Software Inc.
+# Copyright:: Copyright (c) Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -40,6 +40,10 @@ class Chef
             "#{version}.#{arch}" unless version.nil?
           end
 
+          def name_with_arch
+            "#{name}.#{arch}" unless name.nil?
+          end
+
           def matches_name_and_arch?(other)
             other.version == version && other.arch == arch
           end

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

@@ -1,6 +1,6 @@
 
 # Author:: Adam Jacob (<adam@chef.io>)
-# Copyright:: Copyright 2008-2018, Chef Software Inc.
+# Copyright:: Copyright (c) Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,13 +16,13 @@
 # limitations under the License.
 #
 
-require "chef/provider/package/yum/python_helper"
-require "chef/provider/package"
-require "singleton"
+require_relative "python_helper"
+require_relative "../../package"
+require "singleton" unless defined?(Singleton)
 
 #
 # These are largely historical APIs, the YumCache object no longer exists and this is a
-# fascade over the python helper class.  It should be considered deprecated-lite and
+# facade over the python helper class.  It should be considered deprecated-lite and
 # no new APIs should be added and should be added to the python_helper instead.
 #