chef 12.11.18 → 12.12.13

data/lib/chef/node/attribute_collections.rb

@@ -16,15 +16,15 @@
 # limitations under the License.
 #
 
+require "chef/node/common_api"
+
 class Chef
   class Node
-
     # == AttrArray
     # AttrArray is identical to Array, except that it keeps a reference to the
     # "root" (Chef::Node::Attribute) object, and will trigger a cache
     # invalidation on that object when mutated.
     class AttrArray < Array
-
       MUTATOR_METHODS = [
         :<<,
         :[]=,
@@ -62,8 +62,9 @@ class Chef
       # Node::Attribute object.
       MUTATOR_METHODS.each do |mutator|
         define_method(mutator) do |*args, &block|
+          ret = super(*args, &block)
           root.reset_cache(root.top_level_breadcrumb)
-          super(*args, &block)
+          ret
         end
       end
 
@@ -96,14 +97,12 @@ class Chef
     #   in the creation of a new VividMash for that key. (This only works when
     #   using the element reference method, `[]` -- other methods, such as
     #   #fetch, work as normal).
-    # * It supports a set_unless flag (via the root Attribute object) which
-    #   allows `||=` style behavior (`||=` does not work with
-    #   auto-vivification). This is only implemented for #[]=; methods such as
-    #   #store work as normal.
     # * attr_accessor style element set and get are supported via method_missing
     class VividMash < Mash
       attr_reader :root
 
+      include CommonAPI
+
       # Methods that mutate a VividMash. Each of them is overridden so that it
       # also invalidates the cached merged_attributes on the root Attribute
       # object.
@@ -148,12 +147,9 @@ class Chef
 
       def []=(key, value)
         root.top_level_breadcrumb ||= key
-        if set_unless? && key?(key) && !self[key].nil?
-          self[key]
-        else
-          root.reset_cache(root.top_level_breadcrumb)
-          super
-        end
+        ret = super
+        root.reset_cache(root.top_level_breadcrumb)
+        ret
       end
 
       alias :attribute? :has_key?
@@ -176,10 +172,6 @@ class Chef
         end
       end
 
-      def set_unless?
-        @root.set_unless?
-      end
-
       def convert_key(key)
         super
       end
@@ -206,118 +198,5 @@ class Chef
       end
 
     end
-
-    # == MultiMash
-    # This is a Hash-like object that contains multiple VividMashes in it.  Its
-    # purpose is so that the user can descend into the mash and delete a subtree
-    # from all of the Mash objects (used to delete all values in a subtree from
-    # default, force_default, role_default and env_default at the same time).  The
-    # assignment operator strictly does assignment (does no merging) and works
-    # by deleting the subtree and then assigning to the last mash which passed in
-    # the initializer.
-    #
-    # A lot of the complexity of this class comes from the fact that at any key
-    # value some or all of the mashes may walk off their ends and become nil or
-    # true or something.  The schema may change so that one precidence leve may
-    # be 'true' object and another may be a VividMash.  It is also possible that
-    # one or many of them may transition from VividMashes to Hashes or Arrays.
-    #
-    # It also supports the case where you may be deleting a key using node.rm
-    # in which case if intermediate keys all walk off into nil then you don't want
-    # to be autovivifying keys as you go.  On the other hand you may be using
-    # node.force_default! in which case you'll wind up with a []= operator at the
-    # end and you want autovivification, so we conditionally have to support either
-    # operation.
-    #
-    # @todo: can we have an autovivify class that decorates a class that doesn't
-    # autovivify or something so that the code is less awful?
-    #
-    class MultiMash
-      attr_reader :root
-      attr_reader :mashes
-      attr_reader :opts
-      attr_reader :primary_mash
-
-      # Initialize with an array of mashes.  For the delete return value to work
-      # properly the mashes must come from the same attribute level (i.e. all
-      # override or all default, but not a mix of both).
-      def initialize(root, primary_mash, mashes, opts = {})
-        @root = root
-        @primary_mash = primary_mash
-        @mashes = mashes
-        @opts = opts
-        @opts[:autovivify] = true if @opts[:autovivify].nil?
-      end
-
-      def [](key)
-        # handle the secondary mashes
-        new_mashes = []
-        mashes.each do |mash|
-          new_mash = safe_evalute_key(mash, key)
-          # secondary mashes never autovivify so once they fall into nil, we just stop tracking them
-          new_mashes.push(new_mash) unless new_mash.nil?
-        end
-
-        new_primary_mash = safe_evalute_key(primary_mash, key)
-
-        if new_primary_mash.nil? && @opts[:autovivify]
-          primary_mash[key] = VividMash.new(root)
-          new_primary_mash = primary_mash[key]
-        end
-
-        MultiMash.new(root, new_primary_mash, new_mashes, opts)
-      end
-
-      def []=(key, value)
-        if primary_mash.nil?
-          # This theoretically should never happen since node#force_default! setter methods will autovivify and
-          # node#rm methods do not end in #[]= operators.
-          raise TypeError, "No autovivification was specified initially on a method chain ending in assignment"
-        end
-        ret = delete(key)
-        primary_mash[key] = value
-        ret
-      end
-
-      # mash.element('foo', 'bar') is the same as mash['foo']['bar']
-      def element(key = nil, *subkeys)
-        return self if key.nil?
-        submash = self[key]
-        subkeys.empty? ? submash : submash.element(*subkeys)
-      end
-
-      def delete(key)
-        # the return value is a deep merge which is correct semantics when
-        # merging between attributes on the same level (this would be incorrect
-        # if passed both override and default attributes which would need hash_only
-        # merging).
-        ret = mashes.inject(Mash.new) do |merged, mash|
-          Chef::Mixin::DeepMerge.merge(merged, mash)
-        end
-        ret = Chef::Mixin::DeepMerge.merge(ret, primary_mash)
-        mashes.each do |mash|
-          mash.delete(key) if mash.respond_to?(:delete)
-        end
-        primary_mash.delete(key) if primary_mash.respond_to?(:delete)
-        ret[key]
-      end
-
-      private
-
-      def safe_evalute_key(mash, key)
-        if mash.respond_to?(:[])
-          if mash.respond_to?(:has_key?)
-            if mash.has_key?(key)
-              return mash[key] if mash[key].respond_to?(:[])
-            end
-          elsif !mash[key].nil?
-            return mash[key] if mash[key].respond_to?(:[])
-          end
-        end
-        return nil
-      end
-
-    end
-
   end
 end

data/lib/chef/node/common_api.rb

@@ -0,0 +1,124 @@
+#--
+# Copyright:: Copyright 2016, Chef Software, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+class Chef
+  class Node
+    # shared API between VividMash and ImmutableMash, writer code can be
+    # 'shared' to keep it logically in this file by adding them to the
+    # block list in ImmutableMash.
+    module CommonAPI
+      # method-style access to attributes
+
+      def valid_container?(obj, key)
+        return obj.is_a?(Hash) || (obj.is_a?(Array) && key.is_a?(Fixnum))
+      end
+
+      private :valid_container?
+
+      # - autovivifying / autoreplacing writer
+      # - non-container-ey intermediate objects are replaced with hashes
+      def write(*args, &block)
+        value = block_given? ? yield : args.pop
+        last = args.pop
+        prev_memo = prev_key = nil
+        chain = args.inject(self) do |memo, key|
+          if !valid_container?(memo, key)
+            prev_memo[prev_key] = {}
+            memo = prev_memo[prev_key]
+          end
+          prev_memo = memo
+          prev_key = key
+          memo[key]
+        end
+        if !valid_container?(chain, last)
+          prev_memo[prev_key] = {}
+          chain = prev_memo[prev_key]
+        end
+        chain[last] = value
+      end
+
+      # this autovivifies, but can throw NoSuchAttribute when trying to access #[] on
+      # something that is not a container ("schema violation" issues).
+      #
+      def write!(*args, &block)
+        value = block_given? ? yield : args.pop
+        last = args.pop
+        obj = args.inject(self) do |memo, key|
+          raise Chef::Exceptions::AttributeTypeMismatch unless valid_container?(memo, key)
+          memo[key]
+        end
+        raise Chef::Exceptions::AttributeTypeMismatch unless valid_container?(obj, last)
+        obj[last] = value
+      end
+
+      # FIXME:(?) does anyone need a non-autovivifying writer for attributes that throws exceptions?
+
+      # return true or false based on if the attribute exists
+      def exist?(*path)
+        path.inject(self) do |memo, key|
+          return false unless valid_container?(memo, key)
+          if memo.is_a?(Hash)
+            if memo.key?(key)
+              memo[key]
+            else
+              return false
+            end
+          elsif memo.is_a?(Array)
+            if memo.length > key
+              memo[key]
+            else
+              return false
+            end
+          end
+        end
+        return true
+      end
+
+      # this is a safe non-autovivifying reader that returns nil if the attribute does not exist
+      def read(*path)
+        begin
+          read!(*path)
+        rescue Chef::Exceptions::NoSuchAttribute
+          nil
+        end
+      end
+
+      # non-autovivifying reader that throws an exception if the attribute does not exist
+      def read!(*path)
+        raise Chef::Exceptions::NoSuchAttribute unless exist?(*path)
+        path.inject(self) do |memo, key|
+          memo[key]
+        end
+      end
+
+      # FIXME:(?) does anyone really like the autovivifying reader that we have and wants the same behavior?  readers that write?  ugh...
+
+      def unlink(*path, last)
+        hash = path.empty? ? self : read(*path)
+        return nil unless hash.is_a?(Hash) || hash.is_a?(Array)
+        root.top_level_breadcrumb ||= last
+        hash.delete(last)
+      end
+
+      def unlink!(*path)
+        raise Chef::Exceptions::NoSuchAttribute unless exist?(*path)
+        unlink(*path)
+      end
+
+    end
+  end
+end

data/lib/chef/node/immutable_collections.rb

@@ -1,3 +1,21 @@
+#--
+# Copyright:: Copyright 2012-2016, Chef Software, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require "chef/node/common_api"
 
 class Chef
   class Node
@@ -124,6 +142,7 @@ class Chef
     class ImmutableMash < Mash
 
       include Immutablize
+      include CommonAPI
 
       alias :internal_set :[]=
       private :internal_set
@@ -144,6 +163,10 @@ class Chef
         :replace,
         :select!,
         :shift,
+        :write,
+        :write!,
+        :unlink,
+        :unlink!,
       ]
 
       def initialize(mash_data)
@@ -167,13 +190,15 @@ class Chef
       end
 
       def method_missing(symbol, *args)
-        if args.empty?
+        if symbol == :to_ary
+          super
+        elsif args.empty?
           if key?(symbol)
             self[symbol]
           else
             raise NoMethodError, "Undefined method or attribute `#{symbol}' on `node'"
           end
-        # This will raise a ImmutableAttributeModification error:
+          # This will raise a ImmutableAttributeModification error:
         elsif symbol.to_s =~ /=$/
           key_to_set = symbol.to_s[/^(.+)=$/, 1]
           self[key_to_set] = (args.length == 1 ? args[0] : args)

data/lib/chef/property.rb

@@ -531,8 +531,6 @@ class Chef
       end
     end
 
-    protected
-
     #
     # The options this Property will use for get/set behavior and validation.
     #
@@ -583,6 +581,7 @@ class Chef
         (options.has_key?(:is) && resource.send(:_pv_is, { name => nil }, name, options[:is], raise_error: false))
     end
 
+    # @api private
     def get_value(resource)
       if instance_variable_name
         resource.instance_variable_get(instance_variable_name)
@@ -591,6 +590,7 @@ class Chef
       end
     end
 
+    # @api private
     def set_value(resource, value)
       if instance_variable_name
         resource.instance_variable_set(instance_variable_name, value)
@@ -599,6 +599,7 @@ class Chef
       end
     end
 
+    # @api private
     def value_is_set?(resource)
       if instance_variable_name
         resource.instance_variable_defined?(instance_variable_name)
@@ -607,6 +608,7 @@ class Chef
       end
     end
 
+    # @api private
     def reset_value(resource)
       if instance_variable_name
         if value_is_set?(resource)
@@ -617,6 +619,8 @@ class Chef
       end
     end
 
+    private
+
     def exec_in_resource(resource, proc, *args)
       if resource
         if proc.arity > args.size

data/lib/chef/provider.rb

@@ -423,9 +423,9 @@ class Chef
 
     module DeprecatedLWRPClass
       def const_missing(class_name)
-        if deprecated_constants[class_name.to_sym]
+        if Chef::Provider.deprecated_constants[class_name.to_sym]
           Chef.log_deprecation("Using an LWRP provider by its name (#{class_name}) directly is no longer supported in Chef 12 and will be removed.  Use Chef::ProviderResolver.new(node, resource, action) instead.")
-          deprecated_constants[class_name.to_sym]
+          Chef::Provider.deprecated_constants[class_name.to_sym]
         else
           raise NameError, "uninitialized constant Chef::Provider::#{class_name}"
         end
@@ -438,13 +438,12 @@ class Chef
         if Chef::Provider.const_defined?(class_name, false)
           Chef::Log.warn "Chef::Provider::#{class_name} already exists!  Cannot create deprecation class for #{provider_class}"
         else
-          deprecated_constants[class_name.to_sym] = provider_class
+          Chef::Provider.deprecated_constants[class_name.to_sym] = provider_class
         end
       end
 
-      private
-
       def deprecated_constants
+        raise "Deprecated constants should be called only on Chef::Provider" unless self == Chef::Provider
         @deprecated_constants ||= {}
       end
     end

data/lib/chef/provider/batch.rb

@@ -29,7 +29,7 @@ class Chef
       end
 
       def command
-        basepath = is_forced_32bit ? wow64_directory : run_context.node.kernel.os_info.system_directory
+        basepath = is_forced_32bit ? wow64_directory : run_context.node["kernel"]["os_info"]["system_directory"]
 
         interpreter_path = Chef::Util::PathHelper.join(basepath, interpreter)