Central logging now works, although there appear to be a few kinks to work out.

git-svn-id: https://reductivelabs.com/svn/puppet/trunk@732 980ebf18-57e1-0310-9a29-db15c13687c0

5 files changed, 229 insertions, 31 deletions

diff --git a/test/executables/puppetmasterd.rb b/test/executables/puppetmasterd.rb
index 6b67e5e37..a80190d00 100755
--- a/test/executables/puppetmasterd.rb
+++ b/test/executables/puppetmasterd.rb
@@ -29,6 +29,10 @@ class TestPuppetMasterD < Test::Unit::TestCase
     def test_normalstart
         startmasterd
 
+        pidfile = File.join(Puppet[:puppetvar], "puppetmasterd.pid")
+        assert(FileTest.exists?(pidfile), "PID file does not exist")
+
+        sleep(1)
         assert_nothing_raised {
             socket = TCPSocket.new("127.0.0.1", @@port)
             socket.close
@@ -86,7 +90,7 @@ class TestPuppetMasterD < Test::Unit::TestCase
 
     # verify that we can run puppetmasterd in parse-only mode
     def test_parseonly
-        startmasterd("--parseonly")
+        startmasterd("--parseonly > /dev/null")
         sleep(1)
 
         pid = nil
diff --git a/test/other/log.rb b/test/other/log.rb
index 4f59716d7..5caf68bec 100644
--- a/test/other/log.rb
+++ b/test/other/log.rb
@@ -13,20 +13,20 @@ require 'test/unit'
 
 class TestLog < Test::Unit::TestCase
     include TestPuppet
-    @@logfile = File.join(Puppet[:logdir], "puppettest.log")
 
     def teardown
-        system("rm -f %s" % @@logfile)
-        Puppet::Log.destination=(:console)
-        Puppet[:loglevel] = :notice
+        super
+        Puppet::Log.close
     end
 
     def getlevels
         levels = nil
         assert_nothing_raised() {
-            levels = Puppet::Log.levels
+            levels = []
+            Puppet::Log.eachlevel { |level| levels << level }
         }
-        return levels 
+        # Don't test the top levels; too annoying
+        return levels.reject { |level| level == :emerg or level == :crit }
     end
 
     def mkmsgs(levels)
@@ -42,19 +42,19 @@ class TestLog < Test::Unit::TestCase
     end
 
     def test_logfile
-        Puppet[:debug] = true if __FILE__ == $0
         fact = nil
         levels = nil
         levels = getlevels
+        logfile = tempfile()
         assert_nothing_raised() {
-            Puppet::Log.destination=(@@logfile)
+            Puppet::Log.newdestination(logfile)
         }
         msgs = mkmsgs(levels)
         assert(msgs.length == levels.length)
-        Puppet::Log.flush
+        Puppet::Log.close
         count = 0
         assert_nothing_raised() {
-            File.open(@@logfile) { |of|
+            File.open(logfile) { |of|
                 count = of.readlines.length
             }
         }
@@ -69,7 +69,7 @@ class TestLog < Test::Unit::TestCase
             }
         }
         assert_nothing_raised() {
-            Puppet::Log.destination=("syslog")
+            Puppet::Log.newdestination("syslog")
         }
         # there's really no way to verify that we got syslog messages...
         msgs = mkmsgs(levels)
@@ -79,12 +79,9 @@ class TestLog < Test::Unit::TestCase
     def test_consolelog
         Puppet[:debug] = true if __FILE__ == $0
         fact = nil
-        levels = nil
-        assert_nothing_raised() {
-            levels = Puppet::Log.levels
-        }
+        levels = getlevels
         assert_nothing_raised() {
-            Puppet::Log.destination=(:console)
+            Puppet::Log.newdestination(:console)
         }
         msgs = mkmsgs(levels)
         assert(msgs.length == levels.length)
@@ -93,7 +90,7 @@ class TestLog < Test::Unit::TestCase
 
     def test_levelmethods
         assert_nothing_raised() {
-            Puppet::Log.destination=("/dev/null")
+            Puppet::Log.newdestination("/dev/null")
         }
         getlevels.each { |level|
             assert_nothing_raised() {
@@ -112,15 +109,12 @@ class TestLog < Test::Unit::TestCase
     end
 
     def test_creatingdirs
-        curdest = Puppet[:logdest]
-
         Puppet[:logdest] = "/tmp/logtesting/logfile"
         Puppet.info "testing logs"
         assert(FileTest.directory?("/tmp/logtesting"))
         assert(FileTest.file?("/tmp/logtesting/logfile"))
 
         system("rm -rf /tmp/logtesting")
-        Puppet[:logdest] = curdest
     end
 
     def test_logtags
diff --git a/test/puppettest.rb b/test/puppettest.rb
index 5b108712d..6f6b961f8 100644
--- a/test/puppettest.rb
+++ b/test/puppettest.rb
@@ -37,9 +37,11 @@ module TestPuppet
         @@tmppids = []
 
         if $0 =~ /.+\.rb/
+            Puppet[:logdest] = :console
             Puppet[:loglevel] = :debug
             $VERBOSE = 1
         else
+            Puppet::Log.close
             Puppet[:logdest] = "/dev/null"
             Puppet[:httplog] = "/dev/null"
         end
@@ -90,6 +92,9 @@ module TestPuppet
         @@tmppids.clear
         Puppet::Type.allclear
         Puppet.clear
+
+        # reset all of the logs
+        Puppet::Log.close
     end
 
     def tempfile
@@ -276,6 +281,7 @@ module ExeTest
         }
         assert($? == 0, "Puppetmasterd exit status was %s" % $?)
         assert_equal("", output, "Puppetmasterd produced output %s" % output)
+        sleep(1)
 
         return manifest
     end
@@ -283,20 +289,38 @@ module ExeTest
     def stopmasterd(running = true)
         ps = Facter["ps"].value || "ps -ef"
 
+        pidfile = File.join(Puppet[:puppetvar], "puppetmasterd.pid")
+
         pid = nil
-        %x{#{ps}}.chomp.split(/\n/).each { |line|
-            if line =~ /ruby.+puppetmasterd/
-                next if line =~ /\.rb/ # skip the test script itself
-                ary = line.split(" ")
-                pid = ary[1].to_i
+        if FileTest.exists?(pidfile)
+            pid = File.read(pidfile).chomp.to_i
+            File.unlink(pidfile)
+        end
+
+        if running or pid
+            runningpid = nil
+            %x{#{ps}}.chomp.split(/\n/).each { |line|
+                if line =~ /ruby.+puppetmasterd/
+                    next if line =~ /\.rb/ # skip the test script itself
+                    ary = line.split(/\s+/)
+                    runningpid = ary[1].to_i
+                end
+            }
+
+            if running
+                assert(runningpid, "Process is not running")
+                assert_equal(pid, runningpid, "PIDs are not equal")
+            else
+                return
             end
-        }
+        end
 
         # we default to mandating that it's running, but teardown
         # doesn't require that
-        if running or pid
-            assert(pid)
-
+        if pid
+            if pid == $$
+                raise Puppet::Error, "Tried to kill own pid"
+            end
             assert_nothing_raised {
                 Process.kill("-INT", pid)
             }
diff --git a/test/server/logger.rb b/test/server/logger.rb
new file mode 100644
index 000000000..06b79c786
--- /dev/null
+++ b/test/server/logger.rb
@@ -0,0 +1,176 @@
+if __FILE__ == $0
+    $:.unshift '../../lib'
+    $:.unshift '..'
+    $puppetbase = "../.."
+end
+
+require 'puppet'
+require 'test/unit'
+require 'puppettest.rb'
+require 'base64'
+require 'cgi'
+
+class TestLogger < Test::Unit::TestCase
+	include ServerTest
+
+    # Test the log driver manually
+    def test_localaddlog
+        logger = nil
+        assert_nothing_raised {
+            logger = Puppet::Server::Logger.new
+        }
+
+        msg = nil
+        assert_nothing_raised {
+            msg = Puppet::Log.create(
+                :level => :info,
+                :message => "This is a message"
+            )
+        }
+
+        assert_nothing_raised {
+            logger.addlog(msg)
+        }
+    end
+
+    # Test it while replicating a remote client
+    def test_remoteaddlog
+        logger = nil
+        assert_nothing_raised {
+            logger = Puppet::Server::Logger.new
+        }
+
+        msg = nil
+        assert_nothing_raised {
+            msg = Puppet::Log.create(
+                :level => :info,
+                :message => "This is a remote message"
+            )
+        }
+
+        assert_nothing_raised {
+            msg = CGI.escape(Marshal::dump(msg))
+        }
+        assert_nothing_raised {
+            logger.addlog(msg, "localhost", "127.0.0.1")
+        }
+    end
+
+    # Now test it with a real client and server, but not remote
+    def test_localclient
+        client = nil
+        assert_nothing_raised {
+            client = Puppet::Client::LogClient.new(:Logger => true)
+        }
+
+        msg = nil
+        assert_nothing_raised {
+            msg = Puppet::Log.create(
+                :level => :info,
+                :message => "This is a logclient message"
+            )
+        }
+
+        msg = CGI.escape(Marshal::dump(msg))
+
+        assert_nothing_raised {
+            client.addlog(msg, "localhost", "127.0.0.1")
+        }
+    end
+
+    # And now test over the network
+    def test_logclient
+        Puppet.err :mark
+        pid = nil
+        clientlog = tempfile()
+        serverlog = tempfile()
+        Puppet.warning "serverlog is %s" % serverlog
+        Puppet[:logdest] = clientlog
+        Puppet::Log.close(:syslog)
+
+        # For testing
+        Puppet[:autosign] = true
+
+        logger = nil
+        # Create our server
+        assert_nothing_raised {
+            logger = Puppet::Server.new(
+                :Port => @@port,
+                :Handlers => {
+                    :CA => {}, # so that certs autogenerate
+                    :Logger => {}
+                }
+            )
+        }
+
+        # Start our server
+        serverpid = fork {
+            Puppet::Log.close(clientlog)
+            Puppet[:logdest] = serverlog
+            assert_nothing_raised() {
+                trap(:INT) { logger.shutdown }
+                logger.start
+            }
+        }
+        @@tmppids << serverpid
+        sleep(0.5)
+
+        # Start a raw xmlrpc client
+        client = nil
+        assert_nothing_raised() {
+            client = Puppet::Client::LogClient.new(
+                :Server => "localhost",
+                :Port => @@port
+            )
+            unless client.readcert
+                raise "Could not get certs"
+            end
+        }
+        retval = nil
+
+        {
+            :notice => "XMLRPC1",
+            :warning => "XMLRPC2",
+            :err => "XMLRPC3"
+        }.each { |level, str|
+            msg = CGI.escape(Marshal::dump(Puppet::Log.create(
+                :level => level,
+                :message => str
+            )))
+            assert_nothing_raised {
+                retval = client.addlog(msg)
+            }
+        }
+
+        # and now use the normal client action
+
+        # Set the log destination to be the server
+        Puppet[:logdest] = "localhost:%s" % @@port
+
+        # And now do some logging
+        assert_nothing_raised {
+            Puppet.notice "TEST1"
+            Puppet.warning "TEST2"
+            Puppet.err "TEST3"
+        }
+
+        assert_nothing_raised {
+            Process.kill("INT", serverpid)
+        }
+
+        assert(FileTest.exists?(serverlog), "Server log does not exist")
+
+        # Give it a bit to flush to disk
+        sleep(0.5)
+        content = nil
+        assert_nothing_raised {
+            content = File.read(serverlog)
+        }
+
+        %w{TEST1 TEST2 TEST3}.each { |str|
+            assert(content =~ %r{#{str}}, "Content does not match %s" % str)
+        }
+    end
+end
+
+# $Id$
diff --git a/test/types/type.rb b/test/types/type.rb
index 509a4b402..4347ea0b0 100644
--- a/test/types/type.rb
+++ b/test/types/type.rb
@@ -51,7 +51,7 @@ class TestType < Test::Unit::TestCase
 
     def test_stringvssymbols
         file = nil
-        path = "/tmp/testfile"
+        path = tempfile()
         assert_nothing_raised() {
             system("rm -f %s" % path)
             file = Puppet::Type::PFile.create(