chef 10.34.6 → 11.0.0.beta.0

data/lib/chef/node/attribute_collections.rb

@@ -0,0 +1,199 @@
+#--
+# Author:: Daniel DeLeo (<dan@opscode.com>)
+# Copyright:: Copyright (c) 2012 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
+  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|
+        class_eval(<<-METHOD_DEFN, __FILE__, __LINE__)
+          def #{mutator}(*args, &block)
+            root.reset_cache
+            super
+          end
+        METHOD_DEFN
+      end
+
+      attr_reader :root
+
+      def initialize(root, data)
+        @root = root
+        super(data)
+      end
+
+      def dup
+        Array.new(map {|e| e.dup})
+      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|
+        class_eval(<<-METHOD_DEFN, __FILE__, __LINE__)
+          def #{mutator}(*args, &block)
+            root.reset_cache
+            super
+          end
+        METHOD_DEFN
+      end
+
+      def initialize(root, data={})
+        @root = root
+        super(data)
+      end
+
+      def [](key)
+        value = super
+        if !key?(key)
+          value = self.class.new(root)
+          self[key] = value
+        else
+          value
+        end
+      end
+
+      def []=(key, value)
+        if set_unless? && key?(key)
+          self[key]
+        else
+          root.reset_cache
+          super
+        end
+      end
+
+      alias :attribute? :has_key?
+
+      def method_missing(symbol, *args)
+        if 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
+
+  end
+end

data/lib/chef/node/immutable_collections.rb

@@ -0,0 +1,186 @@
+
+class Chef
+  class Node
+
+    module Immutablize
+      def immutablize(value)
+        case value
+        when Hash
+          ImmutableMash.new(value)
+        when Array
+          ImmutableArray.new(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
+
+      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
+      ]
+
+      def initialize(array_data)
+        array_data.each do |value|
+          internal_push(immutablize(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, __FILE__, __LINE__)
+          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
+
+      def dup
+        Array.new(map {|e| e.dup })
+      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
+
+      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
+      ]
+
+      def initialize(mash_data)
+        mash_data.each do |key, value|
+          internal_set(key, immutablize(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, __FILE__, __LINE__)
+        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
+
+      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

data/lib/chef/platform.rb

@@ -20,9 +20,8 @@ require 'chef/config'
 require 'chef/log'
 require 'chef/mixin/params_validate'
 
-# Actually, this file depends on nearly every provider in chef, but actually
-# requiring them causes circular requires resulting in uninitialized constant
-# errors.
+# This file depends on nearly every provider in chef, but requiring them
+# directly causes circular requires resulting in uninitialized constant errors.
 require 'chef/provider'
 require 'chef/provider/log'
 require 'chef/provider/user'
@@ -73,14 +72,6 @@ class Chef
               :mdadm => Chef::Provider::Mdadm
             }
           },
-          :gcel   => {
-            :default => {
-              :package => Chef::Provider::Package::Apt,
-              :service => Chef::Provider::Service::Debian,
-              :cron => Chef::Provider::Cron,
-              :mdadm => Chef::Provider::Mdadm
-            }
-          },
           :linaro   => {
             :default => {
               :package => Chef::Provider::Package::Apt,
@@ -253,8 +244,7 @@ class Chef
               :service => Chef::Provider::Service::Solaris,
               :package => Chef::Provider::Package::Ips,
               :cron => Chef::Provider::Cron::Solaris,
-              :group => Chef::Provider::Group::Usermod,
-              :user => Chef::Provider::User::Solaris,
+              :group => Chef::Provider::Group::Usermod
             }
           },
           :solaris2 => {
@@ -262,22 +252,19 @@ class Chef
               :service => Chef::Provider::Service::Solaris,
               :package => Chef::Provider::Package::Ips,
               :cron => Chef::Provider::Cron::Solaris,
-              :group => Chef::Provider::Group::Usermod,
-              :user => Chef::Provider::User::Solaris
+              :group => Chef::Provider::Group::Usermod
             },
             "5.9" => {
               :service => Chef::Provider::Service::Solaris,
               :package => Chef::Provider::Package::Solaris,
               :cron => Chef::Provider::Cron::Solaris,
-              :group => Chef::Provider::Group::Usermod,
-              :user => Chef::Provider::User::Solaris
+              :group => Chef::Provider::Group::Usermod
             },
             "5.10" => {
               :service => Chef::Provider::Service::Solaris,
               :package => Chef::Provider::Package::Solaris,
               :cron => Chef::Provider::Cron::Solaris,
-              :group => Chef::Provider::Group::Usermod,
-              :user => Chef::Provider::User::Solaris
+              :group => Chef::Provider::Group::Usermod
             }
           },
           :smartos => {
@@ -285,8 +272,7 @@ class Chef
               :service => Chef::Provider::Service::Solaris,
               :package => Chef::Provider::Package::SmartOS,
               :cron => Chef::Provider::Cron::Solaris,
-              :group => Chef::Provider::Group::Usermod,
-              :user => Chef::Provider::User::Solaris
+              :group => Chef::Provider::Group::Usermod
             }
           },
           :netbsd => {
@@ -331,7 +317,6 @@ class Chef
             :route => Chef::Provider::Route,
             :ifconfig => Chef::Provider::Ifconfig,
             :ruby_block => Chef::Provider::RubyBlock,
-            :whyrun_safe_ruby_block => Chef::Provider::WhyrunSafeRubyBlock,
             :erl_call => Chef::Provider::ErlCall,
             :log => Chef::Provider::Log::ChefLog
           }