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

data/lib/chef/mixin/powershell_exec.rb

@@ -20,7 +20,7 @@ require_relative "../powershell"
 # The powershell_exec mixin provides in-process access to PowerShell engine via
 # a COM interop (installed by the Chef Client installer).
 #
-# powershell_exec returns a Chef::PowerShell object that provides 3 methods:
+# powershell_exec returns a Chef::PowerShell object that provides 4 methods:
 #
 # .result - returns a hash representing the results returned by executing the
 #           PowerShell script block
@@ -28,6 +28,7 @@ require_relative "../powershell"
 #           PowerShell error stream during execution
 # .error? - returns true if there were error messages written to the PowerShell
 #           error stream during execution
+# .error! - raise Chef::PowerShell::CommandFailed if there was an error
 #
 # Some examples of usage:
 #
@@ -100,6 +101,14 @@ class Chef
       def powershell_exec(script)
         Chef::PowerShell.new(script)
       end
+
+      # The same as the #powershell_exec method except this will raise
+      # Chef::PowerShell::CommandFailed if the command fails
+      def powershell_exec!(script)
+        cmd = Chef::PowerShell.new(script)
+        cmd.error!
+        cmd
+      end
     end
   end
 end

data/lib/chef/mixin/powershell_out.rb

@@ -66,7 +66,7 @@ class Chef
         with_os_architecture(nil, architecture: arch) do
           shell_out(
             build_powershell_command(script),
-            options
+            **options
           )
         end
       end

data/lib/chef/mixin/properties.rb

@@ -264,10 +264,22 @@ class Chef
           end
 
           result = properties.values.select(&:identity?)
-          result = [ properties[:name] ] if result.empty?
+          # if there are no other identity properites set, then the name_property becomes the identity, or
+          # failing that we use the actual name.
+          if result.empty?
+            result = name_property ? [ properties[name_property] ] : [ properties[:name] ]
+          end
           result
         end
 
+        # Returns the name of the name property.  Returns nil if there is no name property.
+        #
+        # @return [Symbol] the name property for this resource
+        def name_property
+          p = properties.find { |n, p| p.name_property? }
+          p ? p.first : nil
+        end
+
         def included(other)
           other.extend ClassMethods
         end

data/lib/chef/mixin/shell_out.rb

@@ -26,10 +26,6 @@ class Chef
       #
       # all consumers should now call shell_out!/shell_out.
       #
-      # on unix the shell_out API supports the clean_array() kind of syntax (below) so that
-      # array args are flat/compact/to_s'd.  on windows, array args aren't supported to its
-      # up to the caller to join(" ") on arrays of strings.
-      #
       # the shell_out_compacted/shell_out_compacted! APIs are private but are intended for use
       # in rspec tests, and should ideally always be used to make code refactoring that do not
       # change behavior easier:

data/lib/chef/mixin/template.rb

@@ -213,7 +213,6 @@ class Chef
 
       class TemplateError < RuntimeError
         attr_reader :original_exception, :context, :options
-
         SOURCE_CONTEXT_WINDOW = 2
 
         def initialize(original_exception, template, context, options)

data/lib/chef/monkey_patches/net_http.rb

@@ -5,10 +5,6 @@ module ChefNetHTTPExceptionExtensions
   attr_accessor :chef_rest_request
 end
 
-unless defined?(Net::HTTPClientException)
-  Net::HTTPClientException = Net::HTTPServerException
-end
-
 require "net/http" unless defined?(Net::HTTP)
 module Net
   class HTTPError

data/lib/chef/node.rb

@@ -351,28 +351,40 @@ class Chef
       run_list.detect { |r| r == item } ? true : false
     end
 
-    # Consume data from ohai and Attributes provided as JSON on the command line.
+    # Handles both the consumption of ohai data and possibly JSON attributes from the CLI
+    #
+    # @api private
     def consume_external_attrs(ohai_data, json_cli_attrs)
       # FIXME(log): should be trace
       logger.debug("Extracting run list from JSON attributes provided on command line")
       consume_attributes(json_cli_attrs)
 
       self.automatic_attrs = ohai_data
+      fix_automatic_attributes
+    end
+
+    # This is for ohai plugins to consume ohai data and have it merged, it should probably be renamed
+    #
+    # @api private
+    def consume_ohai_data(ohai_data)
+      self.automatic_attrs = Chef::Mixin::DeepMerge.merge(automatic_attrs, ohai_data)
+      fix_automatic_attributes
+    end
 
+    # Always ensure that certain automatic attributes are populated and constructed correctly
+    #
+    # @api private
+    def fix_automatic_attributes
       platform, version = Chef::Platform.find_platform_and_version(self)
       # FIXME(log): should be trace
       logger.debug("Platform is #{platform} version #{version}")
       automatic[:platform] = platform
-      automatic[:platform_version] = version
+      automatic[:platform_version] = Chef::VersionString.new(version)
       automatic[:chef_guid] = Chef::Config[:chef_guid] || ( Chef::Config[:chef_guid] = node_uuid )
       automatic[:name] = name
       automatic[:chef_environment] = chef_environment
     end
 
-    def consume_ohai_data(ohai_data)
-      self.automatic_attrs = Chef::Mixin::DeepMerge.merge(automatic_attrs, ohai_data)
-    end
-
     # Consumes the combined run_list and other attributes in +attrs+
     def consume_attributes(attrs)
       normal_attrs_to_merge = consume_run_list(attrs)

data/lib/chef/node/mixin/deep_merge_cache.rb

@@ -19,9 +19,9 @@ class Chef
   class Node
     module Mixin
       module DeepMergeCache
-        # Cache of deep merged values by top-level key.  This is a simple hash which has keys that are the
-        # top-level keys of the node object, and we save the computed deep-merge for that key here.  There is
-        # no cache of subtrees.
+       # Cache of deep merged values by top-level key.  This is a simple hash which has keys that are the
+       # top-level keys of the node object, and we save the computed deep-merge for that key here.  There is
+       # no cache of subtrees.
         attr_accessor :deep_merge_cache
 
         def initialize
@@ -31,10 +31,10 @@ class Chef
           @deep_merge_cache = {}
         end
 
-        # Invalidate a key in the deep_merge_cache.  If called with nil, or no arg, this will invalidate
-        # the entire deep_merge cache.  In the case of the user doing node.default['foo']['bar']['baz']=
-        # that eventually results in a call to reset_cache('foo') here.  A node.default=hash_thing call
-        # must invalidate the entire cache and re-deep-merge the entire node object.
+       # Invalidate a key in the deep_merge_cache.  If called with nil, or no arg, this will invalidate
+       # the entire deep_merge cache.  In the case of the user doing node.default['foo']['bar']['baz']=
+       # that eventually results in a call to reset_cache('foo') here.  A node.default=hash_thing call
+       # must invalidate the entire cache and re-deep-merge the entire node object.
         def reset_cache(path = nil)
           if path.nil?
             deep_merge_cache.clear

data/lib/chef/node/mixin/immutablize_array.rb

@@ -43,6 +43,7 @@ class Chef
           compact
           count
           cycle
+          deconstruct
           detect
           difference
           dig
@@ -59,6 +60,7 @@ class Chef
           entries
           fetch
           filter
+          filter_map
           find
           find_all
           find_index
@@ -71,6 +73,7 @@ class Chef
           include?
           index
           inject
+          intersection
           join
           last
           lazy
@@ -113,6 +116,7 @@ class Chef
           sum
           take
           take_while
+          tally
           to_a
           to_ary
           to_csv

data/lib/chef/node/mixin/immutablize_hash.rb

@@ -40,6 +40,7 @@ class Chef
           compare_by_identity?
           count
           cycle
+          deconstruct_keys
           default
           default_proc
           detect
@@ -60,6 +61,7 @@ class Chef
           fetch
           fetch_values
           filter
+          filter_map
           find
           find_all
           find_index
@@ -109,6 +111,7 @@ class Chef
           sum
           take
           take_while
+          tally
           to_a
           to_h
           to_hash

data/lib/chef/node_map.rb

@@ -35,13 +35,10 @@
 #
 # XXX: confusingly, in the *_priority_map the :klass may be an array of Strings of class names
 #
-
-require_relative "dist"
-
 class Chef
   class NodeMap
     COLLISION_WARNING = <<~EOH.gsub(/\s+/, " ").strip
-      %{type_caps} %{key} built into %{client_name} is being overridden by the %{type} from a cookbook. Please upgrade your cookbook
+      %{type_caps} %{key} from the client is overriding the %{type} from a cookbook.  Please upgrade your cookbook
         or remove the cookbook from your run_list.
     EOH
 
@@ -58,14 +55,13 @@ class Chef
     #
     # @return [NodeMap] Returns self for possible chaining
     #
-    def set(key, klass, platform: nil, platform_version: nil, platform_family: nil, os: nil, canonical: nil, override: nil, chef_version: nil, target_mode: nil, &block)
+    def set(key, klass, platform: nil, platform_version: nil, platform_family: nil, os: nil, override: nil, chef_version: nil, target_mode: nil, &block)
       new_matcher = { klass: klass }
       new_matcher[:platform] = platform if platform
       new_matcher[:platform_version] = platform_version if platform_version
       new_matcher[:platform_family] = platform_family if platform_family
       new_matcher[:os] = os if os
       new_matcher[:block] = block if block
-      new_matcher[:canonical] = canonical if canonical
       new_matcher[:override] = override if override
       new_matcher[:target_mode] = target_mode
 
@@ -87,7 +83,7 @@ class Chef
                         else
                           klass.superclass.to_s
                         end
-        Chef::Log.warn( COLLISION_WARNING % { type: type_of_thing, key: key, type_caps: type_of_thing.capitalize, client_name: Chef::Dist::PRODUCT } )
+        Chef::Log.warn( COLLISION_WARNING % { type: type_of_thing, key: key, type_caps: type_of_thing.capitalize } )
       end
 
       # The map is sorted in order of preference already; we just need to find
@@ -116,16 +112,14 @@ class Chef
     # @param node [Chef::Node] The Chef::Node object for the run, or `nil` to
     #   ignore all filters.
     # @param key [Object] Key to look up
-    # @param canonical [Boolean] `true` or `false` to match canonical or
-    #   non-canonical values only. `nil` to ignore canonicality.  Default: `nil`
     #
     # @return [Object] Class
     #
-    def get(node, key, canonical: nil)
+    def get(node, key)
       return nil unless map.key?(key)
 
       map[key].map do |matcher|
-        return matcher[:klass] if node_matches?(node, matcher) && canonical_matches?(canonical, matcher)
+        return matcher[:klass] if node_matches?(node, matcher)
       end
       nil
     end
@@ -137,16 +131,14 @@ class Chef
     # @param node [Chef::Node] The Chef::Node object for the run, or `nil` to
     #   ignore all filters.
     # @param key [Object] Key to look up
-    # @param canonical [Boolean] `true` or `false` to match canonical or
-    #   non-canonical values only. `nil` to ignore canonicality.  Default: `nil`
     #
     # @return [Object] Class
     #
-    def list(node, key, canonical: nil)
+    def list(node, key)
       return [] unless map.key?(key)
 
       map[key].select do |matcher|
-        node_matches?(node, matcher) && canonical_matches?(canonical, matcher)
+        node_matches?(node, matcher)
       end.map { |matcher| matcher[:klass] }
     end
 
@@ -177,21 +169,6 @@ class Chef
       deleted
     end
 
-    # Seriously, don't use this, it's nearly certain to change on you
-    # @return remaining
-    # @api private
-    def delete_canonical(key, klass)
-      remaining = map[key]
-      if remaining
-        remaining.delete_if { |matcher| matcher[:canonical] && Array(matcher[:klass]) == Array(klass) }
-        if remaining.empty?
-          map.delete(key)
-          remaining = nil
-        end
-      end
-      remaining
-    end
-
     # Check if this map has been locked.
     #
     # @api internal
@@ -302,12 +279,6 @@ class Chef
       filters_match?(node, matcher) && block_matches?(node, matcher[:block])
     end
 
-    def canonical_matches?(canonical, matcher)
-      return true if canonical.nil?
-
-      !!canonical == !!matcher[:canonical]
-    end
-
     #
     # "provides" lines with identical filters sort by class name (ascending).
     #

data/lib/chef/platform/priority_map.rb

@@ -21,8 +21,8 @@ require_relative "../node_map"
 class Chef
   class Platform
     class PriorityMap < Chef::NodeMap
-      def priority(resource_name, priority_array, *filter)
-        set_priority_array(resource_name.to_sym, priority_array, *filter)
+      def priority(resource_name, priority_array, **filter)
+        set_priority_array(resource_name.to_sym, priority_array, **filter)
       end
 
       # @api private
@@ -31,9 +31,9 @@ class Chef
       end
 
       # @api private
-      def set_priority_array(key, priority_array, *filter, &block)
+      def set_priority_array(key, priority_array, **filter, &block)
         priority_array = Array(priority_array)
-        set(key, priority_array, *filter, &block)
+        set(key, priority_array, **filter, &block)
         priority_array
       end
     end

data/lib/chef/platform/query_helpers.rb

@@ -26,49 +26,21 @@ class Chef
         ChefUtils.windows?
       end
 
+      # @deprecated Windows Nano is not a thing anymore so this check shouldn't be used
       def windows_nano_server?
-        return false unless windows?
-
-        require "win32/registry" unless defined?(Win32::Registry)
-
-        # This method may be called before ohai runs (e.g., it may be used to
-        # determine settings in config.rb). Chef::Win32::Registry.new uses
-        # node attributes to verify the machine architecture which aren't
-        # accessible before ohai runs.
-        nano = nil
-        key = "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Server\\ServerLevels"
-        access = ::Win32::Registry::KEY_QUERY_VALUE | 0x0100 # nano is 64-bit only
-        begin
-          ::Win32::Registry::HKEY_LOCAL_MACHINE.open(key, access) do |reg|
-            nano = reg["NanoServer"]
-          end
-        rescue ::Win32::Registry::Error
-          # If accessing the registry key failed, then we're probably not on
-          # nano. Fail through.
-        end
-        nano == 1
+        false
       end
 
+      # @deprecated we added this method due to Windows Server Nano, which is no longer a platform
       def supports_msi?
         return false unless windows?
 
-        require "win32/registry" unless defined?(Win32::Registry)
-
-        key = "System\\CurrentControlSet\\Services\\msiserver"
-        access = ::Win32::Registry::KEY_QUERY_VALUE
-
-        begin
-          ::Win32::Registry::HKEY_LOCAL_MACHINE.open(key, access) do |reg|
-            true
-          end
-        rescue ::Win32::Registry::Error
-          false
-        end
+        true
       end
 
+      # @deprecated we don't support any release of Windows that isn't PS 3+
       def supports_powershell_execution_bypass?(node)
-        node[:languages] && node[:languages][:powershell] &&
-          node[:languages][:powershell][:version].to_i >= 3
+        true
       end
 
       def supports_dsc?(node)

data/lib/chef/powershell.rb

@@ -39,12 +39,26 @@ class Chef
       exec(script)
     end
 
+    #
+    # Was there an error running the command
+    #
+    # @return [Boolean]
+    #
     def error?
       return true if errors.count > 0
 
       false
     end
 
+    class CommandFailed < RuntimeError; end
+
+    #
+    # @raise [Chef::PowerShell::CommandFailed] raise if the command failed
+    #
+    def error!
+      raise Chef::PowerShell::CommandFailed, "Unexpected exit in PowerShell command: #{@errors}" if error?
+    end
+
     private
 
     def exec(script)