summaryrefslogtreecommitdiff
path: root/chef/lib/chef/node/immutable_collections.rb
blob: 33f722cd4ad77b87b22bb6dce96c07359f903b08 (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
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387

class Chef
  class Node

    module Immutablize
      def immutablize(root, value)
        case value
        when Hash
          ImmutableMash.new(root, value)
        when Array
          ImmutableArray.new(root, value)
        else
          value
        end
      end
    end

    # == ImmutableArray
    # ImmutableArray is used to implement Array collections when reading node
    # attributes.
    #
    # ImmutableArray acts like an ordinary Array, except:
    # * Methods that mutate the array are overridden to raise an error, making
    #   the collection more or less immutable.
    # * Since this class stores values computed from a parent
    #   Chef::Node::Attribute's values, it overrides all reader methods to
    #   detect staleness and raise an error if accessed when stale.
    class ImmutableArray < Array
      include Immutablize

      attr_reader :root

      alias :internal_push :<<
      private :internal_push

      # 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.
      DISALLOWED_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
      ]

      # A list of methods that read values from the Array. Each of these is
      # overridden to verify that the Chef::Node::Attribute object that this
      # object belongs to has not been modified since the value was computed.
      READER_METHODS =
      [
        :&,
        :*,
        :+,
        :-,
        :[],
        :all?,
        :any?,
        :assoc,
        :at,
        :chunk,
        :collect,
        :collect_concat,
        :combination,
        :compact,
        :concat,
        :count,
        :cycle,
        :detect,
        :drop,
        :drop_while,
        :each,
        :each_cons,
        :each_entry,
        :each_index,
        :each_slice,
        :each_with_index,
        :each_with_object,
        :empty?,
        :entries,
        :fetch,
        :find,
        :find_all,
        :find_index,
        :first,
        :flat_map,
        :flatten,
        :grep,
        :group_by,
        :include?,
        :index,
        :inject,
        :join,
        :last,
        :length,
        :map,
        :max,
        :max_by,
        :member?,
        :min,
        :min_by,
        :minmax,
        :minmax_by,
        :none?,
        :one?,
        :pack,
        :partition,
        :permutation,
        :product,
        :rassoc,
        :reduce,
        :reject,
        :repeated_combination,
        :repeated_permutation,
        :reverse,
        :reverse_each,
        :rindex,
        :rotate,
        :sample,
        :select,
        :shelljoin,
        :shuffle,
        :size,
        :slice,
        :slice_before,
        :sort,
        :sort_by,
        :take,
        :take_while,
        :to_a,
        :to_ary,
        :to_set,
        :transpose,
        :uniq,
        :values_at,
        :zip,
        :|
      ]

      def initialize(root, array_data)
        @root = root
        @serial_number = root.serial_number
        array_data.each do |value|
          internal_push(immutablize(root, value))
        end
      end

      # Redefine all of the methods that mutate a Hash to raise an error when called.
      # This is the magic that makes this object "Immutable"
      DISALLOWED_MUTATOR_METHODS.each do |mutator_method_name|
        # Ruby 1.8 blocks can't have block arguments, so we must use string eval:
        class_eval(<<-METHOD_DEFN)
          def #{mutator_method_name}(*args, &block)
            msg = "Node attributes are read-only when you do not specify which precedence level to set. " +
            %Q(To set an attribute use code like `node.default["key"] = "value"')
            raise Exceptions::ImmutableAttributeModification, msg
          end
        METHOD_DEFN
      end

      READER_METHODS.each do |reader|
        class_eval(<<-METHOD_DEFN)
          def #{reader}(*args, &block)
            if root.stale_subtree?(@serial_number)
              raise Exceptions::StaleAttributeRead,
                "Node attributes have been modified since this value was read. Get an updated value by reading from node, e.g., `node[:key]`"
            end
            super
          end
        METHOD_DEFN
      end

      def dup
        Array.new(self)
      end
    end

    # == ImmutableMash
    # ImmutableMash implements Hash/Dict behavior for reading values from node
    # attributes.
    #
    # ImmutableMash acts like a Mash (Hash that is indifferent to String or
    # Symbol keys), with some important exceptions:
    # * Methods that mutate state are overridden to raise an error instead.
    # * Methods that read from the collection are overriden so that they check
    #   if the Chef::Node::Attribute has been modified since an instance of
    #   this class was generated. An error is raised if the object detects that
    #   it is stale.
    # * Values can be accessed in attr_reader-like fashion via method_missing.
    class ImmutableMash < Mash

      include Immutablize

      attr_reader :root

      alias :internal_set :[]=
      private :internal_set

      DISALLOWED_MUTATOR_METHODS = [
        :[]=,
        :clear,
        :collect!,
        :default=,
        :default_proc=,
        :delete,
        :delete_if,
        :keep_if,
        :map!,
        :merge!,
        :update,
        :reject!,
        :replace,
        :select!,
        :shift
      ]

      READER_METHODS = [
        :[],
        :all?,
        :any?,
        :assoc,
        :chunk,
        :collect,
        :collect_concat,
        :count,
        :cycle,
        :detect,
        :drop,
        :drop_while,
        :each,
        :each_cons,
        :each_entry,
        :each_key,
        :each_pair,
        :each_slice,
        :each_value,
        :each_with_index,
        :each_with_object,
        :empty?,
        :entries,
        :except,
        :fetch,
        :find,
        :find_all,
        :find_index,
        :first,
        :flat_map,
        :flatten,
        :grep,
        :group_by,
        :has_key?,
        :has_value?,
        :include?,
        :index,
        :inject,
        :invert,
        :key,
        :key?,
        :keys,
        :length,
        :map,
        :max,
        :max_by,
        :member?,
        :merge,
        :min,
        :min_by,
        :minmax,
        :minmax_by,
        :none?,
        :one?,
        :partition,
        :rassoc,
        :reduce,
        :reject,
        :reverse_each,
        :select,
        :size,
        :slice_before,
        :sort,
        :sort_by,
        :store,
        :symbolize_keys,
        :take,
        :take_while,
        :to_a,
        :to_hash,
        :to_set,
        :value?,
        :values,
        :values_at,
        :zip
      ]

      def initialize(root, mash_data)
        @serial_number = root.serial_number
        @root = root
        mash_data.each do |key, value|
          internal_set(key, immutablize(root, value))
        end
      end

      alias :attribute? :has_key?

      # Redefine all of the methods that mutate a Hash to raise an error when called.
      # This is the magic that makes this object "Immutable"
      DISALLOWED_MUTATOR_METHODS.each do |mutator_method_name|
        # Ruby 1.8 blocks can't have block arguments, so we must use string eval:
        class_eval(<<-METHOD_DEFN)
        def #{mutator_method_name}(*args, &block)
          msg = "Node attributes are read-only when you do not specify which precedence level to set. " +
          %Q(To set an attribute use code like `node.default["key"] = "value"')
          raise Exceptions::ImmutableAttributeModification, msg
        end
        METHOD_DEFN
      end

      READER_METHODS.each do |reader_method|
        class_eval(<<-METHOD_DEFN)
          def #{reader_method}(*args, &block)
            if root.stale_subtree?(@serial_number)
              raise Exceptions::StaleAttributeRead,
                "Node attributes have been modified since this value was read. Get an updated value by reading from node, e.g., `node[:key]`"
            end
            super
          end
        METHOD_DEFN
      end

      def method_missing(symbol, *args)
        if args.empty?
          if key?(symbol)
            self[symbol]
          else
            raise NoMethodError, "Undefined method or attribute `#{symbol}' on `node'"
          end
        # 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)
        else
          raise NoMethodError, "Undefined node attribute or method `#{symbol}' on `node'"
        end
      end

      # Mash uses #convert_value to mashify values on input.
      # Since we're handling this ourselves, override it to be a no-op
      def convert_value(value)
        value
      end

      # NOTE: #default and #default= are likely to be pretty confusing. For a
      # regular ruby Hash, they control what value is returned for, e.g.,
      #   hash[:no_such_key] #=> hash.default
      # Of course, 'default' has a specific meaning in Chef-land

      def dup
        Mash.new(self)
      end
    end

  end
end