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

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

@@ -73,7 +73,7 @@ class Chef
               name = parts[1]
             end
             shell_out_compact_timeout!("pkg_add", "-r", package_string(name, version), env: { "PKG_PATH" => pkg_path }).status
-            Chef::Log.debug("#{new_resource.package_name} installed")
+            logger.trace("#{new_resource.package_name} installed")
           end
         end
 
@@ -94,7 +94,7 @@ class Chef
                  end
           pkg_info = shell_out_compact_timeout!("pkg_info", "-e", "#{name}->0", env: nil, returns: [0, 1])
           result = pkg_info.stdout[/^inst:#{Regexp.escape(name)}-(.+?)\s/, 1]
-          Chef::Log.debug("installed_version of '#{new_resource.package_name}' is '#{result}'")
+          logger.trace("installed_version of '#{new_resource.package_name}' is '#{result}'")
           result
         end
 
@@ -109,7 +109,7 @@ class Chef
                          end
             end
             results = results.reject(&:nil?)
-            Chef::Log.debug("Candidate versions of '#{new_resource.package_name}' are '#{results}'")
+            logger.trace("Candidate versions of '#{new_resource.package_name}' are '#{results}'")
             case results.length
             when 0
               []

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

@@ -25,18 +25,18 @@ class Chef
       class Pacman < Chef::Provider::Package
 
         provides :package, platform: "arch"
-        provides :pacman_package, os: "linux"
+        provides :pacman_package
 
         def load_current_resource
           @current_resource = Chef::Resource::Package.new(new_resource.name)
           current_resource.package_name(new_resource.package_name)
 
-          Chef::Log.debug("#{new_resource} checking pacman for #{new_resource.package_name}")
+          logger.trace("#{new_resource} checking pacman for #{new_resource.package_name}")
           status = shell_out_compact_timeout("pacman", "-Qi", new_resource.package_name)
           status.stdout.each_line do |line|
             case line
             when /^Version(\s?)*: (.+)$/
-              Chef::Log.debug("#{new_resource} current version is #{$2}")
+              logger.trace("#{new_resource} current version is #{$2}")
               current_resource.version($2)
             end
           end

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

@@ -25,13 +25,13 @@ class Chef
       class Paludis < Chef::Provider::Package
 
         provides :package, platform: "exherbo"
-        provides :paludis_package, os: "linux"
+        provides :paludis_package
 
         def load_current_resource
           @current_resource = Chef::Resource::Package.new(new_resource.package_name)
           current_resource.package_name(new_resource.package_name)
 
-          Chef::Log.debug("Checking package status for #{new_resource.package_name}")
+          logger.trace("Checking package status for #{new_resource.package_name}")
           installed = false
           re = Regexp.new("(.*)[[:blank:]](.*)[[:blank:]](.*)$")
 

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

@@ -17,7 +17,7 @@
 #
 
 require "chef/provider/package"
-require "chef/resource/package"
+require "chef/resource/portage_package"
 require "chef/util/path_helper"
 
 class Chef
@@ -53,52 +53,46 @@ class Chef
             end
           elsif versions.size == 1
             current_resource.version(versions.first.last)
-            Chef::Log.debug("#{new_resource} current version #{$1}")
+            logger.trace("#{new_resource} current version #{$1}")
           end
 
           current_resource
         end
 
-        def parse_emerge(package, txt)
-          availables = {}
-          found_package_name = nil
+        def raise_error_for_query(msg)
+          raise Chef::Exceptions::Package, "Query for '#{new_resource.package_name}' #{msg}"
+        end
 
-          txt.each_line do |line|
-            if line =~ /\*\s+#{PACKAGE_NAME_PATTERN}/
-              found_package_name = $&.delete("*").strip
-              if package =~ /\// # the category is specified
-                if found_package_name == package
-                  availables[found_package_name] = nil
-                end
-              else # the category is not specified
-                if found_package_name.split("/").last == package
-                  availables[found_package_name] = nil
-                end
+        def candidate_version
+          return @candidate_version if @candidate_version
+
+          pkginfo = shell_out_compact("portageq", "best_visible", "/", new_resource.package_name)
+
+          if pkginfo.exitstatus != 0
+            pkginfo.stderr.each_line do |line|
+              if line =~ /[Uu]nqualified atom .*match.* multiple/
+                raise_error_for_query("matched multiple packages (please specify a category):\n#{pkginfo.inspect}")
               end
             end
 
-            if line =~ /Latest version available: (.*)/ && availables.key?(found_package_name)
-              availables[found_package_name] = $1.strip
+            if pkginfo.stdout.strip.empty?
+              raise_error_for_query("did not find a matching package:\n#{pkginfo.inspect}")
             end
-          end
 
-          if availables.size > 1
-            # shouldn't happen if a category is specified so just use `package`
-            raise Chef::Exceptions::Package, "Multiple emerge results found for #{package}: #{availables.keys.join(' ')}. Specify a category."
+            raise_error_for_query("resulted in an unknown error:\n#{pkginfo.inspect}")
           end
 
-          availables.values.first
-        end
-
-        def candidate_version
-          return @candidate_version if @candidate_version
-
-          status = shell_out_compact("emerge", "--color", "n", "--nospinner", "--search", new_resource.package_name.split("/").last)
-          available, installed = parse_emerge(new_resource.package_name, status.stdout)
-          @candidate_version = available
+          if pkginfo.stdout.lines.count > 1
+            raise_error_for_query("produced unexpected output (multiple lines):\n#{pkginfo.inspect}")
+          end
 
-          unless status.exitstatus == 0
-            raise Chef::Exceptions::Package, "emerge --search failed - #{status.inspect}!"
+          pkginfo.stdout.chomp!
+          if pkginfo.stdout =~ /-r\d+$/
+            # Latest/Best version of the package is a revision (-rX).
+            @candidate_version = pkginfo.stdout.split(/(?<=-)/).last(2).join
+          else
+            # Latest/Best version of the package is NOT a revision (-rX).
+            @candidate_version = pkginfo.stdout.split("-").last
           end
 
           @candidate_version

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

@@ -25,7 +25,7 @@ class Chef
       class Powershell < Chef::Provider::Package
         include Chef::Mixin::PowershellOut
 
-        provides :powershell_package, os: "windows"
+        provides :powershell_package
 
         def load_current_resource
           @current_resource = Chef::Resource::PowershellPackage.new(new_resource.name)
@@ -53,7 +53,7 @@ class Chef
         # Installs the package specified with the version passed else latest version will be installed
         def install_package(names, versions)
           names.each_with_index do |name, index|
-            powershell_out("Install-Package '#{name}' -Force -ForceBootstrap -RequiredVersion #{versions[index]}", timeout: new_resource.timeout)
+            powershell_out(build_powershell_command("Install-Package '#{name}'", versions[index]), timeout: new_resource.timeout)
           end
         end
 
@@ -61,13 +61,13 @@ class Chef
         def remove_package(names, versions)
           names.each_with_index do |name, index|
             if versions && !versions[index].nil?
-              powershell_out( "Uninstall-Package '#{name}' -Force -ForceBootstrap -RequiredVersion #{versions[index]}", timeout: new_resource.timeout)
+              powershell_out(build_powershell_command("Uninstall-Package '#{name}'", versions[index]), timeout: new_resource.timeout)
             else
               version = "0"
               until version.empty?
-                version = powershell_out( "(Uninstall-Package '#{name}' -Force -ForceBootstrap | select version | Format-Table -HideTableHeaders | Out-String).Trim()", timeout: new_resource.timeout).stdout.strip
+                version = powershell_out(build_powershell_command("Uninstall-Package '#{name}'"), timeout: new_resource.timeout).stdout.strip
                 unless version.empty?
-                  Chef::Log.info("Removed package '#{name}' with version #{version}")
+                  logger.info("Removed package '#{name}' with version #{version}")
                 end
               end
             end
@@ -79,9 +79,9 @@ class Chef
           versions = []
           new_resource.package_name.each_with_index do |name, index|
             version = if new_resource.version && !new_resource.version[index].nil?
-                        powershell_out("(Find-Package '#{name}' -RequiredVersion #{new_resource.version[index]} -ForceBootstrap -Force | select version | Format-Table -HideTableHeaders | Out-String).Trim()", timeout: new_resource.timeout).stdout.strip
+                        powershell_out(build_powershell_command("Find-Package '#{name}'", new_resource.version[index]), timeout: new_resource.timeout).stdout.strip
                       else
-                        powershell_out("(Find-Package '#{name}' -ForceBootstrap -Force | select version | Format-Table -HideTableHeaders | Out-String).Trim()", timeout: new_resource.timeout).stdout.strip
+                        powershell_out(build_powershell_command("Find-Package '#{name}'"), timeout: new_resource.timeout).stdout.strip
                       end
             if version.empty?
               version = nil
@@ -96,9 +96,9 @@ class Chef
           version_list = []
           new_resource.package_name.each_with_index do |name, index|
             version = if new_resource.version && !new_resource.version[index].nil?
-                        powershell_out("(Get-Package -Name '#{name}' -RequiredVersion #{new_resource.version[index]} -ForceBootstrap -Force | select version | Format-Table -HideTableHeaders | Out-String).Trim()", timeout: new_resource.timeout).stdout.strip
+                        powershell_out(build_powershell_command("Get-Package '#{name}'", new_resource.version[index]), timeout: new_resource.timeout).stdout.strip
                       else
-                        powershell_out("(Get-Package -Name '#{name}' -ForceBootstrap -Force | select version | Format-Table -HideTableHeaders | Out-String).Trim()", timeout: new_resource.timeout).stdout.strip
+                        powershell_out(build_powershell_command("Get-Package '#{name}'"), timeout: new_resource.timeout).stdout.strip
                       end
             if version.empty?
               version = nil
@@ -108,6 +108,21 @@ class Chef
           version_list
         end
 
+        def build_powershell_command(command, version = nil)
+          command = [command] unless command.is_a?(Array)
+          command.unshift("(")
+          %w{-Force -ForceBootstrap}.each do |arg|
+            command.push(arg)
+          end
+          command.push("-RequiredVersion #{version}") if version
+          command.push("-Source #{new_resource.source}") if new_resource.source && command[1] =~ Regexp.union(/Install-Package/, /Find-Package/)
+          command.push(").Version")
+          command.join(" ")
+        end
+
+        def check_resource_semantics!
+          # This validation method from Chef::Provider::Package does not apply here, so no-op it.
+        end
       end
     end
   end

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

@@ -24,8 +24,7 @@ class Chef
   class Provider
     class Package
       class Rpm < Chef::Provider::Package
-
-        provides :rpm_package, os: %w{linux aix}
+        provides :rpm_package
 
         include Chef::Mixin::GetSourceFromPackage
 
@@ -57,7 +56,7 @@ class Chef
               return
             end
 
-            Chef::Log.debug("#{new_resource} checking rpm status")
+            logger.trace("#{new_resource} checking rpm status")
             shell_out_compact_timeout!("rpm", "-qp", "--queryformat", "%{NAME} %{VERSION}-%{RELEASE}\n", new_resource.source).stdout.each_line do |line|
               case line
               when /^(\S+)\s(\S+)$/
@@ -73,12 +72,12 @@ class Chef
             end
           end
 
-          Chef::Log.debug("#{new_resource} checking install state")
+          logger.trace("#{new_resource} checking install state")
           @rpm_status = shell_out_compact_timeout("rpm", "-q", "--queryformat", "%{NAME} %{VERSION}-%{RELEASE}\n", current_resource.package_name)
           @rpm_status.stdout.each_line do |line|
             case line
             when /^(\S+)\s(\S+)$/
-              Chef::Log.debug("#{new_resource} current version is #{$2}")
+              logger.trace("#{new_resource} current version is #{$2}")
               current_resource.version($2)
             end
           end
@@ -119,7 +118,7 @@ class Chef
           return false unless scheme
           %w{http https ftp file}.include?(scheme.downcase)
         rescue URI::InvalidURIError
-          return false
+          false
         end
       end
     end

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

@@ -86,7 +86,22 @@ class Chef
           # === Returns
           # [Gem::Specification]  an array of Gem::Specification objects
           def installed_versions(gem_dep)
-            if Gem::Version.new(Gem::VERSION) >= Gem::Version.new("1.8.0")
+            rubygems_version = Gem::Version.new(Gem::VERSION)
+            if rubygems_version >= Gem::Version.new("2.7")
+              # In newer Rubygems, bundler is now a "default gem" which means
+              # even with AlternateGemEnvironment when you try to get the
+              # installed versions, you get the one from Chef's Ruby's default
+              # gems. This workaround ignores default gems entirely so we see
+              # only the installed gems.
+              stubs = gem_specification.send(:installed_stubs, gem_specification.dirs, "#{gem_dep.name}-*.gemspec")
+              # Filter down to only to only stubs we actually want. The name
+              # filter is needed in case of things like `foo-*.gemspec` also
+              # matching a gem named `foo-bar`.
+              stubs.select! { |stub| stub.name == gem_dep.name && gem_dep.requirement.satisfied_by?(stub.version) }
+              # This isn't sorting before returning beacuse the only code that
+              # uses this method calls `max_by` so it doesn't need to be sorted.
+              stubs
+            elsif rubygems_version >= Gem::Version.new("1.8.0")
               gem_specification.find_all_by_name(gem_dep.name, gem_dep.requirement)
             else
               gem_source_index.search(gem_dep)
@@ -133,7 +148,7 @@ class Chef
           def candidate_version_from_file(gem_dependency, source)
             spec = spec_from_file(source)
             if spec.satisfies_requirement?(gem_dependency)
-              logger.debug { "found candidate gem version #{spec.version} from local gem package #{source}" }
+              logger.trace { "found candidate gem version #{spec.version} from local gem package #{source}" }
               spec.version
             else
               # This is probably going to end badly...
@@ -178,7 +193,7 @@ class Chef
 
             version = spec && spec.version
             if version
-              logger.debug { "found gem #{spec.name} version #{version} for platform #{spec.platform} from #{source}" }
+              logger.trace { "found gem #{spec.name} version #{version} for platform #{spec.platform} from #{source}" }
               version
             else
               source_list = sources.compact.empty? ? "[#{Gem.sources.to_a.join(', ')}]" : "[#{sources.join(', ')}]"
@@ -217,7 +232,7 @@ class Chef
           # Set rubygems' user interaction to ConsoleUI or SilentUI depending
           # on our current debug level
           def with_correct_verbosity
-            Gem::DefaultUserInteraction.ui = Chef::Log.debug? ? Gem::ConsoleUI.new : Gem::SilentUI.new
+            Gem::DefaultUserInteraction.ui = logger.trace? ? Gem::ConsoleUI.new : Gem::SilentUI.new
             yield
           end
 
@@ -232,7 +247,7 @@ class Chef
           private
 
           def logger
-            Chef::Log.logger
+            Chef::Log.with_child({ subsytem: "gem_installer_environment" })
           end
 
         end
@@ -352,10 +367,6 @@ class Chef
         attr_reader :gem_env
         attr_reader :cleanup_gem_env
 
-        def logger
-          Chef::Log.logger
-        end
-
         provides :chef_gem
         provides :gem_package
 
@@ -372,7 +383,7 @@ class Chef
               raise ArgumentError, msg
             end
             @gem_env = AlternateGemEnvironment.new(new_resource.gem_binary)
-            Chef::Log.debug("#{new_resource} using gem '#{new_resource.gem_binary}'")
+            logger.trace("#{new_resource} using gem '#{new_resource.gem_binary}'")
           elsif is_omnibus? && (!new_resource.instance_of? Chef::Resource::ChefGem)
             # Opscode Omnibus - The ruby that ships inside omnibus is only used for Chef
             # Default to installing somewhere more functional
@@ -389,21 +400,21 @@ class Chef
             gem_location = find_gem_by_path
             new_resource.gem_binary gem_location
             @gem_env = AlternateGemEnvironment.new(gem_location)
-            Chef::Log.debug("#{new_resource} using gem '#{gem_location}'")
+            logger.trace("#{new_resource} using gem '#{gem_location}'")
           else
             @gem_env = CurrentGemEnvironment.new
             @cleanup_gem_env = false
-            Chef::Log.debug("#{new_resource} using gem from running ruby environment")
+            logger.trace("#{new_resource} using gem from running ruby environment")
           end
         end
 
         def is_omnibus?
           if RbConfig::CONFIG["bindir"] =~ %r{/(opscode|chef|chefdk)/embedded/bin}
-            Chef::Log.debug("#{new_resource} detected omnibus installation in #{RbConfig::CONFIG['bindir']}")
+            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"
-            Chef::Log.debug("#{new_resource} detected omnibus installation in #{RbConfig::CONFIG['bindir']}")
+            logger.trace("#{new_resource} detected omnibus installation in #{RbConfig::CONFIG['bindir']}")
             # windows, with the drive letter removed
             true
           else
@@ -427,32 +438,25 @@ class Chef
           scheme = nil if scheme =~ /^[a-z]$/
           %w{http https}.include?(scheme)
         rescue URI::InvalidURIError
-          Chef::Log.debug("#{new_resource} failed to parse source '#{new_resource.source}' as a URI, assuming a local path")
+          logger.trace("#{new_resource} failed to parse source '#{new_resource.source}' as a URI, assuming a local path")
           false
         end
 
         def current_version
-          # rubygems 2.6.3 ensures that gem lists are sorted newest first
-          pos = if Gem::Version.new(Gem::VERSION) >= Gem::Version.new("2.6.3")
-                  :first
-                else
-                  :last
-                end
-
           # If one or more matching versions are installed, the newest of them
           # is the current version
           if !matching_installed_versions.empty?
-            gemspec = matching_installed_versions.send(pos)
-            logger.debug { "#{new_resource} found installed gem #{gemspec.name} version #{gemspec.version} matching #{gem_dependency}" }
+            gemspec = matching_installed_versions.max_by(&:version)
+            logger.trace { "#{new_resource} found installed gem #{gemspec.name} version #{gemspec.version} matching #{gem_dependency}" }
             gemspec
             # If no version matching the requirements exists, the latest installed
             # version is the current version.
           elsif !all_installed_versions.empty?
-            gemspec = all_installed_versions.send(pos)
-            logger.debug { "#{new_resource} newest installed version of gem #{gemspec.name} is #{gemspec.version}" }
+            gemspec = all_installed_versions.max_by(&:version)
+            logger.trace { "#{new_resource} newest installed version of gem #{gemspec.name} is #{gemspec.version}" }
             gemspec
           else
-            logger.debug { "#{new_resource} no installed version found for #{gem_dependency}" }
+            logger.trace { "#{new_resource} no installed version found for #{gem_dependency}" }
             nil
           end
         end
@@ -484,7 +488,7 @@ class Chef
 
         def cleanup_after_converge
           if @cleanup_gem_env
-            logger.debug { "#{new_resource} resetting gem environment to default" }
+            logger.trace { "#{new_resource} resetting gem environment to default" }
             Gem.clear_paths
           end
         end

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

@@ -30,10 +30,10 @@ class Chef
         attr_accessor :is_virtual_package
 
         provides :package, platform: "smartos"
-        provides :smartos_package, platform_family: "smartos"
+        provides :smartos_package
 
         def load_current_resource
-          Chef::Log.debug("#{new_resource} loading current resource")
+          logger.trace("#{new_resource} loading current resource")
           @current_resource = Chef::Resource::Package.new(new_resource.name)
           current_resource.package_name(new_resource.package_name)
           check_package_state(new_resource.package_name)
@@ -41,7 +41,7 @@ class Chef
         end
 
         def check_package_state(name)
-          Chef::Log.debug("#{new_resource} checking package #{name}")
+          logger.trace("#{new_resource} checking package #{name}")
           version = nil
           info = shell_out_compact_timeout!("/opt/local/sbin/pkg_info", "-E", "#{name}*", env: nil, returns: [0, 1])
 
@@ -70,18 +70,18 @@ class Chef
         end
 
         def install_package(name, version)
-          Chef::Log.debug("#{new_resource} installing package #{name} version #{version}")
+          logger.trace("#{new_resource} installing package #{name} version #{version}")
           package = "#{name}-#{version}"
           out = shell_out_compact_timeout!("/opt/local/bin/pkgin", "-y", "install", package, env: nil)
         end
 
         def upgrade_package(name, version)
-          Chef::Log.debug("#{new_resource} upgrading package #{name} version #{version}")
+          logger.trace("#{new_resource} upgrading package #{name} version #{version}")
           install_package(name, version)
         end
 
         def remove_package(name, version)
-          Chef::Log.debug("#{new_resource} removing package #{name} version #{version}")
+          logger.trace("#{new_resource} removing package #{name} version #{version}")
           package = name.to_s
           out = shell_out_compact_timeout!("/opt/local/bin/pkgin", "-y", "remove", package, env: nil)
         end