Added log4j config to the test launcher

Added shell script to run testkit.py
Removed brokertest.py, instead using the version checked in under python/qpid folder by Alan.
The shell scripts and the setup is work in progress, checking in now to help Alan reproduce an issue.


git-svn-id: https://svn.apache.org/repos/asf/qpid/trunk@881896 13f79535-47bb-0310-9956-ffa450edef68

5 files changed, 105 insertions, 332 deletions

diff --git a/qpid/java/testkit/bin/qpid-python-testkit b/qpid/java/testkit/bin/qpid-python-testkit
new file mode 100755
index 0000000000..3584e14d88
--- /dev/null
+++ b/qpid/java/testkit/bin/qpid-python-testkit
@@ -0,0 +1,32 @@
+#!/bin/bash
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you 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.
+#
+
+# This is wrapper script to run the tests defined in testkit.py 
+# via the python test runner. The defaults are set for a running
+# from an svn checkout
+
+. ./setenv.sh
+
+export PYTHONPATH=../:$PYTHONPATH
+
+echo $PYTHONPATH
+
+$PYTHON_DIR/qpid-python-test -m testkit
+
diff --git a/qpid/java/testkit/bin/setenv.sh b/qpid/java/testkit/bin/setenv.sh
new file mode 100644
index 0000000000..c2a0c46d55
--- /dev/null
+++ b/qpid/java/testkit/bin/setenv.sh
@@ -0,0 +1,44 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you 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.
+#
+
+# Environment for python tests
+test -d ../../../python || { echo "WARNING: skipping test, no python directory."; exit 0; }
+PYTHON_DIR=../../../python
+PYTHONPATH=$PYTHON_DIR:$PYTHON_DIR/qpid
+
+if [ "$QPIDD_EXEC" = "" ] ; then
+   test -x ../../../cpp/src/qpidd || { echo "WARNING: skipping test, QPIDD_EXEC not set and qpidd not found."; exit 0; }
+   QPIDD_EXEC=../../../cpp/src/qpidd
+fi
+
+if [ "$CLUSTER_LIB" = "" ] ; then
+   test -x ../../../cpp/src/.libs/cluster.so || { echo "WARNING: skipping test, CLUSTER_LIB not set and cluster.so not found."; exit 0; }
+   CLUSTER_LIB=../../../cpp/src/.libs/cluster.so
+fi
+
+if [ "$QP_CP" = "" ] ; then
+   QP_CP=`find ../../build/lib/ -name '*.jar' | tr '\n' ':'`
+fi
+
+if [ "$QUTDIR" = "" ] ; then
+   OUTDIR=../
+fi
+
+
+export PYTHONPATH PYTHON_DIR QPIDD_EXEC CLUSTER_LIB QP_CP OUTDIR
diff --git a/qpid/java/testkit/brokertest.py b/qpid/java/testkit/brokertest.py
deleted file mode 100644
index 5989713348..0000000000
--- a/qpid/java/testkit/brokertest.py
+++ /dev/null
@@ -1,324 +0,0 @@
-#
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you 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.
-#
-
-# Support library for tests that start multiple brokers, e.g. cluster
-# or federation
-
-import os, signal, string, tempfile, popen2, socket, threading, time
-import qpid
-from qpid import connection, messaging, util
-from qpid.harness import Skipped
-from unittest import TestCase
-from copy import copy
-from threading import Thread, Lock, Condition
-from shutil import rmtree 
-
-# Values for expected outcome of process at end of test
-EXPECT_EXIT_OK=1           # Expect to exit with 0 status before end of test.
-EXPECT_EXIT_FAIL=2         # Expect to exit with non-0 status before end of test.
-EXPECT_RUNNING=3           # Expect to still be running at end of test
-    
-def is_running(pid):
-    try:
-        os.kill(pid, 0)
-        return True
-    except:
-        return False
-
-class Unexpected(Exception):
-    pass
-
-class Popen(popen2.Popen3):
-    """
-    Similar to subprocess.Popen but using popen2 classes for portability.
-    Can set and verify expectation of process status at end of test.
-    """
-
-    def __init__(self, cmd, expect=EXPECT_EXIT_OK):
-        self.cmd  = [ str(x) for x in cmd ]
-        popen2.Popen3.__init__(self, self.cmd, True)
-        self.expect = expect
-        self.stdin = self.tochild
-        self.stdout = self.fromchild
-        self.stderr = self.childerr
-
-    def unexpected(self,msg):
-        raise Unexpected("%s: %s\n--stdout:\n%s\n--stderr:\n%s" %
-                         (msg, self.cmd_str(), self.stdout.read(), self.stderr.read()))
-    
-    def testend(self):                  # Clean up at end of test.
-        if self.expect == EXPECT_RUNNING:
-            try:
-                self.kill()
-            except:
-                self.unexpected("Expected running but exited %d" % self.wait())
-        else:
-            # Give the process some time to exit.
-            delay = 0.1
-            while (self.poll() is None and delay < 1):
-                time.sleep(delay)
-                delay *= 2
-            if self.returncode is None: # Still haven't stopped
-                self.kill()
-                self.unexpected("Expected to exit but still running")
-            elif self.expect == EXPECT_EXIT_OK and self.returncode != 0:
-                self.unexpected("Expected exit ok but exited %d" % self.returncode)
-            elif self.expect == EXPECT_EXIT_FAIL and self.returncode == 0:
-                self.unexpected("Expected to fail but exited ok")
-               
-    def communicate(self, input=None):
-        if input:
-            self.stdin.write(input)
-            self.stdin.close()
-        outerr = (self.stdout.read(), self.stderr.read())
-        self.wait()
-        return outerr
-
-    def is_running(self): return is_running(self.pid)
-
-    def poll(self):
-        self.returncode = popen2.Popen3.poll(self)
-        if (self.returncode == -1): self.returncode = None
-        return self.returncode
-
-    def wait(self):
-        self.returncode = popen2.Popen3.wait(self)
-        return self.returncode
-
-    def send_signal(self, sig):
-        os.kill(self.pid,sig)
-        self.wait()
-
-    def terminate(self): self.send_signal(signal.SIGTERM)
-    def kill(self): self.send_signal(signal.SIGKILL)
-        
-        
-
-    def cmd_str(self): return " ".join([str(s) for s in self.cmd])
-
-def checkenv(name):
-    value = os.getenv(name)
-    if not value: raise Exception("Environment variable %s is not set" % name)
-    return value
-
-class Broker(Popen):
-    "A broker process. Takes care of start, stop and logging."
-    _store_lib = os.getenv("STORE_LIB")
-    _qpidd = checkenv("QPIDD_EXEC")
-    _broker_count = 0
-
-    def __init__(self, test, args=[], name=None, expect=EXPECT_RUNNING):
-        """Start a broker daemon. name determines the data-dir and log
-        file names."""
-
-        self.test = test
-        cmd = [self._qpidd, "--port=0", "--no-module-dir", "--auth=no"] + args
-        if name: self.name = name
-        else:
-            self.name = "broker%d" % Broker._broker_count
-            Broker._broker_count += 1
-        self.log = os.path.join(test.dir, self.name+".log")
-        cmd += ["--log-to-file", self.log, "--log-prefix", self.name,"--log-to-stderr=no"]
-        self.datadir = os.path.join(test.dir, self.name)
-        cmd += ["--data-dir", self.datadir, "-t"]
-        if self._store_lib: cmd += ["--load-module", self._store_lib]
-
-        Popen.__init__(self, cmd, expect)
-        try: self.port = int(self.stdout.readline())
-        except Exception:
-            raise Exception("Failed to start broker: "+self.cmd_str())
-        test.cleanup_popen(self)
-        self.host = "localhost"         # Placeholder for remote brokers.
-
-    def connect(self):
-        """New API connection to the broker."""
-        return messaging.Connection.open(self.host, self.port)
-
-    def connect_old(self):
-        """Old API connection to the broker."""
-        socket = qpid.util.connect(self.host,self.port)
-        connection = qpid.connection.Connection (sock=socket)
-        connection.start()
-        return connection;
-
-    def declare_queue(self, queue):
-        c = self.connect_old()
-        s = c.session(str(qpid.datatypes.uuid4()))
-        s.queue_declare(queue=queue)
-        c.close()
-
-class Cluster:
-    """A cluster of brokers in a test."""
-
-    _cluster_lib = checkenv("CLUSTER_LIB")
-    _cluster_count = 0
-
-    def __init__(self, test, count=0, args=[], expect=EXPECT_RUNNING):
-        self.test = test
-        self._brokers=[]
-        self.name = "cluster%d" % Cluster._cluster_count
-        Cluster._cluster_count += 1
-        # Use unique cluster name
-        self.args = copy(args)
-        self.args += [ "--cluster-name", "%s-%s:%d" % (self.name, socket.gethostname(), os.getpid()) ]
-        self.args += [ "--load-module", self._cluster_lib ]
-        self.start_n(count, expect=expect)
-
-    def start(self, name=None, expect=EXPECT_RUNNING):
-        """Add a broker to the cluster. Returns the index of the new broker."""
-        if not name: name="%s-%d" % (self.name, len(self._brokers))
-        self._brokers.append(self.test.broker(self.args, name, expect))
-        return self._brokers[-1]
-
-    def start_n(self, count, expect=EXPECT_RUNNING):
-        for i in range(count): self.start(expect=expect)
-
-    def wait(self):
-        """Wait for all cluster members to be ready"""
-        for b in self._brokers:
-            b.connect().close()
-
-    # Behave like a list of brokers.
-    def __len__(self): return len(self._brokers)
-    def __getitem__(self,index): return self._brokers[index]
-    def __iter__(self): return self._brokers.__iter__()
-
-class BrokerTest(TestCase):
-    """
-    Tracks processes started by test and kills at end of test.
-    Provides a well-known working directory for each test.
-    """
-
-    # FIXME aconway 2009-11-05: too many env vars, need a simpler
-    # scheme for locating exes and libs
-
-    cluster_lib = os.getenv("CLUSTER_LIB")
-    xml_lib = os.getenv("XML_LIB")
-    qpidConfig_exec = os.getenv("QPID_CONFIG_EXEC")
-    qpidRoute_exec = os.getenv("QPID_ROUTE_EXEC")
-    receiver_exec = os.getenv("RECEIVER_EXEC")
-    sender_exec = os.getenv("SENDER_EXEC")
-
-    def setUp(self):
-        self.dir = os.path.join("brokertest.tmp", self.id())
-        if os.path.exists(self.dir):
-            rmtree(self.dir)             
-        os.makedirs(self.dir)
-        self.popens = []
-
-    def tearDown(self):
-        err = []
-        for p in self.popens:
-            try: p.testend()
-            except Unexpected, e: err.append(str(e))
-        if err: raise Exception("\n".join(err))
-
-    # FIXME aconway 2009-11-06: check for core files of exited processes.
-    
-    def cleanup_popen(self, popen):
-        """Add process to be killed at end of test"""
-        self.popens.append(popen)
-
-    def popen(self, cmd, expect=EXPECT_EXIT_OK):
-        """Start a process that will be killed at end of test"""
-        p = Popen(cmd, expect)
-        self.cleanup_popen(p)
-        return p
-
-    def broker(self, args=[], name=None, expect=EXPECT_RUNNING):
-        """Create and return a broker ready for use"""
-        b = Broker(self, args, name, expect)
-        b.connect().close()
-        return b
-
-    def cluster(self, count=0, args=[], expect=EXPECT_RUNNING):
-        """Create and return a cluster ready for use"""
-        cluster = Cluster(self, count, args, expect=expect)
-        cluster.wait()
-        return cluster
-
-class StoppableThread(Thread):
-    """
-    Base class for threads that do something in a loop and periodically check
-    to see if they have been stopped.
-    """
-    def __init__(self):
-        self.stopped = False
-        self.error = None
-        Thread.__init__(self)
-
-    def stop(self):
-        self.stopped = True
-        self.join()
-        if self.error: raise self.error
-    
-class Sender(StoppableThread):
-    """
-    Thread to run a sender client and send numbered messages until stopped.
-    """
-
-    def __init__(self, broker):
-        StoppableThread.__init__(self)
-        self.sender = broker.test.popen(
-            [broker.test.sender_exec, "--port", broker.port], expect=EXPECT_RUNNING)
-
-    def run(self):
-        try:
-            self.sent = 0
-            while not self.stopped:
-                self.sender.stdin.write(str(self.sent)+"\n")
-                self.sender.stdin.flush()
-                self.sent += 1
-        except Exception, e: self.error = e
-
-class Receiver(Thread):
-    """
-    Thread to run a receiver client and verify it receives
-    sequentially numbered messages.
-    """
-    def __init__(self, broker):
-        Thread.__init__(self)
-        self.test = broker.test
-        self.receiver = self.test.popen(
-            [self.test.receiver_exec, "--port", broker.port], expect=EXPECT_RUNNING)
-        self.stopat = None
-        self.lock = Lock()
-        self.error = None
-
-    def run(self):
-        try:
-            self.received = 0
-            while self.stopat is None or self.received < self.stopat:
-                self.lock.acquire()
-                try:
-                    self.test.assertEqual(self.receiver.stdout.readline(), str(self.received)+"\n")
-                    self.received += 1
-                finally:
-                    self.lock.release()
-        except Exception, e:
-            self.error = e
-
-    def stop(self, count):
-        """Returns when received >= count"""
-        self.lock.acquire()
-        self.stopat = count
-        self.lock.release()
-        self.join()
-        if self.error: raise self.error
-
diff --git a/qpid/java/testkit/src/main/java/org/apache/qpid/testkit/TestLauncher.java b/qpid/java/testkit/src/main/java/org/apache/qpid/testkit/TestLauncher.java
index f13ee3f75c..b55afa7066 100644
--- a/qpid/java/testkit/src/main/java/org/apache/qpid/testkit/TestLauncher.java
+++ b/qpid/java/testkit/src/main/java/org/apache/qpid/testkit/TestLauncher.java
@@ -39,6 +39,11 @@ import javax.jms.MessageProducer;
 import javax.jms.Session;
 import javax.jms.TextMessage;
 
+import org.apache.log4j.BasicConfigurator;
+import org.apache.log4j.ConsoleAppender;
+import org.apache.log4j.Level;
+import org.apache.log4j.Logger;
+import org.apache.log4j.PatternLayout;
 import org.apache.qpid.client.AMQConnection;
 import org.apache.qpid.client.AMQQueue;
 import org.apache.qpid.client.AMQTopic;
@@ -117,8 +122,26 @@ public class TestLauncher implements ErrorHandler
     	   
     	   System.out.println("Failover exchange " + url );
        }
+       
+       configureLogging();
     }
 
+    protected void configureLogging()
+    {
+    	PatternLayout layout = new PatternLayout();
+    	layout.setConversionPattern("%t %d %p [%c{4}] %m%n");
+    	BasicConfigurator.configure(new ConsoleAppender(layout));
+    	
+    	String logLevel = System.getProperty("log.level","warn");
+    	String logComponent = System.getProperty("log.comp","org.apache.qpid");
+    	
+    	Logger logger = Logger.getLogger(logComponent);
+    	logger.setLevel(Level.toLevel(logLevel, Level.WARN));
+    	
+    	System.out.println("Level " + logger.getLevel());
+    	
+    }
+    
     public void setUpControlChannel()
     {
         try
diff --git a/qpid/java/testkit/testkit.py b/qpid/java/testkit/testkit.py
index 2bb4f234ec..1cfc7a5e59 100755
--- a/qpid/java/testkit/testkit.py
+++ b/qpid/java/testkit/testkit.py
@@ -66,7 +66,8 @@ class JavaClientTest(BrokerTest):
         cmd += ["-Dmsg_count=" + str(options.get("msg_count",10))]
         cmd += ["-Dsleep_time=" + str(options.get("sleep_time",1000))]
         cmd += ["-Dfailover=" + options.get("failover", "failover_exchange")]
-        cmd += ["-Dreliability=" + options.get("reliability", "exactly_once")]        
+        cmd += ["-Dreliability=" + options.get("reliability", "exactly_once")]  
+        cmd += ["-Dlog.level=" + options.get("log.level", "warn")]  
         cmd += [self.client_class]
 
         print str(options.get("port",5672))  
@@ -119,7 +120,7 @@ class JavaClientTest(BrokerTest):
 class ConcurrencyTest(JavaClientTest):
     """A concurrency test suite for the JMS client"""
 
-    def test_multiplexing_con(self):
+    def xtest_multiplexing_con(self):
         """Tests multiple sessions on a single connection""" 
 
         cluster = Cluster(self, 2)
@@ -146,7 +147,7 @@ class ConcurrencyTest(JavaClientTest):
     def test_multiplexing_con_tx(self):
         """Tests multiple transacted sessions on a single connection""" 
 
-        cluster = Cluster(self, 2)
+        cluster = Cluster(self,2)
         ssn = cluster[0].connect().session()
         p = cluster[0].port
      
@@ -173,7 +174,7 @@ class ConcurrencyTest(JavaClientTest):
 class SoakTest(JavaClientTest):
     """A soak test suite for the JMS client"""
 
-    def test_failover(self):
+    def xtest_failover(self):
         cluster = self.cluster(4, expect=EXPECT_EXIT_FAIL)
         p = cluster[0].port
         self.start_error_watcher(broker=cluster[0])
@@ -209,7 +210,4 @@ class SoakTest(JavaClientTest):
         self.verify(receiver,sender)
         if error_msg:      
             raise Exception(error_msg)            
-  
-if __name__ == '__main__':
-    if not test.main(): sys.exit(1)
-        
+