Removing obsolete code and tests for the agent.

Signed-off-by: Luke Kanies <luke@madstop.com>

3 files changed, 0 insertions, 572 deletions

diff --git a/lib/puppet/agent.rb b/lib/puppet/agent.rb
index 240005e3f..e2b4ebdc7 100644
--- a/lib/puppet/agent.rb
+++ b/lib/puppet/agent.rb
@@ -92,15 +92,6 @@ class Puppet::Agent
         end
     end
 
-    # Retrieve the cached config
-    def retrievecache
-        if FileTest.exists?(self.cachefile)
-            return ::File.read(self.cachefile)
-        else
-            return nil
-        end
-    end
-
     # Get the remote catalog, yo.  Returns nil if no catalog can be found.
     def retrieve_catalog
         name = Facter.value("hostname")
@@ -205,50 +196,6 @@ class Puppet::Agent
         return timeout
     end
 
-    # Actually retrieve the catalog, either from the server or from a
-    # local master.
-    def get_actual_config(facts)
-        begin
-            Timeout::timeout(self.class.timeout) do
-                return get_remote_config(facts)
-            end
-        rescue Timeout::Error
-            Puppet.err "Configuration retrieval timed out"
-            return nil
-        end
-    end
-    
-    # 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
-        Puppet::Util::Storage.cache(:configuration)[:facts] = facts
-        Puppet::Util::Storage.cache(:configuration)[:compile_time] = @compile_time
-
-        return textobjects
-    end
-
     def splayed?
         @splayed
     end
@@ -263,40 +210,4 @@ class Puppet::Agent
         sleep(time)
         @splayed = true
     end
-
-    private
-
-    def retrieve_and_apply_catalog(options)
-        catalog = self.retrieve_catalog
-        Puppet.notice "Starting catalog run"
-        benchmark(:notice, "Finished catalog run") do
-            catalog.apply(options)
-        end
-    end
-
-    # 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
-        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
-    end
 end
diff --git a/spec/unit/agent.rb b/spec/unit/agent.rb
index 0d6ed952e..c4f5793d2 100755
--- a/spec/unit/agent.rb
+++ b/spec/unit/agent.rb
@@ -258,166 +258,3 @@ describe Puppet::Agent, "when preparing for a run" do
         @agent.prepare
     end
 end
-
-describe Puppet::Agent, " when using the cached catalog" do
-    before do
-        Puppet.settings.stubs(:use).returns(true)
-        @agent = Puppet::Agent.new
-        @facts = {"one" => "two", "three" => "four"}
-    end
-
-    it "should return do nothing and true if there is already an in-memory catalog" do
-        @agent.catalog = :whatever
-        Puppet::Agent.publicize_methods :use_cached_config do
-            @agent.use_cached_config.should be_true
-        end
-    end
-
-    it "should return do nothing and false if it has been told there is a failure and :nocacheonfailure is enabled" do
-        Puppet.settings.expects(:value).with(:usecacheonfailure).returns(false)
-        Puppet::Agent.publicize_methods :use_cached_config do
-            @agent.use_cached_config(true).should be_false
-        end
-    end
-
-    it "should return false if no cached catalog can be found" do
-        @agent.expects(:retrievecache).returns(nil)
-        Puppet::Agent.publicize_methods :use_cached_config do
-            @agent.use_cached_config().should be_false
-        end
-    end
-
-    it "should return false if the cached catalog cannot be instantiated" do
-        YAML.expects(:load).raises(ArgumentError)
-        @agent.expects(:retrievecache).returns("whatever")
-        Puppet::Agent.publicize_methods :use_cached_config do
-            @agent.use_cached_config().should be_false
-        end
-    end
-
-    it "should warn if the cached catalog cannot be instantiated" do
-        YAML.stubs(:load).raises(ArgumentError)
-        @agent.stubs(:retrievecache).returns("whatever")
-        Puppet.expects(:warning).with { |m| m.include?("Could not load cache") }
-        Puppet::Agent.publicize_methods :use_cached_config do
-            @agent.use_cached_config().should be_false
-        end
-    end
-
-    it "should clear the client if the cached catalog cannot be instantiated" do
-        YAML.stubs(:load).raises(ArgumentError)
-        @agent.stubs(:retrievecache).returns("whatever")
-        @agent.expects(:clear)
-        Puppet::Agent.publicize_methods :use_cached_config do
-            @agent.use_cached_config().should be_false
-        end
-    end
-
-    it "should return true if the cached catalog can be instantiated" do
-        config = mock 'config'
-        YAML.stubs(:load).returns(config)
-
-        ral_config = mock 'ral config'
-        ral_config.stubs(:from_cache=)
-        ral_config.stubs(:host_config=)
-        config.expects(:to_catalog).returns(ral_config)
-
-        @agent.stubs(:retrievecache).returns("whatever")
-        Puppet::Agent.publicize_methods :use_cached_config do
-            @agent.use_cached_config().should be_true
-        end
-    end
-
-    it "should set the catalog instance variable if the cached catalog can be instantiated" do
-        config = mock 'config'
-        YAML.stubs(:load).returns(config)
-
-        ral_config = mock 'ral config'
-        ral_config.stubs(:from_cache=)
-        ral_config.stubs(:host_config=)
-        config.expects(:to_catalog).returns(ral_config)
-
-        @agent.stubs(:retrievecache).returns("whatever")
-        Puppet::Agent.publicize_methods :use_cached_config do
-            @agent.use_cached_config()
-        end
-
-        @agent.catalog.should equal(ral_config)
-    end
-
-    it "should mark the catalog as a host_config if valid" do
-        config = mock 'config'
-        YAML.stubs(:load).returns(config)
-
-        ral_config = mock 'ral config'
-        ral_config.stubs(:from_cache=)
-        ral_config.expects(:host_config=).with(true)
-        config.expects(:to_catalog).returns(ral_config)
-
-        @agent.stubs(:retrievecache).returns("whatever")
-        Puppet::Agent.publicize_methods :use_cached_config do
-            @agent.use_cached_config()
-        end
-
-        @agent.catalog.should equal(ral_config)
-    end
-
-    it "should mark the catalog as from the cache if valid" do
-        config = mock 'config'
-        YAML.stubs(:load).returns(config)
-
-        ral_config = mock 'ral config'
-        ral_config.expects(:from_cache=).with(true)
-        ral_config.stubs(:host_config=)
-        config.expects(:to_catalog).returns(ral_config)
-
-        @agent.stubs(:retrievecache).returns("whatever")
-        Puppet::Agent.publicize_methods :use_cached_config do
-            @agent.use_cached_config()
-        end
-
-        @agent.catalog.should equal(ral_config)
-    end
-
-    describe "when calling splay" do
-        it "should do nothing if splay is not enabled" do
-            Puppet.stubs(:[]).with(:splay).returns(false)
-            @agent.expects(:rand).never
-            @agent.send(:splay)
-        end
-
-        describe "when splay is enabled" do
-            before do
-                Puppet.stubs(:[]).with(:splay).returns(true)
-                Puppet.stubs(:[]).with(:splaylimit).returns(42)
-            end
-
-            it "should sleep for a random time plus 1" do
-                @agent.expects(:rand).with(43).returns(43)
-                @agent.expects(:sleep).with(43)
-                @agent.send(:splay)
-            end
-
-            it "should inform that it is splayed" do
-                @agent.stubs(:rand).with(43).returns(43)
-                @agent.stubs(:sleep).with(43)
-                Puppet.expects(:info)
-                @agent.send(:splay)
-            end
-
-            it "should set splay = true" do
-                @agent.stubs(:rand).returns(43)
-                @agent.stubs(:sleep)
-                @agent.send(:splay)
-                @agent.send(:splayed?).should == true
-            end
-
-            it "should do nothing if already splayed" do
-                @agent.stubs(:rand).returns(43).at_most_once
-                @agent.stubs(:sleep).at_most_once
-                @agent.send(:splay)
-                @agent.send(:splay)
-            end
-        end 
-    end
-end
diff --git a/test/agent.rb b/test/agent.rb
index be0e7a9a6..3ead157be 100755
--- a/test/agent.rb
+++ b/test/agent.rb
@@ -14,298 +14,6 @@ class TestAgent < Test::Unit::TestCase
         @agent_class = Puppet::Agent
     end
 
-    def test_disable
-        FileUtils.mkdir_p(Puppet[:statedir])
-
-        client = Puppet::Agent.new
-
-        assert_nothing_raised("Could not disable client") {
-            client.disable
-        }
-
-        client.expects(:getconfig).never
-
-        client.run
-
-        client = Puppet::Agent.new
-
-        client.expects(:getconfig)
-
-        assert_nothing_raised("Could not enable client") {
-            client.enable
-        }
-        client.run
-    end
-
-    # Make sure non-string facts don't make things go kablooie
-    def test_nonstring_facts
-        FileUtils.mkdir_p(Puppet[:statedir])
-        # Add a nonstring fact
-        Facter.add("nonstring") do
-            setcode { 1 }
-        end
-
-        # so we don't lose our fact setting
-        Facter.stubs(:clear)
-        Puppet::Agent.stubs(:loadfacts)
-
-        assert_equal("1", Puppet::Agent.facts["nonstring"], "Did not convert all facts to strings")
-    end
-    
-    # This method downloads files, and yields each file object if a block is given.
-    def test_download
-        source = tempfile()
-        dest = tempfile()
-        sfile = File.join(source, "file")
-        dfile = File.join(dest, "file")
-        Dir.mkdir(source)
-        File.open(sfile, "w") {|f| f.puts "yay"}
-        
-        files = []
-        assert_nothing_raised do
-            files = Puppet::Agent.download(:dest => dest, :source => source, :name => "testing")
-        end
-        
-        assert(FileTest.directory?(dest), "dest dir was not created")
-        assert(FileTest.file?(dfile), "dest file was not created")
-        assert_equal(File.read(sfile), File.read(dfile), "Dest file had incorrect contents")
-        assert_equal([dest, dfile].sort, files.sort, "Changed files were not returned correctly")
-    end
-
-    def test_getplugins
-        Puppet[:filetimeout] = -1
-        Puppet[:pluginsource] = tempfile()
-        Dir.mkdir(Puppet[:pluginsource])
-        Dir.mkdir(File.join(Puppet[:pluginsource], "testing"))
-
-        $loaded = []
-        loader = Puppet::Util::Autoload.new(self, "testing")
-
-        myplugin = File.join(Puppet[:pluginsource], "testing", "myplugin.rb")
-        File.open(myplugin, "w") do |f|
-            f.puts %{$loaded << :myplugin}
-        end
-
-        assert_nothing_raised("Could not get plugins") {
-            Puppet::Agent.getplugins
-        }
-
-        destfile = File.join(Puppet[:plugindest], "testing", "myplugin.rb")
-
-        assert(File.exists?(destfile), "Did not get plugin")
-
-        assert(loader.load(:myplugin), "Did not load downloaded plugin")
-
-        assert($loaded.include?(:myplugin), "Downloaded code was not evaluated")
-
-        # Now modify the file and make sure the type is replaced
-        File.open(myplugin, "w") do |f|
-            f.puts %{$loaded << :changed}
-        end
-
-        assert_nothing_raised("Could not get plugin changes") {
-            Puppet::Agent.getplugins
-        }
-
-        assert($loaded.include?(:changed), "Changed code was not evaluated")
-
-        # Now try it again, to make sure we don't have any objects lying around
-        assert_nothing_raised {
-            Puppet::Agent.getplugins
-        }
-    end
-
-    def test_getfacts
-        Puppet[:filetimeout] = -1
-        Puppet[:factsource] = tempfile()
-        Dir.mkdir(Puppet[:factsource])
-        hostname = Facter.value(:hostname)
-
-        myfact = File.join(Puppet[:factsource], "myfact.rb")
-        File.open(myfact, "w") do |f|
-            f.puts %{Facter.add("myfact") do
-            setcode { "yayness" }
-end
-}
-        end
-
-        assert_nothing_raised {
-            Puppet::Agent.getfacts
-        }
-
-        destfile = File.join(Puppet[:factdest], "myfact.rb")
-
-        assert(File.exists?(destfile), "Did not get fact")
-
-        facts = Puppet::Agent.facts
-
-        assert_equal(hostname, facts["hostname"],
-            "Lost value to hostname")
-
-        assert_equal("yayness", facts["myfact"],
-            "Did not get correct fact value")
-
-        # Now modify the file and make sure the type is replaced
-        File.open(myfact, "w") do |f|
-            f.puts %{Facter.add("myfact") do
-            setcode { "funtest" }
-end
-}
-        end
-
-        assert_nothing_raised {
-            Puppet::Agent.getfacts
-        }
-        facts = Puppet::Agent.facts
-
-        assert_equal("funtest", facts["myfact"],
-            "Did not reload fact")
-        assert_equal(hostname, facts["hostname"],
-            "Lost value to hostname")
-
-        # Now run it again and make sure the fact still loads
-        assert_nothing_raised {
-            Puppet::Agent.getfacts
-        }
-        facts = Puppet::Agent.facts
-
-        assert_equal("funtest", facts["myfact"],
-            "Did not reload fact")
-        assert_equal(hostname, facts["hostname"],
-            "Lost value to hostname")
-    end
-
-    # Make sure we load all facts on startup.
-    def test_loadfacts
-        dirs = [tempfile(), tempfile()]
-        count = 0
-        names = []
-        dirs.each do |dir|
-            Dir.mkdir(dir)
-            name = "fact%s" % count
-            names << name
-            file = File.join(dir, "%s.rb" % name)
-
-            # Write out a plugin file
-            File.open(file, "w") do |f|
-                f.puts %{Facter.add("#{name}") do setcode { "#{name}" } end }
-            end
-            count += 1
-        end
-
-        Puppet[:factpath] = dirs.join(":")
-
-        names.each do |name|
-            assert_nil(Facter.value(name), "Somehow retrieved invalid fact")
-        end
-
-        assert_nothing_raised {
-            Puppet::Agent.loadfacts
-        }
-
-        names.each do |name|
-            assert_equal(name, Facter.value(name),
-                    "Did not retrieve facts")
-        end
-    end
-
-    if Process.uid == 0
-    # Testing #283.  Make sure plugins et al are downloaded as the running user.
-    def test_download_ownership
-        dir = tstdir()
-        dest = tstdir()
-        file = File.join(dir, "file")
-        File.open(file, "w") { |f| f.puts "funtest" }
-
-        user = nonrootuser()
-        group = nonrootgroup()
-        chowner = Puppet::Type.type(:file).new :path => dir,
-            :owner => user.name, :group => group.name, :recurse => true
-        assert_apply(chowner)
-        chowner.remove
-
-        assert_equal(user.uid, File.stat(file).uid)
-        assert_equal(group.gid, File.stat(file).gid)
-
-
-        assert_nothing_raised {
-            Puppet::Agent.download(:dest => dest, :source => dir,
-                :name => "testing"
-            ) {}
-        }
-
-        destfile = File.join(dest, "file")
-
-        assert(FileTest.exists?(destfile), "Did not create destfile")
-
-        assert_equal(Process.uid, File.stat(destfile).uid)
-    end
-    end
-    
-    # Test retrieving all of the facts.
-    def test_facts
-        facts = nil
-        assert_nothing_raised do
-            facts = Puppet::Agent.facts
-        end
-        Facter.to_hash.each do |fact, value|
-            assert_equal(facts[fact.downcase], value.to_s, "%s is not equal" % fact.inspect)
-        end
-    end
-    
-    # #540 - make sure downloads aren't affected by noop
-    def test_download_in_noop
-        source = tempfile
-        File.open(source, "w") { |f| f.puts "something" }
-        dest = tempfile
-        Puppet[:noop] = true
-        node = stub 'node', :environment => "development"
-        Puppet::Node.stubs(:find).returns node
-        assert_nothing_raised("Could not download in noop") do
-            @agent_class.download(:dest => dest, :source => source, :tag => "yay")
-        end
-
-        assert(FileTest.exists?(dest), "did not download in noop mode")
-
-        assert(Puppet[:noop], "noop got disabled in run")
-    end
-
-    # #491 - make sure a missing config doesn't kill us
-    def test_missing_localconfig
-        master = Puppet::Agent.new
-        Puppet::Node::Facts.indirection.stubs(:save)
-        # Retrieve the configuration
-
-        master.getconfig
-
-        # Now the config is up to date, so get rid of the @objects var and
-        # the cached config
-        master.clear
-        File.unlink(master.cachefile)
-
-        assert_nothing_raised("Missing cache file threw error") do
-            master.getconfig
-        end
-
-        assert(! @logs.detect { |l| l.message =~ /Could not load/},
-            "Tried to load cache when it is non-existent")
-    end
-
-    def test_locking
-        master = Puppet::Agent.new
-
-        class << master
-            def getconfig
-                raise ArgumentError, "Just testing"
-            end
-        end
-
-        master.run
-
-        assert(! master.send(:lockfile).locked?,
-            "Master is still locked after failure")
-    end
-
     # Make sure we get a value for timeout
     def test_config_timeout
         master = Puppet::Agent
@@ -351,32 +59,4 @@ end
             client.send(:splay)
         end
     end
-
-    # #685
-    def test_http_failures_do_not_kill_puppetd
-        client = Puppet::Agent.new
-
-        client.meta_def(:getconfig) { raise "A failure" }
-
-        assert_nothing_raised("Failure in getconfig threw an error") do
-            client.run
-        end
-    end
-
-    def test_classfile
-        Puppet[:code] = "class yaytest {}\n class bootest {}\n include yaytest, bootest"
-
-        Puppet::Node::Facts.indirection.stubs(:save)
-
-        client = Puppet::Agent.new
-
-        # We can't guarantee class ordering
-        client.expects(:setclasses).with do |array|
-            array.length == 2 and array.include?("yaytest") and array.include?("bootest")
-        end
-
-        assert_nothing_raised {
-            client.getconfig
-        }
-    end
 end