Merge lp:~patrick-crews/drizzle/dbqp_randgen into lp:drizzle/7.0

[Patrick Crews]

We now have a randgen-mode : )
A variety of tweaks / changes and fixes are included.
Also added --gendata option that will call the randgen's gendata utility before executing any test - can be useful for ad-hoc or other testing.
randgen tests are organized and execute exactly as dtr tests:
http://paste.drizzle.org/show/403/

Have done some basic tests and have a separate bug for bringing drizzle-automation randgen tests to the tree.

Updated docs to reflect the changes

=== modified file '.bzrignore'
--- .bzrignore	2011-02-22 04:19:44 +0000
+++ .bzrignore	2011-02-23 17:24:15 +0000
@@ -327,6 +327,7 @@
 tests/test-run@
 tests/total_warning_count
 tests/var
+tests/workdir
 thr_malloc.gcno
 time.gcno
 tmp_table.gcno
@@ -345,6 +346,3 @@
 drizzled/message/catalog.pb.h
 drizzled/message/catalog_reader
 drizzled/message/catalog_writer
-drizzled/message/replication_options.pb.cc
-drizzled/message/replication_options.pb.h
-libdrizzle/mysql_password_hash

=== modified file 'docs/testing/dbqp.rst'
--- docs/testing/dbqp.rst	2011-02-14 21:47:46 +0000
+++ docs/testing/dbqp.rst	2011-02-23 17:24:15 +0000
@@ -13,11 +13,7 @@
 :program:`dbqp.py` is BETA software.  It is intended to provide a standardized
 platform to facilitate Drizzle testing.  
 
-Currently, it only serves as a partial substitute for test-run.pl.
-One can execute the test suite, record test cases, and use certain other options.
-Other test-run.pl option such as gdb and valgrind are still in-development.
-
-The current mode is 'dtr' and is used to execute tests from the Drizzle 
+The default mode is 'dtr' and is used to execute tests from the Drizzle 
 test suite.  These tests are included with Drizzle distributions and 
 provide a way for users to verify that the system will operate according
 to expectations.
@@ -28,6 +24,14 @@
 highlighting the differences found between expected and actual results; this
 can be useful for troubleshooting and in bug reports.
 
+The program is also integrated with the random query generator testing tool
+and a 'rangden' mode is available - it will execute randgen tests when
+provided a path to a randgen installation.  Tests are organized similar to dtr
+tests, but are .cnf file based.
+
+A 'cleanup' mode is also available as a convenience - it will simply shutdown
+any servers that may have been started via start-and-exit.
+
 While most users are concerned with ensuring general functionality, the 
 program also allows a user to quickly spin up a server for ad-hoc testing
 and to run the test-suite against an already running Drizzle server.
@@ -150,10 +154,69 @@
 
 NOTE: This feature is still being tested, use caution with your data!!!
 
+Randgen mode / Executing randgen tests
+---------------------------------------
+
+Using :option:`--mode` =randgen and :option:`--randgen-path` =/path/to/randgen
+will cause the randgen tests to execute.  This are simple .cnf file-based
+tests that define various randgen command lines that are useful in testing
+the server.  Test organization is similar to the dtr tests.  Tests live in 
+suites, the default suite is 'main' and they all live in
+drizzle/tests/randgen_tests::
+
+	./dbqp.py --mode=randgen --randgen-path=/path/to/randgen
+
+A user may specify suites and individual tests to run, just as with dtr-based
+testing.  Test output is the same as well::
+
+    ./dbqp --mode=randgen --randgen-path=/home/username/repos/randgen
+    Setting --no-secure-file-priv=True for randgen mode...
+    <snip>
+    23 Feb 2011 11:42:43 INFO: Using testing mode: randgen
+    <snip>
+    23 Feb 2011 11:44:58 : ================================================================================
+    23 Feb 2011 11:44:58 : TEST NAME                                               [ RESULT ]    TIME (ms)
+    23 Feb 2011 11:44:58 : ================================================================================
+    23 Feb 2011 11:44:58 : main.optimizer_subquery                                 [ pass ]       134153
+    23 Feb 2011 11:45:03 : main.outer_join                                         [ pass ]         5136
+    23 Feb 2011 11:45:06 : main.simple                                             [ pass ]         2246
+    23 Feb 2011 11:45:06 : ================================================================================
+    23 Feb 2011 11:45:06 INFO: Test execution complete in 142 seconds
+    23 Feb 2011 11:45:06 INFO: Summary report:
+    23 Feb 2011 11:45:06 INFO: Executed 3/3 test cases, 100.00 percent
+    23 Feb 2011 11:45:06 INFO: STATUS: PASS, 3/3 test cases, 100.00 percent executed
+    23 Feb 2011 11:45:06 INFO: Spent 141 / 142 seconds on: TEST(s)
+    23 Feb 2011 11:45:06 INFO: Test execution complete
+    23 Feb 2011 11:45:06 INFO: Stopping all running servers...
+
+Cleanup mode
+-------------
+A cleanup mode is provided for user convenience.  This simply shuts down
+any servers whose pid files are detected in the dbqp workdir.  It is mainly
+intended as a quick cleanup for post-testing with :option:`--start-and-exit`::
+
+	./dbqp.py --mode=cleanup
+
+    Setting --start-dirty=True for cleanup mode...
+    23 Feb 2011 11:35:59 INFO: Using Drizzle source tree:
+    23 Feb 2011 11:35:59 INFO: basedir: drizzle
+    23 Feb 2011 11:35:59 INFO: clientbindir: drizzle/client
+    23 Feb 2011 11:35:59 INFO: testdir: drizzle/tests
+    23 Feb 2011 11:35:59 INFO: server_version: 2011.02.2188
+    23 Feb 2011 11:35:59 INFO: server_compile_os: unknown-linux-gnu
+    23 Feb 2011 11:35:59 INFO: server_platform: x86_64
+    23 Feb 2011 11:35:59 INFO: server_comment: (Source distribution (dbqp_randgen))
+    23 Feb 2011 11:35:59 INFO: Using --start-dirty, not attempting to touch directories
+    23 Feb 2011 11:35:59 INFO: Using default-storage-engine: innodb
+    23 Feb 2011 11:35:59 INFO: Using testing mode: cleanup
+    23 Feb 2011 11:35:59 INFO: Killing pid 10484 from drizzle/tests/workdir/testbot0/server0/var/run/server0.pid
+    23 Feb 2011 11:35:59 INFO: Stopping all running servers...
+
 Program architecture
 ====================
 
-:program:`dbqp.py` uses a simple diff-based mechanism for testing.  
+:program:`dbqp.py`'s 'dtr' mode uses a simple diff-based mechanism for testing.
+This is the default mode and where the majority of Drizzle testing occurs.  
 It will execute the statements contained in a test and compare the results 
 to pre-recorded expected results.  In the event of a test failure, you
 will be presented with a diff::
@@ -225,6 +288,12 @@
    Don't try to cleanup from earlier runs 
    (currently just a placeholder) [False]
 
+.. option:: --randgen-path=RANDGENPATH
+
+    The path to a randgen installation that can be used to
+    execute randgen-based tests
+
+
 Options for controlling which tests are executed
 ------------------------------------------------
 .. option:: --suite=SUITELIST
@@ -255,6 +324,7 @@
    for the given mode [False]
 
 .. option:: --repeat=REPEAT     
+
     Run each test case the specified number of times.  For
     a given sequence, the first test will be run n times,
     then the second, etc [1]
@@ -329,7 +399,7 @@
 
 
 Options for defining the tools we use for code analysis (valgrind, gprof, gcov, etc)
----------------------------------------------------------------------------------------
+------------------------------------------------------------------------------------
 .. option:: --valgrind          
 
    Run drizzletest and drizzled executables using
@@ -341,7 +411,7 @@
    valgrind options)
 
 Options for controlling the use of debuggers with test execution
-------------------------------------------------------------------
+----------------------------------------------------------------
 .. option:: --gdb
 
     Start the drizzled server(s) in gdb
@@ -351,6 +421,15 @@
     Allows you to start the drizzled server(s) in gdb
     manually (in another window, etc
 
+Options to call additional utilities such as datagen
+------------------------------------------------------
+.. option:: --gendata=GENDATAFILE
+            
+    Call the randgen's gendata utility to use the
+    specified configuration file.  This will populate the
+    server prior to any test execution
+
+
     
 
 

=== modified file 'tests/include.am'
--- tests/include.am	2011-02-16 17:05:26 +0000
+++ tests/include.am	2011-02-23 17:24:15 +0000
@@ -54,7 +54,7 @@
 		--reorder \
 		--basedir=../${top_srcdir} \
 		--testdir=../${top_srcdir}/tests \
-                --workdir=../${top_srcdir}/tests/dbqp_work
+                --workdir=../${top_srcdir}/tests/workdir
 
 
 EXTRA_DIST += \
@@ -160,7 +160,7 @@
 
 nukevar:
 	rm -rf tests/var \
-        rm -rf tests/dbqp_work \
+        rm -rf tests/workdir \
         rm tests/dbqp_data/*
  
 

=== modified file 'tests/lib/drizzle_test_run/dtr_test_execution.py'
--- tests/lib/drizzle_test_run/dtr_test_execution.py	2011-02-10 02:05:07 +0000
+++ tests/lib/drizzle_test_run/dtr_test_execution.py	2011-02-23 17:24:15 +0000
@@ -37,7 +37,7 @@
 
 import lib.test_mgmt.test_execution as test_execution
 
-class dtrTestExecutor(test_execution.testExecutor):
+class testExecutor(test_execution.testExecutor):
     """ dtr-specific testExecutor 
         We currently execute by sending test-case
         data to client/drizzletest...for now
@@ -172,6 +172,7 @@
                    ,  'RABBITMQ_NODE_PORT': str(self.master_server.rabbitmq_node_port)
                    ,  'DRIZZLE_TCP_PORT': str(self.master_server.drizzle_tcp_port)
                    ,  'EXE_DRIZZLE': self.master_server.drizzle_client
+                   ,  'MASTER_SERVER_SLAVE_CONFIG' : self.master_server.slave_config_file
                    ,  'DRIZZLE_DUMP': "%s --no-defaults -uroot -p%d" %( self.master_server.drizzledump
                                                         , self.master_server.master_port)
                    ,  'DRIZZLE_SLAP': "%s -uroot -p%d" %( self.master_server.drizzleslap

=== modified file 'tests/lib/drizzle_test_run/dtr_test_management.py'
--- tests/lib/drizzle_test_run/dtr_test_management.py	2011-02-04 20:41:08 +0000
+++ tests/lib/drizzle_test_run/dtr_test_management.py	2011-02-23 17:24:15 +0000
@@ -64,6 +64,8 @@
         self.slave_count = 0
         self.master_count = 1
         self.server_options = test_server_options
+        # We will populate this in a better fashion later on
+        self.server_requirements=[self.server_options]
         self.comment = comment
         self.master_sh = master_sh
         self.disable = disable
@@ -188,12 +190,7 @@
             a given test
 
         """
-        """
-        (self, test_case=None, test_name=None, suite_name=None
-                 , test_server_options=[], test_path=None, result_path=None
-                 , comment=None, master_sh=None, disable=0, innodb_test=0 
-                 , need_debug=0, debug=0):
-        """
+
         test_path = os.path.join(testdir,test_case)
         result_file_name = test_name+'.result'       
         result_path = self.find_result_path(resultdir, result_file_name)

=== added directory 'tests/lib/randgen'
=== added file 'tests/lib/randgen/__init__.py'
=== added file 'tests/lib/randgen/randgen_test_execution.py'
--- tests/lib/randgen/randgen_test_execution.py	1970-01-01 00:00:00 +0000
+++ tests/lib/randgen/randgen_test_execution.py	2011-02-23 17:24:15 +0000
@@ -0,0 +1,175 @@
+#! /usr/bin/env python
+# -*- mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
+# vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+#
+# Copyright (C) 2010 Patrick Crews
+#
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+""" dtr_test_execution:
+    code related to the execution of dtr test cases 
+    
+    We are provided access to a testManager with 
+    dtr-specific testCases.  We contact teh executionManager
+    to produce the system and server configurations we need
+    to execute a test.
+
+"""
+
+# imports
+import os
+import sys
+import subprocess
+import commands
+
+import lib.test_mgmt.test_execution as test_execution
+
+class randgenTestExecutor(test_execution.testExecutor):
+    """ dtr-specific testExecutor 
+        We currently execute by sending test-case
+        data to client/randgen...for now
+
+    """
+  
+    def execute_testCase (self):
+        """ Execute a dtr testCase via calls to randgen (boo)
+            Eventually, we will replace randgen with pythonic
+            goodness, but we have these classes stored here for the moment
+
+        """
+        test_execution.testExecutor.execute_testCase(self)
+        self.status = 0
+
+        # execute the randgen
+        self.execute_randgen()
+
+        # analyze results
+        self.current_test_status = self.process_randgen_output()
+        self.set_server_status(self.current_test_status)
+ 
+
+    
+
+    def execute_randgen(self):
+        """ Execute the commandline and return the result.
+            We use subprocess as we can pass os.environ dicts and whatnot 
+
+        """
+      
+        testcase_name = self.current_testcase.fullname
+        self.time_manager.start(testcase_name,'test')
+        randgen_outfile = os.path.join(self.logdir,'randgen.out')
+        randgen_output = open(randgen_outfile,'w')
+        dsn = "--dsn=dbi:drizzle:host=localhost:port=%d:user=root:password="":database=test" %(self.master_server.master_port)
+        randgen_cmd = " ".join([self.current_testcase.test_command, dsn])
+        randgen_subproc = subprocess.Popen( randgen_cmd
+                                         , shell=True
+                                         , cwd=self.system_manager.randgen_path
+                                         , env=self.working_environment
+                                         , stdout = randgen_output
+                                         , stderr = subprocess.STDOUT
+                                         )
+        randgen_subproc.wait()
+        retcode = randgen_subproc.returncode     
+        execution_time = int(self.time_manager.stop(testcase_name)*1000) # millisec
+
+        randgen_output.close()
+        randgen_file = open(randgen_outfile,'r')
+        output = ''.join(randgen_file.readlines())
+        #print output
+        randgen_file.close()
+
+        if self.debug:
+            self.logging.debug("randgen_retcode: %d" %(retcode))
+        self.current_test_retcode = retcode
+        self.current_test_output = output
+        self.current_test_exec_time = execution_time
+
+    def process_randgen_output(self):
+        """ randgen has run, we now check out what we have """
+        retcode = self.current_test_retcode
+        if retcode == 0:
+            return 'pass'
+        else:
+            return 'fail'
+
+    def handle_system_reqs(self):
+        """ We check our test case and see what we need to do
+            system-wise to get ready.  This is likely to be 
+            mode-dependent and this is just a placeholder
+            method
+
+        """
+
+        self.process_environment_reqs()
+        self.process_symlink_reqs()
+        self.process_master_sh()  
+        return
+
+    def process_master_sh(self):
+        """ We do what we need to if we have a master.sh file """
+        if self.current_testcase.master_sh:
+            retcode, output = self.system_manager.execute_cmd("/bin/sh %s" %(self.current_testcase.master_sh))
+            if self.debug:
+                self.logging.info("retcode: %retcode")
+                self.logging.info("%output")
+
+    def process_environment_reqs(self):
+        """ We generate the ENV vars we need set
+            and then ask systemManager to do so
+
+        """
+        env_reqs = { 'randgen_VARDIR': self.master_server.vardir
+                   ,  'DRIZZLE_TMP_DIR': self.master_server.tmpdir
+                   ,  'MASTER_MYSOCK': self.master_server.socket_file
+                   ,  'MASTER_MYPORT': str(self.master_server.master_port)
+                   ,  'MC_PORT': str(self.master_server.mc_port)
+                   ,  'PBMS_PORT': str(self.master_server.pbms_port)
+                   ,  'RABBITMQ_NODE_PORT': str(self.master_server.rabbitmq_node_port)
+                   ,  'DRIZZLE_TCP_PORT': str(self.master_server.drizzle_tcp_port)
+                   ,  'EXE_DRIZZLE': self.master_server.drizzle_client
+                   ,  'MASTER_SERVER_SLAVE_CONFIG' : self.master_server.slave_config_file
+                   ,  'DRIZZLE_DUMP': "%s --no-defaults -uroot -p%d" %( self.master_server.drizzledump
+                                                        , self.master_server.master_port)
+                   ,  'DRIZZLE_SLAP': "%s -uroot -p%d" %( self.master_server.drizzleslap
+                                                        , self.master_server.master_port)
+                   ,  'DRIZZLE_IMPORT': "%s -uroot -p%d" %( self.master_server.drizzleimport
+                                                          , self.master_server.master_port)
+                   ,  'DRIZZLE': "%s -uroot -p%d" %( self.master_server.drizzle_client
+                                                   , self.master_server.master_port)
+                   ,  'DRIZZLE_ADMIN' : "%s -uroot -p%d" %( self.master_server.drizzleadmin
+                                                         , self.master_server.master_port)
+                   }     
+
+        self.working_environment = self.system_manager.create_working_environment(env_reqs)
+
+    def process_symlink_reqs(self):
+        """ Create any symlinks we may need """
+        needed_symlinks = []
+
+        # handle filesystem_engine 
+        if self.current_testcase.suitename == 'filesystem_engine':
+            needed_symlinks.append(( os.path.join(self.current_testcase.suitepath
+                                  , 't')
+                                  , os.path.join(self.master_server.vardir
+                                  , "filesystem_ln")))
+
+        self.system_manager.create_symlinks(needed_symlinks)
+
+    
+   
+
+        

=== added file 'tests/lib/randgen/randgen_test_management.py'
--- tests/lib/randgen/randgen_test_management.py	1970-01-01 00:00:00 +0000
+++ tests/lib/randgen/randgen_test_management.py	2011-02-23 17:24:15 +0000
@@ -0,0 +1,149 @@
+#! /usr/bin/env python
+# -*- mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
+# vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+#
+# Copyright (C) 2010 Patrick Crews
+#
+## This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+""" randgen_test_management:
+    code related to the gathering / analysis / management of 
+    the test cases
+    ie - collecting the list of tests in each suite, then
+    gathering additional, relevant information for randgen
+    mode. (stocastic model-based testing)
+
+"""
+
+# imports
+import os
+import re
+import sys
+from ConfigParser import RawConfigParser
+
+import lib.test_mgmt.test_management as test_management
+
+
+    
+class testCase:
+    """Holds info on a single randgen test
+ 
+    """
+    def __init__( self, system_manager, name=None
+                , fullname = None, server_requirements=[[]]
+                , comment=None, test_command=None, debug=False ):
+        self.system_manager = system_manager
+        self.logging = self.system_manager.logging
+        self.skip_keys = ['system_manager','logging']
+        self.name = name
+        self.fullname = fullname
+        self.suitename = 'randgen_tests'
+        self.master_sh = None
+        self.comment = comment
+        self.server_requirements = server_requirements
+        self.test_command = test_command
+        
+        if debug:
+            self.system_manager.logging.debug_class(self)
+
+    def should_run(self):
+        if self.skip_flag or self.disable:
+            return 0
+        else:
+            return 1
+
+ 
+        
+        
+          
+class testManager(test_management.testManager):
+    """Deals with scanning test directories, gathering test cases, and 
+       collecting per-test information (opt files, etc) for use by the
+       test-runner
+
+    """
+
+    def __init__(self, verbose, debug, default_engine, dotest, skiptest
+                , reorder, suitelist, suitepaths, system_manager
+                , test_cases, mode):
+        super(testManager, self).__init__( verbose, debug, default_engine
+                                         , dotest, skiptest, reorder
+                                         , suitelist, suitepaths
+                                         , system_manager, test_cases, mode)
+        self.suitepaths = [os.path.join(self.testdir,'randgen_tests')]
+        if suitelist is None:
+            self.suitelist = ['main']
+        else:
+            self.suitelist = suitelist
+
+    def process_suite(self,suite_dir):
+        """Process a test suite.
+           Look for randgen tests, which are nice clean conf files
+        
+        """
+
+        # We know this based on how we organize randgen test conf files
+        suite_name = os.path.basename(suite_dir) 
+        if self.verbose:
+                self.system_manager.logging.verbose("Processing suite: %s" %(suite_name))
+        testlist = [os.path.join(suite_dir,test_file) for test_file in sorted(os.listdir(suite_dir)) if test_file.endswith('.cnf')]
+
+        # Search for specific test names
+        if self.desired_tests: # We have specific, named tests we want from the suite(s)
+           tests_to_use = []
+           for test in self.desired_tests:
+               if test.endswith('.cnf'): 
+                   pass
+               else:
+                   test = test+'.cnf'
+               test = os.path.join(suite_dir,test)
+               if test in testlist:
+                   tests_to_use.append(test)
+           testlist = tests_to_use
+        for test_case in testlist:
+            self.add_test(self.process_test_file(suite_name, test_case))
+
+
+    def process_test_file(self, suite_name, testfile):
+        """ We convert the info in a testfile into a testCase object """
+
+        config_reader = RawConfigParser()
+        config_reader.read(testfile)
+        # test_name = filename - .cnf...simpler
+        test_name = os.path.basename(testfile).replace('.cnf','')
+        test_comment = config_reader.get('test_info','comment')
+        server_requirements = self.process_server_reqs(config_reader.get('test_servers','servers'))
+        test_command = config_reader.get('test_command','command')
+        return testCase( self.system_manager
+                       , name = test_name
+                       , fullname = "%s.%s" %(suite_name, test_name)
+                       , server_requirements = server_requirements
+                       , test_command = test_command
+                       , debug = self.debug )
+
+        #sys.exit(0)
+
+    def process_server_reqs(self,data_string):
+        """ We read in the list of lists as a string, so we need to 
+            handle this / break it down into proper chunks
+
+        """
+        server_reqs = []
+        # We expect to see a list of lists and throw away the 
+        # enclosing brackets
+        option_sets = data_string[1:-1].strip().split(',')
+        for option_set in option_sets:
+            server_reqs.append([option_set[1:-1].strip()])
+        return server_reqs

=== modified file 'tests/lib/server_mgmt/drizzled.py'
--- tests/lib/server_mgmt/drizzled.py	2011-02-17 00:31:23 +0000
+++ tests/lib/server_mgmt/drizzled.py	2011-02-23 17:24:15 +0000
@@ -2,7 +2,7 @@
 # -*- mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
 # vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
 #
-# Copyright (C) 2010 Patrick Crews
+# Copyright (C) 2010,2011 Patrick Crews
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -27,8 +27,9 @@
 
 # imports
 import os
+from lib.server_mgmt.server import Server
 
-class drizzleServer():
+class drizzleServer(Server):
     """ represents a drizzle server, its possessions
         (datadir, ports, etc), and methods for controlling
         and querying it
@@ -40,49 +41,14 @@
 
     """
 
-    def __init__( self
-                , name
-                , server_manager
-                , default_storage_engine
-                , server_options
-                , requester
-                , workdir_root):
-        self.skip_keys = [ 'server_manager'
-                         , 'system_manager'
-                         , 'dirset'
-                         , 'preferred_base_port'
-                         , 'no_secure_file_priv'
-                         , 'secure_file_string'
-                         , 'port_block'
-                         ]
-        self.debug = server_manager.debug
-        self.verbose = server_manager.verbose
-        self.initial_run = 1
-        self.owner = requester
-        self.server_options = server_options
-        self.default_storage_engine = default_storage_engine
-        self.server_manager = server_manager
-        # We register with server_manager asap
-        self.server_manager.log_server(self, requester)
-
-        self.system_manager = self.server_manager.system_manager
-        self.valgrind = self.system_manager.valgrind
-        self.gdb = self.system_manager.gdb
-        if self.valgrind:
-            self.valgrind_time_buffer = 10
-        else:
-            self.valgrind_time_buffer = 1
-        self.cmd_prefix = self.system_manager.cmd_prefix
-        self.logging = self.system_manager.logging
-        self.no_secure_file_priv = self.server_manager.no_secure_file_priv
+    def __init__( self, name, server_manager, default_storage_engine
+                , server_options, requester, workdir_root):
+        super(drizzleServer, self).__init__( name, server_manager
+                                           , default_storage_engine
+                                           , server_options, requester
+                                           , workdir_root)
         self.code_tree = self.system_manager.code_tree
         self.preferred_base_port = 9306
-        self.name = name
-        self.status = 0 # stopped, 1 = running
-        self.tried_start = 0
-        self.failed_test = 0 # was the last test a failure?  our state is suspect
-        self.server_start_timeout = 60 * self.valgrind_time_buffer
-
         # Get our ports
         self.port_block = self.system_manager.port_manager.get_port_block( self.name
                                                                          , self.preferred_base_port
@@ -118,6 +84,12 @@
         self.pid_file = os.path.join(self.rundir,('%s.pid' %(self.name)))
         self.socket_file = os.path.join(self.vardir, ('%s.sock' %(self.name)))
         self.timer_file = os.path.join(self.logdir,('timer'))
+
+        # Do magic to create a config file for use with the slave
+        # plugin
+        self.slave_config_file = os.path.join(self.logdir,'slave.cnf')
+        self.create_slave_config_file()
+
         self.snapshot_path = os.path.join(self.tmpdir,('snapshot_%s' %(self.master_port)))
         # We want to use --secure-file-priv = $vardir by default
         # but there are times / tools when we need to shut this off
@@ -154,7 +126,7 @@
                         , 'vardir'
                         , 'status'
                         ]
-        self.logging.info("%s master server:" %(self.owner))
+        self.logging.info("%s server:" %(self.owner))
         for key in report_values:
           value = vars(self)[key] 
           self.logging.info("%s: %s" %(key.upper(), value))
@@ -205,55 +177,47 @@
 
         return "%s --ping --port=%d --user=root" % (self.drizzle_client_path, self.master_port)
 
-    def process_server_options(self):
-        """Consume the list of options we have been passed.
-           Return a string with them joined
+    def is_started(self):
+        """ Determine if the server is up and running - 
+            this may vary from server type to server type
 
         """
-        
-        return " ".join(self.server_options)
+
+        # We experiment with waiting for a pid file to be created vs. pinging
+        # This is what test-run.pl does and it helps us pass logging_stats tests
+        # while not self.ping_server(server, quiet=True) and timer != timeout:
+
+        return self.system_manager.find_path( [self.pid_file]
+                                            , required=0)
+
+    def create_slave_config_file(self):
+       """ Create a config file suitable for use
+           with the slave-plugin.  This allows
+           us to tie other servers in easily
+
+       """
+
+       config_data = [ "master-host=127.0.0.1"
+                     , "master-port=%d" %self.master_port
+                     , "master-user=root"
+                     , "master-pass=''"
+                     , "max-reconnects=100"
+                     , "seconds-between-reconnects=20"
+                     ]
+       outfile = open(self.slave_config_file,'w')
+       for line in config_data:
+           outfile.write("%s\n" %(line))
+       outfile.close()
+
+
+
+
                   
-    def initialize_databases(self):
-        """ Call schemawriter to make db.opt files """
-        databases = [ 'test'
-                    , 'mysql'
-                    ]
-        for database in databases:
-            db_path = os.path.join(self.datadir,'local',database,'db.opt')
-            cmd = "%s %s %s" %(self.schemawriter, database, db_path)
-            self.system_manager.execute_cmd(cmd)
-
-    def take_db_snapshot(self):
-        """ Take a snapshot of our vardir for quick restores """
-       
-        self.logging.info("Taking clean db snapshot...")
-        if os.path.exists(self.snapshot_path):
-            # We need to remove an existing path as python shutil
-            # doesn't want an existing target
-            self.system_manager.remove_dir(self.snapshot_path)
-        self.system_manager.copy_dir(self.datadir, self.snapshot_path)
-
-    def restore_snapshot(self):
-        """ Restore from a stored snapshot """
-        
-        if self.verbose:
-            self.logging.verbose("Restoring from db snapshot")
-        if not os.path.exists(self.snapshot_path):
-            self.logging.error("Could not find snapshot: %s" %(self.snapshot_path))
-        self.system_manager.remove_dir(self.datadir)
-        self.system_manager.copy_dir(self.snapshot_path, self.datadir)
-
-    def cleanup(self):
-        """ Cleanup - just free ports for now..."""
-        self.system_manager.port_manager.free_ports(self.port_block)
-
-    def set_server_options(self, server_options):
-        """ We update our server_options to the new set """
-        self.server_options = server_options
-
-    def reset(self):
-        """ Voodoo to reset ourselves """
-        self.failed_test = 0
+
+
+
+
+ 
          
 
 

=== added file 'tests/lib/server_mgmt/server.py'
--- tests/lib/server_mgmt/server.py	1970-01-01 00:00:00 +0000
+++ tests/lib/server_mgmt/server.py	2011-02-23 17:24:15 +0000
@@ -0,0 +1,156 @@
+#! /usr/bin/env python
+# -*- mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
+# vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+#
+# Copyright (C) 2010,2011 Patrick Crews
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+
+""" server.py:  generic server object used by the server
+    manager.  This contains the generic methods for all 
+    servers.  Specific types (Drizzle, MySQL, etc) should
+    inherit from this guy
+
+"""
+
+# imports
+import os
+
+class Server(object):
+    """ the server class from which other servers
+        will inherit - contains generic methods
+        certain methods will be overridden by more
+        specific ones
+
+    """
+
+    def __init__(self
+                , name
+                , server_manager
+                , default_storage_engine
+                , server_options
+                , requester
+                , workdir_root):
+        self.skip_keys = [ 'server_manager'
+                         , 'system_manager'
+                         , 'dirset'
+                         , 'preferred_base_port'
+                         , 'no_secure_file_priv'
+                         , 'secure_file_string'
+                         , 'port_block'
+                         ]
+        self.debug = server_manager.debug
+        self.verbose = server_manager.verbose
+        self.initial_run = 1
+        self.owner = requester
+        self.server_options = server_options
+        self.default_storage_engine = default_storage_engine
+        self.server_manager = server_manager
+        # We register with server_manager asap
+        self.server_manager.log_server(self, requester)
+
+        self.system_manager = self.server_manager.system_manager
+        self.valgrind = self.system_manager.valgrind
+        self.gdb = self.system_manager.gdb
+        if self.valgrind:
+            self.valgrind_time_buffer = 10
+        else:
+            self.valgrind_time_buffer = 1
+        self.cmd_prefix = self.system_manager.cmd_prefix
+        self.logging = self.system_manager.logging
+        self.no_secure_file_priv = self.server_manager.no_secure_file_priv
+        self.name = name
+        self.status = 0 # stopped, 1 = running
+        self.tried_start = 0
+        self.failed_test = 0 # was the last test a failure?  our state is suspect
+        self.server_start_timeout = 60 * self.valgrind_time_buffer
+
+    def initialize_databases(self):
+        """ Call schemawriter to make db.opt files """
+        databases = [ 'test'
+                    , 'mysql'
+                    ]
+        for database in databases:
+            db_path = os.path.join(self.datadir,'local',database,'db.opt')
+            cmd = "%s %s %s" %(self.schemawriter, database, db_path)
+            self.system_manager.execute_cmd(cmd)
+
+    def process_server_options(self):
+        """Consume the list of options we have been passed.
+           Return a string with them joined
+
+        """
+        
+        return " ".join(self.server_options)
+
+    def take_db_snapshot(self):
+        """ Take a snapshot of our vardir for quick restores """
+       
+        self.logging.info("Taking clean db snapshot...")
+        if os.path.exists(self.snapshot_path):
+            # We need to remove an existing path as python shutil
+            # doesn't want an existing target
+            self.system_manager.remove_dir(self.snapshot_path)
+        self.system_manager.copy_dir(self.datadir, self.snapshot_path)
+
+    def restore_snapshot(self):
+        """ Restore from a stored snapshot """
+        
+        if self.verbose:
+            self.logging.verbose("Restoring from db snapshot")
+        if not os.path.exists(self.snapshot_path):
+            self.logging.error("Could not find snapshot: %s" %(self.snapshot_path))
+        self.system_manager.remove_dir(self.datadir)
+        self.system_manager.copy_dir(self.snapshot_path, self.datadir)
+
+    def is_started(self):
+        """ Is the server running?  Particulars are server-dependent """
+
+        return
+
+    def get_start_cmd(self):
+        """ Return the command the server_manager can use to start me """
+
+        return "Allakazam!"
+
+    def get_stop_cmd(self):
+        """ Return the command the server_manager can use to stop me """
+
+        return "Whoa, Nelly!"
+
+    def get_ping_cmd(self):
+        """ Return the command that can be used to 'ping' me 
+            Very similar to is_started, but different
+
+            Determining if a server is still running (ping)
+            may differ from the method used to determine
+            server startup
+
+        """
+   
+        return "Hello?"
+
+    def cleanup(self):
+        """ Cleanup - just free ports for now..."""
+        self.system_manager.port_manager.free_ports(self.port_block)
+
+    def set_server_options(self, server_options):
+        """ We update our server_options to the new set """
+        self.server_options = server_options
+
+    def reset(self):
+        """ Voodoo to reset ourselves """
+        self.failed_test = 0

=== modified file 'tests/lib/server_mgmt/server_management.py'
--- tests/lib/server_mgmt/server_management.py	2011-02-17 00:31:23 +0000
+++ tests/lib/server_mgmt/server_management.py	2011-02-23 17:24:15 +0000
@@ -65,13 +65,16 @@
         if self.debug:
             self.logging.debug_class(self)
 
-    def request_servers( self, requester, workdir, master_count
-                   , slave_count, server_options, working_environ
-                   , expect_fail = 0):
+    def request_servers( self, requester, workdir, server_requirements
+                       , working_environ, expect_fail = 0):
         """ We produce the server objects / start the server processes
             as requested.  We report errors and whatnot if we can't
             That is, unless we expect the server to not start, then
-            we just return a value / message
+            we just return a value / message.
+
+            server_requirements is a list of lists.  Each list
+            is a set of server options - we create one server
+            for each set of options requested
     
         """
 
@@ -80,11 +83,11 @@
         self.check_server_status(requester)
         
         # Make sure we have the proper number of servers for this requester
-        self.process_server_count( requester, master_count+slave_count
-                                 , workdir, server_options)
+        self.process_server_count( requester, len(server_requirements)
+                                 , workdir, server_requirements)
 
         # Make sure we are running with the correct options 
-        self.evaluate_existing_servers(requester, server_options)
+        self.evaluate_existing_servers(requester, server_requirements)
 
         # Fire our servers up
         bad_start = self.start_servers( requester, working_environ
@@ -113,7 +116,6 @@
                                 , server_options
                                 , requester
                                 , workdir )
-        self.add_server(requester, new_server)
         return new_server
 
     def start_servers(self, requester, working_environ, expect_fail):
@@ -188,11 +190,9 @@
         #if server_retcode: # We know we have an error, no need to wait
         #    timer = timeout
 
-        # We experiment with waiting for a pid file to be created vs. pinging
-        # This is what test-run.pl does and it helps us pass logging_stats tests
-        # while not self.ping_server(server, quiet=True) and timer != timeout:
-        while not self.system_manager.find_path( [server.pid_file]
-                                               , required=0) and timer != timeout:
+        
+
+        while not server.is_started() and timer != timeout:
             time.sleep(self.timer_increment)
             # If manual-gdb, this == None and we want to give the 
             # user all the time they need
@@ -307,14 +307,17 @@
     def log_server(self, new_server, requester):
         self.servers[requester].append(new_server)
 
-    def evaluate_existing_servers( self, requester, server_options):
+    def evaluate_existing_servers( self, requester, server_requirements):
         """ See if the requester has any servers and if they
             are suitable for the current test
 
+            We should have the proper number of servers at this point
+
         """
         current_servers = self.servers[requester]
-        
-        for server in current_servers:
+
+        for index,server in enumerate(current_servers):
+            server_options = server_requirements[index]
             # We add in any user-supplied options here
             server_options = server_options + self.user_server_opts
             if self.compare_options( server.server_options
@@ -327,6 +330,9 @@
                 self.reset_server(server)
                 self.update_server_options(server, server_options)
 
+
+       
+
     def filter_server_options(self, server_options):
         """ Remove a list of options we don't want passed to the server
             these are test-case specific options.
@@ -361,7 +367,7 @@
             self.reset_server(server)
 
 
-    def process_server_count(self, requester, desired_count, workdir, server_options):
+    def process_server_count(self, requester, desired_count, workdir, server_reqs):
         """ We see how many servers we have.  We shrink / grow
             the requesters set of servers as needed.
 
@@ -369,11 +375,14 @@
             (naturally)
  
         """
-        server_options = self.filter_server_options(server_options)
+        if desired_count < 0:  desired_count = 1
+
         current_count = self.has_servers(requester)
         if desired_count > current_count:
             for i in range(desired_count - current_count):
-                self.allocate_server(requester, server_options, workdir)
+                # We pass an empty options list when allocating
+                # We'll update the options to what is needed elsewhere
+                self.allocate_server(requester,[] , workdir)
         elif desired_count < current_count:
             good_servers = self.get_server_list(requester)[:desired_count]
             retired_servers = self.get_server_list(requester)[desired_count - current_count:]

=== modified file 'tests/lib/sys_mgmt/port_management.py'
--- tests/lib/sys_mgmt/port_management.py	2011-02-07 17:58:09 +0000
+++ tests/lib/sys_mgmt/port_management.py	2011-02-23 17:24:15 +0000
@@ -77,9 +77,9 @@
             This is a bit bobo, but will work for now...
 
         """
-        
         searching_for_port = 1
-        attempts_remain = 100
+        attempt_count = 100
+        attempts_remain = attempt_count
         max_port_value = 32767
         min_port_value = 5001
         while searching_for_port and attempts_remain:
@@ -93,7 +93,7 @@
                 if desired_port >= max_port_value:
                     desired_port = min_port_value
                 attempts_remain = attempts_remain - 1
-        self.logging.error("Failed to assign a port in %d attempts")
+        self.logging.error("Failed to assign a port in %d attempts" %attempt_count)
         sys.exit(1)
 
     def check_port_status(self, port):

=== modified file 'tests/lib/sys_mgmt/system_management.py'
--- tests/lib/sys_mgmt/system_management.py	2011-02-17 00:31:23 +0000
+++ tests/lib/sys_mgmt/system_management.py	2011-02-23 17:24:15 +0000
@@ -69,6 +69,7 @@
         self.cur_os = os.uname()[0]
         self.cur_user = getpass.getuser()
         self.workdir = os.path.abspath(variables['workdir'])
+        self.testdir = os.path.abspath(variables['testdir'])
         self.datadir = os.path.abspath(os.path.join(variables['testdir'],'dbqp_data'))
         self.top_srcdir = os.path.abspath(variables['topsrcdir'])
         self.top_builddir = os.path.abspath(variables['topbuilddir'])
@@ -76,6 +77,7 @@
         self.valgrind = variables['valgrind']
         self.gdb = variables['gdb']
         self.manual_gdb = variables['manualgdb']
+        self.randgen_path = variables['randgenpath']
 
         # we use this to preface commands in order to run valgrind and such
         self.cmd_prefix = '' 
@@ -232,6 +234,7 @@
                 self.logging.info("Using --start-dirty, not attempting to touch directories")
                 return
             else:
+                self.cleanup() # We crawl / try to kill any server pids we find
                 self.remove_dir(self.workdir)
         self.allocate_workdir()
     
@@ -551,6 +554,36 @@
             self.append_env_var("LD_LIBRARY_PATH", debug_path, suffix=1)
             self.append_env_var("DYLD_LIBRARY_PATH", debug_path, suffix=1)
 
+
+    def cleanup(self, exit=False):
+        """ We try to kill any servers whose pid files
+            we detect lurking about
+
+        """
+        
+        self.pid_hunt_and_kill(exit)
+
+    def pid_hunt_and_kill(self, exit):
+        """ Crawl our workdir and look for server.pid files
+            We read 'em and kill 'em if we find 'em
+
+        """
+
+        for root, dirs, files in os.walk(self.workdir):
+            #print root, dirs, files
+            for found_file in files:
+                if found_file.endswith('.pid'):
+                    file_path = os.path.join(root, found_file)
+                    pid_file = open(file_path,'r')
+                    pid = pid_file.readline().strip()
+                    pid_file.close()
+                    self.logging.info("Killing pid %s from %s" %( pid
+                                                                , file_path
+                                                                ))
+                    self.execute_cmd("kill -9 %s" %pid, must_pass=0)
+        if exit:
+            sys.exit(0)
+
    
     
 

=== modified file 'tests/lib/test_mgmt/execution_management.py'
--- tests/lib/test_mgmt/execution_management.py	2011-02-14 21:20:36 +0000
+++ tests/lib/test_mgmt/execution_management.py	2011-02-23 17:24:15 +0000
@@ -61,6 +61,7 @@
         self.verbose = variables['verbose']
         self.force = variables['force']
         self.record_flag = variables['record']
+        self.gendata_file = variables['gendatafile']
         self.testcase_repeat_count = variables['repeat']
         # We are currently single-threaded execution-wise
         # but in the future, we will likely need to revamp
@@ -101,7 +102,6 @@
                 self.logging.verbose("Starting executor: %s" %(executor_name))
                 # thread.start_new(executor.execute,()) # sigh...one day...damned drizzletest!
             executor.execute(self.start_and_exit)
-        time.sleep(3)
         while self.has_running_executors():
             pass
         self.test_manager.statistical_report()

=== modified file 'tests/lib/test_mgmt/test_execution.py'
--- tests/lib/test_mgmt/test_execution.py	2011-02-17 00:31:23 +0000
+++ tests/lib/test_mgmt/test_execution.py	2011-02-23 17:24:15 +0000
@@ -78,6 +78,27 @@
         if self.debug:
             self.logging.debug_class(self)
 
+    def execute(self, start_and_exit):
+        """ Execute a test case.  The details are *very* mode specific """
+        self.status = 1 # we are running
+        keep_running = 1
+        if self.verbose:
+            self.logging.verbose("Executor: %s beginning test execution..." %(self.name))
+        while self.test_manager.has_tests() and keep_running == 1:
+            self.get_testCase()
+            for i in range(self.testcase_repeat_count):
+                self.handle_system_reqs()
+                self.handle_server_reqs()
+                self.handle_utility_reqs()
+                self.handle_start_and_exit(start_and_exit)
+                if self.current_test_status != 'fail':
+                    self.execute_testCase()
+                self.record_test_result()
+                if self.current_test_status == 'fail' and not self.execution_manager.force:
+                    self.logging.error("Failed test.  Use --force to execute beyond the first test failure")
+                    keep_running = 0
+        self.status = 0
+
     def get_testCase(self):
         """ Ask our execution_manager for a testCase to work on """
         
@@ -86,20 +107,18 @@
         #self.test_manager.mutex.release()
         
 
-    def handle_server_reqs(self, start_and_exit):
+    def handle_server_reqs(self):
         """ Get the servers required to execute the testCase 
             and ensure that we have servers and they were started
             as expected.  We take necessary steps if not
             We also handle --start-and-exit here
  
         """
-       
-        master_count, slave_count, server_options = self.process_server_reqs()
+
+        server_requirements = self.current_testcase.server_requirements
         (self.current_servers,bad_start) = self.server_manager.request_servers( self.name
                                                               , self.workdir
-                                                              , master_count
-                                                              , slave_count
-                                                              , server_options
+                                                              , server_requirements
                                                               , self.working_environment)
         if self.current_servers == 0 or bad_start:
             # error allocating servers, test is a failure
@@ -107,11 +126,18 @@
             self.current_test_status = 'fail'
             self.set_server_status(self.current_test_status)
             output = ''           
-        else:
-            if start_and_exit:
-                # TODO:  Report out all started servers via server_manager/server objects?
-                self.current_servers[0].report()
-                self.logging.info("User specified --start-and-exit.  dbqp.py exiting and leaving servers running...") 
+        if self.initial_run:
+            self.initial_run = 0
+            self.current_servers[0].report()
+        self.master_server = self.current_servers[0]
+        return 
+
+    def handle_start_and_exit(self, start_and_exit):
+        """ Do what needs to be done if we have the
+            --start-and-exit flag
+
+        """
+        if start_and_exit:
                 # We blow away any port_management files for our ports
                 # Technically this won't let us 'lock' any ports that 
                 # we aren't explicitly using (visible to netstat scan)
@@ -119,44 +145,41 @@
                 # We shouldn't hog it ; )
                 # We might need to do this better later
                 for server in self.current_servers:
+                    if server != self.master_server:
+                        server.report()
                     server.cleanup() # this only removes any port files
+                self.logging.info("User specified --start-and-exit.  dbqp.py exiting and leaving servers running...") 
                 sys.exit(0)
-        if self.initial_run:
-            self.initial_run = 0
-            self.current_servers[0].report()
-        self.master_server = self.current_servers[0]
-        return 
 
-    def process_server_reqs(self):
-        """ Check out our current_testcase to see what kinds of servers 
-            we need up and running.  The executionManager sees to 
-            serving the reqs
+    def handle_utility_reqs(self):
+        """ Call any utilities we want to use before starting a test
+            At present this is envisioned for use with datagen
+            but there may be other things we wish to use
+            At that point, we may need to explore other ways of
+            defining our testing environment, such as with
+            nice config files / modules
 
         """
-     
-        master_count = self.current_testcase.master_count
-        slave_count = self.current_testcase.slave_count
-        server_options = self.current_testcase.server_options
-
-        return(master_count, slave_count, server_options)
-
-    def execute(self, start_and_exit):
-        """ Execute a test case.  The details are *very* mode specific """
-        self.status = 1 # we are running
-        keep_running = 1
-        if self.verbose:
-            self.logging.verbose("Executor: %s beginning test execution..." %(self.name))
-        while self.test_manager.has_tests() and keep_running == 1:
-            self.get_testCase()
-            self.handle_system_reqs()
-            self.handle_server_reqs(start_and_exit)
-            for i in range(self.testcase_repeat_count):
-                self.execute_testCase()
-                self.record_test_result()
-                if self.current_test_status == 'fail' and not self.execution_manager.force:
-                    self.logging.error("Failed test.  Use --force to execute beyond the first test failure")
-                    keep_running = 0
-        self.status = 0
+
+        # We call gendata against the server(s) with the
+        # specified file
+        if self.execution_manager.gendata_file:
+            dsn = "--dsn=dbi:drizzle:host=localhost:port=%d:user=root:password="":database=test" %(self.master_server.master_port)
+            gendata_cmd = "./gendata.pl %s --spec=%s" %( dsn 
+                                                       , self.execution_manager.gendata_file
+                                                       )
+            #self.system_manager.execute_cmd(gendata_cmd)
+            gendata_subproc = subprocess.Popen( gendata_cmd
+                                              , shell=True
+                                              , cwd=self.system_manager.randgen_path
+                                              , stdout = None
+                                              , stderr = None
+                                              )
+            gendata_subproc.wait()
+            gendata_retcode = gendata_subproc.returncode
+            if gendata_retcode:
+                self.logging.error("gendata command: %s failed with retcode: %d" %(gendata_cmd
+                                                                             , gendata_retcode))
 
     def execute_testCase(self):
         """ Do whatever evil voodoo we must do to execute a testCase """

=== modified file 'tests/lib/test_mgmt/test_management.py'
--- tests/lib/test_mgmt/test_management.py	2011-02-09 17:41:08 +0000
+++ tests/lib/test_mgmt/test_management.py	2011-02-23 17:24:15 +0000
@@ -18,7 +18,7 @@
 # along with this program; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
-""" dtr_test_management:
+""" test_management:
     code related to the gathering / analysis / management of 
     the test cases
     ie - collecting the list of tests in each suite, then
@@ -33,7 +33,7 @@
 import sys
 import thread
           
-class testManager:
+class testManager(object):
     """Deals with scanning test directories, gathering test cases, and 
        collecting per-test information (opt files, etc) for use by the
        test-runner
@@ -42,7 +42,7 @@
 
     def __init__( self, verbose, debug, default_engine, dotest, skiptest
                 , reorder, suitelist, suitepaths, system_manager
-                , test_cases):
+                , test_cases, mode):
 
         self.system_manager = system_manager
         self.time_manager = system_manager.time_manager
@@ -68,6 +68,7 @@
         self.skiptest = skiptest
         self.reorder = reorder
         self.suitelist = suitelist
+        self.mode = mode
         
         self.code_tree = self.system_manager.code_tree
         self.suitepaths = suitepaths + self.code_tree.suite_paths
@@ -87,7 +88,7 @@
         self.logging.info("Processing test suites...")
         # BEGIN terrible hack to accomodate the fact that
         # our 'main' suite is also our testdir : /
-        if self.suitelist is None:
+        if self.suitelist is None and self.mode=='dtr':
             self.suitepaths = [self.testdir]
             self.suitelist = ['main']
         # END horrible hack
@@ -137,9 +138,10 @@
 
         """
         # BEGIN horrible hack to accomodate bad location of main suite
-        if self.suitepaths == [self.testdir] or suitename == 'main':
-            # We treat this as the 'main' suite
-            return self.testdir
+        if self.mode == 'dtr':
+            if self.suitepaths == [self.testdir] or suitename == 'main':
+                # We treat this as the 'main' suite
+                return self.testdir
         # END horrible hack
         for suitepath in self.suitepaths:
             suite_path = self.system_manager.find_path([ os.path.join(suitepath,suitename,'tests'),
@@ -216,13 +218,15 @@
         # This is probably hacky, but I'll think of a better
         # location later.  When we are ready to see our
         # statistical report, we know to stop the total time timer
-        total_exec_time = self.time_manager.stop('total_time')
-        self.logging.write_thick_line()
-        self.logging.info("Test execution complete in %d seconds" %(total_exec_time))
+        if not self.first_test:
+            total_exec_time = self.time_manager.stop('total_time')
+            self.logging.write_thick_line()
+            self.logging.info("Test execution complete in %d seconds" %(total_exec_time))
         self.logging.info("Summary report:")
         self.report_executed_tests()
         self.report_test_statuses()
-        self.time_manager.summary_report()
+        if not self.first_test:
+            self.time_manager.summary_report()
 
     def report_test_statuses(self):
         """ Method to report out various test statuses we

=== modified file 'tests/lib/test_mode.py'
--- tests/lib/test_mode.py	2011-02-04 20:41:08 +0000
+++ tests/lib/test_mode.py	2011-02-23 17:24:15 +0000
@@ -33,27 +33,46 @@
         the appropriate code objects for the test-runner to play with
 
     """
+
+    test_mode = variables['mode']
+    system_manager.logging.info("Using testing mode: %s" %test_mode)
+
     # drizzle-test-run mode - the default
-    if variables['mode'] == 'dtr':
+    if test_mode == 'dtr':
         # DTR mode - this is what we are coding to initially
         # We are just setting the code up this way to hopefully make
         # other coolness easier in the future
 
-        system_manager.logging.info("Using testing mode: %s" %variables['mode'])
-
-        # Set up our testManager
+        # get our mode-specific testManager
         from drizzle_test_run.dtr_test_management import testManager
-        test_manager = testManager( variables['verbose'], variables['debug'] 
-                                  , variables['defaultengine'], variables['dotest']
-                                  , variables['skiptest'], variables['reorder']
-                                  , variables['suitelist'], variables['suitepaths']
-                                  , system_manager, variables['test_cases'])
-
+ 
         # get our mode-specific testExecutor
-        from drizzle_test_run.dtr_test_execution import dtrTestExecutor
-        
-        return (test_manager, dtrTestExecutor)
-
+        from drizzle_test_run.dtr_test_execution import testExecutor as testExecutor
+
+    elif test_mode == 'randgen':
+        # randgen mode - we run the randgen grammar against
+        # the specified server configs and report the randgen error code
+
+        # get manager and executor
+        from randgen.randgen_test_management import testManager
+        from randgen.randgen_test_execution import randgenTestExecutor as testExecutor
+
+    elif test_mode == 'cleanup':
+        # cleanup mode - we try to kill any servers whose pid's we detect
+        # in our workdir.  Might extend to other things (file cleanup, etc)
+        # at some later point
+        system_manager.cleanup(exit=True)
+ 
     else:
         system_manager.logging.error("unknown mode argument: %s" %variables['mode'])
         sys.exit(1)
+
+    test_manager = testManager( variables['verbose'], variables['debug'] 
+                              , variables['defaultengine'], variables['dotest']
+                              , variables['skiptest'], variables['reorder']
+                              , variables['suitelist'], variables['suitepaths']
+                              , system_manager, variables['test_cases']
+                              , variables['mode'] )
+
+    return (test_manager, testExecutor)
+

=== modified file 'tests/lib/test_run_options.py'
--- tests/lib/test_run_options.py	2011-02-14 21:29:35 +0000
+++ tests/lib/test_run_options.py	2011-02-23 17:24:15 +0000
@@ -58,6 +58,12 @@
     if variables['repeat'] <= 0:
         print "Setting --repeat=1.  You chose a silly value that I will ignore :P"
         variables['repeat'] = 1
+    if variables['mode'] == 'randgen':
+        print "Setting --no-secure-file-priv=True for randgen mode..."
+        variables['nosecurefilepriv']=True
+    if variables['mode'] == 'cleanup':
+        print "Setting --start-dirty=True for cleanup mode..."
+        variables['startdirty']=True
     return variables
 
 # Create the CLI option parser
@@ -70,7 +76,7 @@
 server_default = os.path.abspath(os.path.join(testdir_default,
                                        '../drizzled/drizzled'))
 
-workdir_default = os.path.join(testdir_default,'dbqp_work')
+workdir_default = os.path.join(testdir_default,'workdir')
 
 clientbindir_default = os.path.abspath(os.path.join(testdir_default,
                                        '../client'))
@@ -119,7 +125,7 @@
     "--mode"
   , dest="mode"
   , default="dtr"
-  , help="Testing mode.  We only support dtr...for now >;) [%default]"
+  , help="Testing mode.  We currently support dtr, randgen, and cleanup modes.  See docs for further details about individual modes [%default]"
   )
 
 system_control_group.add_option(
@@ -138,6 +144,14 @@
   , help="Don't try to cleanup from earlier runs (currently just a placeholder) [%default]"
   )
 
+system_control_group.add_option(
+    "--randgen-path"
+  , dest="randgenpath"
+  , action='store'
+  , default=None
+  , help = "The path to a randgen installation that can be used to execute randgen-based tests"
+  )
+
 parser.add_option_group(system_control_group)
 
 # end system_control_group
@@ -366,6 +380,20 @@
 parser.add_option_group(debugger_control_group)
 
 
+utility_group = optparse.OptionGroup(parser,
+                  "Options to call additional utilities such as datagen")
+
+utility_group.add_option(
+    "--gendata"
+  , dest="gendatafile"
+  , action='store'
+  , type='string'
+  , default=None
+  , help="Call the randgen's gendata utility to use the specified configuration file.  This will populate the server prior to any test execution")
+
+parser.add_option_group(utility_group)
+
+
 # supplied will be those arguments matching an option, 
 # and test_cases will be everything else
 (args, test_cases)= parser.parse_args()

=== added directory 'tests/randgen_tests'
=== added directory 'tests/randgen_tests/innodb_trx_log'
=== added directory 'tests/randgen_tests/main'
=== added file 'tests/randgen_tests/main/optimizer_subquery.cnf'
--- tests/randgen_tests/main/optimizer_subquery.cnf	1970-01-01 00:00:00 +0000
+++ tests/randgen_tests/main/optimizer_subquery.cnf	2011-02-23 17:24:15 +0000
@@ -0,0 +1,8 @@
+[test_info]
+comment = optimizer subquery test 
+
+[test_command]
+command = ./gentest.pl --gendata=conf/drizzle/drizzle.zz --grammar=conf/drizzle/optimizer_subquery_drizzle.yy --queries=500 --threads=5
+
+[test_servers]
+servers = [[]]

=== added file 'tests/randgen_tests/main/outer_join.cnf'
--- tests/randgen_tests/main/outer_join.cnf	1970-01-01 00:00:00 +0000
+++ tests/randgen_tests/main/outer_join.cnf	2011-02-23 17:24:15 +0000
@@ -0,0 +1,8 @@
+[test_info]
+comment = optimizer subquery test 
+
+[test_command]
+command = ./gentest.pl --gendata=conf/drizzle/outer_join_drizzle.zz --grammar=conf/drizzle/outer_join_drizzle.yy --queries=500 --threads=5
+
+[test_servers]
+servers = [[]]

=== added file 'tests/randgen_tests/main/simple.cnf'
--- tests/randgen_tests/main/simple.cnf	1970-01-01 00:00:00 +0000
+++ tests/randgen_tests/main/simple.cnf	2011-02-23 17:24:15 +0000
@@ -0,0 +1,9 @@
+[test_info]
+name = randgen_simple
+comment = basic, basic randgen test
+
+[test_command]
+command = ./gentest.pl --gendata=conf/drizzle/drizzle.zz --grammar=conf/drizzle/optimizer_subquery_drizzle.yy --queries=10 --threads=1
+
+[test_servers]
+servers = [[--transaction-log.enable]]

=== added directory 'tests/randgen_tests/slave_plugin'
=== added file 'tests/randgen_tests/slave_plugin/slave_plugin.disabled'
--- tests/randgen_tests/slave_plugin/slave_plugin.disabled	1970-01-01 00:00:00 +0000
+++ tests/randgen_tests/slave_plugin/slave_plugin.disabled	2011-02-23 17:24:15 +0000
@@ -0,0 +1,9 @@
+[test_info]
+name = randgen_slave_plugin
+comment = basic, basic randgen test
+
+[test_command]
+command = ./gentest.pl --gendata=conf/drizzle/drizzle.zz --grammar=conf/drizzle/optimizer_subquery_drizzle.yy --queries=10 --threads=1
+
+[test_servers]
+servers = [[--innodb.replication-log=true],[--plugin-add=slave --slave.config-file=$MASTER_SERVER_SLAVE_CONFIG]]

=== added directory 'tests/randgen_tests/trx_log'
=== added file 'tests/randgen_tests/trx_log/simple.cnf'
--- tests/randgen_tests/trx_log/simple.cnf	1970-01-01 00:00:00 +0000
+++ tests/randgen_tests/trx_log/simple.cnf	2011-02-23 17:24:15 +0000
@@ -0,0 +1,9 @@
+[test_info]
+name = randgen_simple
+comment = basic, basic randgen test
+
+[test_command]
+command = ./gentest.pl --gendata=conf/drizzle/drizzle.zz --grammar=conf/drizzle/optimizer_subquery_drizzle.yy --queries=10 --threads=1
+
+[test_servers]
+servers = [[--transaction-log.enable]]