chef 15.11.3-universal-mingw32 → 16.1.16-universal-mingw32

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/attribute.rb

@@ -184,7 +184,7 @@ class Chef
       # return the role level override attribute component
       attr_reader :role_override
 
-      # return the enviroment level override attribute component
+      # return the environment level override attribute component
       attr_reader :env_override
 
       # return the force override level attribute component
@@ -535,7 +535,7 @@ class Chef
         e
       end
 
-      # Deep merge all attribute levels using hash-only merging between different precidence
+      # Deep merge all attribute levels using hash-only merging between different precedence
       # levels (so override arrays completely replace arrays set at any default level).
       #
       # The path allows for selectively deep-merging a subtree of the node object.

data/lib/chef/node/immutable_collections.rb

@@ -120,7 +120,7 @@ class Chef
     # ImmutableMash acts like a Mash (Hash that is indifferent to String or
     # Symbol keys), with some important exceptions:
     # * Methods that mutate state are overridden to raise an error instead.
-    # * Methods that read from the collection are overriden so that they check
+    # * Methods that read from the collection are overridden so that they check
     #   if the Chef::Node::Attribute has been modified since an instance of
     #   this class was generated. An error is raised if the object detects that
     #   it is stale.

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

@@ -55,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
 
@@ -113,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
@@ -134,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
 
@@ -174,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
@@ -299,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/policy_builder/policyfile.rb

@@ -328,7 +328,7 @@ class Chef
         end
       end
 
-      # Do some mimimal validation of the policyfile we fetched from the
+      # Do some minimal validation of the policyfile we fetched from the
       # server. Compatibility mode relies on using data bags to store policy
       # files; therefore no real validation will be performed server-side and
       # we need to make additional checks to ensure the data will be formatted

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)

data/lib/chef/property.rb

@@ -1,6 +1,7 @@
 #
 # Author:: John Keiser <jkeiser@chef.io>
-# Copyright:: Copyright 2015-2016, John Keiser.
+# Copyright:: Copyright 2015-2016, John Keiser
+# Copyright:: Copyright (c) Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -140,6 +141,10 @@ class Chef
         raise ArgumentError, "A property cannot be both a name_property/name_attribute and have a default value. Use one or the other on property #{self}"
       end
 
+      if options[:name_property]
+        options[:desired_state] = false unless options.key?(:desired_state)
+      end
+
       # Recursively freeze the default if it isn't a lazy value.
       unless default.is_a?(DelayedEvaluator)
         visitor = lambda do |obj|
@@ -244,6 +249,15 @@ class Chef
       options[:default_description]
     end
 
+    #
+    # The equal_to field of this property.
+    #
+    # @return [Array, NilClass]
+    #
+    def equal_to
+      options[:equal_to]
+    end
+
     #
     # Whether this is part of the resource's natural identity or not.
     #
@@ -289,8 +303,12 @@ class Chef
     #
     # @return [Boolean]
     #
-    def required?
-      options[:required]
+    def required?(action = nil)
+      if !action.nil? && options[:required].is_a?(Array)
+        options[:required].include?(action)
+      else
+        !!options[:required]
+      end
     end
 
     #
@@ -543,7 +561,7 @@ class Chef
           modified_options.key?(:default)
         options = options.reject { |k, v| k == :name_attribute || k == :name_property || k == :default }
       end
-      self.class.new(options.merge(modified_options))
+      self.class.new(**options.merge(modified_options))
     end
 
     #
@@ -556,7 +574,7 @@ class Chef
       # be using the existing getter/setter to manipulate it instead.
       return unless instance_variable_name
 
-      # Properties may override existing properties up the inheritance heirarchy, but
+      # Properties may override existing properties up the inheritance hierarchy, but
       # properties must not override inherited methods like Object#hash.  When the Resource is
       # placed into the resource collection the ruby Hash object will call the
       # Object#hash method on the resource, and overriding that with a property will cause
@@ -684,7 +702,7 @@ class Chef
       # override their own properties.
       return false unless [ Object, BasicObject, Kernel, Chef::Resource ].include?(declared_in.instance_method(name).owner)
 
-      # Allow top-level Chef::Resource proprties, such as `name`, to be overridden.
+      # Allow top-level Chef::Resource properties, such as `name`, to be overridden.
       # As of this writing, `name` is the only Chef::Resource property created with the
       # `property` definition, but this will allow for future properties to be extended
       # as needed.

data/lib/chef/provider.rb

@@ -23,7 +23,7 @@ require_relative "mixin/enforce_ownership_and_permissions"
 require_relative "mixin/why_run"
 require_relative "mixin/shell_out"
 require_relative "mixin/provides"
-require_relative "dsl/core"
+require_relative "dsl/recipe"
 require_relative "platform/service_helpers"
 require_relative "node_map"
 require "forwardable" unless defined?(Forwardable)
@@ -35,6 +35,7 @@ class Chef
 
     attr_accessor :new_resource
     attr_accessor :current_resource
+    attr_accessor :after_resource
     attr_accessor :run_context
 
     attr_reader :recipe_name
@@ -44,8 +45,7 @@ class Chef
     extend Chef::Mixin::Provides
     extend Forwardable
 
-    # includes the "core" DSL and not the "recipe" DSL by design
-    include Chef::DSL::Core
+    include Chef::DSL::Recipe
     # the class only gets the Universal DSL (no resource_collection at class parsing time)
     extend Chef::DSL::Universal
 
@@ -64,7 +64,7 @@ class Chef
     #
     # @return [void]
     def self.action(name, &block)
-      # We need the block directly in a method so that `super` works.
+      # We need the block directly in a method so that `return` works.
       define_method("compile_action_#{name}", &block)
       class_eval <<-EOM
         def action_#{name}
@@ -81,6 +81,20 @@ class Chef
       # Chef.deprecated(:use_inline_resources, "The use_inline_resources mode is no longer optional and the line enabling it can be removed")
     end
 
+    # Use a partial code fragment.  This can be used for code sharing between multiple resources.
+    #
+    # Do not wrap the code fragment in a class or module.  It also does not support the use of super
+    # to subclass any methods defined in the fragment, the methods will just be overwritten.
+    #
+    # @param partial [String] the code fragment to eval against the class
+    #
+    def self.use(partial)
+      dirname = ::File.dirname(partial)
+      basename = ::File.basename(partial, ".rb")
+      basename = basename[1..-1] if basename.start_with?("_")
+      class_eval IO.read(::File.expand_path("#{dirname}/_#{basename}.rb", ::File.dirname(caller_locations.first.absolute_path)))
+    end
+
     # delegate to the resource
     #
     def_delegators :@new_resource, :property_is_set?
@@ -95,6 +109,7 @@ class Chef
       @new_resource = new_resource
       @action = action
       @current_resource = nil
+      @after_resource = nil
       @run_context = run_context
       @converge_actions = nil
 
@@ -137,6 +152,7 @@ class Chef
       new_resource.cookbook_name
     end
 
+    # hook that subclasses can use to do lazy validation for where properties aren't flexible enough
     def check_resource_semantics!; end
 
     # a simple placeholder method that will be called / raise if a resource tries to
@@ -149,6 +165,13 @@ class Chef
 
     def cleanup_after_converge; end
 
+    def load_after_resource
+      # This is a backwards compatible hack, custom resources properly wire up a new after_resource
+      # via load_current_value.  It is acceptable for old style resources that cannot be easily made
+      # into custom resources to override this method and provide a proper after_resource.
+      @after_resource = @new_resource
+    end
+
     # the :nothing action which is available on all resources by default
     def action_nothing
       logger.trace("Doing nothing for #{@new_resource}")
@@ -159,12 +182,20 @@ class Chef
       run_context.events
     end
 
+    def validate_required_properties!
+      # all we do is run through all the required properties for this action and vivify them
+      new_resource.class.properties.each { |name, property| property.required?(action) && property.get(new_resource) }
+    end
+
     def run_action(action = nil)
       @action = action unless action.nil?
 
-      # @todo it would be preferable to get the action to be executed in the constructor...
+      # hook that subclasses can use to do lazy validation for where properties aren't flexible enough
       check_resource_semantics!
 
+      # force the validation of required properties
+      validate_required_properties!
+
       # user-defined LWRPs may include unsafe load_current_resource methods that cannot be run in whyrun mode
       if whyrun_mode? && !whyrun_supported?
         events.resource_current_state_load_bypassed(@new_resource, @action, @current_resource)
@@ -192,6 +223,9 @@ class Chef
       set_updated_status
 
       cleanup_after_converge
+
+      load_after_resource
+      events.resource_after_state_loaded(@new_resource, @action, @after_resource)
     end
 
     def process_resource_requirements
@@ -334,7 +368,7 @@ class Chef
     end
 
     def self.provides(short_name, opts = {}, &block)
-      Chef.provider_handler_map.set(short_name, self, opts, &block)
+      Chef.provider_handler_map.set(short_name, self, **opts, &block)
     end
 
     def self.provides?(node, resource)