chef 12.0.0.rc.0-x86-mingw32 → 12.0.0-x86-mingw32

data/lib/chef/mixin/which.rb

@@ -0,0 +1,37 @@
+#--
+# Author:: Lamont Granquist <lamont@getchef.io>
+# Copyright:: Copyright (c) 2010 Opscode, 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
+  module Mixin
+    module Which
+      def which(cmd, opts = {})
+        extra_path =
+          if opts[:extra_path].nil?
+            [ '/bin', '/usr/bin', '/sbin', '/usr/sbin' ]
+          else
+            [ opts[:extra_path] ].flatten
+          end
+        paths = ENV['PATH'].split(File::PATH_SEPARATOR) + extra_path
+        paths.each do |path|
+          filename = File.join(path, cmd)
+          return filename if File.executable?(filename)
+        end
+        false
+      end
+    end
+  end
+end

data/lib/chef/node.rb

@@ -42,6 +42,8 @@ class Chef
     extend Forwardable
 
     def_delegators :attributes, :keys, :each_key, :each_value, :key?, :has_key?
+    def_delegators :attributes, :rm, :rm_default, :rm_normal, :rm_override
+    def_delegators :attributes, :default!, :normal!, :override!, :force_default!, :force_override!
 
     attr_accessor :recipe_list, :run_state, :override_runlist
 
@@ -125,6 +127,7 @@ class Chef
     # Set a normal attribute of this node, but auto-vivify any Mashes that
     # might be missing
     def normal
+      attributes.top_level_breadcrumb = nil
       attributes.set_unless_value_present = false
       attributes.normal
     end
@@ -134,28 +137,25 @@ class Chef
     # Set a normal attribute of this node, auto-vivifying any mashes that are
     # missing, but if the final value already exists, don't set it
     def normal_unless
+      attributes.top_level_breadcrumb = nil
       attributes.set_unless_value_present = true
       attributes.normal
     end
+
     alias_method :set_unless, :normal_unless
 
     # Set a default of this node, but auto-vivify any Mashes that might
     # be missing
     def default
+      attributes.top_level_breadcrumb = nil
       attributes.set_unless_value_present = false
       attributes.default
     end
 
-    # Set a force default attribute. Intermediate mashes will be created by
-    # auto-vivify if necessary.
-    def default!
-      attributes.set_unless_value_present = false
-      attributes.default!
-    end
-
     # Set a default attribute of this node, auto-vivifying any mashes that are
     # missing, but if the final value already exists, don't set it
     def default_unless
+      attributes.top_level_breadcrumb = nil
       attributes.set_unless_value_present = true
       attributes.default
     end
@@ -163,49 +163,38 @@ class Chef
     # Set an override attribute of this node, but auto-vivify any Mashes that
     # might be missing
     def override
+      attributes.top_level_breadcrumb = nil
       attributes.set_unless_value_present = false
       attributes.override
     end
 
-    # Set a force override attribute. Intermediate mashes will be created by
-    # auto-vivify if needed.
-    def override!
-      attributes.set_unless_value_present = false
-      attributes.override!
-    end
-
     # Set an override attribute of this node, auto-vivifying any mashes that
     # are missing, but if the final value already exists, don't set it
     def override_unless
+      attributes.top_level_breadcrumb = nil
       attributes.set_unless_value_present = true
       attributes.override
     end
 
-    def override_attrs
-     attributes.override
-    end
+    alias :override_attrs :override
+    alias :default_attrs :default
+    alias :normal_attrs :normal
 
     def override_attrs=(new_values)
       attributes.override = new_values
     end
 
-    def default_attrs
-      attributes.default
-    end
-
     def default_attrs=(new_values)
       attributes.default = new_values
     end
 
-    def normal_attrs
-      attributes.normal
-    end
-
     def normal_attrs=(new_values)
       attributes.normal = new_values
     end
 
     def automatic_attrs
+      attributes.top_level_breadcrumb = nil
+      attributes.set_unless_value_present = false
       attributes.automatic
     end
 

data/lib/chef/node/attribute.rb

@@ -58,7 +58,6 @@ class Chef
         :@force_default
       ]
 
-
       OVERRIDE_COMPONENTS = [
         :@override,
         :@role_override,
@@ -146,7 +145,6 @@ class Chef
          METHOD_DEFN
        end
 
-
        # return the cookbook level default attribute component
        attr_reader :default
 
@@ -159,11 +157,6 @@ class Chef
        # return the force_default level attribute component
        attr_reader :force_default
 
-       # default! is the "advertised" method for force_default, but is
-       # implemented as an alias because instance variables can't (easily) have
-       # +!+ characters.
-       alias :default! :force_default
-
        # return the "normal" level attribute component
        attr_reader :normal
 
@@ -179,14 +172,22 @@ class Chef
        # return the force override level attribute component
        attr_reader :force_override
 
-       # +override!+ is the "advertised" method for +force_override+ but is
-       # implemented as an alias because instance variables can't easily have
-       # +!+ characters.
-       alias :override! :force_override
-
        # return the automatic level attribute component
        attr_reader :automatic
 
+       # This is used to track the top level key as we descend through method chaining into
+       # a precedence level (e.g. node.default['foo']['bar']['baz']= results in 'foo' here).  We
+       # need this so that when we hit the end of a method chain which results in a mutator method
+       # that we can invalidate the whole top-level deep merge cache for the top-level key.  It is
+       # the responsibility of the accessor on the Chef::Node object to reset this to nil, and then
+       # the first VividMash#[] call can ||= and set this to the first key we encounter.
+       attr_accessor :top_level_breadcrumb
+
+       # 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(normal, default, override, automatic)
          @set_unless_present = false
 
@@ -207,6 +208,8 @@ class Chef
          @merged_attributes = nil
          @combined_override = nil
          @combined_default = nil
+         @top_level_breadcrumb = nil
+         @deep_merge_cache = {}
        end
 
        # Debug what's going on with an attribute. +args+ is a path spec to the
@@ -242,13 +245,16 @@ class Chef
          @set_unless_present = setting
        end
 
-       # Clears merged_attributes, which will cause it to be recomputed on the
-       # next access.
-       def reset_cache
-         @merged_attributes = nil
-         @combined_default  = nil
-         @combined_override = nil
-         @set_unless_present = false
+       # 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 = {}
+         else
+           deep_merge_cache.delete(path)
+         end
        end
 
        alias :reset :reset_cache
@@ -311,30 +317,136 @@ class Chef
          @automatic = VividMash.new(self, new_data)
        end
 
-       def merged_attributes
-         @merged_attributes ||= begin
-                                  components = [merge_defaults, @normal, merge_overrides, @automatic]
-                                  resolved_attrs = components.inject(Mash.new) do |merged, component|
-                                    Chef::Mixin::DeepMerge.hash_only_merge(merged, component)
-                                  end
-                                  immutablize(resolved_attrs)
-                                end
+       #
+       # Deleting attributes
+       #
+
+       # clears attributes from all precedence levels
+       def rm(*args)
+         reset(args[0])
+         # just easier to compute our retval, rather than collect+merge sub-retvals
+         ret = args.inject(merged_attributes) do |attr, arg|
+           if attr.nil? || !attr.respond_to?(:[])
+             nil
+           else
+             begin
+               attr[arg]
+             rescue TypeError
+               raise TypeError, "Wrong type in index of attribute (did you use a Hash index on an Array?)"
+             end
+           end
+         end
+         rm_default(*args)
+         rm_normal(*args)
+         rm_override(*args)
+         ret
+       end
+
+       # does <level>['foo']['bar'].delete('baz')
+       def remove_from_precedence_level(level, *args, key)
+         multimash = level.element(*args)
+         multimash.nil? ? nil : multimash.delete(key)
+       end
+
+       private :remove_from_precedence_level
+
+       # clears attributes from all default precedence levels
+       #
+       # equivalent to: force_default!['foo']['bar'].delete('baz')
+       def rm_default(*args)
+         reset(args[0])
+         remove_from_precedence_level(force_default!(autovivify: false), *args)
+       end
+
+       # clears attributes from normal precedence
+       #
+       # equivalent to: normal!['foo']['bar'].delete('baz')
+       def rm_normal(*args)
+         reset(args[0])
+         remove_from_precedence_level(normal!(autovivify: false), *args)
+       end
+
+       # clears attributes from all override precedence levels
+       #
+       # equivalent to: force_override!['foo']['bar'].delete('baz')
+       def rm_override(*args)
+         reset(args[0])
+         remove_from_precedence_level(force_override!(autovivify: false), *args)
+       end
+
+       #
+       # Replacing attributes without merging
+       #
+
+       # sets default attributes without merging
+       def default!(opts={})
+         # FIXME: do not flush whole cache
+         reset
+         MultiMash.new(self, @default, [], opts)
+       end
+
+       # sets normal attributes without merging
+       def normal!(opts={})
+         # FIXME: do not flush whole cache
+         reset
+         MultiMash.new(self, @normal, [], opts)
+       end
+
+       # sets override attributes without merging
+       def override!(opts={})
+         # FIXME: do not flush whole cache
+         reset
+         MultiMash.new(self, @override, [], opts)
        end
 
-       def combined_override
-         @combined_override ||= immutablize(merge_overrides)
+       # clears from all default precedence levels and then sets force_default
+       def force_default!(opts={})
+         # FIXME: do not flush whole cache
+         reset
+         MultiMash.new(self, @force_default, [@default, @env_default, @role_default], opts)
        end
 
-       def combined_default
-         @combined_default ||= immutablize(merge_defaults)
+       # clears from all override precedence levels and then sets force_override
+       def force_override!(opts={})
+         # FIXME: do not flush whole cache
+         reset
+         MultiMash.new(self, @force_override, [@override, @env_override, @role_override], opts)
+       end
+
+       #
+       # Accessing merged attributes.
+       #
+       # Note that merged_attributes('foo', 'bar', 'baz') can be called to compute only the
+       # deep merge of node['foo']['bar']['baz'], but in practice we currently always compute
+       # all of node['foo'] even if the user only requires node['foo']['bar']['baz'].
+       #
+
+       def merged_attributes(*path)
+        # immutablize(
+           merge_all(path)
+        # )
+       end
+
+       def combined_override(*path)
+         immutablize(merge_overrides(path))
+       end
+
+       def combined_default(*path)
+         immutablize(merge_defaults(path))
        end
 
        def [](key)
-         merged_attributes[key]
+         if deep_merge_cache.has_key?(key)
+           # return the cache of the deep merged values by top-level key
+           deep_merge_cache[key]
+         else
+           # save all the work of computing node[key]
+           deep_merge_cache[key] = merged_attributes(key)
+         end
        end
 
        def []=(key, value)
-         merged_attributes[key] = value
+         raise Exceptions::ImmutableAttributeModification
        end
 
        def has_key?(key)
@@ -377,20 +489,94 @@ class Chef
 
        private
 
-       def merge_defaults
-         DEFAULT_COMPONENTS.inject(Mash.new) do |merged, component_ivar|
-           component_value = instance_variable_get(component_ivar)
-           Chef::Mixin::DeepMerge.merge(merged, component_value)
+       # Helper method for merge_all/merge_defaults/merge_overrides.
+       #
+       # apply_path(thing, [ "foo", "bar", "baz" ]) = thing["foo"]["bar"]["baz"]
+       #
+       # The path value can be nil in which case the whole component is returned.
+       #
+       # It returns nil (does not raise an exception) if it walks off the end of an Mash/Hash/Array, it does not
+       # raise any TypeError if it attempts to apply a hash key to an Integer/String/TrueClass, and just returns
+       # nil in that case.
+       #
+       def apply_path(component, path)
+         path ||= []
+         path.inject(component) do |val, path_arg|
+           if val.respond_to?(:[])
+             # Have an Array-like or Hash-like thing
+             if !val.respond_to?(:has_key?)
+               # Have an Array-like thing
+               val[path_arg]
+             elsif val.has_key?(path_arg)
+               # Hash-like thing (must check has_key? first to protect against Autovivification)
+               val[path_arg]
+             else
+               nil
+             end
+           else
+             nil
+           end
+         end
+       end
+
+       # For elements like Fixnums, true, nil...
+       def safe_dup(e)
+         e.dup
+       rescue TypeError
+         e
+       end
+
+       # Deep merge all attribute levels using hash-only merging between different precidence
+       # 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.
+       #
+       # @param path [Array] Array of args to method chain to descend into the node object
+       # @return [attr] Deep Merged values (may be VividMash, Hash, Array, etc) from the node object
+       def merge_all(path)
+         components = [
+           merge_defaults(path),
+           apply_path(@normal, path),
+           merge_overrides(path),
+           apply_path(@automatic, path),
+         ]
+
+         components.map! do |component|
+           safe_dup(component)
+         end
+
+         return nil if components.compact.empty?
+
+         components.inject(ImmutableMash.new({})) do |merged, component|
+           Chef::Mixin::DeepMerge.hash_only_merge!(merged, component)
          end
        end
 
-       def merge_overrides
-         OVERRIDE_COMPONENTS.inject(Mash.new) do |merged, component_ivar|
-           component_value = instance_variable_get(component_ivar)
-           Chef::Mixin::DeepMerge.merge(merged, component_value)
+       # Deep merge the default attribute levels with array merging.
+       #
+       # The path allows for selectively deep-merging a subtree of the node object.
+       #
+       # @param path [Array] Array of args to method chain to descend into the node object
+       # @return [attr] Deep Merged values (may be VividMash, Hash, Array, etc) from the node object
+       def merge_defaults(path)
+         DEFAULT_COMPONENTS.inject(nil) do |merged, component_ivar|
+           component_value = apply_path(instance_variable_get(component_ivar), path)
+           Chef::Mixin::DeepMerge.deep_merge(component_value, merged)
          end
        end
 
+       # Deep merge the override attribute levels with array merging.
+       #
+       # The path allows for selectively deep-merging a subtree of the node object.
+       #
+       # @param path [Array] Array of args to method chain to descend into the node object
+       # @return [attr] Deep Merged values (may be VividMash, Hash, Array, etc) from the node object
+       def merge_overrides(path)
+         OVERRIDE_COMPONENTS.inject(nil) do |merged, component_ivar|
+           component_value = apply_path(instance_variable_get(component_ivar), path)
+           Chef::Mixin::DeepMerge.deep_merge(component_value, merged)
+         end
+       end
 
     end