summaryrefslogtreecommitdiff
path: root/lib/chef/node/attribute_collections.rb
blob: 3cb31c5a2d171945f7fcd61c5e8bb2c3914d0f00 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
#--
# Author:: Daniel DeLeo (<dan@opscode.com>)
# 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.
#

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 = [
        :<<,
        :[]=,
        :clear,
        :collect!,
        :compact!,
        :default=,
        :default_proc=,
        :delete,
        :delete_at,
        :delete_if,
        :fill,
        :flatten!,
        :insert,
        :keep_if,
        :map!,
        :merge!,
        :pop,
        :push,
        :update,
        :reject!,
        :reverse!,
        :replace,
        :select!,
        :shift,
        :slice!,
        :sort!,
        :sort_by!,
        :uniq!,
        :unshift,
      ]

      # For all of the methods that may mutate an Array, we override them to
      # also invalidate the cached merged_attributes on the root
      # Node::Attribute object.
      MUTATOR_METHODS.each do |mutator|
        define_method(mutator) do |*args, &block|
          root.reset_cache(root.top_level_breadcrumb)
          super(*args, &block)
        end
      end

      attr_reader :root

      def initialize(root, data)
        @root = root
        super(data)
      end

      # For elements like Fixnums, true, nil...
      def safe_dup(e)
        e.dup
      rescue TypeError
        e
      end

      def dup
        Array.new(map {|e| safe_dup(e)})
      end

    end

    # == VividMash
    # VividMash is identical to a Mash, with a few exceptions:
    # * It has a reference to the root Chef::Node::Attribute to which it
    #   belongs, and will trigger cache invalidation on that object when
    #   mutated.
    # * It auto-vivifies, that is a reference to a missing element will result
    #   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

      # Methods that mutate a VividMash. Each of them is overridden so that it
      # also invalidates the cached merged_attributes on the root Attribute
      # object.
      MUTATOR_METHODS = [
        :clear,
        :delete,
        :delete_if,
        :keep_if,
        :merge!,
        :update,
        :reject!,
        :replace,
        :select!,
        :shift,
      ]

      # For all of the mutating methods on Mash, override them so that they
      # also invalidate the cached `merged_attributes` on the root Attribute
      # object.
      MUTATOR_METHODS.each do |mutator|
        define_method(mutator) do |*args, &block|
          root.reset_cache(root.top_level_breadcrumb)
          super(*args, &block)
        end
      end

      def initialize(root, data={})
        @root = root
        super(data)
      end

      def [](key)
        root.top_level_breadcrumb ||= key
        value = super
        if !key?(key)
          value = self.class.new(root)
          self[key] = value
        else
          value
        end
      end

      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
      end

      alias :attribute? :has_key?

      def method_missing(symbol, *args)
        # Calling `puts arg` implicitly calls #to_ary on `arg`. If `arg` does
        # not implement #to_ary, ruby recognizes it as a single argument, and
        # if it returns an Array, then ruby prints each element. If we don't
        # account for that here, we'll auto-vivify a VividMash for the key
        # :to_ary which creates an unwanted key and raises a TypeError.
        if symbol == :to_ary
          super
        elsif args.empty?
          self[symbol]
        elsif symbol.to_s =~ /=$/
          key_to_set = symbol.to_s[/^(.+)=$/, 1]
          self[key_to_set] = (args.length == 1 ? args[0] : args)
        else
          raise NoMethodError, "Undefined node attribute or method `#{symbol}' on `node'. To set an attribute, use `#{symbol}=value' instead."
        end
      end

      def set_unless?
        @root.set_unless?
      end

      def convert_key(key)
        super
      end

      # Mash uses #convert_value to mashify values on input.
      # We override it here to convert hash or array values to VividMash or
      # AttrArray for consistency and to ensure that the added parts of the
      # attribute tree will have the correct cache invalidation behavior.
      def convert_value(value)
        case value
        when VividMash
          value
        when Hash
          VividMash.new(root, value)
        when Array
          AttrArray.new(root, value)
        else
          value
        end
      end

      def dup
        Mash.new(self)
      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