diff options
Diffstat (limited to 'lib')
| -rw-r--r-- | lib/chef/node.rb | 16 | ||||
| -rw-r--r-- | lib/chef/node/attribute.rb | 107 | ||||
| -rw-r--r-- | lib/chef/node/attribute_collections.rb | 112 |
3 files changed, 208 insertions, 27 deletions
diff --git a/lib/chef/node.rb b/lib/chef/node.rb index 5f788af4d4..dbb7852586 100644 --- a/lib/chef/node.rb +++ b/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 @@ -146,13 +148,6 @@ class Chef 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 @@ -167,13 +162,6 @@ class Chef 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 diff --git a/lib/chef/node/attribute.rb b/lib/chef/node/attribute.rb index 66569cf0e1..3eb6449046 100644 --- a/lib/chef/node/attribute.rb +++ b/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,11 +172,6 @@ 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 @@ -311,6 +299,100 @@ class Chef @automatic = VividMash.new(self, new_data) end + # + # Deleting attributes + # + + # clears attributes from all precedence levels + def rm(*args) + # 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 + 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 + 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 + remove_from_precedence_level(force_override!(autovivify: false), *args) + end + + # + # Replacing attributes without merging + # + + # sets default attributes without merging + def default!(opts={}) + reset + MultiMash.new(self, @default, [], opts) + end + + # sets normal attributes without merging + def normal!(opts={}) + reset + MultiMash.new(self, @normal, [], opts) + end + + # sets override attributes without merging + def override!(opts={}) + reset + MultiMash.new(self, @override, [], opts) + end + + # clears from all default precedence levels and then sets force_default + def force_default!(opts={}) + reset + MultiMash.new(self, @force_default, [@default, @env_default, @role_default], opts) + end + + # clears from all override precedence levels and then sets force_override + def force_override!(opts={}) + reset + MultiMash.new(self, @force_override, [@override, @env_override, @role_override], opts) + end + + # + # Accessing merged attributes + # + def merged_attributes @merged_attributes ||= begin components = [merge_defaults, @normal, merge_overrides, @automatic] @@ -391,7 +473,6 @@ class Chef end end - end end diff --git a/lib/chef/node/attribute_collections.rb b/lib/chef/node/attribute_collections.rb index f09b02b106..c8bc618762 100644 --- a/lib/chef/node/attribute_collections.rb +++ b/lib/chef/node/attribute_collections.rb @@ -209,5 +209,117 @@ class Chef 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 |