chef 14.2.0 → 14.3.37

data/lib/chef/mixin/wide_string.rb

@@ -31,40 +31,22 @@ class Chef
       def utf8_to_wide(ustring)
         # ensure it is actually UTF-8
         # Ruby likes to mark binary data as ASCII-8BIT
-        ustring = (ustring + "").force_encoding("UTF-8") if ustring.respond_to?(:force_encoding) && ustring.encoding.name != "UTF-8"
+        ustring = (ustring + "").force_encoding("UTF-8")
 
         # ensure we have the double-null termination Windows Wide likes
         ustring += "\000\000" if ustring.length == 0 || ustring[-1].chr != "\000"
 
         # encode it all as UTF-16LE AKA Windows Wide Character AKA Windows Unicode
-        ustring = begin
-          if ustring.respond_to?(:encode)
-            ustring.encode("UTF-16LE")
-          else
-            require "iconv"
-            Iconv.conv("UTF-16LE", "UTF-8", ustring)
-          end
-        end
-        ustring
+        ustring.encode("UTF-16LE")
       end
 
       def wide_to_utf8(wstring)
         # ensure it is actually UTF-16LE
         # Ruby likes to mark binary data as ASCII-8BIT
-        wstring = wstring.force_encoding("UTF-16LE") if wstring.respond_to?(:force_encoding)
+        wstring = wstring.force_encoding("UTF-16LE")
 
-        # encode it all as UTF-8
-        wstring = begin
-          if wstring.respond_to?(:encode)
-            wstring.encode("UTF-8")
-          else
-            require "iconv"
-            Iconv.conv("UTF-8", "UTF-16LE", wstring)
-          end
-        end
-        # remove trailing CRLF and NULL characters
-        wstring.strip!
-        wstring
+        # encode it all as UTF-8 and remove trailing CRLF and NULL characters
+        wstring.encode("UTF-8").strip
       end
 
     end

data/lib/chef/mixin/windows_env_helper.rb

@@ -32,7 +32,7 @@ class Chef
         include Chef::ReservedNames::Win32::API::System
       end
 
-      #see: http://msdn.microsoft.com/en-us/library/ms682653%28VS.85%29.aspx
+      # see: http://msdn.microsoft.com/en-us/library/ms682653%28VS.85%29.aspx
       HWND_BROADCAST = 0xffff
       WM_SETTINGCHANGE = 0x001A
       SMTO_BLOCK = 0x0001

data/lib/chef/mixin/xml_escape.rb

@@ -89,18 +89,18 @@ class Chef
           156 =>  339, # latin small ligature oe
           158 =>  382, # latin small letter z with caron
           159 =>  376 # latin capital letter y with diaeresis
-        }
+        }.freeze
 
         # http://www.w3.org/TR/REC-xml/#dt-chardata
         PREDEFINED = {
           38 => "&", # ampersand
           60 => "<",  # left angle bracket
           62 => ">" # right angle bracket
-        }
+        }.freeze
 
         # http://www.w3.org/TR/REC-xml/#charsets
         VALID = [[0x9, 0xA, 0xD], (0x20..0xD7FF),
-          (0xE000..0xFFFD), (0x10000..0x10FFFF)]
+          (0xE000..0xFFFD), (0x10000..0x10FFFF)].freeze
 
         def xml_escape(unescaped_str)
           unescaped_str.unpack("U*").map { |char| xml_escape_char!(char) }.join

data/lib/chef/node.rb

@@ -115,10 +115,10 @@ class Chef
     def name(arg = nil)
       if !arg.nil?
         validate(
-                 { :name => arg },
-                 { :name => { :kind_of => String,
-                              :cannot_be => :blank,
-                              :regex => /^[\-[:alnum:]_:.]+$/ },
+                 { name: arg },
+                 { name: { kind_of: String,
+                           cannot_be: :blank,
+                           regex: /^[\-[:alnum:]_:.]+$/ },
                  })
         @name = arg
       else
@@ -130,7 +130,7 @@ class Chef
       set_or_return(
         :chef_environment,
         arg,
-        { :regex => /^[\-[:alnum:]_]+$/, :kind_of => String }
+        { regex: /^[\-[:alnum:]_]+$/, kind_of: String }
       )
     end
 
@@ -495,7 +495,7 @@ class Chef
         "chef_type" => "node",
         "default" => attributes.combined_default,
         "override" => attributes.combined_override,
-        #Render correctly for run_list items so malformed json does not result
+        # Render correctly for run_list items so malformed json does not result
         "run_list" => @primary_runlist.run_list.map { |item| item.to_s },
       }
       # Chef Server rejects node JSON with extra keys; prior to 12.3,
@@ -524,8 +524,8 @@ class Chef
       node = new
       node.name(o["name"])
 
-      node.policy_name = o["policy_name"] if o.has_key?("policy_name")
-      node.policy_group = o["policy_group"] if o.has_key?("policy_group")
+      node.policy_name = o["policy_name"] if o.key?("policy_name")
+      node.policy_group = o["policy_group"] if o.key?("policy_group")
 
       unless node.policy_group.nil?
         node.chef_environment(o["policy_group"])
@@ -533,17 +533,17 @@ class Chef
         node.chef_environment(o["chef_environment"])
       end
 
-      if o.has_key?("attributes")
+      if o.key?("attributes")
         node.normal_attrs = o["attributes"]
       end
-      node.automatic_attrs = Mash.new(o["automatic"]) if o.has_key?("automatic")
-      node.normal_attrs = Mash.new(o["normal"]) if o.has_key?("normal")
-      node.default_attrs = Mash.new(o["default"]) if o.has_key?("default")
-      node.override_attrs = Mash.new(o["override"]) if o.has_key?("override")
+      node.automatic_attrs = Mash.new(o["automatic"]) if o.key?("automatic")
+      node.normal_attrs = Mash.new(o["normal"]) if o.key?("normal")
+      node.default_attrs = Mash.new(o["default"]) if o.key?("default")
+      node.override_attrs = Mash.new(o["override"]) if o.key?("override")
 
-      if o.has_key?("run_list")
+      if o.key?("run_list")
         node.run_list.reset!(o["run_list"])
-      elsif o.has_key?("recipes")
+      elsif o.key?("recipes")
         o["recipes"].each { |r| node.recipes << r }
       end
 

data/lib/chef/node/attribute.rb

@@ -69,14 +69,14 @@ class Chef
         :@env_default,
         :@role_default,
         :@force_default,
-      ]
+      ].freeze
 
       OVERRIDE_COMPONENTS = [
         :@override,
         :@role_override,
         :@env_override,
         :@force_override,
-      ]
+      ].freeze
 
       [:all?,
        :any?,
@@ -427,7 +427,7 @@ class Chef
 
       def has_key?(key)
         COMPONENTS.any? do |component_ivar|
-          instance_variable_get(component_ivar).has_key?(key)
+          instance_variable_get(component_ivar).key?(key)
         end
       end
        # method-style access to attributes (has to come after the prepended ImmutablizeHash)
@@ -497,7 +497,7 @@ class Chef
             if !val.respond_to?(:has_key?)
               # Have an Array-like thing
               val[path_arg]
-            elsif val.has_key?(path_arg)
+            elsif val.key?(path_arg)
               # Hash-like thing (must check has_key? first to protect against Autovivification)
               val[path_arg]
             else
@@ -578,7 +578,7 @@ class Chef
         if merge_onto.kind_of?(Hash) && merge_with.kind_of?(Hash)
           merge_with.each do |key, merge_with_value|
             value =
-              if merge_onto.has_key?(key)
+              if merge_onto.key?(key)
                 deep_merge!(safe_dup(merge_onto[key]), merge_with_value)
               else
                 merge_with_value
@@ -614,7 +614,7 @@ class Chef
         if merge_onto.kind_of?(Hash) && merge_with.kind_of?(Hash)
           merge_with.each do |key, merge_with_value|
             value =
-              if merge_onto.has_key?(key)
+              if merge_onto.key?(key)
                 hash_only_merge!(safe_dup(merge_onto[key]), merge_with_value)
               else
                 merge_with_value

data/lib/chef/node/attribute_collections.rb

@@ -55,7 +55,7 @@ class Chef
         :sort_by!,
         :uniq!,
         :unshift,
-      ]
+      ].freeze
 
       # For all of the methods that may mutate an Array, we override them to
       # also invalidate the cached merged_attributes on the root
@@ -140,7 +140,7 @@ class Chef
         :replace,
         :select!,
         :shift,
-      ]
+      ].freeze
 
       # For all of the mutating methods on Mash, override them so that they
       # also invalidate the cached `merged_attributes` on the root Attribute

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

@@ -46,7 +46,7 @@ class Chef
         alias :reset :reset_cache
 
         def [](key)
-          if deep_merge_cache.has_key?(key.to_s)
+          if deep_merge_cache.key?(key.to_s)
             # return the cache of the deep merged values by top-level key
             deep_merge_cache[key.to_s]
           else

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

@@ -121,7 +121,7 @@ class Chef
           :values_at,
           :zip,
           :|,
-        ]
+        ].freeze
         # A list of methods that mutate Array. Each of these is overridden to
         # raise an error, making this instances of this class more or less
         # immutable.
@@ -160,7 +160,7 @@ class Chef
           :uniq!,
           :unshift,
           :update,
-        ]
+        ].freeze
 
         # Redefine all of the methods that mutate a Hash to raise an error when called.
         # This is the magic that makes this object "Immutable"

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

@@ -121,7 +121,7 @@ class Chef
           :values,
           :values_at,
           :zip,
-        ]
+        ].freeze
         DISALLOWED_MUTATOR_METHODS = [
           :[]=,
           :clear,
@@ -147,7 +147,7 @@ class Chef
           :update,
           :write!,
           :write,
-        ]
+        ].freeze
 
         # Redefine all of the methods that mutate a Hash to raise an error when called.
         # This is the magic that makes this object "Immutable"

data/lib/chef/node_map.rb

@@ -37,6 +37,21 @@
 #
 class Chef
   class NodeMap
+    COLLISION_WARNING_14 = <<~EOH.gsub(/\s+/, " ").strip
+      %{type_caps} %{key} has been loaded from a cookbook. The %{type} %{key} is now
+      included in Chef and will take precedence over the existing cookbook %{type} in the
+      next major release of Chef (15.0, April 2019). You may be able to remove this cookbook dependency from
+      your runlist if you do not use other recipes/resources/libraries from the cookbook.
+      Alternatively there may be a newer version of this cookbook without the %{key} %{type}.
+EOH
+
+    COLLISION_WARNING_15 = <<~EOH.gsub(/\s+/, " ").strip
+      %{type_caps} %{key} attempted to load from a cookbook. The %{type} %{key} is now
+      included in Chef and takes precedence over the existing cookbook %{type}
+      which will be ignored. You may be able to remove this cookbook dependency from
+      your runlist if you do not use other recipes/resources/libraries from the cookbook.
+      Alternatively there may be a newer version of this cookbook without the %{key} %{type}.
+EOH
 
     #
     # Set a key/value pair on the map with a filter.  The filter must be true
@@ -45,12 +60,18 @@ class Chef
     # @param key [Object] Key to store
     # @param value [Object] Value associated with the key
     # @param filters [Hash] Node filter options to apply to key retrieval
+    # @param allow_cookbook_override [Boolean, String] Allow a cookbook to add
+    #   to this key even in locked mode. If a string is given, it should be a
+    #   Gem::Requirement-compatible value indicating for which Chef versions an
+    #   override from cookbooks is allowed.
+    # @param __core_override__ [Boolean] Advanced-mode override to add to a key
+    #   even in locked mode.
     #
     # @yield [node] Arbitrary node filter as a block which takes a node argument
     #
     # @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, &block)
+    def set(key, klass, platform: nil, platform_version: nil, platform_family: nil, os: nil, canonical: nil, override: nil, allow_cookbook_override: false, __core_override__: false, &block) # rubocop:disable Lint/UnderscorePrefixedVariableName
       new_matcher = { klass: klass }
       new_matcher[:platform] = platform if platform
       new_matcher[:platform_version] = platform_version if platform_version
@@ -59,6 +80,31 @@ class Chef
       new_matcher[:block] = block if block
       new_matcher[:canonical] = canonical if canonical
       new_matcher[:override] = override if override
+      new_matcher[:cookbook_override] = allow_cookbook_override
+      new_matcher[:core_override] = __core_override__
+
+      # Check if the key is already present and locked, unless the override is allowed.
+      # The checks to see if we should reject, in order:
+      # 1. Core override mode is not set.
+      # 2. The key exists.
+      # 3. At least one previous `provides` is now locked.
+      # 4. No previous `provides` had `allow_cookbook_override`, either set to
+      #    true or with a string version matcher that still matches Chef::VERSION
+      if !__core_override__ && map[key] && map[key].any? { |matcher| matcher[:locked] } && !map[key].any? { |matcher| matcher[:cookbook_override].is_a?(String) ? Chef::VERSION =~ matcher[:cookbook_override] : matcher[:cookbook_override] }
+        # If we ever use locked mode on things other than the resource and provider handler maps, this probably needs a tweak.
+        type_of_thing = if klass < Chef::Resource
+                          "resource"
+                        elsif klass < Chef::Provider
+                          "provider"
+                        else
+                          klass.superclass.to_s
+                        end
+        # For now, only log the warning.
+        Chef.deprecated(:map_collision, COLLISION_WARNING_14 % { type: type_of_thing, key: key, type_caps: type_of_thing.capitalize })
+        # In 15.0, uncomment this and remove the log above.
+        # Chef.deprecated(:map_collision, COLLISION_WARNING_15 % {type: type_of_thing, key: key, type_caps: type_of_thing.capitalize}))
+        # return
+      end
 
       # The map is sorted in order of preference already; we just need to find
       # our place in it (just before the first value with the same preference level).
@@ -92,7 +138,7 @@ class Chef
     # @return [Object] Class
     #
     def get(node, key, canonical: nil)
-      return nil unless map.has_key?(key)
+      return nil unless map.key?(key)
       map[key].map do |matcher|
         return matcher[:klass] if node_matches?(node, matcher) && canonical_matches?(canonical, matcher)
       end
@@ -112,7 +158,7 @@ class Chef
     # @return [Object] Class
     #
     def list(node, key, canonical: nil)
-      return [] unless map.has_key?(key)
+      return [] unless map.key?(key)
       map[key].select do |matcher|
         node_matches?(node, matcher) && canonical_matches?(canonical, matcher)
       end.map { |matcher| matcher[:klass] }
@@ -159,6 +205,34 @@ class Chef
       remaining
     end
 
+    # Check if this map has been locked.
+    #
+    # @api internal
+    # @since 14.2
+    # @return [Boolean]
+    def locked?
+      if defined?(@locked)
+        @locked
+      else
+        false
+      end
+    end
+
+    # Set this map to locked mode. This is used to prevent future overwriting
+    # of existing names.
+    #
+    # @api internal
+    # @since 14.2
+    # @return [void]
+    def lock!
+      map.each do |key, matchers|
+        matchers.each do |matcher|
+          matcher[:locked] = true
+        end
+      end
+      @locked = true
+    end
+
     private
 
     #

data/lib/chef/org.rb

@@ -40,22 +40,22 @@ class Chef
 
     def name(arg = nil)
       set_or_return(:name, arg,
-                    :regex => /^[a-z0-9\-_]+$/)
+                    regex: /^[a-z0-9\-_]+$/)
     end
 
     def full_name(arg = nil)
       set_or_return(:full_name,
-                    arg, :kind_of => String)
+                    arg, kind_of: String)
     end
 
     def private_key(arg = nil)
       set_or_return(:private_key,
-                    arg, :kind_of => String)
+                    arg, kind_of: String)
     end
 
     def guid(arg = nil)
       set_or_return(:guid,
-                    arg, :kind_of => String)
+                    arg, kind_of: String)
     end
 
     def to_hash
@@ -73,13 +73,13 @@ class Chef
     end
 
     def create
-      payload = { :name => name, :full_name => full_name }
+      payload = { name: name, full_name: full_name }
       new_org = chef_rest.post("organizations", payload)
       Chef::Org.from_hash(to_hash.merge(new_org))
     end
 
     def update
-      payload = { :name => name, :full_name => full_name }
+      payload = { name: name, full_name: full_name }
       new_org = chef_rest.put("organizations/#{name}", payload)
       Chef::Org.from_hash(to_hash.merge(new_org))
     end
@@ -99,10 +99,10 @@ class Chef
     end
 
     def associate_user(username)
-      request_body = { :user => username }
+      request_body = { user: username }
       response = chef_rest.post "organizations/#{@name}/association_requests", request_body
       association_id = response["uri"].split("/").last
-      chef_rest.put "users/#{username}/association_requests/#{association_id}", { :response => "accept" }
+      chef_rest.put "users/#{username}/association_requests/#{association_id}", { response: "accept" }
     end
 
     def dissociate_user(username)

data/lib/chef/policy_builder/expand_node_object.rb

@@ -175,7 +175,7 @@ class Chef
         begin
           events.cookbook_resolution_start(@expanded_run_list_with_versions)
           cookbook_hash = api_service.post("environments/#{node.chef_environment}/cookbook_versions",
-                                           { :run_list => @expanded_run_list_with_versions })
+                                           { run_list: @expanded_run_list_with_versions })
 
           cookbook_hash = cookbook_hash.inject({}) do |memo, (key, value)|
             memo[key] = Chef::CookbookVersion.from_hash(value)