chef 0.8.16 → 0.9.0.a3

data/lib/chef/mixin/recipe_definition_dsl_core.rb

@@ -36,14 +36,14 @@ class Chef
         # 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 @definitions.has_key?(method_symbol)
+        if run_context.definitions.has_key?(method_symbol)
           # This dupes the high level object, but we still need to dup the params
-          new_def = @definitions[method_symbol].dup
+          new_def = run_context.definitions[method_symbol].dup
           new_def.params = new_def.params.dup
-          new_def.node = @node
+          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, @node, @collection, @definitions, @cookbook_loader)
+          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)
@@ -51,32 +51,29 @@ class Chef
           # Otherwise, we're rocking the regular resource call route.
           method_name = method_symbol.to_s
           rname = convert_to_class_name(method_name)
-          
+
+          super unless Chef::Resource.const_defined?(rname)
+          raise ArgumentError, "You must supply a name when declaring a #{method_name} resource" unless args.size > 0
+
           # If we have a resource like this one, we want to steal its state
-          resource = begin
-                       args << @collection
-                       args << @node
-                       Chef::Resource.const_get(rname).new(*args)
-                     rescue NameError => e
-                       if e.to_s =~ /Chef::Resource/
-                         raise NameError, "Cannot find #{rname} for #{method_name}\nOriginal exception: #{e.class}: #{e.message}"
-                       else
-                         raise e
-                       end
-                     end
+          args << run_context
+          resource = Chef::Resource.const_get(rname).new(*args)
           resource.load_prior_resource
-          resource.cookbook_name = @cookbook_name
-          resource.recipe_name = @recipe_name
+          resource.cookbook_name = cookbook_name
+          # TODO: 5/21/2010 cw/dan: do we need recipe_name for
+          # anything? it's not even possible that this ivar is set on
+          # Chef::Provider.
+#          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
           resource.instance_eval(&block) if block
 
-          @collection.insert(resource)
+          run_context.resource_collection.insert(resource)
           resource
         end
       end
       
     end
   end
-end
+end

data/lib/chef/mixin/shell_out.rb

@@ -0,0 +1,38 @@
+#
+# Author:: Daniel DeLeo (<dan@opscode.com>)
+# Copyright:: Copyright (c) 2010 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.
+
+require 'chef/shell_out'
+
+class Chef
+  module Mixin
+    module ShellOut
+      
+      def shell_out(*command_args)
+        cmd = Chef::ShellOut.new(*command_args)
+        cmd.run_command
+        cmd
+      end
+      
+      def shell_out!(*command_args)
+        cmd = Chef::ShellOut.new(*command_args)
+        cmd.run_command
+        cmd.error!
+        cmd
+      end
+    end
+  end
+end

data/lib/chef/mixins.rb

@@ -1,3 +1,4 @@
+require 'chef/mixin/shell_out'
 require 'chef/mixin/check_helper'
 require 'chef/mixin/checksum'
 require 'chef/mixin/command'
@@ -6,7 +7,6 @@ require 'chef/mixin/create_path'
 require 'chef/mixin/deep_merge'
 require 'chef/mixin/find_preferred_file'
 require 'chef/mixin/from_file'
-require 'chef/mixin/generate_url'
 require 'chef/mixin/language'
 require 'chef/mixin/language_include_attribute'
 require 'chef/mixin/language_include_recipe'

data/lib/chef/node.rb

@@ -1,7 +1,9 @@
 #
 # Author:: Adam Jacob (<adam@opscode.com>)
 # Author:: Christopher Brown (<cb@opscode.com>)
-# Copyright:: Copyright (c) 2008 Opscode, Inc.
+# Author:: Christopher Walters (<cw@opscode.com>)
+# Author:: Tim Hinderliter (<tim@opscode.com>)
+# Copyright:: Copyright (c) 2008-2010 Opscode, Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -18,6 +20,7 @@
 #
 
 require 'chef/config'
+require 'chef/cookbook/cookbook_collection'
 require 'chef/mixin/check_helper'
 require 'chef/mixin/params_validate'
 require 'chef/mixin/from_file'
@@ -33,10 +36,15 @@ require 'json'
 
 class Chef
   class Node
-
-    attr_accessor :attribute, :recipe_list, :couchdb, :couchdb_rev, :run_state, :run_list, :override_attrs, :default_attrs, :cookbook_loader
-    attr_reader :node
+    
+    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
+    
+    # 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
 
     include Chef::Mixin::CheckHelper
     include Chef::Mixin::FromFile
@@ -130,11 +138,11 @@ class Chef
     # Create a new Chef::Node object.
     def initialize(couchdb=nil)
       @name = nil
-      @node = self
-
-      @attribute = Mash.new
+      
+      @normal_attrs = Mash.new
       @override_attrs = Mash.new
       @default_attrs = Mash.new
+      @automatic_attrs = Mash.new
       @run_list = Chef::RunList.new
 
       @couchdb_rev = nil
@@ -146,22 +154,26 @@ class Chef
         :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
 
     def couchdb_id=(value)
       @couchdb_id = value
-      self.index_id = value
+      @index_id = value
     end
-
-    def chef_server_rest
-      Chef::REST.new(Chef::Config[:chef_server_url])
+    
+    # Used by DSL
+    def node
+      self
     end
 
-    def self.chef_server_rest
+    def chef_server_rest
       Chef::REST.new(Chef::Config[:chef_server_url])
     end
 
-    # Find a recipe for this Chef::Node by fqdn.  Will search first for
+    # 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.
@@ -183,48 +195,102 @@ class Chef
     def name(arg=nil)
       if arg != nil
         validate(
-          {:name => arg },
-          {:name => { :kind_of => String,
-                      :cannot_be => :blank}
-          })
+                 {:name => arg },
+                 {:name => { :kind_of => String,
+                     :cannot_be => :blank}
+                 })
         @name = arg
       else
         @name
       end
     end
 
+    # Used by the DSL
+    def attribute
+      construct_attributes
+    end
+    
+    def construct_attributes
+      Chef::Node::Attribute.new(normal_attrs, default_attrs, override_attrs, automatic_attrs)
+    end
+
+    def attribute=(value)
+      self.normal_attrs = value
+    end
+    
     # Return an attribute of this node.  Returns nil if the attribute is not found.
     def [](attrib)
-      Chef::Node::Attribute.new(@attribute, @default_attrs, @override_attrs)[attrib]
+      construct_attributes[attrib]
     end
 
     # Set an attribute of this node
     def []=(attrib, value)
-      Chef::Node::Attribute.new(@attribute, @default_attrs, @override_attrs)[attrib] = value
+      construct_attributes[attrib] = value
     end
 
     def store(attrib, value)
       self[attrib] = value
     end
 
-    # Set an attribute of this node, but auto-vivifiy any Mashes that might
+    # Set a normal attribute of this node, but auto-vivifiy any Mashes that
+    # might be missing
+    def normal 
+      attrs = construct_attributes
+      attrs.set_type = :normal
+      attrs.auto_vivifiy_on_read = true
+      attrs
+    end
+
+    alias_method :set, :normal
+
+    # Set a normal attribute of this node, auto-vivifiying 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
+    end
+    alias_method :set_unless, :normal_unless
+  
+    # Set a default of this node, but auto-vivifiy any Mashes that might
     # be missing
-    def set
-      attrs = Chef::Node::Attribute.new(@attribute, @default_attrs, @override_attrs)
+    def default 
+      attrs = construct_attributes
+      attrs.set_type = :default
       attrs.auto_vivifiy_on_read = true
       attrs
     end
 
-    # Set an attribute of this node, auto-vivifiying any mashes that are
+    # Set a default attribute of this node, auto-vivifiying any mashes that are
     # missing, but if the final value already exists, don't set it
-    def set_unless
-      attrs = Chef::Node::Attribute.new(@attribute, @default_attrs, @override_attrs)
+    def default_unless
+      attrs = construct_attributes
+      attrs.set_type = :default
       attrs.auto_vivifiy_on_read = true
       attrs.set_unless_value_present = true
       attrs
     end
 
-    alias_method :default, :set_unless
+    # Set an override attribute of this node, but auto-vivifiy any Mashes that
+    # might be missing
+    def override 
+      attrs = construct_attributes
+      attrs.set_type = :override
+      attrs.auto_vivifiy_on_read = true
+      attrs
+    end
+
+    # Set an override attribute of this node, auto-vivifiying 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
+    end
 
     # Return true if this Node has a given attribute, false if not.  Takes either a symbol or
     # a string.
@@ -232,34 +298,43 @@ class Chef
     # Only works on the top level. Preferred way is to use the normal [] style
     # lookup and call attribute?()
     def attribute?(attrib)
-      Chef::Node::Attribute.new(@attribute, @default_attrs, @override_attrs).attribute?(attrib)
+      construct_attributes.attribute?(attrib)
     end
 
     # Yield each key of the top level to the block.
     def each(&block)
-      Chef::Node::Attribute.new(@attribute, @default_attrs, @override_attrs).each(&block)
+      construct_attributes.each(&block)
     end
 
     # Iterates over each attribute, passing the attribute and value to the block.
     def each_attribute(&block)
-      Chef::Node::Attribute.new(@attribute, @default_attrs, @override_attrs).each_attribute(&block)
+      construct_attributes.each_attribute(&block)
     end
 
-    # Set an attribute based on the missing method.  If you pass an argument, we'll use that
-    # to set the attribute values.  Otherwise, we'll wind up just returning the attributes
-    # value.
+    # 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.
     def method_missing(symbol, *args)
-      Chef::Node::Attribute.new(@attribute, @default_attrs, @override_attrs).send(symbol, *args)
+      attrs = construct_attributes
+      attrs.set_type = :normal
+      attrs.send(symbol, *args)
     end
 
     # Returns true if this Node expects a given recipe, false if not.
-    def recipe?(recipe_name)
-      @run_list.include?(recipe_name) || @run_state[:seen_recipes].include?(recipe_name)
-    end
-
+    #
+    # 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).
+    #
+    # NOTE: We believe this is dead code, but if it's not, please
+    # email chef-dev@opscode.com. [cw,timh]
+#     def recipe?(recipe_name)
+#       run_list.include?(recipe_name) || run_state[:seen_recipes].include?(recipe_name)
+#     end
+    
     # Returns true if this Node expects a given role, false if not.
     def role?(role_name)
-      @run_list.include?("role[#{role_name}]")
+      run_list.include?("role[#{role_name}]")
     end
 
     # Returns an Array of roles and recipes, in the order they will be applied.
@@ -275,7 +350,7 @@ class Chef
 
     # Returns true if this Node expects a given role, false if not.
     def run_list?(item)
-      @run_list.detect { |r| r == item } ? true : false
+      run_list.detect { |r| r == item } ? true : false
     end
 
     def consume_attributes(attrs)
@@ -288,7 +363,7 @@ class Chef
         Chef::Log.info("Replacing the run_list with #{new_run_list.inspect} from JSON")
         run_list(new_run_list)
       end
-      Chef::Mixin::DeepMerge.merge(@attribute, attrs)
+      Chef::Mixin::DeepMerge.merge(@normal_attrs, attrs)
 
       self[:tags] = Array.new unless attribute?(:tags)
     end
@@ -296,29 +371,30 @@ class Chef
     # Transform the node to a Hash
     def to_hash
       index_hash = Hash.new
-      self.each do |k, v|
-        index_hash[k] = v
-      end
       index_hash["chef_type"] = "node"
-      index_hash["name"] = @name
-      index_hash["recipe"] = @run_list.recipes if @run_list.recipes.length > 0
-      index_hash["role"] = @run_list.roles if @run_list.roles.length > 0
-      index_hash["run_list"] = @run_list.run_list if @run_list.run_list.length > 0
+      index_hash["name"] = name
+      attribute.each do |key, value|
+        index_hash[key] = value
+      end
+      index_hash["recipe"] = run_list.recipe_names if run_list.recipe_names.length > 0
+      index_hash["role"] = run_list.role_names if run_list.role_names.length > 0
+      index_hash["run_list"] = run_list.run_list if run_list.run_list.length > 0
       index_hash
     end
 
     # Serialize this object as a hash
     def to_json(*a)
       result = {
-        "name" => @name,
+        "name" => name,
         'json_class' => self.class.name,
-        "attributes" => @attribute,
+        "automatic" => automatic_attrs,
+        "normal" => normal_attrs,
         "chef_type" => "node",
-        "defaults" => @default_attrs,
-        "overrides" => @override_attrs,
-        "run_list" => @run_list.run_list,
+        "default" => default_attrs,
+        "override" => override_attrs,
+        "run_list" => run_list.run_list
       }
-      result["_rev"] = @couchdb_rev if @couchdb_rev
+      result["_rev"] = couchdb_rev if couchdb_rev
       result.to_json(*a)
     end
 
@@ -326,10 +402,14 @@ class Chef
     def self.json_create(o)
       node = new
       node.name(o["name"])
-      o["attributes"].each { |k,v| node[k] = v }
 
-      node.default_attrs = Mash.new(o["defaults"]) if o.has_key?("defaults")
-      node.override_attrs = Mash.new(o["overrides"]) if o.has_key?("overrides")
+      if o.has_key?("attributes")
+        node.normal_attrs = o["attributes"]
+      end
+      node.automatic_attrs = Mash.new(o["automatic"]) if o.has_key?("automatic")
+      node.normal_attrs = Mash.new(o["normal"]) if o.has_key?("normal")
+      node.default_attrs = Mash.new(o["default"]) if o.has_key?("default")
+      node.override_attrs = Mash.new(o["override"]) if o.has_key?("override")
 
       if o.has_key?("run_list")
         node.run_list.reset!(o["run_list"])
@@ -382,23 +462,25 @@ class Chef
 
     # Remove this node from the CouchDB
     def cdb_destroy
-      @couchdb.delete("node", @name, @couchdb_rev)
+      couchdb.delete("node", name, couchdb_rev)
     end
 
     # Remove this node via the REST API
     def destroy
-      chef_server_rest.delete_rest("nodes/#{@name}")
+      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"]
+      @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,
+      # so then POST to create.
       begin
-        chef_server_rest.put_rest("nodes/#{@name}", self)
+        chef_server_rest.put_rest("nodes/#{name}", self)
       rescue Net::HTTPServerException => e
         raise e unless e.response.code == "404"
         chef_server_rest.post_rest("nodes", self)
@@ -416,11 +498,56 @@ class Chef
     def self.create_design_document(couchdb=nil)
       (couchdb || Chef::CouchDB.new).create_design_document("nodes", DESIGN_DOCUMENT)
     end
-
-    # As a string
+    
     def to_s
-      "node[#{@name}]"
+      "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
 
+    # Expands the node's run list and deep merges the default and
+    # override attributes.
+    #
+    # Returns the fully-expanded list of recipes.
+    #
+    # TODO: timh/cw, 5-14-2010: Should this method exist? Should we
+    # instead modify default_attrs and override_attrs whenever our
+    # run_list is mutated? Or perhaps do something smarter like
+    # on-demand generation of default_attrs and override_attrs,
+    # invalidated only when run_list is mutated?
+    def expand_node!
+      # This call should only be called on a chef-client run.
+      recipes, expanded_default_attrs, expanded_override_attrs = run_list.expand('server')
+      self.default_attrs = Chef::Mixin::DeepMerge.merge(default_attrs, expanded_default_attrs)
+      self.override_attrs = Chef::Mixin::DeepMerge.merge(override_attrs, expanded_override_attrs)
+      recipes
+    end
+    
   end
 end