puppet 0.18.4 → 0.22.4

data/test/network/handler/handler.rb

@@ -0,0 +1,64 @@
+#!/usr/bin/env ruby
+
+$:.unshift("../../lib") if __FILE__ =~ /\.rb$/
+
+require 'puppettest'
+require 'puppet/network/handler'
+
+class TestHandler < Test::Unit::TestCase
+    include PuppetTest::ServerTest
+
+    def test_load_handlers
+        # Make sure we don't get a failure but that we also get nothing back
+        assert_nothing_raised do
+            assert_nil(Puppet::Network::Handler.handler(:fake),
+                "Got something back from a missing handler")
+        end
+        # Make a fake handler
+        dir = tempfile()
+        libdir = File.join([dir, %w{puppet network handler}].flatten)
+        FileUtils.mkdir_p(libdir)
+
+        file = File.join(libdir, "fake.rb")
+        File.open(file, "w") do |f|
+            f.puts %{class Puppet::Network::Handler
+                class Fake < Handler
+                end
+            end
+            }
+        end
+
+        $: << dir
+        cleanup { $:.delete(dir) if $:.include?(dir) }
+
+        handler = nil
+        assert_nothing_raised do
+            handler = Puppet::Network::Handler.handler(:fake)
+        end
+        assert(handler, "did not load handler")
+
+        # Now make sure the handler behaves correctly
+        assert_equal(:Fake, handler.name, "name was not calculated correctly")
+
+        Puppet[:trace] = false
+        assert_raise(Puppet::DevError,
+            "did not throw an error on missing interface") do
+                handler.interface
+        end
+    end
+
+    def test_handlers_by_name
+        %w{ca filebucket fileserver logger master report resource runner status}.each do |name|
+            handler = nil
+            assert_nothing_raised do
+                handler = Puppet::Network::Handler.handler(name)
+            end
+            assert(handler, "did not get handler for %s" % name)
+            assert(handler.name, "did not get name for %s" % name)
+            assert(handler.interface, "did not get interface for %s" % name)
+            assert(handler.interface.prefix, "did not get interface prefix for %s" % name)
+        end
+    end
+end
+
+# $Id: handler.rb 2259 2007-03-06 19:03:05Z luke $

data/test/{server → network/handler}/logger.rb

@@ -1,34 +1,34 @@
-if __FILE__ == $0
-    $:.unshift '../../lib'
-    $:.unshift '..'
-    $puppetbase = "../.."
-end
+#!/usr/bin/env ruby
+
+$:.unshift("../../lib") if __FILE__ =~ /\.rb$/
 
-require 'puppet'
-require 'test/unit'
-require 'puppettest.rb'
+require 'puppettest'
+require 'puppet/network/handler/logger'
 require 'base64'
 require 'cgi'
 
 class TestLogger < Test::Unit::TestCase
-	include ServerTest
+    include PuppetTest::ServerTest
 
     def setup
         super
-        #Puppet[:debug] = true
-        Puppet::Log.newdestination :console
+        
+        # Send the logs to an array, yo.
+        Puppet::Util::Log.close
+        @logs = []
+        Puppet::Util::Log.newdestination @logs
     end
 
     # Test the log driver manually
     def test_localaddlog
         logger = nil
         assert_nothing_raised {
-            logger = Puppet::Server::Logger.new
+            logger = Puppet::Network::Handler.logger.new
         }
 
         msg = nil
         assert_nothing_raised {
-            msg = Puppet::Log.create(
+            msg = Puppet::Util::Log.create(
                 :level => :warning,
                 :message => "This is a message"
             )
@@ -43,12 +43,12 @@ class TestLogger < Test::Unit::TestCase
     def test_remoteaddlog
         logger = nil
         assert_nothing_raised {
-            logger = Puppet::Server::Logger.new
+            logger = Puppet::Network::Handler.logger.new
         }
 
         msg = nil
         assert_nothing_raised {
-            msg = Puppet::Log.create(
+            msg = Puppet::Util::Log.create(
                 :level => :warning,
                 :message => "This is a remote message"
             )
@@ -66,12 +66,12 @@ class TestLogger < Test::Unit::TestCase
     def test_localclient
         client = nil
         assert_nothing_raised {
-            client = Puppet::Client::LogClient.new(:Logger => true)
+            client = Puppet::Network::Client.logger.new(:Logger => true)
         }
 
         msg = nil
         assert_nothing_raised {
-            msg = Puppet::Log.create(
+            msg = Puppet::Util::Log.create(
                 :level => :warning,
                 :message => "This is a logclient message"
             )
@@ -92,8 +92,8 @@ class TestLogger < Test::Unit::TestCase
         clientlog = tempfile()
         serverlog = tempfile()
         Puppet.warning "serverlog is %s" % serverlog
-        Puppet::Log.newdestination clientlog
-        Puppet::Log.close(:syslog)
+        Puppet::Util::Log.newdestination clientlog
+        Puppet::Util::Log.close(:syslog)
 
         # For testing
         Puppet[:autosign] = true
@@ -101,7 +101,7 @@ class TestLogger < Test::Unit::TestCase
         logger = nil
         # Create our server
         assert_nothing_raised {
-            logger = Puppet::Server.new(
+            logger = Puppet::Network::Server.new(
                 :Port => @@port,
                 :Handlers => {
                     :CA => {}, # so that certs autogenerate
@@ -112,8 +112,8 @@ class TestLogger < Test::Unit::TestCase
 
         # Start our server
         serverpid = fork {
-            Puppet::Log.close(clientlog)
-            Puppet::Log.newdestination serverlog
+            Puppet::Util::Log.close(clientlog)
+            Puppet::Util::Log.newdestination serverlog
             assert_nothing_raised() {
                 trap(:INT) { logger.shutdown }
                 logger.start
@@ -125,7 +125,7 @@ class TestLogger < Test::Unit::TestCase
         # Start a raw xmlrpc client
         client = nil
         assert_nothing_raised() {
-            client = Puppet::Client::LogClient.new(
+            client = Puppet::Network::Client.logger.new(
                 :Server => "localhost",
                 :Port => @@port
             )
@@ -140,7 +140,7 @@ class TestLogger < Test::Unit::TestCase
             :warning => "XMLRPC2",
             :err => "XMLRPC3"
         }.each { |level, str|
-            msg = CGI.escape(YAML.dump(Puppet::Log.create(
+            msg = CGI.escape(YAML.dump(Puppet::Util::Log.create(
                 :level => level,
                 :message => str
             )))
@@ -152,7 +152,7 @@ class TestLogger < Test::Unit::TestCase
         # and now use the normal client action
 
         # Set the log destination to be the server
-        Puppet::Log.newdestination "localhost:%s" % @@port
+        Puppet::Util::Log.newdestination "localhost:%s" % @@port
 
         # And now do some logging
         assert_nothing_raised {
@@ -180,4 +180,4 @@ class TestLogger < Test::Unit::TestCase
     end
 end
 
-# $Id: logger.rb 873 2006-02-07 23:12:33Z luke $
+# $Id: logger.rb 2259 2007-03-06 19:03:05Z luke $

data/test/network/handler/master.rb

@@ -0,0 +1,352 @@
+#!/usr/bin/env ruby
+
+$:.unshift("../../lib") if __FILE__ =~ /\.rb$/
+
+require 'puppettest'
+require 'puppet/network/handler/master'
+
+class TestMaster < Test::Unit::TestCase
+    include PuppetTest::ServerTest
+    def teardown
+        super
+        #print "\n\n\n\n" if Puppet[:debug]
+    end
+
+    # run through all of the existing test files and make sure everything
+    # works
+    def test_files
+        count = 0
+        textfiles { |file|
+            Puppet.debug("parsing %s" % file)
+            client = nil
+            master = nil
+
+            # create our master
+            assert_nothing_raised() {
+                # this is the default server setup
+                master = Puppet::Network::Handler.master.new(
+                    :Manifest => file,
+                    :UseNodes => false,
+                    :Local => true
+                )
+            }
+
+            # and our client
+            assert_nothing_raised() {
+                client = Puppet::Network::Client.master.new(
+                    :Master => master
+                )
+            }
+
+            # pull our configuration a few times
+            assert_nothing_raised() {
+                client.getconfig
+                stopservices
+                Puppet::Type.allclear
+            }
+            assert_nothing_raised() {
+                client.getconfig
+                stopservices
+                Puppet::Type.allclear
+            }
+            assert_nothing_raised() {
+                client.getconfig
+                stopservices
+                Puppet::Type.allclear
+            }
+            # only test three files; that's plenty
+            if count > 3
+                break
+            end
+            count += 1
+        }
+    end
+
+    def test_defaultmanifest
+        textfiles { |file|
+            Puppet[:manifest] = file
+            client = nil
+            master = nil
+            assert_nothing_raised() {
+                # this is the default server setup
+                master = Puppet::Network::Handler.master.new(
+                    :Manifest => file,
+                    :UseNodes => false,
+                    :Local => true
+                )
+            }
+            assert_nothing_raised() {
+                client = Puppet::Network::Client.master.new(
+                    :Master => master
+                )
+            }
+
+            # pull our configuration
+            assert_nothing_raised() {
+                client.getconfig
+                stopservices
+                Puppet::Type.allclear
+            }
+
+            break
+        }
+    end
+
+    def test_filereread
+        # Start with a normal setting
+        Puppet[:filetimeout] = 15
+        manifest = mktestmanifest()
+
+        facts = Puppet::Network::Client.master.facts
+        # Store them, so we don't determine frshness based on facts.
+        Puppet::Util::Storage.cache(:configuration)[:facts] = facts
+
+        file2 = @createdfile + "2"
+        @@tmpfiles << file2
+
+        client = master = nil
+        assert_nothing_raised() {
+            # this is the default server setup
+            master = Puppet::Network::Handler.master.new(
+                :Manifest => manifest,
+                :UseNodes => false,
+                :Local => true
+            )
+        }
+        assert_nothing_raised() {
+            client = Puppet::Network::Client.master.new(
+                :Master => master
+            )
+        }
+
+        assert(client, "did not create master client")
+        # The client doesn't have a config, so it can't be up to date
+        assert(! client.fresh?(facts),
+            "Client is incorrectly up to date")
+
+        Puppet.config.use(:puppet)
+        assert_nothing_raised {
+            client.getconfig
+            client.apply
+        }
+
+        # Now it should be up to date
+        assert(client.fresh?(facts), "Client is not up to date")
+
+        # Cache this value for later
+        parse1 = master.freshness
+
+        # Verify the config got applied
+        assert(FileTest.exists?(@createdfile),
+            "Created file %s does not exist" % @createdfile)
+        Puppet::Type.allclear
+
+        sleep 1.5
+        # Create a new manifest
+        File.open(manifest, "w") { |f|
+            f.puts "file { \"%s\": ensure => file }\n" % file2
+        }
+
+        # Verify that the master doesn't immediately reparse the file; we
+        # want to wait through the timeout
+        assert_equal(parse1, master.freshness, "Master did not wait through timeout")
+        assert(client.fresh?(facts), "Client is not up to date")
+
+        # Then eliminate it
+        Puppet[:filetimeout] = 0
+
+        # Now make sure the master does reparse
+        #Puppet.notice "%s vs %s" % [parse1, master.freshness]
+        assert(parse1 != master.freshness, "Master did not reparse file")
+        assert(! client.fresh?(facts), "Client is incorrectly up to date")
+
+        # Retrieve and apply the new config
+        assert_nothing_raised {
+            client.getconfig
+            client.apply
+        }
+        assert(client.fresh?(facts), "Client is not up to date")
+
+        assert(FileTest.exists?(file2), "Second file %s does not exist" % file2)
+    end
+
+    def test_addfacts
+        master = nil
+        file = mktestmanifest()
+        # create our master
+        assert_nothing_raised() {
+            # this is the default server setup
+            master = Puppet::Network::Handler.master.new(
+                :Manifest => file,
+                :UseNodes => false,
+                :Local => true
+            )
+        }
+
+        facts = {}
+
+        assert_nothing_raised {
+            master.addfacts(facts)
+        }
+
+        %w{serverversion servername serverip}.each do |fact|
+            assert(facts.include?(fact), "Fact %s was not set" % fact)
+        end
+    end
+
+    # Make sure we're using the hostname as configured with :node_name
+    def test_hostname_in_getconfig
+        master = nil
+        file = tempfile()
+        #@createdfile = File.join(tmpdir(), self.class.to_s + "manifesttesting" +
+        #    "_" + @method_name)
+        file_cert = tempfile()
+        file_fact = tempfile()
+
+        certname = "y4yn3ss"
+        factname = Facter.value("hostname")
+
+        File.open(file, "w") { |f|
+            f.puts %{
+    node #{certname} { file { "#{file_cert}": ensure => file, mode => 755 } }
+    node #{factname} { file { "#{file_fact}": ensure => file, mode => 755 } }
+}
+        }
+        # create our master
+        assert_nothing_raised() {
+            # this is the default server setup
+            master = Puppet::Network::Handler.master.new(
+                :Manifest => file,
+                :UseNodes => true,
+                :Local => true
+            )
+        }
+
+        result = nil
+
+        # Use the hostname from facter
+        Puppet[:node_name] = 'facter'
+        assert_nothing_raised {
+            result = master.getconfig({"hostname" => factname}, "yaml", certname, "127.0.0.1")
+        }
+
+        result = result.flatten
+
+        assert(result.find { |obj| obj.name == file_fact },
+            "Could not find correct file")
+        assert(!result.find { |obj| obj.name == file_cert },
+            "Found incorrect file")
+
+        # Use the hostname from the cert
+        Puppet[:node_name] = 'cert'
+        assert_nothing_raised {
+            result = master.getconfig({"hostname" => factname}, "yaml", certname, "127.0.0.1")
+        }
+
+        result = result.flatten
+
+        assert(!result.find { |obj| obj.name == file_fact },
+            "Could not find correct file")
+        assert(result.find { |obj| obj.name == file_cert },
+            "Found incorrect file")
+    end
+
+    # Make sure we're correctly doing clientname manipulations.
+    # Testing to make sure we always get a hostname and IP address.
+    def test_clientname
+        master = nil
+        file = tempfile()
+
+        File.open(file, "w") { |f|
+            f.puts %{
+    node yay { file { "/something": ensure => file, mode => 755 } }
+}
+        }
+        # create our master
+        assert_nothing_raised() {
+            # this is the default server setup
+            master = Puppet::Network::Handler.master.new(
+                :Manifest => file,
+                :UseNodes => true,
+                :Local => true
+            )
+        }
+
+        Puppet[:node_name] = "cert"
+        # First act like we're local
+        fakename = nil
+        fakeip = nil
+
+        name = ip = nil
+        facts = Facter.to_hash
+        assert_nothing_raised do
+            name, ip = master.clientname(fakename, fakeip, facts)
+        end
+
+        assert(facts["hostname"], "Removed hostname fact")
+        assert(facts["ipaddress"], "Removed ipaddress fact")
+
+        assert_equal(facts["hostname"], name)
+        assert_equal(facts["ipaddress"], ip)
+
+        # Now set them to something real, and make sure we get them back
+        fakename = "yayness"
+        fakeip = "192.168.0.1"
+        facts = Facter.to_hash
+        assert_nothing_raised do
+            name, ip = master.clientname(fakename, fakeip, facts)
+        end
+
+        assert(facts["hostname"], "Removed hostname fact")
+        assert(facts["ipaddress"], "Removed ipaddress fact")
+
+        assert_equal(fakename, name)
+        assert_equal(fakeip, ip)
+    end
+
+    if Puppet.features.rails?
+    def test_freshness_connect_update
+        Puppet::Rails.init
+        Puppet[:storeconfigs] = true
+
+        # this is the default server setup
+        master = Puppet::Network::Handler.master.new(
+            :Code => "",
+            :UseNodes => true,
+            :Local => true
+        )
+
+        # Create a host
+        Puppet::Rails::Host.new(:name => "test", :ip => "192.168.0.3").save
+
+        assert_nothing_raised("Failed to update last_connect for unknown host") do
+            master.freshness("created",'192.168.0.1')
+        end
+        
+        # Make sure it created the host
+        created = Puppet::Rails::Host.find_by_name("created")
+        assert(created, "Freshness did not create host")
+        assert(created.last_freshcheck,
+            "Did not set last_freshcheck on created host")
+        assert_equal("192.168.0.1", created.ip,
+            "Did not set IP address on created host")
+
+        # Now check on the existing host
+        assert_nothing_raised("Failed to update last_connect for unknown host") do
+            master.freshness("test",'192.168.0.2')
+        end
+
+        # Recreate it, so we're not using the cached object.
+        host = Puppet::Rails::Host.find_by_name("test")
+        
+        # Make sure it created the host
+        assert(host.last_freshcheck,
+            "Did not set last_freshcheck on existing host")
+        assert_equal("192.168.0.3", host.ip,
+            "Overrode IP on found host")
+    end
+    end
+end
+
+# $Id: master.rb 2316 2007-03-19 16:42:41Z luke $
+