7 files changed, 106 insertions, 669 deletions

diff --git a/bin/puppetd b/bin/puppetd
index cc60d8cdc..ecea2d894 100755
--- a/bin/puppetd
+++ b/bin/puppetd
@@ -328,23 +328,20 @@ end
 Puppet::SSL::Host.ca_location = :remote
 
 Puppet::Transaction::Report.terminus_class = :rest
-Puppet::Node::Facts.terminus_class = :facter
-Puppet::Node::Facts.cache_class = :rest
 
+# We need tomake the client either way, we just don't start it
+# if --no-client is set.
+client = Puppet::Network::Client.master.new(args)
 if options[:enable]
-    Puppet::Agent.enable
+    client.enable
 elsif options[:disable]
-    Puppet::Agent.disable
+    client.disable
 end
 
 if options[:enable] or options[:disable]
     exit(0)
 end
 
-# We need tomake the client either way, we just don't start it
-# if --no-client is set.
-client = Puppet::Network::Client.master.new(args)
-
 server = nil
 
 # It'd be nice to daemonize later, but we have to daemonize before the
diff --git a/lib/puppet/agent.rb b/lib/puppet/agent.rb
index e94835959..095a2942b 100644
--- a/lib/puppet/agent.rb
+++ b/lib/puppet/agent.rb
@@ -1,87 +1,23 @@
-# The class that functions as our client agent.  It has all
-# of the logic for downloading and applying catalogs, and anything
-# else needed by puppetd to do its job.
 class Puppet::Agent
-    # The 'require' is inside the class so the Agent constant already exists.
-    require 'puppet/agent/downloader'
-
-    # Disable all agent activity.  This would be used by someone to
-    # temporarily stop puppetd without killing the daemon.
-    def self.disable
-        lockfile.lock :anonymous => true
-    end
-
-    # Enable activity again.
-    def self.enable
-        lockfile.unlock :anonymous => true
-    end
-
-    def self.enabled?
-        ! lockfile.locked?
-    end
-
-    # The lockfile we're using.
-    def self.lockfile
-        unless defined?(@lockfile) and @lockfile
-            @lockfile = Puppet::Util::Pidlock.new(Puppet[:puppetdlockfile])
-        end
-
-        @lockfile
-    end
-
-    # Determine the timeout value to use.
-    def self.timeout
-        timeout = Puppet[:configtimeout]
-        case timeout
-        when String:
-            if timeout =~ /^\d+$/
-                timeout = Integer(timeout)
-            else
-                raise ArgumentError, "Configuration timeout must be an integer"
-            end
-        when Integer: # nothing
-        else
-            raise ArgumentError, "Configuration timeout must be an integer"
-        end
-
-        return timeout
-    end
+    # enable/disable
 
     # storage
 
+    # locking
+
     # config timeout
 
     # setclasses
 
     # Retrieve our catalog, possibly from the cache.
-    def download_catalog
-        unless c = Puppet::Resource::Catalog.find(name, :use_cache => (!Puppet[:ignorecache]))
+    def catalog
+        unless c = Puppet::Node::Catalog.find(name, :use_cache => (!Puppet[:ignorecache]))
             raise "Could not retrieve catalog"
         end
         c.host_config = true
         c
     end
 
-    # Should we be downloading plugins?
-    def download_plugins?
-        Puppet[:pluginsync]
-    end
-
-    # Download, and load if necessary, central plugins.
-    def download_plugins
-        Puppet::Agent::Downloader.new("plugin", Puppet[:pluginsource], Puppet[:plugindest], Puppet[:pluginsignore]).evaluate
-    end
-
-    # Should we be downloading facts?
-    def download_facts?
-        Puppet[:factsync]
-    end
-
-    # Download, and load if necessary, central facts.
-    def download_facts
-        Puppet::Agent::Downloader.new("fact", Puppet[:factsource], Puppet[:factdest], Puppet[:factsignore]).evaluate
-    end
-
     def initialize(options = {})
         options.each do |param, value|
             if respond_to?(param.to_s + "=")
@@ -103,11 +39,9 @@ class Puppet::Agent
     end
 
     def run
-        splay() if splay?
-
-        download_plugins() if download_plugins?
+        splay()
 
-        download_facts() if download_facts?
+        download_plugins()
 
         upload_facts()
 
@@ -116,343 +50,58 @@ class Puppet::Agent
         apply(catalog)
     end
 
-    # Should we splay?
-    def splay?
-        Puppet[:splay]
-    end
-
     # Sleep for a random but consistent period of time if configured to
     # do so.
     def splay
         return unless Puppet[:splay]
-        return if splayed?
 
-        time = rand(Integer(Puppet[:splaylimit]) + 1)
+        time = splay_time()
+
         Puppet.info "Sleeping for %s seconds (splay is enabled)" % time
         sleep(time)
-        @splayed = true
-    end
-
-    # Have we already splayed?
-    def splayed?
-        defined?(@splayed) and @splayed
     end
 
     def start
+#        # Create our timer.  Puppet will handle observing it and such.
+#        timer = Puppet.newtimer(
+#            :interval => Puppet[:runinterval],
+#            :tolerance => 1,
+#            :start? => true
+#        ) do
+#            begin
+#                self.runnow if self.scheduled?
+#            rescue => detail
+#                puts detail.backtrace if Puppet[:trace]
+#                Puppet.err "Could not run client; got otherwise uncaught exception: %s" % detail
+#            end
+#        end
+#
+#        # Run once before we start following the timer
+#        self.runnow
     end
 
-    # This works because puppetd configures Facts to use 'facter' for
-    # finding facts and the 'rest' terminus for caching them.  Thus, we'll
-    # compile them and then "cache" them on the server.
-    def upload_facts
-        Puppet::Node::Facts.find(Puppet[:certname])
-    end
-end
-
-class OldMaster
-    attr_accessor :catalog
-    attr_reader :compile_time
-
-    class << self
-        # Puppetd should only have one instance running, and we need a way
-        # to retrieve it.
-        attr_accessor :instance
-        include Puppet::Util
-    end
-
-    def self.facts
-        
-        down = Puppet[:downcasefacts]
-
-        Facter.clear
-
-        # Reload everything.
-        if Facter.respond_to? :loadfacts
-            Facter.loadfacts
-        elsif Facter.respond_to? :load
-            Facter.load
-        else
-            Puppet.warning "You should upgrade your version of Facter to at least 1.3.8"
-        end
-
-        # This loads all existing facts and any new ones.  We have to remove and
-        # reload because there's no way to unload specific facts.
-        loadfacts()
-        facts = Facter.to_hash.inject({}) do |newhash, array|
-            name, fact = array
-            if down
-                newhash[name] = fact.to_s.downcase
-            else
-                newhash[name] = fact.to_s
-            end
-            newhash
-        end
- 
-        facts
-    end
-
-    # Retrieve the config from a remote server.  If this fails, then
-    # use the cached copy.
-    def getconfig
-        dostorage()
-
-        facts = nil
-        Puppet::Util.benchmark(:debug, "Retrieved facts") do
-            facts = self.class.facts
-        end
-
-        raise Puppet::Network::ClientError.new("Could not retrieve any facts") unless facts.length > 0
-
-        Puppet.debug("Retrieving catalog")
-
-        # If we can't retrieve the catalog, just return, which will either
-        # fail, or use the in-memory catalog.
-        unless marshalled_objects = get_actual_config(facts)
-            use_cached_config(true)
-            return
-        end
-
-        begin
-            case Puppet[:catalog_format]
-            when "marshal": objects = Marshal.load(marshalled_objects)
-            when "yaml": objects = YAML.load(marshalled_objects)
-            else
-                raise "Invalid catalog format '%s'" % Puppet[:catalog_format]
-            end
-        rescue => detail
-            msg = "Configuration could not be translated from %s" % Puppet[:catalog_format]
-            msg += "; using cached catalog" if use_cached_config(true)
-            Puppet.warning msg
-            return
-        end
-
-        self.setclasses(objects.classes)
-
-        # Clear all existing objects, so we can recreate our stack.
-        clear() if self.catalog
-
-        # Now convert the objects to a puppet catalog graph.
-        begin
-            @catalog = objects.to_catalog
-        rescue => detail
-            clear()
-            puts detail.backtrace if Puppet[:trace]
-            msg = "Configuration could not be instantiated: %s" % detail
-            msg += "; using cached catalog" if use_cached_config(true)
-            Puppet.warning msg
-            return
-        end
-
-        # Keep the state database up to date.
-        @catalog.host_config = true
-    end
-    
-    # Just so we can specify that we are "the" instance.
-    def initialize(*args)
-        Puppet.settings.use(:main, :ssl, :puppetd)
-        super
-
-        self.class.instance = self
-        @running = false
-        @splayed = false
-    end
-
-    # Mark that we should restart.  The Puppet module checks whether we're running,
-    # so this only gets called if we're in the middle of a run.
-    def restart
-        # If we're currently running, then just mark for later
-        Puppet.notice "Received signal to restart; waiting until run is complete"
-        @restart = true
-    end
-
-    # Should we restart?
-    def restart?
-        if defined? @restart
-            @restart
-        else
-            false
-        end
-    end
-
-    # Retrieve the cached config
-    def retrievecache
-        if FileTest.exists?(self.cachefile)
-            return ::File.read(self.cachefile)
-        else
-            return nil
-        end
-    end
-
-    # The code that actually runs the catalog.  
-    # This just passes any options on to the catalog,
-    # which accepts :tags and :ignoreschedules.
-    def run(options = {})
-        got_lock = false
-        splay
-        Puppet::Util.sync(:puppetrun).synchronize(Sync::EX) do
-            if !lockfile.lock
-                Puppet.notice "Lock file %s exists; skipping catalog run" %
-                    lockfile.lockfile
-            else
-                got_lock = true
-                begin
-                    duration = thinmark do
-                        self.getconfig
-                    end
-                rescue => detail
-                    puts detail.backtrace if Puppet[:trace]
-                    Puppet.err "Could not retrieve catalog: %s" % detail
-                end
-
-                if self.catalog
-                    @catalog.retrieval_duration = duration
-                    Puppet.notice "Starting catalog run" unless @local
-                    benchmark(:notice, "Finished catalog run") do
-                        @catalog.apply(options)
-                    end
-                end
-
-                # Now close all of our existing http connections, since there's no
-                # reason to leave them lying open.
-                Puppet::Network::HttpPool.clear_http_instances
-            end
-            
-            lockfile.unlock
-
-            # Did we get HUPped during the run?  If so, then restart now that we're
-            # done with the run.
-            if self.restart?
-                Process.kill(:HUP, $$)
-            end
-        end
-    ensure
-        # Just make sure we remove the lock file if we set it.
-        lockfile.unlock if got_lock and lockfile.locked?
-        clear()
-    end
-
-    def running?
-        lockfile.locked?
-    end
-
-    # Store the classes in the classfile, but only if we're not local.
-    def setclasses(ary)
-        if @local
-            return
-        end
-        unless ary and ary.length > 0
-            Puppet.info "No classes to store"
-            return
-        end
-        begin
-            ::File.open(Puppet[:classfile], "w") { |f|
-                f.puts ary.join("\n")
-            }
-        rescue => detail
-            Puppet.err "Could not create class file %s: %s" %
-                [Puppet[:classfile], detail]
-        end
-    end
-
-    private
-
-    def self.loaddir(dir, type)
-        return unless FileTest.directory?(dir)
-
-        Dir.entries(dir).find_all { |e| e =~ /\.rb$/ }.each do |file|
-            fqfile = ::File.join(dir, file)
-            begin
-                Puppet.info "Loading %s %s" % 
-                    [type, ::File.basename(file.sub(".rb",''))]
-                Timeout::timeout(self.timeout) do
-                    load fqfile
-                end
-            rescue => detail
-                Puppet.warning "Could not load %s %s: %s" % [type, fqfile, detail]
-            end
-        end
+    def download_catalog
+        # LAK:NOTE This needs to handle skipping cached configs
+        # if configured to do so.
+        Puppet::Node::Catalog.find name
     end
 
-    def self.loadfacts
-        # LAK:NOTE See http://snurl.com/21zf8  [groups_google_com] 
-        x = Puppet[:factpath].split(":").each do |dir|
-            loaddir(dir, "fact")
-        end
-    end
-    
-    def self.timeout
-        timeout = Puppet[:configtimeout]
-        case timeout
-        when String:
-            if timeout =~ /^\d+$/
-                timeout = Integer(timeout)
-            else
-                raise ArgumentError, "Configuration timeout must be an integer"
-            end
-        when Integer: # nothing
-        else
-            raise ArgumentError, "Configuration timeout must be an integer"
-        end
-
-        return timeout
+    def download_plugins
+        raise "Plugin downloads not implemented"
     end
 
-    loadfacts()
-    
-    # Retrieve a config from a remote master.
-    def get_remote_config(facts)
-        textobjects = ""
-
-        textfacts = CGI.escape(YAML.dump(facts))
-
-        benchmark(:debug, "Retrieved catalog") do
-            # error handling for this is done in the network client
-            begin
-                textobjects = @driver.getconfig(textfacts, Puppet[:catalog_format])
-                begin
-                    textobjects = CGI.unescape(textobjects)
-                rescue => detail
-                    raise Puppet::Error, "Could not CGI.unescape catalog"
-                end
-
-            rescue => detail
-                Puppet.err "Could not retrieve catalog: %s" % detail
-                return nil
-            end
-        end
-
-        return nil if textobjects == ""
-
-        @compile_time = Time.now
-
-        return textobjects
+    def upload_facts
     end
 
-    private
+    def splay_time
+        limit = Integer(Puppet[:splaylimit])
 
-    # Use our cached config, optionally specifying whether this is
-    # necessary because of a failure.
-    def use_cached_config(because_of_failure = false)
-        return true if self.catalog
-
-        if because_of_failure and ! Puppet[:usecacheonfailure]
-            @catalog = nil
-            Puppet.warning "Not using cache on failed catalog"
-            return false
+        # Pick a splay time and then cache it.
+        unless time = Puppet::Util::Storage.cache(:configuration)[:splay_time]
+            time = rand(limit)
+            Puppet::Util::Storage.cache(:configuration)[:splay_time] = time
         end
 
-        return false unless oldtext = self.retrievecache
-
-        begin
-            @catalog = YAML.load(oldtext).to_catalog
-            @catalog.from_cache = true
-            @catalog.host_config = true
-        rescue => detail
-            puts detail.backtrace if Puppet[:trace]
-            Puppet.warning "Could not load cached catalog: %s" % detail
-            clear
-            return false
-        end
-        return true
+        time
     end
 end
diff --git a/lib/puppet/agent/downloader.rb b/lib/puppet/agent/downloader.rb
index e838d4d79..46a64d52d 100644
--- a/lib/puppet/agent/downloader.rb
+++ b/lib/puppet/agent/downloader.rb
@@ -1,20 +1,36 @@
 require 'puppet/agent'
 
-# A simple class that abstracts downloading files
-# fromthe server.
 class Puppet::Agent::Downloader
     attr_reader :name, :path, :source, :ignore
 
+    # Determine the timeout value to use.
+    def self.timeout
+        timeout = Puppet[:configtimeout]
+        case timeout
+        when String:
+            if timeout =~ /^\d+$/
+                timeout = Integer(timeout)
+            else
+                raise ArgumentError, "Configuration timeout must be an integer"
+            end
+        when Integer: # nothing
+        else
+            raise ArgumentError, "Configuration timeout must be an integer"
+        end
+
+        return timeout
+    end
+
     # Evaluate our download, returning the list of changed values.
     def evaluate
         Puppet.info "Retrieving #{name}"
 
         files = []
         begin
-            Timeout.timeout(Puppet::Agent.timeout) do
+            Timeout.timeout(self.class.timeout) do
                 catalog.apply do |trans|
                     trans.changed?.find_all do |resource|
-                        yield resource[:path] if block_given?
+                        yield resource if block_given?
                         files << resource[:path]
                     end
                 end
diff --git a/lib/puppet/agent/splayer.rb b/lib/puppet/agent/splayer.rb
deleted file mode 100644
index 6c2b1ba51..000000000
--- a/lib/puppet/agent/splayer.rb
+++ /dev/null
@@ -1,29 +0,0 @@
-require 'puppet/agent'
-
-# The class that handles sleeping for the appropriate splay
-# time, if at all.
-class Puppet::Agent::Splayer
-    attr_reader :splayed
-
-    # Should we splay?
-    def splay?
-        Puppet[:splay]
-    end
-
-    # Sleep for a random but consistent period of time if configured to
-    # do so.
-    def splay
-        return unless Puppet[:splay]
-        return if splayed?
-
-        time = rand(Integer(Puppet[:splaylimit]) + 1)
-        Puppet.info "Sleeping for %s seconds (splay is enabled)" % time
-        sleep(time)
-        @splayed = true
-    end
-
-    # Have we already splayed?
-    def splayed?
-        defined?(@splayed) and @splayed
-    end
-end
diff --git a/spec/unit/agent.rb b/spec/unit/agent.rb
index a564308be..63914c3a3 100755
--- a/spec/unit/agent.rb
+++ b/spec/unit/agent.rb
@@ -5,66 +5,6 @@ require File.dirname(__FILE__) + '/../spec_helper'
 require 'puppet/agent'
 
 describe Puppet::Agent do
-    it "should be able to provide a timeout value" do
-        Puppet::Agent.should respond_to(:timeout)
-    end
-
-    it "should use the configtimeout, converted to an integer, as its timeout" do
-        Puppet.settings.expects(:value).with(:configtimeout).returns "50"
-        Puppet::Agent.timeout.should == 50
-    end
-
-    describe "when managing the lockfile" do
-        after do
-            Puppet::Agent.instance_variable_set("@lockfile", nil)
-        end
-
-        it "should use Pidlock to manage the lock file itself" do
-            Puppet::Agent.instance_variable_set("@lockfile", nil)
-
-            Puppet.settings.expects(:value).with(:puppetdlockfile).returns "/lock/file"
-            Puppet::Util::Pidlock.expects(:new).with("/lock/file").returns "mylock"
-
-            Puppet::Agent.lockfile.should == "mylock"
-        end
-
-        it "should always reuse the same lock file instance" do
-            Puppet::Agent.lockfile.should equal(Puppet::Agent.lockfile)
-        end
-
-        it "should have a class method for disabling the agent" do
-            Puppet::Agent.should respond_to(:disable)
-        end
-
-        it "should have a class method for enabling the agent" do
-            Puppet::Agent.should respond_to(:enable)
-        end
-
-        it "should use the lockfile to disable the agent anonymously" do
-            Puppet::Agent.lockfile.expects(:lock).with(:anonymous => true)
-            Puppet::Agent.disable
-        end
-
-        it "should use the lockfile to enable the agent anonymously" do
-            Puppet::Agent.lockfile.expects(:unlock).with(:anonymous => true)
-            Puppet::Agent.enable
-        end
-
-        it "should have a class method for determining whether the agent is enabled" do
-            Puppet::Agent.should respond_to(:enabled?)
-        end
-
-        it "should consider the agent enabled if the lockfile is not locked" do
-            Puppet::Agent.lockfile.expects(:locked?).returns false
-            Puppet::Agent.should be_enabled
-        end
-
-        it "should consider the agent disabled if the lockfile is locked" do
-            Puppet::Agent.lockfile.expects(:locked?).returns true
-            Puppet::Agent.should_not be_enabled
-        end
-    end
-
     it "should have a start method" do
         Puppet::Agent.new.should respond_to(:start)
     end
@@ -92,22 +32,22 @@ describe Puppet::Agent do
             @agent.stubs(:name).returns "foo"
 
             Puppet.settings.stubs(:value).with(:splaylimit).returns "1800"
-            Puppet.settings.stubs(:value).with(:splay).returns true
+            Puppet.settings.stubs(:value).with(:splaylimit).returns "1800"
         end
 
-        it "should sleep if it has not previously splayed" do
-            Puppet.settings.expects(:value).with(:splay).returns true
-            @agent.expects(:sleep)
+        it "should do nothing if splay is disabled" do
+            Puppet.settings.expects(:value).with(:splay).returns false
+            @agent.expects(:sleep).never
             @agent.splay
         end
-        
-        it "should do nothing if it has already splayed" do
-            @agent.expects(:sleep).once
-            @agent.splay
+
+        it "should sleep if splay is enabled" do
+            Puppet.settings.expects(:value).with(:splay).returns true
+            @agent.expects(:sleep)
             @agent.splay
         end
 
-        it "should log if it is sleeping" do
+        it "should log when splay is enabled" do
             Puppet.settings.expects(:value).with(:splay).returns true
             @agent.stubs(:sleep)
 
@@ -117,125 +57,22 @@ describe Puppet::Agent do
         end
     end
 
-    describe "when running" do
-        before do
-            @agent = Puppet::Agent.new
-            [:upload_facts, :download_catalog, :apply].each { |m| @agent.stubs(m) }
-        end
+    it "should default to using splay time"
 
-        it "should splay if splay is enabled" do
-            @agent.expects(:splay?).returns true
-            @agent.expects(:splay)
-            @agent.run
-        end
+    it "should be able to ignore splay time"
 
-        it "should not splay if splay is disabled" do
-            @agent.expects(:splay?).returns false
-            @agent.expects(:splay).never
-            @agent.run
-        end
-
-        it "should download plugins if plugin downloading is enabled" do
-            @agent.expects(:download_plugins?).returns true
-            @agent.expects(:download_plugins)
-            @agent.run
-        end
-
-        it "should not download plugins if plugin downloading is disabled" do
-            @agent.expects(:download_plugins?).returns false
-            @agent.expects(:download_plugins).never
-            @agent.run
-        end
-
-        it "should download facts if fact downloading is enabled" do
-            @agent.expects(:download_facts?).returns true
-            @agent.expects(:download_facts)
-            @agent.run
-        end
-
-        it "should not download facts if fact downloading is disabled" do
-            @agent.expects(:download_facts?).returns false
-            @agent.expects(:download_facts).never
-            @agent.run
-        end
-
-        it "should retrieve the facts and save them to the server" do
-            @agent.expects(:upload_facts)
-            @agent.run
-        end
-
-        it "should retrieve the catalog" do
-            @agent.expects(:download_catalog)
-            @agent.run
-        end
-
-        it "should apply the catalog" do
-            catalog = mock("catalog")
-            @agent.expects(:download_catalog).returns catalog
-            @agent.expects(:apply).with(catalog)
-            @agent.run
-        end
-    end
-
-    describe "when downloading plugins" do
-        before do
-            @agent = Puppet::Agent.new
-            @downloader = stub 'downloader', :evaluate
-        end
-
-        it "should download plugins if the :pluginsync setting is true" do
-            Puppet.settings.expects(:value).with(:pluginsync).returns true
-            @agent.should be_download_plugins
-        end
-
-        it "should not download plugins if the :pluginsync setting is false" do
-            Puppet.settings.expects(:value).with(:pluginsync).returns false
-            @agent.should_not be_download_plugins
-        end
+    it "should be able to retrieve facts"
 
-        it "should use a Downloader instance with its name set to 'plugin' and the pluginsource, plugindest, and pluginsignore settings" do
-            Puppet.settings.expects(:value).with(:pluginsource).returns "plugsource"
-            Puppet.settings.expects(:value).with(:plugindest).returns "plugdest"
-            Puppet.settings.expects(:value).with(:pluginsignore).returns "plugig"
-            Puppet::Agent::Downloader.expects(:new).with("plugin", "plugsource", "plugdest", "plugig").returns @downloader
-            @downloader.expects(:evaluate)
-            @agent.download_plugins
-        end
-    end
-
-    describe "when downloading facts" do
-        before do
-            @agent = Puppet::Agent.new
-            @downloader = stub 'downloader', :evaluate
-        end
+    describe "when running" do
+        it "should download plugins"
 
-        it "should download facts if the :factsync setting is true" do
-            Puppet.settings.expects(:value).with(:factsync).returns true
-            @agent.should be_download_facts
-        end
+        it "should download facts"
 
-        it "should not download facts if the :factsync setting is false" do
-            Puppet.settings.expects(:value).with(:factsync).returns false
-            @agent.should_not be_download_facts
-        end
+        it "should retrieve the facts and save them to the server"
 
-        it "should use a Downloader instance with its name set to 'facts' and the factssource, factsdest, and factsignore settings" do
-            Puppet.settings.expects(:value).with(:factsource).returns "factsource"
-            Puppet.settings.expects(:value).with(:factdest).returns "factdest"
-            Puppet.settings.expects(:value).with(:factsignore).returns "factig"
-            Puppet::Agent::Downloader.expects(:new).with("fact", "factsource", "factdest", "factig").returns @downloader
-            @downloader.expects(:evaluate)
-            @agent.download_facts
-        end
-    end
-
-    describe "when uploading facts" do
-        it "should just retrieve the facts for the current host" do
-            @agent = Puppet::Agent.new
+        it "should retrieve the catalog"
 
-            Puppet::Node::Facts.expects(:find).with(Puppet[:certname])
-            @agent.upload_facts
-        end
+        it "should apply the catalog"
     end
 
     describe "when retrieving the catalog" do
@@ -247,34 +84,34 @@ describe Puppet::Agent do
         end
 
         it "should use the Catalog class to find the catalog" do
-            Puppet::Resource::Catalog.expects(:find).with { |name, options| name == "me" }.returns @catalog
+            Puppet::Node::Catalog.expects(:find).with { |name, options| name == "me" }.returns @catalog
 
-            @agent.download_catalog.should equal(@catalog)
+            @agent.catalog.should equal(@catalog)
         end
 
         it "should default to allowing use of the cache" do
-            Puppet::Resource::Catalog.expects(:find).with { |name, options| options[:use_cache] == true }.returns @catalog
+            Puppet::Node::Catalog.expects(:find).with { |name, options| options[:use_cache] == true }.returns @catalog
 
-            @agent.download_catalog
+            @agent.catalog
         end
 
         it "should ignore a cached catalog if configured to do so" do
             Puppet.settings.expects(:value).with(:ignorecache).returns true
-            Puppet::Resource::Catalog.expects(:find).with { |name, options| options[:use_cache] == false }.returns @catalog
+            Puppet::Node::Catalog.expects(:find).with { |name, options| options[:use_cache] == false }.returns @catalog
 
-            @agent.download_catalog
+            @agent.catalog
         end
 
         it "should mark the catalog as a host catalog" do
             @catalog.expects(:host_config=).with true
-            Puppet::Resource::Catalog.expects(:find).returns @catalog
+            Puppet::Node::Catalog.expects(:find).returns @catalog
 
-            @agent.download_catalog
+            @agent.catalog
         end
 
         it "should fail if a catalog can not be retrieved" do
-            Puppet::Resource::Catalog.expects(:find).returns nil
-            lambda { @agent.download_catalog }.should raise_error(RuntimeError)
+            Puppet::Node::Catalog.expects(:find).returns nil
+            lambda { @agent.catalog }.should raise_error(RuntimeError)
         end
     end
 end
diff --git a/spec/unit/agent/downloader.rb b/spec/unit/agent/downloader.rb
index 5c53de824..6b07e5bb4 100755
--- a/spec/unit/agent/downloader.rb
+++ b/spec/unit/agent/downloader.rb
@@ -20,6 +20,15 @@ describe Puppet::Agent::Downloader do
         dler.source.should == "source"
     end
 
+    it "should be able to provide a timeout value" do
+        Puppet::Agent::Downloader.should respond_to(:timeout)
+    end
+
+    it "should use the configtimeout, converted to an integer, as its timeout" do
+        Puppet.settings.expects(:value).with(:configtimeout).returns "50"
+        Puppet::Agent::Downloader.timeout.should == 50
+    end
+
     describe "when creating the file that does the downloading" do
         before do
             @dler = Puppet::Agent::Downloader.new("foo", "path", "source")
@@ -109,8 +118,8 @@ describe Puppet::Agent::Downloader do
             @dler.evaluate
         end
 
-        it "should use the agent timeout for the download" do
-            Puppet::Agent.expects(:timeout).returns 50
+        it "should set a timeout for the download" do
+            Puppet::Agent::Downloader.expects(:timeout).returns 50
             Timeout.expects(:timeout).with(50)
 
             @dler.evaluate
@@ -144,7 +153,7 @@ describe Puppet::Agent::Downloader do
             @dler.evaluate.should == %w{/changed/file}
         end
 
-        it "should yield the downloaded file's path if a block is given" do
+        it "should yield the resources if a block is given" do
             trans = mock 'transaction'
 
             catalog = mock 'catalog'
@@ -154,13 +163,13 @@ describe Puppet::Agent::Downloader do
             Timeout.expects(:timeout).yields
 
             resource = mock 'resource'
-            resource.stubs(:[]).with(:path).returns "/changed/file"
+            resource.expects(:[]).with(:path).returns "/changed/file"
 
             trans.expects(:changed?).returns([resource])
 
             yielded = nil
             @dler.evaluate { |r| yielded = r }
-            yielded.should == "/changed/file"
+            yielded.should == resource
         end
 
         it "should catch and log exceptions" do
diff --git a/spec/unit/agent/splayer.rb b/spec/unit/agent/splayer.rb
deleted file mode 100755
index e097cc98b..000000000
--- a/spec/unit/agent/splayer.rb
+++ /dev/null
@@ -1,42 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-require 'puppet/agent/splayer'
-
-describe Puppet::Agent::Splayer do
-    it "should be able to splay" do
-        Puppet::Agent::Splayer.new.should respond_to(:splay)
-    end
-
-    describe "when splaying" do
-        before do
-            @agent = Puppet::Agent::Splayer.new
-            @agent.stubs(:name).returns "foo"
-
-            Puppet.settings.stubs(:value).with(:splaylimit).returns "1800"
-            Puppet.settings.stubs(:value).with(:splay).returns true
-        end
-
-        it "should sleep if it has not previously splayed" do
-            Puppet.settings.expects(:value).with(:splay).returns true
-            @agent.expects(:sleep)
-            @agent.splay
-        end
-        
-        it "should do nothing if it has already splayed" do
-            @agent.expects(:sleep).once
-            @agent.splay
-            @agent.splay
-        end
-
-        it "should log if it is sleeping" do
-            Puppet.settings.expects(:value).with(:splay).returns true
-            @agent.stubs(:sleep)
-
-            Puppet.expects(:info)
-
-            @agent.splay
-        end
-    end
-end