chef 16.6.14-universal-mingw32 → 16.9.17-universal-mingw32

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

@@ -98,14 +98,27 @@ def query(command):
         q = q.available()
 
     if 'epoch' in command:
-        q = q.filterm(epoch=int(command['epoch']))
+        # We assume that any glob is "*" so just omit the filter since the dnf libraries have no
+        # epoch__glob filter.  That means "?" wildcards in epochs will fail.  The workaround is to
+        # not use the version filter here but to put the version with all the globs in the package name.
+        if not dnf.util.is_glob_pattern(command['epoch']):
+            q = q.filterm(epoch=int(command['epoch']))
     if 'version' in command:
-        q = q.filterm(version__glob=command['version'])
+        if dnf.util.is_glob_pattern(command['version']):
+            q = q.filterm(version__glob=command['version'])
+        else:
+            q = q.filterm(version=command['version'])
     if 'release' in command:
-        q = q.filterm(release__glob=command['release'])
+        if dnf.util.is_glob_pattern(command['release']):
+            q = q.filterm(release__glob=command['release'])
+        else:
+            q = q.filterm(release=command['release'])
 
     if 'arch' in command:
-        q = q.filterm(arch__glob=command['arch'])
+        if dnf.util.is_glob_pattern(command['arch']):
+            q = q.filterm(arch__glob=command['arch'])
+        else:
+            q = q.filterm(arch=command['arch'])
 
     # only apply the default arch query filter if it returns something
     archq = q.filter(arch=[ 'noarch', hawkey.detect_arch() ])
@@ -170,4 +183,4 @@ try:
             raise RuntimeError("bad command")
 finally:
     if base is not None:
-        base.closeRpmDB()
+        base.close()

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

@@ -42,13 +42,13 @@ class Chef
           def dnf_command
             # platform-python is used for system tools on RHEL 8 and is installed under /usr/libexec
             @dnf_command ||= begin
-              cmd = which("platform-python", "python", "python3", "python2", "python2.7", extra_path: "/usr/libexec") do |f|
-                shell_out("#{f} -c 'import dnf'").exitstatus == 0
-              end
-              raise Chef::Exceptions::Package, "cannot find dnf libraries, you may need to use yum_package" unless cmd
+                               cmd = which("platform-python", "python", "python3", "python2", "python2.7", extra_path: "/usr/libexec") do |f|
+                                 shell_out("#{f} -c 'import dnf'").exitstatus == 0
+                               end
+                               raise Chef::Exceptions::Package, "cannot find dnf libraries, you may need to use yum_package" unless cmd
 
-              "#{cmd} #{DNF_HELPER}"
-            end
+                               "#{cmd} #{DNF_HELPER}"
+                             end
           end
 
           def start

data/lib/chef/provider/package/freebsd/base.rb

@@ -58,9 +58,10 @@ class Chef
 
           def makefile_variable_value(variable, dir = nil)
             options = dir ? { cwd: dir } : {}
-            options.merge!(env: nil, returns: [0, 1])
+            options[:env] = nil
+            options[:returns] = [0, 1]
             make_v = shell_out!("make", "-V", variable, **options)
-            make_v.exitstatus == 0 ? make_v.stdout.strip.split($OUTPUT_RECORD_SEPARATOR).first : nil # $\ is the line separator, i.e. newline.
+            make_v.exitstatus == 0 ? make_v.stdout.strip.split($OUTPUT_RECORD_SEPARATOR).first : nil
           end
         end
 

data/lib/chef/provider/package/freebsd/pkgng.rb

@@ -62,7 +62,7 @@ class Chef
             end
 
             pkg_query = shell_out!("pkg", "rquery", options, "%v", new_resource.package_name, env: nil)
-            pkg_query.exitstatus == 0 ? pkg_query.stdout.strip.split(/\n/).last : nil
+            pkg_query.exitstatus == 0 ? pkg_query.stdout.strip.split('\n').last : nil
           end
 
           def repo_regex

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

@@ -26,7 +26,7 @@ class Chef
     class Package
       class Ips < Chef::Provider::Package
 
-        provides :package, platform: %w{openindiana opensolaris omnios solaris2}
+        provides :package, platform: %w{openindiana omnios solaris2}
         provides :ips_package
 
         attr_accessor :virtual

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

@@ -53,9 +53,6 @@ class Chef
 
         # Installs the package specified with the version passed else latest version will be installed
         def install_package(names, versions)
-          # To enable tls 1.2, which is disabled by default in some OS
-          powershell_out("[Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12")
-
           names.each_with_index do |name, index|
             cmd = powershell_out(build_powershell_package_command("Install-Package '#{name}'", versions[index]), timeout: new_resource.timeout)
             next if cmd.nil?
@@ -118,6 +115,8 @@ class Chef
           command = [command] unless command.is_a?(Array)
           cmdlet_name = command.first
           command.unshift("(")
+          # PowerShell Gallery requires tls 1.2
+          command.unshift("if ([Net.ServicePointManager]::SecurityProtocol -lt [Net.SecurityProtocolType]::Tls12) { [Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12 };")
           # -WarningAction SilentlyContinue is used to suppress the warnings from stdout
           %w{-Force -ForceBootstrap -WarningAction SilentlyContinue}.each do |arg|
             command.push(arg)

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

@@ -427,7 +427,7 @@ class Chef
             logger.trace("#{new_resource} detected omnibus installation in #{RbConfig::CONFIG["bindir"]}")
             # Omnibus installs to a static path because of linking on unix, find it.
             true
-          elsif RbConfig::CONFIG["bindir"].sub(/^[\w]:/, "") == "/opscode/chef/embedded/bin"
+          elsif RbConfig::CONFIG["bindir"].sub(/^\w:/, "") == "/opscode/chef/embedded/bin"
             logger.trace("#{new_resource} detected omnibus installation in #{RbConfig::CONFIG["bindir"]}")
             # windows, with the drive letter removed
             true

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

@@ -221,9 +221,7 @@ class Chef
             case result["result"]["status"]
             when "Do", "Doing", "Undoing", "Undo"
               # Continue
-            when "Abort"
-              raise result
-            when "Hold", "Error"
+            when "Abort", "Hold", "Error"
               raise result
             when "Done"
               waiting = false

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

@@ -26,8 +26,6 @@ class Chef
 
         include Chef::Mixin::GetSourceFromPackage
 
-        provides :package, platform: "nexentacore"
-        provides :package, platform: "solaris2", platform_version: "< 5.11"
         provides :solaris_package
 
         # def initialize(*args)

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

@@ -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

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

@@ -26,87 +26,18 @@ class Chef
     class Package
       class Zypper < Chef::Provider::Package
         use_multipackage_api
+        allow_nils
 
         provides :package, platform_family: "suse"
         provides :zypper_package
 
-        def get_versions(package_name)
-          candidate_version = current_version = nil
-          is_installed = false
-          logger.trace("#{new_resource} checking zypper")
-          status = shell_out!("zypper", "--non-interactive", "info", package_name)
-          status.stdout.each_line do |line|
-            case line
-            when /^Version *: (.+) *$/
-              candidate_version = $1.strip
-              logger.trace("#{new_resource} version #{candidate_version}")
-            when /^Installed *: Yes.*$/ # http://rubular.com/r/9StcAMjOn6
-              is_installed = true
-              logger.trace("#{new_resource} is installed")
-            when /^Status *: out-of-date \(version (.+) installed\) *$/
-              current_version = $1.strip
-              logger.trace("#{new_resource} out of date version #{current_version}")
-            end
-          end
-          current_version ||= candidate_version if is_installed
-          { current_version: current_version, candidate_version: candidate_version }
-        end
-
-        def versions
-          @versions ||=
-            begin
-              raw_versions = package_name_array.map do |package_name|
-                get_versions(package_name)
-              end
-              Hash[*package_name_array.zip(raw_versions).flatten]
-            end
-        end
-
-        def get_candidate_versions
-          package_name_array.map do |package_name|
-            versions[package_name][:candidate_version]
-          end
-        end
-
-        def get_current_versions
-          package_name_array.map do |package_name|
-            versions[package_name][:current_version]
-          end
-        end
-
-        def packages_all_locked?(names, versions)
-          names.all? { |n| locked_packages.include? n }
-        end
-
-        def packages_all_unlocked?(names, versions)
-          names.all? { |n| !locked_packages.include? n }
-        end
-
-        def locked_packages
-          @locked_packages ||=
-            begin
-              locked = shell_out!("zypper", "locks")
-              locked.stdout.each_line.map do |line|
-                line.split("|").shift(2).last.strip
-              end
-            end
-        end
-
         def load_current_resource
           @current_resource = Chef::Resource::ZypperPackage.new(new_resource.name)
           current_resource.package_name(new_resource.package_name)
-
-          @candidate_version = get_candidate_versions
           current_resource.version(get_current_versions)
-
           current_resource
         end
 
-        def zypper_version
-          @zypper_version ||=
-            `zypper -V 2>&1`.scan(/\d+/).join(".").to_f
-        end
-
         def install_package(name, version)
           zypper_package("install", global_options, *options, "--auto-agree-with-licenses", allow_downgrade, name, version)
         end
@@ -134,10 +65,77 @@ class Chef
 
         private
 
+        def get_current_versions
+          package_name_array.each_with_index.map { |pkg, i| installed_version(i) }
+        end
+
+        def candidate_version
+          @candidate_version ||= package_name_array.each_with_index.map { |pkg, i| available_version(i) }
+        end
+
+        def resolve_current_version(package_name)
+          latest_version = current_version = nil
+          is_installed = false
+          logger.trace("#{new_resource} checking zypper")
+          status = shell_out!("zypper", "--non-interactive", "info", package_name)
+          status.stdout.each_line do |line|
+            case line
+            when /^Version *: (.+) *$/
+              latest_version = $1.strip
+              logger.trace("#{new_resource} version #{latest_version}")
+            when /^Installed *: Yes.*$/ # http://rubular.com/r/9StcAMjOn6
+              is_installed = true
+              logger.trace("#{new_resource} is installed")
+            when /^Status *: out-of-date \(version (.+) installed\) *$/
+              current_version = $1.strip
+              logger.trace("#{new_resource} out of date version #{current_version}")
+            end
+          end
+          current_version ||= latest_version if is_installed
+          current_version
+        end
+
+        def resolve_available_version(package_name, new_version)
+          search_string = new_version.nil? ? package_name : "#{package_name}=#{new_version}"
+          so = shell_out!("zypper", "--non-interactive", "search", "-s", "--provides", "--match-exact", "--type=package", search_string)
+          so.stdout.each_line do |line|
+            if md = line.match(/^(\S*)\s+\|\s+(\S+)\s+\|\s+(\S+)\s+\|\s+(\S+)\s+\|\s+(\S+)\s+\|\s+(.*)$/)
+              (status, name, type, version, arch, repo) = [ md[1], md[2], md[3], md[4], md[5], md[6] ]
+              next if version == "Version" # header
+
+              # sometimes even though we request a specific version in the search string above and have match exact, we wind up
+              # with other versions in the output, particularly getting the installed version when downgrading.
+              if new_version
+                next unless version == new_version || version.start_with?("#{new_version}-")
+              end
+
+              return version
+            end
+          end
+          nil
+        end
+
+        def available_version(index)
+          @available_version ||= []
+          @available_version[index] ||= resolve_available_version(package_name_array[index], safe_version_array[index])
+          @available_version[index]
+        end
+
+        def installed_version(index)
+          @installed_version ||= []
+          @installed_version[index] ||= resolve_current_version(package_name_array[index])
+          @installed_version[index]
+        end
+
         def zip(names, versions)
           names.zip(versions).map do |n, v|
             (v.nil? || v.empty?) ? n : "#{n}=#{v}"
-          end
+          end.compact
+        end
+
+        def zypper_version
+          @zypper_version ||=
+            `zypper -V 2>&1`.scan(/\d+/).join(".").to_f
         end
 
         def zypper_package(command, global_options, *options, names, versions)
@@ -160,6 +158,35 @@ class Chef
         def global_options
           new_resource.global_options
         end
+
+        def packages_all_locked?(names, versions)
+          names.all? { |n| locked_packages.include? n }
+        end
+
+        def packages_all_unlocked?(names, versions)
+          names.all? { |n| !locked_packages.include? n }
+        end
+
+        def locked_packages
+          @locked_packages ||=
+            begin
+              locked = shell_out!("zypper", "locks")
+              locked.stdout.each_line.map do |line|
+                line.split("|").shift(2).last.strip
+              end
+            end
+        end
+
+        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.version ]
+          end
+        end
+
       end
     end
   end

data/lib/chef/provider/registry_key.rb

@@ -35,6 +35,8 @@ class Chef
 
       include Chef::Mixin::Checksum
 
+      WORD_TYPES = %i{dword dword_big_endian qword}.freeze
+
       def running_on_windows!
         unless ChefUtils.windows?
           raise Chef::Exceptions::Win32NotWindows, "Attempt to manipulate the windows registry on a non-windows node"
@@ -122,9 +124,8 @@ class Chef
         new_resource.unscrubbed_values.each do |value|
           if @name_hash.key?(value[:name].downcase)
             current_value = @name_hash[value[:name].downcase]
-            if %i{dword dword_big_endian qword}.include? value[:type]
-              value[:data] = value[:data].to_i
-            end
+            value[:data] = value[:data].to_i if WORD_TYPES.include?(value[:type])
+
             unless current_value[:type] == value[:type] && current_value[:data] == value[:data]
               converge_by_value = if new_resource.sensitive
                                     value.merge(data: "*sensitive value suppressed*")

data/lib/chef/provider/route.rb

@@ -188,8 +188,8 @@ class Chef
                 logger.trace("#{new_resource} writing default route #{new_resource.gateway} to #{network_file_name}")
                 if ::File.exist?(network_file_name)
                   network_file = ::Chef::Util::FileEdit.new(network_file_name)
-                  network_file.search_file_replace_line /^GATEWAY=/, "GATEWAY=#{new_resource.gateway}"
-                  network_file.insert_line_if_no_match /^GATEWAY=/, "GATEWAY=#{new_resource.gateway}"
+                  network_file.search_file_replace_line(/^GATEWAY=/, "GATEWAY=#{new_resource.gateway}")
+                  network_file.insert_line_if_no_match(/^GATEWAY=/, "GATEWAY=#{new_resource.gateway}")
                   network_file.write_file
                 else
                   network_file = ::File.new(network_file_name, "w")

data/lib/chef/provider/service/debian.rb

@@ -28,6 +28,7 @@ class Chef
 
         UPDATE_RC_D_ENABLED_MATCHES = %r{/rc[\dS].d/S|not installed}i.freeze
         UPDATE_RC_D_PRIORITIES = %r{/rc([\dS]).d/([SK])(\d\d)}i.freeze
+        RUNLEVELS = %w{ 1 2 3 4 5 S }.freeze
 
         def self.supports?(resource, action)
           service_script_exist?(:initd, resource.service_name)
@@ -121,7 +122,7 @@ class Chef
           priority.each do |runlevel, arguments|
             logger.trace("#{new_resource} runlevel #{runlevel}, action #{arguments[0]}, priority #{arguments[1]}")
             # if we are in a update-rc.d default startup runlevel && we start in this runlevel
-            if %w{ 1 2 3 4 5 S }.include?(runlevel) && arguments[0] == :start
+            if RUNLEVELS.include?(runlevel) && arguments[0] == :start
               enabled = true
             end
           end

data/lib/chef/provider/user.rb

@@ -24,6 +24,7 @@ class Chef
     class User < Chef::Provider
 
       attr_accessor :user_exists, :locked
+      attr_accessor :change_desc
 
       def initialize(new_resource, run_context)
         super
@@ -107,13 +108,20 @@ class Chef
       # <true>:: If a change is required
       # <false>:: If the users are identical
       def compare_user
-        return true if !new_resource.home.nil? && Pathname.new(new_resource.home).cleanpath != Pathname.new(current_resource.home).cleanpath
+        @change_desc = []
+        if !new_resource.home.nil? && Pathname.new(new_resource.home).cleanpath != Pathname.new(current_resource.home).cleanpath
+          @change_desc << "change homedir from #{current_resource.home} to #{new_resource.home}"
+        end
 
         %i{comment shell password uid gid}.each do |user_attrib|
-          return true if !new_resource.send(user_attrib).nil? && new_resource.send(user_attrib).to_s != current_resource.send(user_attrib).to_s
+          new_val = new_resource.send(user_attrib)
+          cur_val = current_resource.send(user_attrib)
+          if !new_val.nil? && new_val.to_s != cur_val.to_s
+            @change_desc << "change #{user_attrib} from #{cur_val} to #{new_val}"
+          end
         end
 
-        false
+        !@change_desc.empty?
       end
 
       action :create do
@@ -123,9 +131,9 @@ class Chef
             logger.info("#{new_resource} created")
           end
         elsif compare_user
-          converge_by("alter user #{new_resource.username}") do
+          converge_by(["alter user #{new_resource.username}"] + change_desc) do
             manage_user
-            logger.info("#{new_resource} altered")
+            logger.info("#{new_resource} altered, #{change_desc.join(", ")}")
           end
         end
       end
@@ -142,18 +150,18 @@ class Chef
       action :manage do
         return unless @user_exists && compare_user
 
-        converge_by("manage user #{new_resource.username}") do
+        converge_by(["manage user #{new_resource.username}"] + change_desc) do
           manage_user
-          logger.info("#{new_resource} managed")
+          logger.info("#{new_resource} managed: #{change_desc.join(", ")}")
         end
       end
 
       action :modify do
         return unless compare_user
 
-        converge_by("modify user #{new_resource.username}") do
+        converge_by(["modify user #{new_resource.username}"] + change_desc) do
           manage_user
-          logger.info("#{new_resource} modified")
+          logger.info("#{new_resource} modified: #{change_desc.join(", ")}")
         end
       end