chef 10.34.6 → 11.0.0.beta.0

data/lib/chef/mixin/language_include_attribute.rb

@@ -6,9 +6,9 @@
 # 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.
@@ -16,46 +16,14 @@
 # limitations under the License.
 #
 
-require 'chef/log'
+require 'chef/dsl/include_attribute'
 
 class Chef
   module Mixin
-    module LanguageIncludeAttribute
-
-      # Loads the attribute file specified by the short name of the
-      # file, e.g., loads specified cookbook's
-      #   "attributes/mailservers.rb"
-      # if passed
-      #   "mailservers"
-      def include_attribute(*fully_qualified_attribute_short_filenames)
-        if self.kind_of?(Chef::Node)
-          node = self
-        else
-          node = @node
-        end
-
-        fully_qualified_attribute_short_filenames.flatten.each do |fully_qualified_attribute_short_filename|
-          if node.run_state[:seen_attributes].has_key?(fully_qualified_attribute_short_filename)
-            Chef::Log.debug("I am not loading attribute file #{fully_qualified_attribute_short_filename}, because I have already seen it.")
-            next
-          end
-
-          Chef::Log.debug("Loading Attribute #{fully_qualified_attribute_short_filename}")
-          node.run_state[:seen_attributes][fully_qualified_attribute_short_filename] = true
-
-          if amatch = fully_qualified_attribute_short_filename.match(/(.+?)::(.+)/)
-            cookbook_name = amatch[1].to_sym
-            node.load_attribute_by_short_filename(amatch[2], cookbook_name)
-          else
-            cookbook_name = fully_qualified_attribute_short_filename.to_sym
-            node.load_attribute_by_short_filename("default", cookbook_name)
-          end
-        end
-        true
-      end
 
-    end
+    # DEPRECATED: This is just here for compatibility, use
+    # Chef::DSL::IncludeAttribute instead.
+    LanguageIncludeAttribute = Chef::DSL::IncludeAttribute
   end
 end
-      
 

data/lib/chef/mixin/language_include_recipe.rb

@@ -16,43 +16,11 @@
 # limitations under the License.
 #
 
-require 'chef/log'
+require 'chef/dsl/include_recipe'
 
 class Chef
   module Mixin
-    module LanguageIncludeRecipe
-
-      def include_recipe(*recipe_names)
-        result_recipes = Array.new
-        recipe_names.flatten.each do |recipe_name|
-          if node.run_state[:seen_recipes].has_key?(recipe_name) or node.run_state[:seen_recipes].has_key?(recipe_name + "::default")
-            Chef::Log.debug("I am not loading #{recipe_name}, because I have already seen it.")
-            next
-          end
-
-          result_recipes << load_recipe(recipe_name)
-        end
-        result_recipes
-      end
-
-      def load_recipe(recipe_name)
-        Chef::Log.debug("Loading Recipe #{recipe_name} via include_recipe")
-        node.run_state[:seen_recipes][recipe_name] = true
-
-        cookbook_name, recipe_short_name = Chef::Recipe.parse_recipe_name(recipe_name)
-
-        run_context = self.is_a?(Chef::RunContext) ? self : self.run_context
-        cookbook = run_context.cookbook_collection[cookbook_name]
-        cookbook.load_recipe(recipe_short_name, run_context)
-      end
-
-
-      def require_recipe(*args)
-        Chef::Log.warn("require_recipe is deprecated and will be removed in a future release, please use include_recipe")
-        include_recipe(*args)
-      end
-
-    end
+    LanguageIncludeRecipe = Chef::DSL::IncludeRecipe
   end
 end
-      
+

data/lib/chef/mixin/params_validate.rb

@@ -16,8 +16,7 @@
 # limitations under the License.
 
 class Chef
-  class DelayedEvaluator < Proc
-  end
+  
   module Mixin
     module ParamsValidate
       
@@ -76,30 +75,18 @@ class Chef
         end
         opts
       end
-      
-      def lazy(&block)
-        DelayedEvaluator.new(&block)
-      end
-
+          
       def set_or_return(symbol, arg, validation)
         iv_symbol = "@#{symbol.to_s}".to_sym
         map = {
           symbol => validation
         }
+
         if arg == nil && self.instance_variable_defined?(iv_symbol) == true
-          ivar = self.instance_variable_get(iv_symbol)
-          if(ivar.is_a?(DelayedEvaluator))
-            validate({ symbol => ivar.call }, { symbol => validation })[symbol]
-          else
-            ivar
-          end
+          self.instance_variable_get(iv_symbol)
         else
-          if(arg.is_a?(DelayedEvaluator))
-            val = arg
-          else
-            val = validate({ symbol => arg }, { symbol => validation })[symbol]
-          end
-          self.instance_variable_set(iv_symbol, val)
+          opts = validate({ symbol => arg }, { symbol => validation })
+          self.instance_variable_set(iv_symbol, opts[symbol])
         end
       end
             

data/lib/chef/mixin/recipe_definition_dsl_core.rb

@@ -17,70 +17,17 @@
 # limitations under the License.
 #
 
-require 'chef/resource'
-require 'chef/resource_platform_map'
-require 'chef/mixin/convert_to_class_name'
-require 'chef/mixin/language'
+###
+# NOTE: This file and constant are here only for backwards compatibility.
+# New code should use Chef::DSL::Recipe instead.
+#
+# This constant (module name) will eventually be deprecated and then removed.
+###
 
-#--
-# UGH. this is a circular require that will cause an uninitialized constant
-# error, but this file really does depend on Chef::Recipe. oh well.
-# require 'chef/recipe'
+require 'chef/dsl/recipe'
 
 class Chef
   module Mixin
-    module RecipeDefinitionDSLCore
-
-      include Chef::Mixin::ConvertToClassName
-      include Chef::Mixin::Language
-
-      def method_missing(method_symbol, *args, &block)
-        # If we have a definition that matches, we want to use that instead.  This should
-        # let you do some really crazy over-riding of "native" types, if you really want
-        # to.
-        if run_context.definitions.has_key?(method_symbol)
-          # This dupes the high level object, but we still need to dup the params
-          new_def = run_context.definitions[method_symbol].dup
-          new_def.params = new_def.params.dup
-          new_def.node = run_context.node
-          # This sets up the parameter overrides
-          new_def.instance_eval(&block) if block
-          new_recipe = Chef::Recipe.new(cookbook_name, @recipe_name, run_context)
-          new_recipe.params = new_def.params
-          new_recipe.params[:name] = args[0]
-          new_recipe.instance_eval(&new_def.recipe)
-        else
-          # Otherwise, we're rocking the regular resource call route.
-
-          # Checks the new platform => short_name => resource mapping initially
-          # then fall back to the older approach (Chef::Resource.const_get) for
-          # backward compatibility
-          resource_class = Chef::Resource.resource_for_node(method_symbol, run_context.node)
-
-          super unless resource_class
-          raise ArgumentError, "You must supply a name when declaring a #{method_symbol} resource" unless args.size > 0
-
-          # If we have a resource like this one, we want to steal its state
-          args << run_context
-          resource = resource_class.new(*args)
-          resource.source_line = caller[0]
-          resource.load_prior_resource
-          resource.cookbook_name = cookbook_name
-          resource.recipe_name = @recipe_name
-          resource.params = @params
-          # Determine whether this resource is being created in the context of an enclosing Provider
-          resource.enclosing_provider = self.is_a?(Chef::Provider) ? self : nil
-          # Evaluate resource attribute DSL
-          resource.instance_eval(&block) if block
-
-          # Run optional resource hook
-          resource.after_created
-
-          run_context.resource_collection.insert(resource)
-          resource
-        end
-      end
-
-    end
+    RecipeDefinitionDSLCore = Chef::DSL::Recipe
   end
 end

data/lib/chef/mixin/securable.rb

@@ -59,9 +59,17 @@ class Chef
         )
       end
 
-      # TODO should this be separated into different files?
-      if RUBY_PLATFORM =~ /mswin|mingw|windows/
 
+      #==WindowsMacros
+      # Defines methods for adding attributes to a chef resource to describe
+      # Windows file security metadata.
+      #
+      # This module is meant to be used to extend a class (instead of
+      # `include`-ing). A class is automatically extended with this module when
+      # it includes WindowsSecurableAttributes.
+      # --
+      # TODO should this be separated into different files?
+      module WindowsMacros
         # === rights_attribute
         # "meta-method" for dynamically creating rights attributes on resources.
         #
@@ -99,7 +107,7 @@ class Chef
         # * `:applies_to_self` (optional): Boolean
         # * `:one_level_deep` (optional): Boolean
         #
-        def self.rights_attribute(name)
+        def rights_attribute(name)
 
           # equivalent to something like:
           # def rights(permissions=nil, principals=nil, args_hash=nil)
@@ -160,10 +168,13 @@ class Chef
             )
           end
         end
+      end
+
+      #==WindowsSecurableAttributes
+      # Defines #inherits to describe Windows file security ACLs on the
+      # including class
+      module WindowsSecurableAttributes
 
-        # create a default 'rights' attribute
-        rights_attribute(:rights)
-        rights_attribute(:deny_rights)
 
         def inherits(arg=nil)
           set_or_return(
@@ -172,8 +183,22 @@ class Chef
             :kind_of => [ TrueClass, FalseClass ]
           )
         end
+      end
 
-      end # Windows-specific
+      if RUBY_PLATFORM =~ /mswin|mingw|windows/
+        include WindowsSecurableAttributes
+      end
+
+      # Callback that fires when included; will extend the including class
+      # with WindowsMacros and define #rights and #deny_rights on it.
+      def self.included(including_class)
+        if RUBY_PLATFORM =~ /mswin|mingw|windows/
+          including_class.extend(WindowsMacros)
+          # create a default 'rights' attribute
+          including_class.rights_attribute(:rights)
+          including_class.rights_attribute(:deny_rights)
+        end
+      end
 
     end
   end

data/lib/chef/mixin/template.rb

@@ -29,6 +29,46 @@ class Chef
           raise "Could not find a value for node. If you are explicitly setting variables in a template, " +
                 "include a node variable if you plan to use it."
         end
+
+        #
+        # Takes the name of the partial, plus a hash of options. Returns a
+        # string that contains the result of the evaluation of the partial.
+        #
+        # All variables from the parent template will be propagated down to
+        # the partial, unless you pass the +variables+ option (see below).
+        #
+        # Valid options are:
+        #
+        # :local:: If true then the partial name will be interpreted as the
+        #          path to a file on the local filesystem; if false (the
+        #          default) it will be looked up in the cookbook according to
+        #          the normal rules for templates.
+        # :source:: If specified then the partial will be looked up with this
+        #           name or path (according to the +local+ option) instead of
+        #           +partial_name+.
+        # :cookbook:: Search for the partial in the provided cookbook instead
+        #             of the cookbook that contains the top-level template.
+        # :variables:: A Hash of variable_name => value that will be made
+        #              available to the partial. If specified, none of the
+        #              variables from the master template will be, so if you
+        #              need them you will need to propagate them explicitly.
+        #
+        def render(partial_name, options = {})
+          raise "You cannot render partials in this context" unless @template_finder
+
+          if variables = options.delete(:variables)
+            context = {}
+            context.merge!(variables)
+            context[:node] = @node
+            context[:template_finder] = @template_finder
+          else
+            context = self.dup
+          end
+
+          template_location = @template_finder.find(partial_name, options)
+          eruby = Erubis::Eruby.new(IO.read(template_location))
+          output = eruby.evaluate(context)
+        end
       end
       
       ::Erubis::Context.send(:include, ChefContext)

data/lib/chef/mixins.rb

@@ -7,12 +7,8 @@ require 'chef/mixin/create_path'
 require 'chef/mixin/deep_merge'
 require 'chef/mixin/enforce_ownership_and_permissions'
 require 'chef/mixin/from_file'
-require 'chef/mixin/language'
-require 'chef/mixin/language_include_attribute'
-require 'chef/mixin/language_include_recipe'
 require 'chef/mixin/params_validate'
 require 'chef/mixin/path_sanity'
-require 'chef/mixin/recipe_definition_dsl_core'
 require 'chef/mixin/template'
 require 'chef/mixin/securable'
 require 'chef/mixin/xml_escape'

data/lib/chef/monkey_patches/net_http.rb

@@ -20,37 +20,3 @@ module Net
     include ChefNetHTTPExceptionExtensions
   end
 end
-
-if Net::HTTP.instance_methods.map {|m| m.to_s}.include?("proxy_uri")
-  begin
-    # Ruby 2.0 changes the way proxy support is implemented in Net::HTTP.
-    # The implementation does not work correctly with IPv6 literals because it
-    # concatenates the address into a URI without adding square brackets for
-    # IPv6 addresses.
-    #
-    # If the bug is present, a call to Net::HTTP#proxy_uri when the host is an
-    # IPv6 address will fail by creating an invalid URI, like so:
-    #
-    #    ruby -r'net/http' -e 'Net::HTTP.new("::1", 80).proxy_uri'
-    #    /Users/ddeleo/.rbenv/versions/2.0.0-p247/lib/ruby/2.0.0/uri/generic.rb:214:in `initialize': the scheme http does not accept registry part: ::1:80 (or bad hostname?) (URI::InvalidURIError)
-    #    	from /Users/ddeleo/.rbenv/versions/2.0.0-p247/lib/ruby/2.0.0/uri/http.rb:84:in `initialize'
-    #    	from /Users/ddeleo/.rbenv/versions/2.0.0-p247/lib/ruby/2.0.0/uri/common.rb:214:in `new'
-    #    	from /Users/ddeleo/.rbenv/versions/2.0.0-p247/lib/ruby/2.0.0/uri/common.rb:214:in `parse'
-    #    	from /Users/ddeleo/.rbenv/versions/2.0.0-p247/lib/ruby/2.0.0/uri/common.rb:747:in `parse'
-    #    	from /Users/ddeleo/.rbenv/versions/2.0.0-p247/lib/ruby/2.0.0/uri/common.rb:994:in `URI'
-    #    	from /Users/ddeleo/.rbenv/versions/2.0.0-p247/lib/ruby/2.0.0/net/http.rb:1027:in `proxy_uri'
-    #    	from -e:1:in `<main>'
-    #
-    # https://bugs.ruby-lang.org/issues/9129
-    Net::HTTP.new("::1", 80).proxy_uri
-  rescue URI::InvalidURIError
-    class Net::HTTP
-
-      def proxy_uri # :nodoc:
-        ipv6_safe_addr = address.to_s.include?(":") ? "[#{address}]" : address
-        @proxy_uri ||= URI("http://#{ipv6_safe_addr}:#{port}").find_proxy
-      end
-
-    end
-  end
-end

data/lib/chef/node.rb

@@ -21,19 +21,17 @@
 
 require 'forwardable'
 require 'chef/config'
-require 'chef/cookbook/cookbook_collection'
 require 'chef/nil_argument'
 require 'chef/mixin/check_helper'
 require 'chef/mixin/params_validate'
 require 'chef/mixin/from_file'
-require 'chef/mixin/language_include_attribute'
 require 'chef/mixin/deep_merge'
+require 'chef/dsl/include_attribute'
+require 'chef/dsl/platform_introspection'
 require 'chef/environment'
-require 'chef/couchdb'
 require 'chef/rest'
 require 'chef/run_list'
 require 'chef/node/attribute'
-require 'chef/index_queue'
 require 'chef/mash'
 require 'chef/json_compat'
 require 'chef/search/query'
@@ -43,144 +41,35 @@ class Chef
 
     extend Forwardable
 
-    def_delegators :construct_attributes, :keys, :each_key, :each_value, :key?, :has_key?
+    def_delegators :attributes, :keys, :each_key, :each_value, :key?, :has_key?
 
-    attr_accessor :recipe_list, :couchdb, :couchdb_rev, :run_state, :run_list
-    attr_accessor :override_attrs, :default_attrs, :normal_attrs, :automatic_attrs
-    attr_reader :couchdb_id
+    attr_accessor :recipe_list, :run_state, :run_list
 
-    # TODO: 5/18/2010 cw/timh. cookbook_collection should be removed
-    # from here and for any place it's needed, it should be accessed
-    # through a Chef::RunContext
-    attr_accessor :cookbook_collection
+    # RunContext will set itself as run_context via this setter when
+    # initialized. This is needed so DSL::IncludeAttribute (in particular,
+    # #include_recipe) can access the run_context to determine if an attributes
+    # file has been seen yet.
+    #--
+    # TODO: This is a pretty ugly way to solve that problem.
+    attr_accessor :run_context
 
-    include Chef::Mixin::CheckHelper
     include Chef::Mixin::FromFile
+    include Chef::DSL::IncludeAttribute
+    include Chef::DSL::PlatformIntrospection
+
+    include Chef::Mixin::CheckHelper
     include Chef::Mixin::ParamsValidate
-    include Chef::Mixin::LanguageIncludeAttribute
-    include Chef::IndexQueue::Indexable
-
-    DESIGN_DOCUMENT = {
-      "version" => 11,
-      "language" => "javascript",
-      "views" => {
-        "all" => {
-          "map" => <<-EOJS
-          function(doc) {
-            if (doc.chef_type == "node") {
-              emit(doc.name, doc);
-            }
-          }
-          EOJS
-        },
-        "all_id" => {
-          "map" => <<-EOJS
-          function(doc) {
-            if (doc.chef_type == "node") {
-              emit(doc.name, doc.name);
-            }
-          }
-          EOJS
-        },
-        "status" => {
-          "map" => <<-EOJS
-            function(doc) {
-              if (doc.chef_type == "node") {
-                var to_emit = { "name": doc.name, "chef_environment": doc.chef_environment };
-                if (doc["attributes"]["fqdn"]) {
-                  to_emit["fqdn"] = doc["attributes"]["fqdn"];
-                } else {
-                  to_emit["fqdn"] = "Undefined";
-                }
-                if (doc["attributes"]["ipaddress"]) {
-                  to_emit["ipaddress"] = doc["attributes"]["ipaddress"];
-                } else {
-                  to_emit["ipaddress"] = "Undefined";
-                }
-                if (doc["attributes"]["ohai_time"]) {
-                  to_emit["ohai_time"] = doc["attributes"]["ohai_time"];
-                } else {
-                  to_emit["ohai_time"] = "Undefined";
-                }
-                if (doc["attributes"]["uptime"]) {
-                  to_emit["uptime"] = doc["attributes"]["uptime"];
-                } else {
-                  to_emit["uptime"] = "Undefined";
-                }
-                if (doc["attributes"]["platform"]) {
-                  to_emit["platform"] = doc["attributes"]["platform"];
-                } else {
-                  to_emit["platform"] = "Undefined";
-                }
-                if (doc["attributes"]["platform_version"]) {
-                  to_emit["platform_version"] = doc["attributes"]["platform_version"];
-                } else {
-                  to_emit["platform_version"] = "Undefined";
-                }
-                if (doc["run_list"]) {
-                  to_emit["run_list"] = doc["run_list"];
-                } else {
-                  to_emit["run_list"] = "Undefined";
-                }
-                emit(doc.name, to_emit);
-              }
-            }
-          EOJS
-        },
-        "by_run_list" => {
-          "map" => <<-EOJS
-            function(doc) {
-              if (doc.chef_type == "node") {
-                if (doc['run_list']) {
-                  for (var i=0; i < doc.run_list.length; i++) {
-                    emit(doc['run_list'][i], doc.name);
-                  }
-                }
-              }
-            }
-          EOJS
-        },
-        "by_environment" => {
-          "map" => <<-EOJS
-            function(doc) {
-              if (doc.chef_type == "node") {
-                var env = (doc['chef_environment'] == null ? "_default" : doc['chef_environment']);
-                emit(env, doc.name);
-              }
-            }
-          EOJS
-        }
-      },
-    }
 
     # Create a new Chef::Node object.
-    def initialize(couchdb=nil)
+    def initialize
       @name = nil
 
       @chef_environment = '_default'
-      @normal_attrs = Mash.new
-      @override_attrs = Mash.new
-      @default_attrs = Mash.new
-      @automatic_attrs = Mash.new
       @run_list = Chef::RunList.new
 
-      @couchdb_rev = nil
-      @couchdb_id = nil
-      @couchdb = couchdb || Chef::CouchDB.new
-
-      @run_state = {
-        :template_cache => Hash.new,
-        :seen_recipes => Hash.new,
-        :seen_attributes => Hash.new
-      }
-      # TODO: 5/20/2010 need this here as long as other objects try to access
-      # the cookbook collection via Node, otherwise get NoMethodError on nil.
-      @cookbook_collection = CookbookCollection.new
-    end
+      @attributes = Chef::Node::Attribute.new({}, {}, {}, {})
 
-    def couchdb_id=(value)
-      @couchdb_id = value
-      @index_id = value
+      @run_state = {}
     end
 
     # Used by DSL
@@ -192,24 +81,6 @@ class Chef
       Chef::REST.new(Chef::Config[:chef_server_url])
     end
 
-    # Find a recipe for this Chef::Node by fqdn.  Will search first for
-    # Chef::Config["node_path"]/fqdn.rb, then hostname.rb, then default.rb.
-    #
-    # Returns a new Chef::Node object.
-    #
-    # Raises an ArgumentError if it cannot find the node.
-    def find_file(fqdn)
-      host_parts = fqdn.split(".")
-      hostname = host_parts[0]
-
-      [fqdn, hostname, "default"].each { |fname|
-       node_file = File.join(Chef::Config[:node_path], "#{fname.to_s}.rb")
-       return self.from_file(node_file) if File.exists?(node_file)
-     }
-
-      raise ArgumentError, "Cannot find a node matching #{fqdn}, not even with default.rb!"
-    end
-
     # Set the name of this Node, or return the current name.
     def name(arg=nil)
       if arg != nil
@@ -233,91 +104,109 @@ class Chef
       )
     end
 
-    # Used by the DSL
-    def attribute
-      construct_attributes
+    def chef_environment=(environment)
+      chef_environment(environment)
     end
 
-    def construct_attributes
-      Chef::Node::Attribute.new(normal_attrs, default_attrs, override_attrs, automatic_attrs)
-    end
+    alias :environment :chef_environment
 
-    def attribute=(value)
-      self.normal_attrs = value
+    def attributes
+      @attributes
     end
 
+    alias :attribute :attributes
+    alias :construct_attributes :attributes
+
     # Return an attribute of this node.  Returns nil if the attribute is not found.
     def [](attrib)
-      construct_attributes[attrib]
-    end
-
-    # Set an attribute of this node
-    def []=(attrib, value)
-      construct_attributes[attrib] = value
-    end
-
-    def store(attrib, value)
-      self[attrib] = value
+      attributes[attrib]
     end
 
-    # Set a normal attribute of this node, but auto-vivifiy any Mashes that
+    # Set a normal attribute of this node, but auto-vivify any Mashes that
     # might be missing
     def normal
-      attrs = construct_attributes
-      attrs.set_type = :normal
-      attrs.auto_vivifiy_on_read = true
-      attrs
+      attributes.normal
     end
 
     alias_method :set, :normal
 
-    # Set a normal attribute of this node, auto-vivifiying any mashes that are
+    # 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
-      attrs = construct_attributes
-      attrs.set_type = :normal
-      attrs.auto_vivifiy_on_read = true
-      attrs.set_unless_value_present = true
-      attrs
+      attributes.set_unless_value_present = true
+      attributes.normal
     end
     alias_method :set_unless, :normal_unless
 
-    # Set a default of this node, but auto-vivifiy any Mashes that might
+    # Set a default of this node, but auto-vivify any Mashes that might
     # be missing
     def default
-      attrs = construct_attributes
-      attrs.set_type = :default
-      attrs.auto_vivifiy_on_read = true
-      attrs
+      attributes.default
+    end
+
+    # Set a force default attribute. Intermediate mashes will be created by
+    # auto-vivify if necessary.
+    def default!
+      attributes.default!
     end
 
-    # Set a default attribute of this node, auto-vivifiying any mashes that are
+    # 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
-      attrs = construct_attributes
-      attrs.set_type = :default
-      attrs.auto_vivifiy_on_read = true
-      attrs.set_unless_value_present = true
-      attrs
+      attributes.set_unless_value_present = true
+      attributes.default
     end
 
-    # Set an override attribute of this node, but auto-vivifiy any Mashes that
+    # Set an override attribute of this node, but auto-vivify any Mashes that
     # might be missing
     def override
-      attrs = construct_attributes
-      attrs.set_type = :override
-      attrs.auto_vivifiy_on_read = true
-      attrs
+      attributes.override
     end
 
-    # Set an override attribute of this node, auto-vivifiying any mashes that
+    # Set a force override attribute. Intermediate mashes will be created by
+    # auto-vivify if needed.
+    def override!
+      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
-      attrs = construct_attributes
-      attrs.set_type = :override
-      attrs.auto_vivifiy_on_read = true
-      attrs.set_unless_value_present = true
-      attrs
+      attributes.set_unless_value_present = true
+      attributes.override
+    end
+
+
+    def override_attrs
+     attributes.override
+    end
+
+    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.automatic
+    end
+
+    def automatic_attrs=(new_values)
+      attributes.automatic = new_values
     end
 
     # Return true if this Node has a given attribute, false if not.  Takes either a symbol or
@@ -326,36 +215,33 @@ class Chef
     # Only works on the top level. Preferred way is to use the normal [] style
     # lookup and call attribute?()
     def attribute?(attrib)
-      construct_attributes.attribute?(attrib)
+      attributes.attribute?(attrib)
     end
 
     # Yield each key of the top level to the block.
     def each(&block)
-      construct_attributes.each(&block)
+      attributes.each(&block)
     end
 
     # Iterates over each attribute, passing the attribute and value to the block.
     def each_attribute(&block)
-      construct_attributes.each_attribute(&block)
+      attributes.each_attribute(&block)
     end
 
-    # Encouraged to only get used for lookups - while you can do sets from here, it's not as explicit
-    # as using the normal/default/override interface.
+    # Only works for attribute fetches, setting is no longer supported
     def method_missing(symbol, *args)
-      attrs = construct_attributes
-      attrs.send(symbol, *args)
+      attributes.send(symbol, *args)
     end
 
     # Returns true if this Node expects a given recipe, false if not.
     #
     # First, the run list is consulted to see whether the recipe is
     # explicitly included. If it's not there, it looks in
-    # run_state[:seen_recipes], which is populated by include_recipe
-    # statements in the DSL (and thus would not be in the run list).
+    # `node[:recipes]`, which is populated when the run_list is expanded
     #
     # NOTE: It's used by cookbook authors
     def recipe?(recipe_name)
-      run_list.include?(recipe_name) || run_state[:seen_recipes].include?(recipe_name)
+      run_list.include?(recipe_name) || Array(self[:recipes]).include?(recipe_name)
     end
 
     # Returns true if this Node expects a given role, false if not.
@@ -379,26 +265,26 @@ class Chef
       Chef::Log.debug("Extracting run list from JSON attributes provided on command line")
       consume_attributes(json_cli_attrs)
 
-      @automatic_attrs = ohai_data
+      self.automatic_attrs = ohai_data
 
       platform, version = Chef::Platform.find_platform_and_version(self)
       Chef::Log.debug("Platform is #{platform} version #{version}")
-      @automatic_attrs[:platform] = platform
-      @automatic_attrs[:platform_version] = version
+      self.automatic[:platform] = platform
+      self.automatic[:platform_version] = version
     end
 
     # Consumes the combined run_list and other attributes in +attrs+
     def consume_attributes(attrs)
       normal_attrs_to_merge = consume_run_list(attrs)
       Chef::Log.debug("Applying attributes from json file")
-      @normal_attrs = Chef::Mixin::DeepMerge.horizontal_merge(@normal_attrs,normal_attrs_to_merge)
+      self.normal_attrs = Chef::Mixin::DeepMerge.merge(normal_attrs,normal_attrs_to_merge)
       self.tags # make sure they're defined
     end
 
     # Lazy initializer for tags attribute
     def tags
-      self.set[:tags] = [] unless attribute?(:tags)
-      self[:tags]
+      normal[:tags] = [] unless attribute?(:tags)
+      normal[:tags]
     end
 
     # Extracts the run list from +attrs+ and applies it. Returns the remaining attributes
@@ -417,8 +303,8 @@ class Chef
     # Clear defaults and overrides, so that any deleted attributes
     # between runs are still gone.
     def reset_defaults_and_overrides
-      @default_attrs = Mash.new
-      @override_attrs = Mash.new
+      self.default.clear
+      self.override.clear
     end
 
     # Expands the node's run list and sets the default and override
@@ -439,8 +325,10 @@ class Chef
 
       self.tags # make sure they're defined
 
-      @automatic_attrs[:recipes] = expansion.recipes
-      @automatic_attrs[:roles] = expansion.roles
+      automatic_attrs[:recipes] = expansion.recipes
+      automatic_attrs[:roles] = expansion.roles
+
+      apply_expansion_attributes(expansion)
 
       expansion
     end
@@ -448,13 +336,17 @@ class Chef
     # Apply the default and overrides attributes from the expansion
     # passed in, which came from roles.
     def apply_expansion_attributes(expansion)
-      load_chef_environment_object = (chef_environment == "_default" ? nil : Chef::Environment.load(chef_environment))
-      environment_default_attrs = load_chef_environment_object.nil? ? {} : load_chef_environment_object.default_attributes
-      default_before_roles = Chef::Mixin::DeepMerge.horizontal_merge(default_attrs, environment_default_attrs)
-      @default_attrs = Chef::Mixin::DeepMerge.horizontal_merge(default_before_roles, expansion.default_attrs)
-      environment_override_attrs = load_chef_environment_object.nil? ? {} : load_chef_environment_object.override_attributes
-      overrides_before_environments = Chef::Mixin::DeepMerge.horizontal_merge(override_attrs, expansion.override_attrs)
-      @override_attrs = Chef::Mixin::DeepMerge.horizontal_merge(overrides_before_environments, environment_override_attrs)
+      loaded_environment = if chef_environment == "_default"
+                             Chef::Environment.new.tap {|e| e.name("_default")}
+                           else
+                             Chef::Environment.load(chef_environment)
+                           end
+
+      attributes.env_default = loaded_environment.default_attributes
+      attributes.env_override = loaded_environment.override_attributes
+
+      attribute.role_default = expansion.default_attrs
+      attributes.role_override = expansion.override_attrs
     end
 
     # Transform the node to a Hash
@@ -478,36 +370,39 @@ class Chef
       display["chef_environment"] = chef_environment
       display["automatic"]        = automatic_attrs
       display["normal"]           = normal_attrs
-      display["default"]          = default_attrs
-      display["override"]         = override_attrs
+      display["default"]          = attributes.combined_default
+      display["override"]         = attributes.combined_override
       display["run_list"]         = run_list.run_list
       display
     end
 
     # Serialize this object as a hash
     def to_json(*a)
+      for_json.to_json(*a)
+    end
+
+    def for_json
       result = {
         "name" => name,
         "chef_environment" => chef_environment,
         'json_class' => self.class.name,
-        "automatic" => automatic_attrs,
-        "normal" => normal_attrs,
+        "automatic" => attributes.automatic,
+        "normal" => attributes.normal,
         "chef_type" => "node",
-        "default" => default_attrs,
-        "override" => override_attrs,
+        "default" => attributes.combined_default,
+        "override" => attributes.combined_override,
         #Render correctly for run_list items so malformed json does not result
         "run_list" => run_list.run_list.map { |item| item.to_s }
       }
-      result["_rev"] = couchdb_rev if couchdb_rev
-      result.to_json(*a)
+      result
     end
 
     def update_from!(o)
       run_list.reset!(o.run_list)
-      @automatic_attrs = o.automatic_attrs
-      @normal_attrs = o.normal_attrs
-      @override_attrs = o.override_attrs
-      @default_attrs = o.default_attrs
+      self.automatic_attrs = o.automatic_attrs
+      self.normal_attrs = o.normal_attrs
+      self.override_attrs = o.override_attrs
+      self.default_attrs = o.default_attrs
       chef_environment(o.chef_environment)
       self
     end
@@ -530,17 +425,9 @@ class Chef
       else
         o["recipes"].each { |r| node.recipes << r }
       end
-      node.couchdb_rev = o["_rev"] if o.has_key?("_rev")
-      node.couchdb_id = o["_id"] if o.has_key?("_id")
-      node.index_id = node.couchdb_id
       node
     end
 
-    def self.cdb_list_by_environment(environment, inflate=false, couchdb=nil)
-      rs = (couchdb || Chef::CouchDB.new).get_view("nodes", "by_environment", :include_docs => inflate, :startkey => environment, :endkey => environment)
-      inflate ? rs["rows"].collect {|r| r["doc"]} : rs["rows"].collect {|r| r["value"]}
-    end
-
     def self.list_by_environment(environment, inflate=false)
       if inflate
         response = Hash.new
@@ -551,14 +438,6 @@ class Chef
       end
     end
 
-    # List all the Chef::Node objects in the CouchDB.  If inflate is set to true, you will get
-    # the full list of all Nodes, fully inflated.
-    def self.cdb_list(inflate=false, couchdb=nil)
-      rs =(couchdb || Chef::CouchDB.new).list("nodes", inflate)
-      lookup = (inflate ? "value" : "key")
-      rs["rows"].collect { |r| r[lookup] }
-    end
-
     def self.list(inflate=false)
       if inflate
         response = Hash.new
@@ -571,19 +450,6 @@ class Chef
       end
     end
 
-    # Load a node by name from CouchDB
-    def self.cdb_load(name, couchdb=nil)
-      (couchdb || Chef::CouchDB.new).load("node", name)
-    end
-
-    def self.exists?(nodename, couchdb)
-      begin
-        self.cdb_load(nodename, couchdb)
-      rescue Chef::Exceptions::CouchDBNotFound
-        nil
-      end
-    end
-
     def self.find_or_create(node_name)
       load(node_name)
     rescue Net::HTTPServerException => e
@@ -595,7 +461,7 @@ class Chef
     def self.build(node_name)
       node = new
       node.name(node_name)
-      node.chef_environment(Chef::Config[:environment]) unless Chef::Config[:environment].nil? || Chef::Config[:environment].chomp.empty?
+      node.chef_environment(Chef::Config[:environment]) unless Chef::Config[:environment].nil? || Chef::Config[:environment].chop.empty?
       node
     end
 
@@ -604,21 +470,11 @@ class Chef
       Chef::REST.new(Chef::Config[:chef_server_url]).get_rest("nodes/#{name}")
     end
 
-    # Remove this node from the CouchDB
-    def cdb_destroy
-      couchdb.delete("node", name, couchdb_rev)
-    end
-
     # Remove this node via the REST API
     def destroy
       chef_server_rest.delete_rest("nodes/#{name}")
     end
 
-    # Save this node to the CouchDB
-    def cdb_save
-      @couchdb_rev = couchdb.store("node", name, self)["rev"]
-    end
-
     # Save this node via the REST API
     def save
       # Try PUT. If the node doesn't yet exist, PUT will return 404,
@@ -642,41 +498,9 @@ class Chef
       self
     end
 
-    # Set up our CouchDB design document
-    def self.create_design_document(couchdb=nil)
-      (couchdb || Chef::CouchDB.new).create_design_document("nodes", DESIGN_DOCUMENT)
-    end
-
     def to_s
       "node[#{name}]"
     end
 
-    # Load all attribute files for all cookbooks associated with this
-    # node.
-    def load_attributes
-      cookbook_collection.values.each do |cookbook|
-        cookbook.segment_filenames(:attributes).each do |segment_filename|
-          Chef::Log.debug("Node #{name} loading cookbook #{cookbook.name}'s attribute file #{segment_filename}")
-          self.from_file(segment_filename)
-        end
-      end
-    end
-
-    # Used by DSL.
-    # Loads the attribute file specified by the short name of the
-    # file, e.g., loads specified cookbook's
-    #   "attributes/mailservers.rb"
-    # if passed
-    #   "mailservers"
-    def load_attribute_by_short_filename(name, src_cookbook_name)
-      src_cookbook = cookbook_collection[src_cookbook_name]
-      raise Chef::Exceptions::CookbookNotFound, "could not find cookbook #{src_cookbook_name} while loading attribute #{name}" unless src_cookbook
-
-      attribute_filename = src_cookbook.attribute_filenames_by_short_filename[name]
-      raise Chef::Exceptions::AttributeNotFound, "could not find filename for attribute #{name} in cookbook #{src_cookbook_name}" unless attribute_filename
-
-      self.from_file(attribute_filename)
-      self
-    end
   end
 end