chef 0.8.16 → 0.9.0.a3

data/distro/redhat/etc/logrotate.d/chef-client

@@ -0,0 +1,8 @@
+/var/log/chef/client.log {
+  rotate 12
+  weekly
+  compress
+  postrotate
+    /etc/init.d/chef-client condrestart >/dev/null || :
+  endscript
+}

data/distro/redhat/etc/logrotate.d/chef-server

@@ -0,0 +1,8 @@
+/var/log/chef/server.log {
+  rotate 12
+  weekly
+  compress
+  postrotate
+    /etc/init.d/chef-server condrestart >/dev/null || :
+  endscript
+}

data/distro/redhat/etc/logrotate.d/chef-server-webui

@@ -0,0 +1,8 @@
+/var/log/chef/server-webui.log {
+  rotate 12
+  weekly
+  compress
+  postrotate
+    /etc/init.d/chef-server-webui condrestart >/dev/null || :
+  endscript
+}

data/distro/redhat/etc/logrotate.d/chef-solr

@@ -0,0 +1,8 @@
+/var/log/chef/solr.log {
+  rotate 12
+  weekly
+  compress
+  postrotate
+    /etc/init.d/chef-solr condrestart >/dev/null || :
+  endscript
+}

data/distro/redhat/etc/logrotate.d/chef-solr-indexer

@@ -0,0 +1,8 @@
+/var/log/chef/solr-indexer.log {
+  rotate 12
+  weekly
+  compress
+  postrotate
+    /etc/init.d/chef-solr-indexer condrestart >/dev/null || :
+  endscript
+}

data/distro/redhat/etc/sysconfig/chef-client

@@ -1,10 +1,15 @@
 # Configuration file for the chef-client service
 
-#PIDFILE=/var/run/chef/client.pid
 #CONFIG=/etc/chef/client.rb
-#CHEF_USER=root
-#CHEF_GROUP=root
+#PIDFILE=/var/run/chef/client.pid
+#LOCKFILE=/var/lock/subsys/chef-client
+#LOGFILE=/var/log/chef/client.log
+# Sleep interval between runs.
+# This value is in seconds.
 #INTERVAL=1800
+# Maximum amount of random delay before starting a run. Prevents every client
+# from contacting the server at the exact same time.
+# This value is in seconds.
 #SPLAY=20
-#LOGFILE=/var/log/chef/client.log
+# Any additional chef-client options.
 #OPTIONS=

data/distro/redhat/etc/sysconfig/chef-server

@@ -1,10 +1,14 @@
 # Configuration file for the chef-server service
 
-#CHILDPIDFILES=/var/run/chef/server.%s.pid
-#PIDFILE=/var/run/chef/server.pid
 #CONFIG=/etc/chef/server.rb
-#CHEF_USER=chef
-#CHEF_GROUP=chef
-#CLUSTER_NODES=1
-#LOGFILE=/var/log/chef/merb.%s.log
+#PIDFILE=/var/run/chef/server.pid
+#LOCKFILE=/var/lock/subsys/chef-server
+#LOGFILE=/var/log/chef/server.log
+#PORT=4000
+#ENVIRONMENT=production
+#ADAPTER=thin
+#CHILDPIDFILES=/var/run/chef/server.%s.pid
+#SERVER_USER=chef
+#SERVER_GROUP=chef
+# Any additional chef-server options.
 #OPTIONS=

data/distro/redhat/etc/sysconfig/chef-server-webui

@@ -1,10 +1,14 @@
 # Configuration file for the chef-server-webui service
 
-#CHILDPIDFILES=/var/run/chef/server-webui.%s.pid
+#CONFIG=/etc/chef/webui.rb
 #PIDFILE=/var/run/chef/server-webui.pid
-#CONFIG=/etc/chef/server.rb
-#CHEF_USER=chef
-#CHEF_GROUP=chef
-#CLUSTER_NODES=1
-#LOGFILE=/var/log/chef/merb-webui.%s.log
+#LOCKFILE=/var/lock/subsys/chef-server-webui
+#LOGFILE=/var/log/chef/server-webui.log
+#PORT=4040
+#ENVIRONMENT=production
+#ADAPTER=thin
+#CHILDPIDFILES=/var/run/chef/server-webui.%s.pid
+#SERVER_USER=chef
+#SERVER_GROUP=chef
+# Any additional chef-server-webui options.
 #OPTIONS=

data/distro/redhat/etc/sysconfig/chef-solr

@@ -1,9 +1,8 @@
 # Configuration file for the chef-solr service
 
+#CONFIG=/etc/chef/solr.rb
 #PIDFILE=/var/run/chef/solr.pid
-#CONFIG=/etc/chef/server.rb
-#CHEF_USER=chef
-#CHEF_GROUP=chef
+#LOCKFILE=/var/lock/subsys/chef-solr
 #LOGFILE=/var/log/chef/solr.log
-# options for Java. Need to start with -j followed by options..
+# Options for Java. Need to start with -j followed by options.
 #OPTIONS="-j "

data/distro/redhat/etc/sysconfig/chef-solr-indexer

@@ -1,7 +1,7 @@
 # Configuration file for the chef-solr-indexer service
 
 #PIDFILE=/var/run/chef/solr-indexer.pid
-#CONFIG=/etc/chef/server.rb
-#CHEF_USER=chef
-#CHEF_GROUP=chef
+#CONFIG=/etc/chef/solr-indexer.rb
 #LOGFILE=/var/log/chef/solr-indexer.log
+# Any additional chef-solr-indexer options.
+#OPTIONS=

data/lib/chef.rb

@@ -16,22 +16,22 @@
 # limitations under the License.
 #
 
+require 'chef/version'
+
 require 'extlib'
 require 'chef/exceptions'
 require 'chef/log'
 require 'chef/config'
 require 'chef/providers'
 require 'chef/resources'
+require 'chef/shell_out'
 
-require 'chef/compile'
 require 'chef/daemon'
-require 'chef/runner'
 require 'chef/webui_user'
 require 'chef/openid_registration'
 
-class Chef
-  VERSION = "0.8.16"
-end
+require 'chef/handler'
+require 'chef/handler/json_file'
 
 # Adds a Dir.glob to Ruby 1.8.5, for compat
 if RUBY_VERSION < "1.8.6" || RUBY_PLATFORM =~ /mswin|mingw32|windows/
@@ -51,3 +51,14 @@ if RUBY_VERSION < "1.8.6" || RUBY_PLATFORM =~ /mswin|mingw32|windows/
     end 
   end 
 end 
+
+
+# On ruby 1.9, Strings are aware of multibyte characters, so #size and length
+# give the actual number of characters. In Chef::REST, we need the bytesize
+# so we can correctly set the Content-Length headers, but ruby 1.8.6 and lower
+# don't define String#bytesize. Monkey patching time!
+class String
+  unless method_defined?(:bytesize)
+    alias :bytesize :size
+  end
+end

data/lib/chef/application/knife.rb

@@ -36,7 +36,6 @@ class Chef::Application::Knife < Chef::Application
   option :config_file, 
     :short => "-c CONFIG",
     :long  => "--config CONFIG",
-    :default => File.join(ENV['HOME'], '.chef', 'knife.rb'),
     :description => "The configuration file to use"
 
   option :log_level, 
@@ -96,7 +95,7 @@ class Chef::Application::Knife < Chef::Application
     :description => "Show the data after a destructive operation"
 
   option :format,
-    :short => "-f FORMAT",
+    :short => "-F FORMAT",
     :long => "--format FORMAT",
     :description => "Which format to use for output",
     :default => "json"
@@ -114,6 +113,7 @@ class Chef::Application::Knife < Chef::Application
     validate_and_parse_options
     knife = Chef::Knife.find_command(ARGV, self.class.options)
     knife.run
+    exit 0
   end
   
   private

data/lib/chef/application/solo.rb

@@ -95,12 +95,6 @@ class Chef::Application::Solo < Chef::Application
     :description => "The splay time for running at intervals, in seconds",
     :proc => lambda { |s| s.to_i }
 
-  option :json_attribs,
-    :short => "-j JSON_ATTRIBS",
-    :long => "--json-attributes JSON_ATTRIBS",
-    :description => "Load attributes from a JSON file or URL",
-    :proc => nil
-  
   option :recipe_url,
       :short => "-r RECIPE_URL",
       :long => "--recipe-url RECIPE_URL",
@@ -195,7 +189,7 @@ class Chef::Application::Solo < Chef::Application
           sleep splay
         end
 
-        @chef_solo.run_solo
+        @chef_solo.run
         
         if Chef::Config[:interval]
           Chef::Log.debug("Sleeping for #{Chef::Config[:interval]} seconds")

data/lib/chef/cache/checksum.rb

@@ -19,6 +19,7 @@
 #
 
 require 'chef/cache'
+require 'digest/md5'
 
 class Chef
   class Cache
@@ -44,7 +45,7 @@ class Chef
       end
       
       def generate_checksum(key, file, fstat)
-        checksum = checksum_file(file)
+        checksum = checksum_file(file, Digest::SHA256.new)
         moneta.store(key, {"mtime" => fstat.mtime.to_f, "checksum" => checksum})
         checksum
       end
@@ -52,19 +53,25 @@ class Chef
       def generate_key(file, group="chef")
         "#{group}-file-#{file.gsub(/(#{File::SEPARATOR}|\.)/, '-')}"
       end
-
+      
+      def self.generate_md5_checksum_for_file(*args)
+        instance.generate_md5_checksum_for_file(*args)
+      end
+      
+      def generate_md5_checksum_for_file(file)
+        checksum_file(file, Digest::MD5.new)
+      end
+      
       private
       
       def file_unchanged?(cached, fstat)
         cached["mtime"].to_f == fstat.mtime.to_f
       end
       
-      def checksum_file(file)
-        digest = Digest::SHA256.new
+      def checksum_file(file, digest)
         IO.foreach(file) {|line| digest.update(line) }
         digest.hexdigest
       end
-
     end
   end
 end

data/lib/chef/cache/file_cache_by_checksum.rb

@@ -0,0 +1,52 @@
+#
+# Author:: Tim Hinderliter (<tim@opscode.com>)
+# Author:: Christopher Walters (<cw@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.
+#
+
+class Chef
+  class Cache
+    class FileCacheByChecksum
+      attr_reader :basedir
+      
+      def initialize(basedir = Chef::Config[:file_cache_path])
+        @basedir = basedir
+      end
+
+      # returns path
+      def get_path(checksum)
+        path = checksum_path(checksum)
+        
+        File.exists?(path) ? path : nil
+      end
+      
+      # path = path to tempfile as input
+      # returns destination path
+      def put(checksum, src_path)
+        dest_path = checksum_path(checksum)
+        FileUtils.mkdir_p(File.dirname(dest_path))
+      
+        FileUtils.cp(src_path, dest_path)
+        
+        dest_path
+      end
+      
+      def checksum_path(checksum)
+        File.join(basedir, checksum[0..1], checksum)
+      end
+    end
+  end
+end

data/lib/chef/checksum.rb

@@ -0,0 +1,115 @@
+#
+# Author:: Tim Hinderliter (<tim@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/log'
+require 'uuidtools'
+
+
+# Checksum for an individual file; e.g., used for sandbox/cookbook uploading
+# to track which files the system already manages.
+class Chef
+  class Checksum
+    attr_accessor :checksum, :create_time
+    attr_accessor :couchdb_id, :couchdb_rev
+    
+    DESIGN_DOCUMENT = {
+      "version" => 1,
+      "language" => "javascript",
+      "views" => {
+        "all" => {
+          "map" => <<-EOJS
+          function(doc) { 
+            if (doc.chef_type == "checksum") {
+              emit(doc.checksum, doc);
+            }
+          }
+          EOJS
+        },
+      }
+    }
+    
+    # Creates a new Chef::Checksum object.  
+    #
+    # === Returns
+    # object<Chef::Checksum>:: Duh. :)
+    def initialize(checksum=nil, couchdb=nil)
+      @create_time = Time.now.iso8601
+      @checksum = checksum
+    end
+    
+    def to_json(*a)
+      result = {
+        :checksum => checksum,
+        :create_time => create_time,
+        :json_class => self.class.name,
+        :chef_type => 'checksum',
+
+        # For Chef::CouchDB (id_to_name, name_to_id)
+        :name => checksum
+      }
+      result.to_json(*a)
+    end
+
+    def self.json_create(o)
+      checksum = new(o['checksum'])
+      checksum.create_time = o['create_time']
+
+      if o.has_key?('_rev')
+        checksum.couchdb_rev = o["_rev"]
+        o.delete("_rev")
+      end
+      if o.has_key?("_id")
+        checksum.couchdb_id = o["_id"]
+        o.delete("_id")
+      end
+      checksum
+    end
+
+    ##
+    # Couchdb
+    ##
+
+    def self.create_design_document(couchdb=nil)
+      (couchdb || Chef::CouchDB.new).create_design_document("checksums", DESIGN_DOCUMENT)
+    end
+    
+    def self.cdb_list(inflate=false, couchdb=nil)
+      rs = (couchdb || Chef::CouchDB.new).list("checksums", inflate)
+      lookup = (inflate ? "value" : "key")
+      rs["rows"].collect { |r| r[lookup] }        
+    end
+    
+    def self.cdb_all_checksums(couchdb = nil)
+      rs = (couchdb || Chef::CouchDB.new).list("checksums", true)
+      rs["rows"].inject({}) { |hash_result, r| hash_result[r['key']] = 1; hash_result }
+    end
+
+    def self.cdb_load(checksum, couchdb=nil)
+      # Probably want to look for a view here at some point
+      (couchdb || Chef::CouchDB.new).load("checksum", checksum)
+    end
+
+    def cdb_destroy(couchdb=nil)
+      (couchdb || Chef::CouchDB.new).delete("checksum", checksum, @couchdb_rev)
+    end
+
+    def cdb_save(couchdb=nil)
+      @couchdb_rev = (couchdb || Chef::CouchDB.new).store("checksum", checksum, self)["rev"]
+    end
+
+  end
+end

data/lib/chef/client.rb

@@ -2,7 +2,8 @@
 # Author:: Adam Jacob (<adam@opscode.com>)
 # Author:: Christopher Walters (<cw@opscode.com>)
 # Author:: Christopher Brown (<cb@opscode.com>)
-# Copyright:: Copyright (c) 2008 Opscode, Inc.
+# 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");
@@ -19,25 +20,24 @@
 
 require 'chef/config'
 require 'chef/mixin/params_validate'
-require 'chef/mixin/generate_url'
-require 'chef/mixin/checksum'
 require 'chef/log'
 require 'chef/rest'
 require 'chef/platform'
 require 'chef/node'
 require 'chef/role'
 require 'chef/file_cache'
-require 'chef/compile'
+require 'chef/run_context'
 require 'chef/runner'
+require 'chef/cookbook/cookbook_collection'
+require 'chef/cookbook/file_vendor'
+require 'chef/cookbook/file_system_file_vendor'
 require 'ohai'
 
 class Chef
   class Client
-    
-    include Chef::Mixin::GenerateURL
-    include Chef::Mixin::Checksum
-    
-    attr_accessor :node, :registration, :json_attribs, :node_name, :ohai, :rest
+    # TODO: timh/cw: 5-19-2010: json_attribs should be moved to RunContext?
+    attr_accessor :node, :registration, :json_attribs, :node_name, :ohai, :rest, :runner
+    attr_reader :node_exists
     
     # Creates a new Chef::Client.
     def initialize()
@@ -46,72 +46,95 @@ class Chef
       @json_attribs = nil
       @node_name = nil
       @node_exists = true
+      @runner = nil
       @ohai = Ohai::System.new
       Chef::Log.verbose = Chef::Config[:verbose_logging]
       Mixlib::Authentication::Log.logger = Ohai::Log.logger = Chef::Log.logger
       @ohai_has_run = false
-      @rest = if File.exists?(Chef::Config[:client_key])
-                Chef::REST.new(Chef::Config[:chef_server_url])
-              else
-                Chef::REST.new(Chef::Config[:chef_server_url], nil, nil)
-              end
     end
     
     # Do a full run for this Chef::Client.  Calls:
-    # 
+    #
+    #  * run_ohai - Collect information about the system
     #  * build_node - Get the last known state, merge with local changes
-    #  * register - Make sure we have an openid
-    #  * authenticate - Authenticate with our openid
-    #  * sync_library_files - Populate the local cache with all the library files
-    #  * sync_provider_files - Populate the local cache with all the provider files
-    #  * sync_resource_files - Populate the local cache with all the resource files
-    #  * sync_attribute_files - Populate the local cache with all the attribute files
-    #  * sync_definitions - Populate the local cache with all the definitions
-    #  * sync_recipes - Populate the local cache with all the recipes
-    #  * do_attribute_files - Populate the local cache with all attributes, and execute them
-    #  * save_node - Store the new node configuration
-    #  * converge - Bring this system up to date, based on the local cache
-    #  * save_node - Store the node again, in case convergence altered future state
+    #  * register - If not in solo mode, make sure the server knows about this client
+    #  * sync_cookbooks - If not in solo mode, populate the local cache with the node's cookbooks
+    #  * converge - Bring this system up to date
     #
     # === Returns
     # true:: Always returns true.
     def run
-      start_time = Time.now
-      Chef::Log.info("Starting Chef Run")
-      
+      self.runner = nil
+      run_context = nil
+
+      run_ohai
       determine_node_name
-      register
-      build_node(@node_name)
-      save_node
-      sync_cookbooks
-      converge
-      save_node
+      register unless Chef::Config[:solo]
+      build_node
       
-      end_time = Time.now
-      Chef::Log.info("Chef Run complete in #{end_time - start_time} seconds")
-      true
+      begin
+        start_time = Time.now
+        Chef::Log.info("Starting Chef Run")
+        
+        if Chef::Config[:solo]
+          Chef::Cookbook::FileVendor.on_create { |manifest| Chef::Cookbook::FileSystemFileVendor.new(manifest) }
+          run_context = Chef::RunContext.new(node, Chef::CookbookCollection.new(Chef::CookbookLoader.new))
+          assert_cookbook_path_not_empty(run_context)
+          converge(run_context)
+        else
+          save_node
+          
+          # Note: When we move to lazily loading all cookbook files,
+          # replace sync_cookbooks with a method that simply gets the
+          # cookbook manifests from the remote server (and their
+          # download URLs) from the server and feeds them to
+          # RemoteFileVendors. [cw/tim-5/11/2010, 5/23/2010]
+          Chef::Cookbook::FileVendor.on_create { |manifest| Chef::Cookbook::FileSystemFileVendor.new(manifest) }
+#          Chef::Cookbook::FileVendor.on_create { |manifest| Chef::Cookbook::RemoteFileVendor.new(manifest) }
+          sync_cookbooks
+          run_context = Chef::RunContext.new(node, Chef::CookbookCollection.new(Chef::CookbookLoader.new))
+          assert_cookbook_path_not_empty(run_context)
+          save_node
+          
+          converge(run_context)
+          save_node
+        end
+        
+        end_time = Time.now
+        elapsed_time = end_time - start_time
+        Chef::Log.info("Chef Run complete in #{elapsed_time} seconds")
+        run_report_handlers(start_time, end_time, elapsed_time) 
+        true
+      rescue Exception => e
+        run_exception_handlers(node, runner ? runner : run_context, start_time, end_time, elapsed_time, e)
+        Chef::Log.error("Re-raising exception: #{e.class} - #{e.message}\n#{e.backtrace.join("\n  ")}")
+        raise
+      end
     end
-    
-    # Similar to Chef::Client#run, but instead of talking to the Chef server,
-    # simply runs in a standalone ("solo") mode.
-    #
-    # Someday, we'll have chef_chewbacca.
-    #
-    # === Returns
-    # true:: Always returns true.
-    def run_solo
-      start_time = Time.now
-      Chef::Log.info("Starting Chef Solo Run")
 
-      determine_node_name
-      build_node(@node_name, true)
-      converge(true)
-      
-      end_time = Time.now
-      Chef::Log.info("Chef Run complete in #{end_time - start_time} seconds")
-      true
+    def run_report_handlers(start_time, end_time, elapsed_time)
+      if Chef::Config[:report_handlers].length > 0
+        Chef::Log.info("Running report handlers")
+        Chef::Config[:report_handlers].each do |handler|
+          handler.report(node, runner, start_time, end_time, elapsed_time)
+        end
+        Chef::Log.info("Report handlers complete")
+      end
     end
 
+    def run_exception_handlers(node, runner, start_time, end_time, elapsed_time, exception)
+      if Chef::Config[:exception_handlers].length > 0
+        end_time   ||= Time.now
+        elapsed_time ||= end_time - start_time 
+        Chef::Log.error("Received exception: #{exception.message}")
+        Chef::Log.error("Running exception handlers")
+        Chef::Config[:exception_handlers].each do |handler|
+          handler.report(node, runner, start_time, end_time, elapsed_time, exception)
+        end
+        Chef::Log.error("Exception handlers complete")
+      end
+    end
+    
     def run_ohai
       if ohai.keys
         ohai.refresh_plugins
@@ -121,55 +144,53 @@ class Chef
     end
 
     def determine_node_name
-      run_ohai      
       unless node_name
         if Chef::Config[:node_name]
-          @node_name = Chef::Config[:node_name]
+          self.node_name = Chef::Config[:node_name]
         else
-          @node_name ||= ohai[:fqdn] ? ohai[:fqdn] : ohai[:hostname]
-          Chef::Config[:node_name] = @node_name
+          self.node_name = ohai[:fqdn] ? ohai[:fqdn] : ohai[:hostname]
+          Chef::Config[:node_name] = node_name
         end
+
+        raise RuntimeError, "Unable to determine node name from ohai" unless node_name
       end
-      @node_name
+      node_name
     end
-
+    
     # Builds a new node object for this client.  Starts with querying for the FQDN of the current
     # host (unless it is supplied), then merges in the facts from Ohai.
     #
-    # === Parameters
-    # node_name<String>:: The name of the node to build - defaults to nil
-    #
     # === Returns
     # node<Chef::Node>:: Returns the created node object, also stored in @node
-    def build_node(node_name=nil, solo=false)
-      node_name ||= determine_node_name
-      raise RuntimeError, "Unable to determine node name from ohai" unless node_name
-      Chef::Log.debug("Building node object for #{@node_name}")
-
-      unless solo
-        @node = begin
-                  rest.get_rest("nodes/#{@node_name}")
-                rescue Net::HTTPServerException => e
-                  raise unless e.message =~ /^404/
-                end
-      end
+    def build_node
+      Chef::Log.debug("Building node object for #{node_name}")
       
-      unless @node
-        @node_exists = false
-        @node ||= Chef::Node.new
-        @node.name(node_name)
+      unless Chef::Config[:solo]
+        self.node = begin
+                      rest.get_rest("nodes/#{node_name}")
+                    rescue Net::HTTPServerException => e
+                      raise unless e.message =~ /^404/
+                    end
       end
       
-      @node.consume_attributes(@json_attribs)
-      
-      ohai.each do |field, value|
-        Chef::Log.debug("Ohai Attribute: #{field} - #{value.inspect}")
-        @node[field] = value
+      unless node
+        @node_exists = false
+        self.node = Chef::Node.new
+        node.name(node_name)
       end
-      platform, version = Chef::Platform.find_platform_and_version(@node)
+
+      node.consume_attributes(json_attribs)
+    
+      node.automatic_attrs = ohai.data
+
+      platform, version = Chef::Platform.find_platform_and_version(node)
       Chef::Log.debug("Platform is #{platform} version #{version}")
-      @node[:platform] = platform
-      @node[:platform_version] = version
+      @node.automatic_attrs[:platform] = platform
+      @node.automatic_attrs[:platform_version] = version
+      # We clear defaults and overrides, so that any deleted attributes between runs are
+      # still gone.
+      @node.default_attrs = Mash.new
+      @node.override_attrs = Mash.new
       @node
     end
    
@@ -181,10 +202,10 @@ class Chef
         Chef::Log.debug("Client key #{Chef::Config[:client_key]} is present - skipping registration")
       else
         Chef::Log.info("Client key #{Chef::Config[:client_key]} is not present - registering")
-        Chef::REST.new(Chef::Config[:client_url], Chef::Config[:validation_client_name], Chef::Config[:validation_key]).register(@node_name, Chef::Config[:client_key])
+        Chef::REST.new(Chef::Config[:client_url], Chef::Config[:validation_client_name], Chef::Config[:validation_key]).register(node_name, Chef::Config[:client_key])
       end
       # We now have the client key, and should use it from now on.
-      self.rest = Chef::REST.new(Chef::Config[:chef_server_url])
+      self.rest = Chef::REST.new(Chef::Config[:chef_server_url], node_name, Chef::Config[:client_key])
     end
     
     # Update the file caches for a given cache segment.  Takes a segment name
@@ -194,71 +215,52 @@ class Chef
     # === Parameters
     # segment<String>:: The cache segment to update
     # remote_list<Hash>:: A cookbooks/_attribute_files style remote file listing
-    def update_file_cache(cookbook_name, parts)  
-      Chef::Log.debug("Synchronizing cookbook #{cookbook_name}")
+    def sync_cookbook_file_cache(cookbook)
+      Chef::Log.debug("Synchronizing cookbook #{cookbook.name}")
 
-      file_canonical = Hash.new
+      filenames_seen = Hash.new
 
-      [ "recipes", "attributes", "definitions", "libraries", "resources", "providers" ].each do |segment|
-        remote_list = parts.has_key?(segment) ? parts[segment] : []
-
-        # segement = cookbook segment
-        # remote_list = list of file hashes
-        #
-        # We need the list of known good attribute files, so we can delete any that are
-        # just laying about.
+      Chef::CookbookVersion::COOKBOOK_SEGMENTS.each do |segment|
+        cookbook.manifest[segment].each do |manifest_record|
+          # segment = cookbook segment
+          # remote_list = list of file hashes
+          #
+          # We need the list of known good attribute files, so we can delete any that are
+          # just laying about.
         
-        remote_list.each do |rf|
-          cache_file = File.join("cookbooks", cookbook_name, segment, rf['name'])
-          file_canonical[cache_file] = true
+          cache_filename = File.join("cookbooks", cookbook.name, manifest_record['path'])
+          filenames_seen[cache_filename] = true
 
-          # For back-compat between older clients and new chef servers
-          rf['checksum'] ||= nil 
-        
           current_checksum = nil
-          if Chef::FileCache.has_key?(cache_file)
-            current_checksum = checksum(Chef::FileCache.load(cache_file, false))
+          if Chef::FileCache.has_key?(cache_filename)
+            current_checksum = Chef::CookbookVersion.checksum_cookbook_file(Chef::FileCache.load(cache_filename, false))
           end
-
-          if current_checksum != rf['checksum']
-            rf_url = generate_cookbook_url(
-              rf['name'], 
-              cookbook_name, 
-              segment, 
-              @node, 
-              current_checksum ? { 'checksum' => current_checksum } : nil
-            )
-
-            changed = true
-            begin
-              raw_file = rest.get_rest(rf_url, true)
-            rescue Net::HTTPRetriableError => e
-              if e.response.kind_of?(Net::HTTPNotModified)
-                changed = false
-                Chef::Log.debug("Cache file #{cache_file} is unchanged")
-              else
-                raise e
-              end
-            end
-
-            if changed
-              Chef::Log.info("Storing updated #{cache_file} in the cache.")
-              Chef::FileCache.move_to(raw_file.path, cache_file)
-            end
+          
+          # If the checksums are different between on-disk (current) and on-server
+          # (remote, per manifest), do the update. This will also execute if there
+          # is no current checksum.
+          if current_checksum != manifest_record['checksum']
+            raw_file = rest.get_rest(manifest_record[:url], true)
+            
+            Chef::Log.info("Storing updated #{cache_filename} in the cache.")
+            Chef::FileCache.move_to(raw_file.path, cache_filename)
+          else
           end
         end
-
       end
 
-      Chef::FileCache.list.each do |cache_file|
-        if cache_file =~ /^cookbooks\/#{cookbook_name}\/(recipes|attributes|definitions|libraries|resources|providers)\//
-          unless file_canonical[cache_file]
-            Chef::Log.info("Removing #{cache_file} from the cache; it is no longer on the server.")
-            Chef::FileCache.delete(cache_file)
-          end
+      filenames_seen
+    end
+    
+    def cleanup_file_cache(valid_cache_entries)
+      # Delete each file in the cache that we didn't encounter in the
+      # manifest.
+      Chef::FileCache.list.each do |cache_filename|
+        unless valid_cache_entries[cache_filename]
+          Chef::Log.info("Removing #{cache_filename} from the cache; it is no longer on the server.")
+          Chef::FileCache.delete(cache_filename)
         end
       end
-      
     end
 
     # Synchronizes all the cookbooks from the chef-server.
@@ -267,8 +269,10 @@ class Chef
     # true:: Always returns true
     def sync_cookbooks
       Chef::Log.debug("Synchronizing cookbooks")
-      cookbook_hash = rest.get_rest("nodes/#{@node_name}/cookbooks")
+      cookbook_hash = rest.get_rest("nodes/#{node_name}/cookbooks")
       Chef::Log.debug("Cookbooks to load: #{cookbook_hash.inspect}")
+
+      # Remove all cookbooks no longer relevant to this node
       Chef::FileCache.list.each do |cache_file|
         if cache_file =~ /^cookbooks\/(.+?)\//
           unless cookbook_hash.has_key?($1)
@@ -277,9 +281,17 @@ class Chef
           end
         end
       end
-      cookbook_hash.each do |cookbook_name, parts|
-        update_file_cache(cookbook_name, parts)
+
+      # Synchronize each of the node's cookbooks
+      valid_cache_entries = cookbook_hash.values.inject({}) do |memo, cookbook|
+        memo.merge!(sync_cookbook_file_cache(cookbook))
+        memo
       end
+
+      cleanup_file_cache(valid_cache_entries)
+      
+      # register the file cache path in the cookbook path so that CookbookLoader actually picks up the synced cookbooks
+      Chef::Config[:cookbook_path] = File.join(Chef::Config[:file_cache_path], "cookbooks")
     end
     
     # Updates the current node configuration on the server.
@@ -287,31 +299,39 @@ class Chef
     # === Returns
     # true:: Always returns true
     def save_node
-      Chef::Log.debug("Saving the current state of node #{@node_name}")
-      @node = begin
-                if @node_exists
-                  rest.put_rest("nodes/#{@node_name}", @node)
-                else
-                  result = rest.post_rest("nodes", @node)
-                  @node_exists = true
-                  rest.get_rest(result['uri'])
-                end
-              rescue
-                nil
-              end
+      Chef::Log.debug("Saving the current state of node #{node_name}")
+      self.node = if node_exists
+                    rest.put_rest("nodes/#{node_name}", node)
+                  else
+                    result = rest.post_rest("nodes", node)
+                    @node_exists = true
+                    rest.get_rest(result['uri'])
+                  end
     end
-    
-    # Compiles the full list of recipes for the server, and passes it to an instance of
-    # Chef::Runner.converge.
+
+    # Converges the node.
     #
     # === Returns
     # true:: Always returns true
-    def converge(solo=false)
-      Chef::Log.debug("Compiling recipes for node #{@node_name}")
-      unless solo
-        Chef::Config[:cookbook_path] = File.join(Chef::Config[:file_cache_path], "cookbooks")
-        Chef::Log.warn("Node #{@node_name} has an empty run list.") if @node.run_list.empty?
-      else
+    def converge(run_context)
+      Chef::Log.debug("Converging node #{node_name}")
+      self.runner = Chef::Runner.new(run_context)
+      runner.converge
+      true
+    end
+    
+    private
+    
+    def directory_not_empty?(path)
+      File.exists?(path) && (Dir.entries(path).size > 2)
+    end
+    
+    def is_last_element?(index, object)
+      object.kind_of?(Array) ? index == object.size - 1 : true 
+    end  
+    
+    def assert_cookbook_path_not_empty(run_context)
+      if Chef::Config[:solo]
         # Check for cookbooks in the path given
         # Chef::Config[:cookbook_path] can be a string or an array
         # if it's an array, go through it and check each one, raise error at the last one if no files are found
@@ -325,23 +345,11 @@ class Chef
             raise Chef::Exceptions::CookbookNotFound, msg if is_last_element?(index, Chef::Config[:cookbook_path])
           end
         end
+      else
+        Chef::Log.warn("Node #{node_name} has an empty run list.") if run_context.node.run_list.empty?
       end
-      compile = Chef::Compile.new(@node)
-      
-      Chef::Log.debug("Converging node #{@node_name}")
-      Chef::Runner.new(@node, compile.collection, compile.definitions, compile.cookbook_loader).converge
-      true
-    end
-    
-    private
-    
-    def directory_not_empty?(path)
-      File.exists?(path) && (Dir.entries(path).size > 2)
-    end
-    
-    def is_last_element?(index, object)
-      object.kind_of?(Array) ? index == object.size - 1 : true 
-    end  
 
+    end
   end
 end
+