chef 0.7.16 → 0.8.2

data/lib/chef/mixin/generate_url.rb

@@ -30,19 +30,28 @@ class Chef
         else
           new_url = "cookbooks/#{cookbook}/#{type}?"
           new_url += "id=#{url}"
-          platform, version = Chef::Platform.find_platform_and_version(node)
-          if type == "files" || type == "templates"
-            new_url += "&platform=#{platform}&version=#{version}&fqdn=#{node[:fqdn]}&node_name=#{node.name}"
-          end
-          if args
-            args.each do |key, value|
-              new_url += "&#{key}=#{value}"
-            end
-          end
+          new_url = generate_cookbook_url_from_uri(new_url, node, args)
         end
         Chef::Log.debug("generated cookbook url: #{new_url}")
         return new_url
       end
+
+      def generate_cookbook_url_from_uri(uri, node, args=nil)
+        platform, version = Chef::Platform.find_platform_and_version(node)
+        uri =~ /cookbooks\/(.+?)\/(.+)\?/
+        cookbook = $1
+        type = $2
+        if type == "files" || type == "templates"
+          uri += "&platform=#{platform}&version=#{version}&fqdn=#{node[:fqdn]}&node_name=#{node.name}"
+        end
+        if args
+          args.each do |key, value|
+            uri += "&#{key}=#{value}"
+          end
+        end
+
+        uri
+      end
       
     end
   end

data/lib/chef/mixin/language.rb

@@ -16,6 +16,10 @@
 # limitations under the License.
 #
 
+require 'chef/search/query'
+require 'chef/data_bag'
+require 'chef/data_bag_item'
+
 class Chef
   module Mixin
     module Language
@@ -73,7 +77,31 @@ class Chef
   
         has_platform
       end
-      
+
+      def search(*args, &block)
+        # If you pass a block, or have at least the start argument, do raw result parsing
+        # 
+        # Otherwise, do the iteration for the end user
+        if Kernel.block_given? || args.length >= 4 
+          Chef::Search::Query.new.search(*args, &block)
+        else 
+          results = Array.new
+          Chef::Search::Query.new.search(*args) do |o|
+            results << o 
+          end
+          results
+        end
+      end
+
+      def data_bag(bag)
+        rbag = Chef::DataBag.load(bag)
+        rbag.keys
+      end
+
+      def data_bag_item(bag, item)
+        Chef::DataBagItem.load(bag, item)
+      end
+
     end
   end
 end

data/lib/chef/mixin/language_include_attribute.rb

@@ -0,0 +1,56 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Copyright:: Copyright (c) 2008, 2009 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/log'
+
+class Chef
+  module Mixin
+    module LanguageIncludeAttribute
+
+      def include_attribute(*args)
+        if self.kind_of?(Chef::Node)
+          node = self
+        else
+          node = @node
+        end
+
+        args.flatten.each do |attrib|
+          if node.run_state[:seen_attributes].has_key?(attrib)
+            Chef::Log.debug("I am not loading attribute file #{attrib}, because I have already seen it.")
+            next
+          end
+
+          Chef::Log.debug("Loading Attribute #{attrib}")
+          node.run_state[:seen_attributes][attrib] = true
+
+          if amatch = attrib.match(/(.+?)::(.+)/)
+            cookbook = @cookbook_loader[amatch[1].to_sym]
+            cookbook.load_attribute(amatch[2], node)
+          else
+            cookbook = @cookbook_loader[amatch[1].to_sym]
+            cookbook.load_attribute("default", node)
+          end
+        end
+        true
+      end
+
+    end
+  end
+end
+      
+

data/lib/chef/mixin/language_include_recipe.rb

@@ -0,0 +1,53 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Copyright:: Copyright (c) 2008, 2009 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/log'
+
+class Chef
+  module Mixin
+    module LanguageIncludeRecipe
+
+      def include_recipe(*args)
+        args.flatten.each do |recipe|
+          if @node.run_state[:seen_recipes].has_key?(recipe)
+            Chef::Log.debug("I am not loading #{recipe}, because I have already seen it.")
+            next
+          end        
+
+          Chef::Log.debug("Loading Recipe #{recipe} via include_recipe")
+          @node.run_state[:seen_recipes][recipe] = true
+
+          rmatch = recipe.match(/(.+?)::(.+)/)
+          if rmatch
+            cookbook = @cookbook_loader[rmatch[1]]
+            cookbook.load_recipe(rmatch[2], @node, @collection, @definitions, @cookbook_loader)
+          else
+            cookbook = @cookbook_loader[recipe]
+            cookbook.load_recipe("default", @node, @collection, @definitions, @cookbook_loader)
+          end
+        end
+      end
+
+      def require_recipe(*args)
+        include_recipe(*args)
+      end
+
+    end
+  end
+end
+      

data/lib/chef/mixin/params_validate.rb

@@ -80,11 +80,12 @@ class Chef
         map = {
           symbol => validation
         }
-        if arg == nil
+
+        if arg == nil && self.instance_variable_defined?(iv_symbol) == true
           self.instance_variable_get(iv_symbol)
         else
-          validate({ symbol => arg }, { symbol => validation })
-          self.instance_variable_set(iv_symbol, arg)
+          opts = validate({ symbol => arg }, { symbol => validation })
+          self.instance_variable_set(iv_symbol, opts[symbol])
         end
       end
             
@@ -104,7 +105,8 @@ class Chef
         # Raise an exception if the parameter is not found.
         def _pv_required(opts, key, is_required=true)
           if is_required
-            if opts.has_key?(key.to_s) || opts.has_key?(key.to_sym)
+            if (opts.has_key?(key.to_s) && opts[key.to_s] != nil) ||
+                (opts.has_key?(key.to_sym) && opts[key.to_sym] != nil)
               true
             else
               raise ArgumentError, "Required argument #{key} is missing!"
@@ -166,16 +168,18 @@ class Chef
         # Check a parameter against a regular expression.
         def _pv_regex(opts, key, regex)
           value = _pv_opts_lookup(opts, key)
-          passes = false
-          [ regex ].flatten.each do |r|
-            if value != nil
-              if r.match(value.to_s)
-                passes = true
+          if value != nil
+            passes = false
+            [ regex ].flatten.each do |r|
+              if value != nil
+                if r.match(value.to_s)
+                  passes = true
+                end
               end
             end
-          end
-          unless passes
-            raise ArgumentError, "Option #{key}'s value #{value} does not match regular expression #{regex.to_s}"
+            unless passes
+              raise ArgumentError, "Option #{key}'s value #{value} does not match regular expression #{regex.to_s}"
+            end
           end
         end
         
@@ -191,6 +195,15 @@ class Chef
             end
           end
         end
+
+        # Allow a parameter to default to @name
+        def _pv_name_attribute(opts, key, is_name_attribute=true)
+          if is_name_attribute
+            if opts[key] == nil
+              opts[key] = self.instance_variable_get("@name")
+            end
+          end
+        end
     end
   end
 end

data/lib/chef/mixin/recipe_definition_dsl_core.rb

@@ -20,12 +20,14 @@
 require 'chef/recipe'
 require 'chef/resource'
 require 'chef/mixin/convert_to_class_name'
+require 'chef/mixin/language'
 
 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

data/lib/chef/mixin/template.rb

@@ -22,7 +22,17 @@ require 'erubis'
 class Chef
   module Mixin
     module Template
-    
+      
+      module ChefContext
+        def node
+          return @node if @node
+          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
+      end
+      
+      ::Erubis::Context.send(:include, ChefContext)
+      
       # Render a template with Erubis.  Takes a template as a string, and a 
       # context hash.  
       def render_template(template, context)

data/lib/chef/mixin/xml_escape.rb

@@ -0,0 +1,87 @@
+#
+# Author:: Sam Ruby
+# Author:: Daniel DeLeo (<dan@opscode.com>)
+# Copyright:: Copyright (c) 2009 Opscode, Inc.
+# Copyright:: Copyright (c) 2005 Sam Ruby
+# 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.
+
+# Code adapted from Sam Ruby's xchar.rb http://intertwingly.net/stories/2005/09/28/xchar.rb
+# Thanks, Sam!
+
+class Chef
+  module Mixin
+    module XMLEscape
+      extend self
+
+      CP1252 = {
+        128 => 8364, # euro sign
+        130 => 8218, # single low-9 quotation mark
+        131 =>  402, # latin small letter f with hook
+        132 => 8222, # double low-9 quotation mark
+        133 => 8230, # horizontal ellipsis
+        134 => 8224, # dagger
+        135 => 8225, # double dagger
+        136 =>  710, # modifier letter circumflex accent
+        137 => 8240, # per mille sign
+        138 =>  352, # latin capital letter s with caron
+        139 => 8249, # single left-pointing angle quotation mark
+        140 =>  338, # latin capital ligature oe
+        142 =>  381, # latin capital letter z with caron
+        145 => 8216, # left single quotation mark
+        146 => 8217, # right single quotation mark
+        147 => 8220, # left double quotation mark
+        148 => 8221, # right double quotation mark
+        149 => 8226, # bullet
+        150 => 8211, # en dash
+        151 => 8212, # em dash
+        152 =>  732, # small tilde
+        153 => 8482, # trade mark sign
+        154 =>  353, # latin small letter s with caron
+        155 => 8250, # single right-pointing angle quotation mark
+        156 =>  339, # latin small ligature oe
+        158 =>  382, # latin small letter z with caron
+        159 =>  376 # latin capital letter y with diaeresis
+      } unless defined?(CP1252)
+
+      # http://www.w3.org/TR/REC-xml/#dt-chardata
+      PREDEFINED = {
+        38 => '&amp;', # ampersand
+        60 => '&lt;',  # left angle bracket
+        62 => '&gt;'  # right angle bracket
+      } unless defined?(PREDEFINED)
+
+      # http://www.w3.org/TR/REC-xml/#charsets
+      VALID = [[0x9, 0xA, 0xD], (0x20..0xD7FF), 
+        (0xE000..0xFFFD), (0x10000..0x10FFFF)] unless defined?(VALID)
+
+      def xml_escape(unescaped_str)
+        begin
+          unescaped_str.unpack("U*").map {|char| xml_escape_char!(char)}.join
+        rescue
+          unescaped_str.unpack("C*").map {|char| xml_escape_char!(char)}.join
+        end
+      end
+
+      private
+
+      def xml_escape_char!(char)
+        char = CP1252[char] || char
+        char = 42 unless VALID.detect {|range| range.include? char}
+        char = PREDEFINED[char] || (char<128 ? char.chr : "&##{char};")
+      end
+
+    end
+  end
+end

data/lib/chef/node.rb

@@ -1,5 +1,6 @@
 #
 # Author:: Adam Jacob (<adam@opscode.com>)
+# Author:: Christopher Brown (<cb@opscode.com>)
 # Copyright:: Copyright (c) 2008 Opscode, Inc.
 # License:: Apache License, Version 2.0
 #
@@ -20,24 +21,30 @@ require 'chef/config'
 require 'chef/mixin/check_helper'
 require 'chef/mixin/params_validate'
 require 'chef/mixin/from_file'
+require 'chef/mixin/language_include_attribute'
 require 'chef/couchdb'
-require 'chef/queue'
+require 'chef/rest'
 require 'chef/run_list'
 require 'chef/node/attribute'
+require 'chef/index_queue'
 require 'extlib'
 require 'json'
 
 class Chef
   class Node
     
-    attr_accessor :attribute, :recipe_list, :couchdb_rev, :run_state, :run_list, :override, :default
+    attr_accessor :attribute, :recipe_list, :couchdb, :couchdb_rev, :run_state, :run_list, :override_attrs, :default_attrs, :cookbook_loader
+    attr_reader :node
+    attr_reader :couchdb_id
     
     include Chef::Mixin::CheckHelper
     include Chef::Mixin::FromFile
     include Chef::Mixin::ParamsValidate
+    include Chef::Mixin::LanguageIncludeAttribute
+    include Chef::IndexQueue::Indexable
     
     DESIGN_DOCUMENT = {
-      "version" => 8,
+      "version" => 9,
       "language" => "javascript",
       "views" => {
         "all" => {
@@ -120,22 +127,39 @@ class Chef
     }
     
     # Create a new Chef::Node object.
-    def initialize()
+    def initialize(couchdb=nil)
       @name = nil
+      @node = self
 
       @attribute = Mash.new
-      @override = Mash.new
-      @default = Mash.new
-      @run_list = Chef::RunList.new 
+      @override_attrs = Mash.new
+      @default_attrs = Mash.new
+      @run_list = Chef::RunList.new
 
       @couchdb_rev = nil
-      @couchdb = Chef::CouchDB.new
+      @couchdb_id = nil
+      @couchdb = couchdb || Chef::CouchDB.new
+
       @run_state = {
         :template_cache => Hash.new,
-        :seen_recipes => Hash.new
+        :seen_recipes => Hash.new,
+        :seen_attributes => Hash.new
       }
     end
-    
+
+    def couchdb_id=(value)
+      @couchdb_id = value
+      self.index_id = value
+    end
+
+    def chef_server_rest
+      Chef::REST.new(Chef::Config[:chef_server_url])      
+    end
+
+    def self.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 
     # Chef::Config["node_path"]/fqdn.rb, then hostname.rb, then default.rb.
     # 
@@ -143,21 +167,15 @@ class Chef
     #
     # Raises an ArgumentError if it cannot find the node. 
     def find_file(fqdn)
-      node_file = nil
       host_parts = fqdn.split(".")
       hostname = host_parts[0]
-
-      if File.exists?(File.join(Chef::Config[:node_path], "#{fqdn}.rb"))
-        node_file = File.join(Chef::Config[:node_path], "#{fqdn}.rb")
-      elsif File.exists?(File.join(Chef::Config[:node_path], "#{hostname}.rb"))
-        node_file = File.join(Chef::Config[:node_path], "#{hostname}.rb")
-      elsif File.exists?(File.join(Chef::Config[:node_path], "default.rb"))
-        node_file = File.join(Chef::Config[:node_path], "default.rb")
-      end
-      unless node_file
-        raise ArgumentError, "Cannot find a node matching #{fqdn}, not even with default.rb!" 
-      end
-      self.from_file(node_file)
+      
+      [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.
@@ -179,20 +197,22 @@ class Chef
     
     # Return an attribute of this node.  Returns nil if the attribute is not found.
     def [](attrib)
-      attrs = Chef::Node::Attribute.new(@attribute, @default, @override)
-      attrs[attrib] 
+      Chef::Node::Attribute.new(@attribute, @default_attrs, @override_attrs)[attrib]
     end
     
     # Set an attribute of this node
     def []=(attrib, value)
-      attrs = Chef::Node::Attribute.new(@attribute, @default, @override)
-      attrs[attrib] = value
+      Chef::Node::Attribute.new(@attribute, @default_attrs, @override_attrs)[attrib] = value
+    end
+    
+    def store(attrib, value)
+      self[attrib] = value
     end
 
     # Set an attribute of this node, but auto-vivifiy any Mashes that might
     # be missing
     def set
-      attrs = Chef::Node::Attribute.new(@attribute, @default, @override)
+      attrs = Chef::Node::Attribute.new(@attribute, @default_attrs, @override_attrs)
       attrs.auto_vivifiy_on_read = true
       attrs
     end
@@ -200,7 +220,7 @@ class Chef
     # Set an 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, @override)
+      attrs = Chef::Node::Attribute.new(@attribute, @default_attrs, @override_attrs)
       attrs.auto_vivifiy_on_read = true
       attrs.set_unless_value_present = true
       attrs
@@ -214,53 +234,31 @@ class Chef
     # Only works on the top level. Preferred way is to use the normal [] style
     # lookup and call attribute?()
     def attribute?(attrib)
-      attrs = Chef::Node::Attribute.new(@attribute, @default, @override)
-      attrs.attribute?(attrib)
+      Chef::Node::Attribute.new(@attribute, @default_attrs, @override_attrs).attribute?(attrib)
     end
   
     # Yield each key of the top level to the block. 
     def each(&block)
-      attrs = Chef::Node::Attribute.new(@attribute, @default, @override)
-      attrs.each(&block)
+      Chef::Node::Attribute.new(@attribute, @default_attrs, @override_attrs).each(&block)
     end
     
     # Iterates over each attribute, passing the attribute and value to the block.
     def each_attribute(&block)
-      attrs = Chef::Node::Attribute.new(@attribute, @default, @override)
-      attrs.each_attribute(&block)
+      Chef::Node::Attribute.new(@attribute, @default_attrs, @override_attrs).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.
     def method_missing(symbol, *args)
-      attrs = Chef::Node::Attribute.new(@attribute, @default, @override)
-      attrs.send(symbol, *args)
+      Chef::Node::Attribute.new(@attribute, @default_attrs, @override_attrs).send(symbol, *args)
     end
     
     # Returns true if this Node expects a given recipe, false if not.
     def recipe?(recipe_name)
-      if @run_list.include?(recipe_name)
-        true
-      else
-        if @run_state[:seen_recipes].include?(recipe_name)
-          true
-        else
-          false
-        end
-      end
+      @run_list.include?(recipe_name) || @run_state[:seen_recipes].include?(recipe_name)
     end
     
-    # Returns an Array of recipes.  If you call it with arguments, they will become the new
-    # list of recipes.
-    def recipes(*args)
-      if args.length > 0
-        @run_list.reset(args)
-      else
-        @run_list
-      end
-    end
-
     # Returns true if this Node expects a given role, false if not.
     def role?(role_name)
       @run_list.include?("role[#{role_name}]")
@@ -269,11 +267,12 @@ class Chef
     # Returns an Array of roles and recipes, in the order they will be applied.
     # If you call it with arguments, they will become the new list of roles and recipes. 
     def run_list(*args)
-      if args.length > 0
-        @run_list.reset(args)
-      else
-        @run_list
-      end
+      args.length > 0 ? @run_list.reset!(args) : @run_list
+    end
+    
+    def recipes(*args)
+      Chef::Log.warn "Chef::Node#recipes method is deprecated.  Please use Chef::Node#run_list"
+      run_list(*args)
     end
 
     # Returns true if this Node expects a given role, false if not.
@@ -281,51 +280,33 @@ class Chef
       @run_list.detect { |r| r == item } ? true : false
     end
     
-    # Turns the node into an object that we can index.  I apologize up front for the
-    # super confusion that is the recursive index_flatten hash, which comes up next.
-    # Faith, young one, faith.
-    #
-    # === Returns
-    # index_hash<Hash>:: A flattened hash of all the nodes attributes, suitable for indexing.
-    def to_index
-      index_hash = {
-        "index_name" => "node",
-        "id" => "node_#{@name}",
-        "name" => @name,
-      }
-      @attribute.each do |key, value|
-        if value.kind_of?(Hash) || value.kind_of?(Mash)
-          index_flatten_hash(key, value).each do |to_index|
-            to_index.each do |nk, nv|
-              index_hash[nk] = nv
-            end
-          end
+    def consume_attributes(attrs)
+      attrs ||= {}
+      Chef::Log.debug("Adding JSON Attributes")
+      attrs.each do |key, value|
+        if ["recipes", "run_list"].include?(key)
+          run_list(value)
         else
-          index_hash[key] = value
+          Chef::Log.debug("JSON Attribute: #{key} - #{value.inspect}")
+          store(key, value)
         end
       end
-      index_hash["recipe"] = @run_list.recipes if @run_list.recipes.length > 0
-      index_hash["roles"] = @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
+      self[:tags] = Array.new unless attribute?(:tags)
+      
     end
     
-    # Ah, song of my heart, index_flatten_hash.  This method flattens a hash in preparation
-    # for indexing, by appending the name of it's parent to a current key with an _.  Hence,
-    # node[:bar][:baz] = 'monkey' becomes bar_baz:monkey.
-    #
-    # === Returns
-    # results<Array>:: An array of hashes with one element.
-    def index_flatten_hash(parent_name, hash)
-      results = Array.new
-      hash.each do |k, v|
-        if v.kind_of?(Hash) || v.kind_of?(Mash)
-          results << index_flatten_hash("#{parent_name}_#{k}", v)
-        else
-          results << { "#{parent_name}_#{k}", v }
-        end
+    # Transform the node to a Hash
+    def to_hash
+      index_hash = Hash.new
+      self.each do |k, v|
+        index_hash[k] = v
       end
-      results.flatten
+      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
     end
     
     # Serialize this object as a hash 
@@ -335,6 +316,8 @@ class Chef
         'json_class' => self.class.name,
         "attributes" => @attribute,
         "chef_type" => "node",
+        "defaults" => @default_attrs,
+        "overrides" => @override_attrs,
         "run_list" => @run_list.run_list,
       }
       result["_rev"] = @couchdb_rev if @couchdb_rev
@@ -345,62 +328,101 @@ class Chef
     def self.json_create(o)
       node = new
       node.name(o["name"])
-      o["attributes"].each do |k,v|
-        node[k] = v
-      end
-      if o.has_key?("defaults")
-        node.default = o["defaults"]
-      end
-      if o.has_key?("overrides")
-        node.override = o["overrides"]
-      end
+      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?("run_list")
-        node.run_list.reset(o["run_list"])
+        node.run_list.reset!(o["run_list"])
       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
     
     # 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)
-      rs = Chef::CouchDB.new.list("nodes", inflate)
       if inflate
-        rs["rows"].collect { |r| r["value"] }
+        response = Hash.new
+        Chef::Search::Query.new.search(:node) do |n|
+          response[n.name] = n unless n.nil?
+        end
+        response
       else
-        rs["rows"].collect { |r| r["key"] }
+        Chef::REST.new(Chef::Config[:chef_server_url]).get_rest("nodes")
       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
+    
+    # Load a node by name
     def self.load(name)
-      Chef::CouchDB.new.load("node", name)
+      Chef::REST.new(Chef::Config[:chef_server_url]).get_rest("nodes/#{name}")
     end
     
     # Remove this node from the CouchDB
-    def destroy
-      Chef::Queue.send_msg(:queue, :remove, self)
+    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
-      Chef::Queue.send_msg(:queue, :index, self)
-      results = @couchdb.store("node", @name, self)
-      @couchdb_rev = results["rev"]
+      begin
+        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)
+      end
+      self
     end
     
+    # Create the node via the REST API
+    def create
+      chef_server_rest.post_rest("nodes", self)
+      self
+    end 
+
     # Set up our CouchDB design document
-    def self.create_design_document
-      Chef::CouchDB.new.create_design_document("nodes", DESIGN_DOCUMENT)
+    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}]"
     end
-    
+
   end
 end