chef 15.17.4-universal-mingw32 → 16.0.257-universal-mingw32

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

@@ -42,9 +42,7 @@ class Chef
           end
 
           def current_installed_version
-            # pkgng up to version 1.15.99.7 returns 70 for pkg not found,
-            # later versions return 1
-            pkg_info = shell_out!("pkg", "info", new_resource.package_name, env: nil, returns: [0, 1, 70])
+            pkg_info = shell_out!("pkg", "info", new_resource.package_name, env: nil, returns: [0, 70])
             pkg_info.stdout[/^Version +: (.+)$/, 1]
           end
 

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

@@ -24,6 +24,8 @@ class Chef
   class Provider
     class Package
       class Homebrew < Chef::Provider::Package
+        allow_nils
+        use_multipackage_api
 
         provides :package, os: "darwin", override: true
         provides :homebrew_package
@@ -31,49 +33,51 @@ class Chef
         include Chef::Mixin::HomebrewUser
 
         def load_current_resource
-          self.current_resource = Chef::Resource::HomebrewPackage.new(new_resource.name)
+          @current_resource = Chef::Resource::HomebrewPackage.new(new_resource.name)
           current_resource.package_name(new_resource.package_name)
-          current_resource.version(current_installed_version)
-          logger.trace("#{new_resource} current version is #{current_resource.version}") if current_resource.version
-
-          @candidate_version = candidate_version
-
-          logger.trace("#{new_resource} candidate version is #{@candidate_version}") if @candidate_version
+          current_resource.version(get_current_versions)
+          logger.trace("#{new_resource} current package version(s): #{current_resource.version}") if current_resource.version
 
           current_resource
         end
 
-        def install_package(name, version)
-          unless current_resource.version == version
-            brew("install", options, name)
+        def candidate_version
+          package_name_array.map do |package_name|
+            available_version(package_name)
           end
         end
 
-        def upgrade_package(name, version)
-          current_version = current_resource.version
-
-          if current_version.nil? || current_version.empty?
-            install_package(name, version)
-          elsif current_version != version
-            brew("upgrade", options, name)
+        def get_current_versions
+          package_name_array.map do |package_name|
+            installed_version(package_name)
           end
         end
 
-        def remove_package(name, version)
-          if current_resource.version
-            brew("uninstall", options, name)
-          end
+        def install_package(names, versions)
+          brew_cmd_output("install", options, names.compact)
         end
 
-        # Homebrew doesn't really have a notion of purging, do a "force remove"
-        def purge_package(name, version)
-          if current_resource.version
-            brew("uninstall", "--force", options, name)
-          end
+        # upgrades are a bit harder in homebrew than other package formats. If you try to
+        # brew upgrade a package that isn't installed it will fail so if a user specifies
+        # the action of upgrade we need to figure out which packages need to be installed
+        # and which packages can be upgrades. We do this by checking if brew_info has an entry
+        # via the installed_version helper.
+        def upgrade_package(names, versions)
+          # @todo when we no longer support Ruby 2.6 this can be simplified to be a .filter_map
+          upgrade_pkgs = names.select { |x| x if installed_version(x) }.compact
+          install_pkgs = names.select { |x| x unless installed_version(x) }.compact
+
+          brew_cmd_output("upgrade", options, upgrade_pkgs) unless upgrade_pkgs.empty?
+          brew_cmd_output("install", options, install_pkgs) unless install_pkgs.empty?
         end
 
-        def brew(*args)
-          get_response_from_command("brew", *args)
+        def remove_package(names, versions)
+          brew_cmd_output("uninstall", options, names.compact)
+        end
+
+        # Homebrew doesn't really have a notion of purging, do a "force remove"
+        def purge_package(names, versions)
+          brew_cmd_output("uninstall", "--force", options, names.compact)
         end
 
         # We implement a querying method that returns the JSON-as-Hash
@@ -83,9 +87,50 @@ class Chef
         # information, but that is not any more robust than using the
         # command-line interface that returns the same thing.
         #
-        # https://github.com/Homebrew/homebrew/wiki/Querying-Brew
+        # https://docs.brew.sh/Querying-Brew
+        #
+        # @returns [Hash] a hash of package information where the key is the package name
         def brew_info
-          @brew_info ||= Chef::JSONCompat.from_json(brew("info", "--json=v1", new_resource.package_name)).first
+          @brew_info ||= begin
+            command_array = ["info", "--json=v1"].concat package_name_array
+            # convert the array of hashes into a hash where the key is the package name
+
+            cmd_output = brew_cmd_output(command_array, allow_failure: true)
+
+            if cmd_output.empty?
+              # we had some kind of failure so we need to iterate through each package to find them
+              package_name_array.each_with_object({}) do |package_name, hsh|
+                cmd_output = brew_cmd_output("info", "--json=v1", package_name, allow_failure: true)
+                if cmd_output.empty?
+                  hsh[package_name] = {}
+                else
+                  json = Chef::JSONCompat.from_json(cmd_output).first
+                  hsh[json["name"]] = json
+                end
+              end
+            else
+              Hash[Chef::JSONCompat.from_json(cmd_output).collect { |pkg| [pkg["name"], pkg] }]
+            end
+          end
+        end
+
+        #
+        # Return the package information given a package name or package alias
+        #
+        # @param [String] name_or_alias The name of the package or its alias
+        #
+        # @return [Hash] Package information
+        #
+        def package_info(package_name)
+          # return the package hash if it's in the brew info hash
+          return brew_info[package_name] if brew_info[package_name]
+
+          # check each item in the hash to see if we were passed an alias
+          brew_info.each_value do |p|
+            return p if p["aliases"].include?(package_name)
+          end
+
+          {}
         end
 
         # Some packages (formula) are "keg only" and aren't linked,
@@ -94,15 +139,20 @@ class Chef
         # "current" (as in latest). Otherwise, we will use the version
         # that brew thinks is linked as the current version.
         #
-        def current_installed_version
-          if brew_info["keg_only"]
-            if brew_info["installed"].empty?
+        # @param [String] package name
+        #
+        # @returns [String] package version
+        def installed_version(i)
+          p_data = package_info(i)
+
+          if p_data["keg_only"]
+            if p_data["installed"].empty?
               nil
             else
-              brew_info["installed"].last["version"]
+              p_data["installed"].last["version"]
             end
           else
-            brew_info["linked_keg"]
+            p_data["linked_keg"]
           end
         end
 
@@ -115,19 +165,33 @@ class Chef
         # forward project.
         #
         # https://github.com/Homebrew/homebrew/wiki/Acceptable-Formulae#stable-versions
-        def candidate_version
-          brew_info["versions"]["stable"]
-        end
+        #
+        # @param [String] package name
+        #
+        # @returns [String] package version
+        def available_version(i)
+          p_data = package_info(i)
 
-        private
+          # nothing is available
+          return nil if p_data.empty?
 
-        def get_response_from_command(*command)
+          p_data["versions"]["stable"]
+        end
+
+        def brew_cmd_output(*command, **options)
           homebrew_uid = find_homebrew_uid(new_resource.respond_to?(:homebrew_user) && new_resource.homebrew_user)
           homebrew_user = Etc.getpwuid(homebrew_uid)
 
-          logger.trace "Executing '#{command.join(" ")}' as user '#{homebrew_user.name}'"
+          logger.trace "Executing 'brew #{command.join(" ")}' as user '#{homebrew_user.name}'"
+
+          # allow the calling method to decide if the cmd should raise or not
+          # brew_info uses this when querying out available package info since a bad
+          # package name will raise and we want to surface a nil available package so that
+          # the package provider can magically handle that
+          shell_out_cmd = options[:allow_failure] ? :shell_out : :shell_out!
+
           # FIXME: this 1800 second default timeout should be deprecated
-          output = shell_out!(*command, timeout: 1800, user: homebrew_uid, environment: { "HOME" => homebrew_user.dir, "RUBYOPT" => nil, "TMPDIR" => nil })
+          output = send(shell_out_cmd, "brew", *command, timeout: 1800, user: homebrew_uid, environment: { "HOME" => homebrew_user.dir, "RUBYOPT" => nil, "TMPDIR" => nil })
           output.stdout.chomp
         end
 

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

@@ -27,6 +27,7 @@ require_relative "cab"
 require_relative "../../util/path_helper"
 require_relative "../../mixin/uris"
 require_relative "../../mixin/checksum"
+require "cgi" unless defined?(CGI)
 
 class Chef
   class Provider
@@ -99,7 +100,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
@@ -120,6 +121,7 @@ class Chef
           @cab_files.each do |cab_file|
             declare_resource(:cab_package, new_resource.name) do
               source cab_file
+              timeout new_resource.timeout
               action :remove
             end
           end

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

@@ -27,29 +27,13 @@ class Chef
         provides :package, platform: "arch"
         provides :pacman_package
 
+        use_multipackage_api
+        allow_nils
+
         def load_current_resource
           @current_resource = Chef::Resource::Package.new(new_resource.name)
           current_resource.package_name(new_resource.package_name)
-
-          logger.trace("#{new_resource} checking pacman for #{new_resource.package_name}")
-          status = shell_out("pacman", "-Qi", new_resource.package_name)
-          status.stdout.each_line do |line|
-            case line
-            when /^Version(\s?)*: (.+)$/
-              logger.trace("#{new_resource} current version is #{$2}")
-              current_resource.version($2)
-            end
-          end
-
-          unless status.exitstatus == 0 || status.exitstatus == 1
-            raise Chef::Exceptions::Package, "pacman failed - #{status.inspect}!"
-          end
-
-          current_resource
-        end
-
-        def candidate_version
-          return @candidate_version if @candidate_version
+          current_resource.version = []
 
           repos = %w{extra core community}
 
@@ -58,31 +42,38 @@ class Chef
             repos = pacman.scan(/\[(.+)\]/).flatten
           end
 
-          package_repos = repos.map { |r| Regexp.escape(r) }.join("|")
-
+          repos = Regexp.union(repos)
           status = shell_out("pacman", "-Sl")
-          status.stdout.each_line do |line|
-            case line
-            when /^(#{package_repos}) #{Regexp.escape(new_resource.package_name)} (.+)$/
-              # $2 contains a string like "4.4.0-1" or "3.10-4 [installed]"
-              # simply split by space and use first token
-              @candidate_version = $2.split(" ").first
-            end
-          end
 
           unless status.exitstatus == 0 || status.exitstatus == 1
             raise Chef::Exceptions::Package, "pacman failed - #{status.inspect}!"
           end
 
-          unless @candidate_version
-            raise Chef::Exceptions::Package, "pacman does not have a version of package #{new_resource.package_name}"
+          pkg_db_data = status.stdout
+          @candidate_version = []
+          package_name_array.each do |pkg|
+            pkg_data = pkg_db_data.match(/(#{repos}) #{pkg} (?<candidate>.*?-[0-9]+)(?<installed> \[.*?( (?<current>.*?-[0-9]+))?\])?\n/m)
+            unless pkg_data
+              raise Chef::Exceptions::Package, "pacman does not have a version of package #{pkg}"
+            end
+
+            @candidate_version << pkg_data[:candidate]
+            if pkg_data[:installed]
+              current_resource.version << (pkg_data[:current] || pkg_data[:candidate])
+            else
+              current_resource.version << nil
+            end
           end
 
+          current_resource
+        end
+
+        def candidate_version
           @candidate_version
         end
 
         def install_package(name, version)
-          shell_out!( "pacman", "--sync", "--noconfirm", "--noprogressbar", options, name)
+          shell_out!("pacman", "--sync", "--noconfirm", "--noprogressbar", options, *name)
         end
 
         def upgrade_package(name, version)
@@ -90,7 +81,7 @@ class Chef
         end
 
         def remove_package(name, version)
-          shell_out!( "pacman", "--remove", "--noconfirm", "--noprogressbar", options, name )
+          shell_out!("pacman", "--remove", "--noconfirm", "--noprogressbar", options, *name)
         end
 
         def purge_package(name, version)

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

@@ -36,7 +36,7 @@ class Chef
 
         def define_resource_requirements
           super
-          if powershell_out("$PSVersionTable.PSVersion.Major").stdout.strip.to_i < 5
+          if powershell_version < 5
             raise "Minimum installed PowerShell Version required is 5"
           end
 
@@ -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,8 +115,7 @@ class Chef
           command = [command] unless command.is_a?(Array)
           cmdlet_name = command.first
           command.unshift("(")
-          # -WarningAction SilentlyContinue is used to suppress the warnings from stdout
-          %w{-Force -ForceBootstrap -WarningAction SilentlyContinue}.each do |arg|
+          %w{-Force -ForceBootstrap}.each do |arg|
             command.push(arg)
           end
           command.push("-RequiredVersion #{version}") if version

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

@@ -483,9 +483,23 @@ class Chef
                                       end
         end
 
+        ##
+        # If `include_default_source` is nil, return true if the global
+        # `rubygems_url` was set or if `clear_sources` and `source` on the
+        # resource are not set.
+        # If `include_default_source` is not nil, it has been set explicitly on
+        # the resource and that value should be used.
+        def include_default_source?
+          if new_resource.include_default_source.nil?
+            !!Chef::Config[:rubygems_url] || !(new_resource.source || new_resource.clear_sources)
+          else
+            new_resource.include_default_source
+          end
+        end
+
         def gem_sources
           srcs = [ new_resource.source ]
-          srcs << Chef::Config[:rubygems_url] if new_resource.include_default_source
+          srcs << (Chef::Config[:rubygems_url] || "https://rubygems.org") if include_default_source?
           srcs.flatten.compact
         end
 
@@ -550,12 +564,25 @@ class Chef
           new_resource.gem_binary || "gem"
         end
 
+        ##
+        # If `clear_sources` is nil, clearing sources is implied if a `source`
+        # was added or if the global rubygems URL is set. If `clear_sources`
+        # is not nil, it has been set explicitly on the resource and its value
+        # should be used.
+        def clear_sources?
+          if new_resource.clear_sources.nil?
+            !!(new_resource.source || Chef::Config[:rubygems_url])
+          else
+            new_resource.clear_sources
+          end
+        end
+
         def install_via_gem_command(name, version)
           src = []
           if new_resource.source.is_a?(String) && new_resource.source =~ /\.gem$/i
             name = new_resource.source
           else
-            src << "--clear-sources" if new_resource.clear_sources
+            src << "--clear-sources" if clear_sources?
             src += gem_sources.map { |s| "--source=#{s}" }
           end
           src_str = src.empty? ? "" : " #{src.join(" ")}"

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

@@ -59,14 +59,15 @@ class Chef
         def get_current_versions
           package_name_array.each_with_index.map do |pkg, i|
             installed_version(i)
-          end.compact
+          end
         end
 
         def install_package(names, versions)
           if new_resource.source
             install_snap_from_source(names, new_resource.source)
           else
-            install_snaps(names)
+            resolved_names = names.each_with_index.map { |name, i| available_version(i).to_s unless name.nil? }
+            install_snaps(resolved_names)
           end
         end
 
@@ -74,16 +75,14 @@ class Chef
           if new_resource.source
             install_snap_from_source(names, new_resource.source)
           else
-            if get_current_versions.empty?
-              install_snaps(names, versions)
-            else
-              update_snaps(names)
-            end
+            resolved_names = names.each_with_index.map { |name, i| available_version(i).to_s unless name.nil? }
+            update_snaps(resolved_names)
           end
         end
 
         def remove_package(names, versions)
-          uninstall_snaps(names)
+          resolved_names = names.each_with_index.map { |name, i| installed_version(i).to_s unless name.nil? }
+          uninstall_snaps(resolved_names)
         end
 
         alias purge_package remove_package
@@ -130,73 +129,19 @@ class Chef
             "Accept: application/json\r\n" +
             "Content-Type: application/json\r\n"
           if method == "POST"
-            pdata = post_data.to_json.to_s
-            request.concat("Content-Length: #{pdata.bytesize}\r\n\r\n#{pdata}")
+            request.concat("Content-Length: #{post_data.bytesize}\r\n\r\n#{post_data}")
           end
           request.concat("\r\n")
-
-          # while it is expected to allow clients to connect using https over
-          # a tcp socket, at this point only a unix socket is supported. the
-          # socket is /run/snapd.socket note - unixsocket is not defined on
-          # windows systems
+          # While it is expected to allow clients to connect using HTTPS over a TCP socket,
+          # at this point only a UNIX socket is supported. The socket is /run/snapd.socket
+          # Note - UNIXSocket is not defined on windows systems
           if defined?(::UNIXSocket)
             UNIXSocket.open("/run/snapd.socket") do |socket|
-              # send request, read the response, split the response and parse
-              # the body
-              socket.write(request)
-
-              # WARNING!!! HERE BE DRAGONs
-              #
-              # So snapd doesn't return an EOF at the end of its body, so
-              # doing a normal read will just hang forever.
-              #
-              # Well, sort of. if, after it writes everything, you then send
-              # yet-another newline, it'll then send its EOF and promptly
-              # disconnect closing the pipe and preventing reading. so, you
-              # have to read first, and therein lies the EOF problem.
-              #
-              # So you can do non-blocking reads with selects, but it
-              # makes every read take about 5 seconds. If, instead, we
-              # read the last line char-by-char, it's about half a second.
-              #
-              # Reading a character at a time isn't efficient, and since we
-              # know that http headers always have a blank line after them,
-              # we can read lines until we find a blank line and *then* read
-              # a character at a time. snap returns all the json on a single
-              # line, so once you pass headers you must read a character a
-              # time.
-              #
-              # - jaymzh
-
-              Chef::Log.trace(
-                "snap_package[#{new_resource.package_name}]: reading headers"
-              )
-              loop do
-                response = socket.readline
-                break if response.strip.empty? # finished headers
-              end
-              Chef::Log.trace(
-                "snap_package[#{new_resource.package_name}]: past headers, " +
-                "onto the body..."
-              )
-              result = nil
-              body = ""
-              socket.each_char do |c|
-                body << c
-                # we know we're not done if we don't have a char that
-                # can end JSON
-                next unless ["}", "]"].include?(c)
-
-                begin
-                  result = JSON.parse(body)
-                  # if we get here, we were able to parse the json so we
-                  # are done reading
-                  break
-                rescue JSON::ParserError
-                  next
-                end
-              end
-              result
+              # Send request, read the response, split the response and parse the body
+              socket.print(request)
+              response = socket.read
+              headers, body = response.split("\r\n\r\n", 2)
+              JSON.parse(body)
             end
           end
         end
@@ -266,22 +211,20 @@ class Chef
           response.error!
         end
 
-        def install_snaps(snap_names, versions)
-          snap_names.each do |snap|
-            response = post_snap(snap, "install", new_resource.channel, new_resource.options)
-            id = get_id_from_async_response(response)
-            wait_for_completion(id)
-          end
+        def install_snaps(snap_names)
+          response = post_snaps(snap_names, "install", new_resource.channel, new_resource.options)
+          id = get_id_from_async_response(response)
+          wait_for_completion(id)
         end
 
         def update_snaps(snap_names)
-          response = post_snaps(snap_names, "refresh", nil, new_resource.options)
+          response = post_snaps(snap_names, "refresh", new_resource.channel, new_resource.options)
           id = get_id_from_async_response(response)
           wait_for_completion(id)
         end
 
         def uninstall_snaps(snap_names)
-          response = post_snaps(snap_names, "remove", nil, new_resource.options)
+          response = post_snaps(snap_names, "remove", new_resource.channel, new_resource.options)
           id = get_id_from_async_response(response)
           wait_for_completion(id)
         end
@@ -335,20 +278,18 @@ class Chef
               "action" => action,
               "snaps" => snap_names,
           }
-          if %w{install refresh switch}.include?(action) && channel
+          if %w{install refresh switch}.include?(action)
             request["channel"] = channel
           end
 
           # No defensive handling of params
           # Snap will throw the proper exception if called improperly
           # And we can provide that exception to the end user
-          if options
-            request["classic"] = true if options.include?("classic")
-            request["devmode"] = true if options.include?("devmode")
-            request["jailmode"] = true if options.include?("jailmode")
-            request["ignore_validation"] = true if options.include?("ignore-validation")
-          end
+          request["classic"] = true if options["classic"]
+          request["devmode"] = true if options["devmode"]
+          request["jailmode"] = true if options["jailmode"]
           request["revision"] = revision unless revision.nil?
+          request["ignore_validation"] = true if options["ignore-validation"]
           request
         end
 
@@ -364,22 +305,12 @@ class Chef
           call_snap_api("POST", "/v2/snaps", json)
         end
 
-        def post_snap(snap_name, action, channel, options, revision = nil)
-          json = generate_snap_json(snap_name, action, channel, options, revision = nil)
-          json.delete("snaps")
-          call_snap_api("POST", "/v2/snaps/#{snap_name}", json)
-        end
-
         def get_latest_package_version(name, channel)
           json = call_snap_api("GET", "/v2/find?name=#{name}")
           if json["status-code"] != 200
             raise Chef::Exceptions::Package, json["result"], caller
           end
 
-          unless json["result"][0]["channels"]["latest/#{channel}"]
-            raise Chef::Exceptions::Package, "No version of #{name} in channel #{channel}", caller
-          end
-
           # Return the version matching the channel
           json["result"][0]["channels"]["latest/#{channel}"]["version"]
         end