Merge lp:~patrick-crews/percona-xtradb-cluster/qp-integrate into lp:~percona-dev/percona-xtradb-cluster/5.5.20

[Patrick Crews]

Removed dbqp and integrated kewpie (updated / improved dbqp) into the tree.
Cut down on the size to 25MB from 400+.

To execute tests, simply type ./kewpie.py from the kewpie directory (additional options may apply)

[Vadim Tkachenko (vadim-tk)]

review: Approve

=== modified file '.bzrignore'
--- .bzrignore	2012-02-07 18:26:15 +0000
+++ .bzrignore	2012-02-17 20:55:33 +0000
@@ -656,6 +656,8 @@
 isamchk/*.ds?
 isamchk/*.vcproj
 item_xmlfunc.cc
+kewpie/qp_data/uuid
+kewpie/workdir
 lib_debug/*
 lib_release/*
 libmysql/*.c
 
=== removed directory 'dbqp'
=== removed file 'dbqp/.bzrignore'
--- dbqp/.bzrignore	2012-02-04 01:22:23 +0000
+++ dbqp/.bzrignore	1970-01-01 00:00:00 +0000
@@ -1,3 +0,0 @@
-dbqp
-dbqp_data/uuid
-workdir
 
=== removed file 'dbqp/dbqp.py'
--- dbqp/dbqp.py	2012-02-04 01:22:23 +0000
+++ dbqp/dbqp.py	1970-01-01 00:00:00 +0000
@@ -1,99 +0,0 @@
-#! /usr/bin/env python
-# -*- mode: python; 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
-
-
-""" dbqp.py
-
-DataBase Quality Platform - system for executing various
-testing systems and the helper code 
-
-Designed to be a modular test-runner.  Different testing tools
-and databases may be plugged into the system via hacking the
-appropriate modules
-
-Currently geared towards Drizzle / will expand to MySQL
-"""
-
-# imports
-import os
-import sys
-
-import lib.opts.test_run_options as test_run_options
-from lib.modes.test_mode import handle_mode
-from lib.server_mgmt.server_management import serverManager
-from lib.sys_mgmt.system_management import systemManager
-from lib.test_mgmt.execution_management import executionManager
-
-# functions
-
-
-# main
-variables = test_run_options.variables
-system_manager = None
-server_manager = None
-test_manager = None
-test_executor = None
-execution_manager = None
-
-try:
-        # Some system-level work is constant regardless
-        # of the test to be run
-        system_manager = systemManager(variables)
-
-        # Create our server_manager
-        server_manager = serverManager(system_manager, variables)
-
-        # Get our mode-specific test_manager and test_executor
-        (test_manager,test_executor) = handle_mode(variables, system_manager)
-
-        # Gather our tests for execution
-        test_manager.gather_tests()
-
-        # Initialize test execution manager
-        execution_manager = executionManager(server_manager, system_manager
-                                        , test_manager, test_executor
-                                        , variables)
-
-        # Execute our tests!
-        execution_manager.execute_tests()
-    
-except Exception, e:
-       print Exception, e
-
-except KeyboardInterrupt:
-      print "\n\nDetected <Ctrl>+c, shutting down and cleaning up..."
-
-finally:
-# TODO - make a more robust cleanup
-# At the moment, runaway servers are our biggest concern
-    if server_manager and not variables['startandexit']:
-        if variables['gdb']:
-            server_manager.cleanup_all_servers()
-        else:
-            server_manager.cleanup()
-    if not variables['startandexit']:
-        if test_manager:
-            fail_count = test_manager.has_failing_tests()
-            sys.exit(test_manager.has_failing_tests())
-        else:
-            # return 1 as we likely have a problem if we don't have a
-            # test_manager
-            sys.exit(1)
-
 
=== removed directory 'dbqp/dbqp_data'
=== removed directory 'dbqp/docs'
=== removed file 'dbqp/docs/dbqp.rst'
--- dbqp/docs/dbqp.rst	2012-02-04 01:22:23 +0000
+++ dbqp/docs/dbqp.rst	1970-01-01 00:00:00 +0000
@@ -1,458 +0,0 @@
-**********************************
-dbqp
-**********************************
-
-Synopsis
-========
-Drizzle testing tool
-
-**./dbqp** [ *OPTIONS* ] [ TESTCASE ]
-
-Description
-===========
-
-:program:`dbqp.py` is BETA software.  It is intended to provide a standardized
-platform to facilitate Drizzle testing.  
-
-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.
-
-The dtr tests use a diff-based paradigm, meaning that the test runner executes
-a test and then compares the results received with pre-recorded expected 
-results.  In the event of a test failure, the program will provide output
-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.
-
-Running tests
-=========================
-
-There are several different ways to run tests using :program:`dbqp.py`.
-
-It should be noted that unless :option:`--force` is used, the program will
-stop execution upon encountering the first failing test. 
-:option:`--force` is recommended if you are running several tests - it will
-allow you to view all successes and failures in one run.
-
-Running individual tests
-------------------------
-If one only wants to run a few, specific tests, they may do so this way::
-
-    ./dbqp.py [OPTIONS] test1 [test2 ... testN]
-
-Running all tests within a suite
---------------------------------
-Many of the tests supplied with Drizzle are organized into suites.  
-
-The tests within drizzle/tests/t are considered the 'main' suite.  
-Other suites are located in either drizzle/tests/suite or within the various
-directories in drizzle/plugin.  Tests for a specific plugin should live in 
-the plugin's directory - drizzle/plugin/example_plugin/tests
-
-To run the tests in a specific suite::
-
-    ./dbqp.py [OPTIONS] --suite=SUITENAME
-
-Running specific tests within a suite
---------------------------------------
-To run a specific set of tests within a suite::
-
-    ./dbqp.py [OPTIONS] --suite=SUITENAME TEST1 [TEST2..TESTN]
-
-Calling tests using <suitename>.<testname> currently does not work.
-One must specify the test suite via the :option:`--suite` option.
-
-
-Running all available tests
----------------------------
-Currently, the quickest way to execute all tests in all suites is
-to use 'make test-dbqp' from the drizzle root.
-
-Otherwise, one should simply name all suites::
-
-    ./dbqp.py [OPTIONS] --suite=SUITE1, SUITE2, ...SUITEN
-
-Interpreting test results
-=========================
-The output of the test runner is quite simple.  Every test should pass.
-In the event of a test failure, please take the time to file a bug here:
-*https://bugs.launchpad.net/drizzle*
-
-During a run, the program will provide the user with:
-  * test name (suite + name)
-  * test status (pass/fail/skipped)
-  * time spent executing each test
-
-At the end of a run, the program will provide the user with a listing of:
-  * how many tests were run
-  * counts and percentages of total exectuted for all test statuses
-  * a listing of failing, skipped, or disabled tests
-  * total time spent executing the tests
-
-Example output::
-
-    <snip>
-    30 Jan 2011 16:26:31 : main.small_tmp_table                                    [ pass ]           38
-    30 Jan 2011 16:26:31 : main.snowman                                            [ pass ]           42
-    30 Jan 2011 16:26:31 : main.statement_boundaries                               [ pass ]           47
-    30 Jan 2011 16:26:31 : main.status                                             [ pass ]           51
-    30 Jan 2011 16:26:31 : main.strict                                             [ pass ]          138
-    30 Jan 2011 16:26:43 : main.subselect                                          [ fail ]        12361
-    30 Jan 2011 16:26:43 : --- drizzle/tests/r/subselect.result	2011-01-30 16:23:54.975776148 -0500
-    30 Jan 2011 16:26:43 : +++ drizzle/tests/r/subselect.reject	2011-01-30 16:26:43.835519303 -0500
-    30 Jan 2011 16:26:43 : @@ -5,7 +5,7 @@
-    30 Jan 2011 16:26:43 : 2
-    30 Jan 2011 16:26:43 : explain extended select (select 2);
-    30 Jan 2011 16:26:43 : id	select_type	table	type	possible_keys	key	key_len	ref	rows	filtered	Extra
-    30 Jan 2011 16:26:43 : -9	PRIMARY	NULL	NULL	NULL	NULL	NULL	NULL	NULL	NULL	No tables used
-    30 Jan 2011 16:26:43 : +1	PRIMARY	NULL	NULL	NULL	NULL	NULL	NULL	NULL	NULL	No tables used
-    <snip>
-    30 Jan 2011 16:30:20 : ================================================================================
-    30 Jan 2011 16:30:20 INFO: Test execution complete in 314 seconds
-    30 Jan 2011 16:30:20 INFO: Summary report:
-    30 Jan 2011 16:30:20 INFO: Executed 552/552 test cases, 100.00 percent
-    30 Jan 2011 16:30:20 INFO: STATUS: FAIL, 1/552 test cases, 0.18 percent executed
-    30 Jan 2011 16:30:20 INFO: STATUS: PASS, 551/552 test cases, 99.82 percent executed
-    30 Jan 2011 16:30:20 INFO: FAIL tests: main.subselect
-    30 Jan 2011 16:30:20 INFO: Spent 308 / 314 seconds on: TEST(s)
-    30 Jan 2011 16:30:20 INFO: Test execution complete
-    30 Jan 2011 16:30:20 INFO: Stopping all running servers...
-
-    
-Additional uses
-===============
-Starting a server for manual testing
-------------------------------------
-
-:program:`dbqp.py` allows a user to get a Drizzle server up and running
-quickly.  This can be useful for fast ad-hoc testing.
-
-To do so call::
-
-    ./dbqp.py --start-and-exit [*OPTIONS*]
-
-This will start a Drizzle server that you can connect to and query
-
-Starting a server against a pre-populated DATADIR
---------------------------------------------------
-
-Using :option:`--start-dirty` prevents :program:`dbqp.py` from attempting
-to initialize (clean) the datadir.  This can be useful if you want to use
-an already-populated datadir for testing.
-
-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`'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::
-
-    main.exp1                                                    [ fail ]
-    --- drizzle/tests/r/exp1.result	2010-11-02 02:10:25.107013998 +0300
-    +++ drizzle/tests/r/exp1.reject	2010-11-02 02:10:32.017013999 +0300
-    @@ -5,4 +5,5 @@
-    a
-    1
-    2
-    +3
-    DROP TABLE t1;
-
-A test case consists of a .test and a .result file.  The .test file includes
-the various statements to be executed for a test.  The .result file lists
-the expected results for a given test file.  These files live in tests/t 
-and tests/r, respectively.  This structure is the same for all test suites.
-
-dbqp.py options
-===================
-
-The :program:`dbqp.py` tool has several available options:
-
-./dbqp.py [ OPTIONS ] [ TESTCASE ]
-
-
-Options
--------
-
-.. program:: dbqp.py
-
-.. option:: -h, --help
- 
-   show this help message and exit
-
-Options for the test-runner itself
-----------------------------------
-
-.. program:: dbqp.py
-
-.. option:: --force
-
-    Set this to continue test execution beyond the first failed test
-
-.. option:: --start-and-exit
-
-   Spin up the server(s) for the first specified test then exit 
-   (will leave servers running)
-
-.. option:: --verbose
-
-   Produces extensive output about test-runner state.  
-   Distinct from --debug
-
-.. option:: --debug
-
-   Provide internal-level debugging output.  
-   Distinct from --verbose
-
-.. option:: --mode=MODE
-
-   Testing mode.  
-   We only support dtr...for now >;) 
-   [dtr]
-
-.. option:: --record
-
-   Record a testcase result 
-   (if the testing mode supports it) 
-   [False]
-
-.. option:: --fast
-
-   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
-------------------------------------------------
-
-.. program:: dbqp.py
-
-.. option:: --suite=SUITELIST
-
-   The name of the suite containing tests we want. 
-   Can accept comma-separated list (with no spaces). 
-   Additional --suite args are appended to existing list 
-   [autosearch]
-
-.. option:: --suitepath=SUITEPATHS 
-
-   The path containing the suite(s) you wish to execute. 
-   Use on --suitepath for each suite you want to use.
-
-.. option:: --do-test=DOTEST
-
-   input can either be a prefix or a regex. 
-   Will only execute tests that match the provided pattern
-
-.. option:: --skip-test=SKIPTEST
-
-   input can either be a prefix or a regex.  
-   Will exclude tests that match the provided pattern
-
-.. option:: --reorder
-
-   sort the testcases so that they are executed optimally
-   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]
-
-Options for defining the code that will be under test
------------------------------------------------------
-
-.. program:: dbqp.py
-
-.. option:: --basedir=BASEDIR   
-
-   Pass this argument to signal to the test-runner 
-   that this is an in-tree test (not required).  
-   We automatically set a number of variables 
-   relative to the argument (client-bindir, 
-   serverdir, testdir) [../]
-
-.. option:: --serverdir=SERVERPATH
-
-   Path to the server executable.  [auto-search]
-
-.. option:: --client-bindir=CLIENTBINDIR
-
-   Path to the directory containing client program
-   binaries for use in testing [auto-search]
-
-.. option:: --default-storage-engine=DEFAULTENGINE
-                        
-   Start drizzled using the specified engine [innodb]
-
-Options for defining the testing environment
---------------------------------------------
-
-.. program:: dbqp.py
-
-.. option:: --testdir=TESTDIR   
-
-    Path to the test dir, containing additional files for
-    test execution. [pwd]
-
-.. option:: --workdir=WORKDIR   
-
-   Path to the directory test-run will use to store
-   generated files and directories.
-   [basedir/tests/dbqp_work]
-
-.. option:: --top-srcdir=TOPSRCDIR
-
-   build option [basedir_default]
-
-.. option:: --top-builddir=TOPBUILDDIR
-
-   build option [basedir_default]
-
-.. option:: --no-shm            
-
-   By default, we symlink workdir to a location in shm.
-   Use this flag to not symlink [False]
-
-.. option:: --start-dirty       
-
-   Don't try to clean up working directories before test
-   execution [False]
-
-.. option:: --no-secure-file-priv
-                        
-   Turn off the use of --secure-file-priv=vardir for
-   started servers
-
-Options to pass options on to the server
------------------------------------------
-
-.. program:: dbqp.py
-
-.. option:: --drizzled=DRIZZLEDOPTIONS
-           
-    Pass additional options to the server.  Will be passed
-    to all servers for all tests (mostly for --start-and-
-    exit)
-
-
-Options for defining the tools we use for code analysis (valgrind, gprof, gcov, etc)
-------------------------------------------------------------------------------------
-
-.. program:: dbqp.py
-
-.. option:: --valgrind          
-
-   Run drizzletest and drizzled executables using
-   valgrind with default options [False]
-
-.. option:: --valgrind-option=VALGRINDARGLIST
-                       
-   Pass an option to valgrind (overrides/removes default
-   valgrind options)
-
-Options for controlling the use of debuggers with test execution
-----------------------------------------------------------------
-
-.. program:: dbqp.py
-
-.. option:: --gdb
-
-    Start the drizzled server(s) in gdb
-
-.. option:: --manual-gdb
-
-    Allows you to start the drizzled server(s) in gdb
-    manually (in another window, etc
-
-Options to call additional utilities such as datagen
-------------------------------------------------------
-
-.. program:: dbqp.py
-
-.. 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
-
 
=== removed file 'dbqp/docs/index.rst'
--- dbqp/docs/index.rst	2012-02-04 01:22:23 +0000
+++ dbqp/docs/index.rst	1970-01-01 00:00:00 +0000
@@ -1,33 +0,0 @@
-.. dbqp documentation master file, created by
-   sphinx-quickstart on Fri Aug 27 08:33:41 2010.
-   You can adapt this file completely to your liking, but it should at least
-   contain the root `toctree` directive.
-
-Welcome to dbqp's documentation!
-===================================
-
-dbqp (DataBase Quality Platform) is designed to facilitate testing of MySQL-based database systems.  Its aim is to provide a pluggable system that allows one to run a variety of testing tools and to share standard helper code (server allocation and management / test result reporting / etc)
-
-Introduction:
--------------
-.. toctree::
-   :maxdepth: 2
-   
-Testing:
---------
-.. toctree::
-   :maxdepth: 2
- 
-   dbqp.rst
-   test-run.rst
-   randgen.rst
-   sql-bench.rst
-   sysbench.rst
-   writing_tests.rst
-
-Indices and tables
-==================
-
-* :ref:`genindex`
-* :ref:`search`
-
 
=== removed file 'dbqp/docs/randgen.rst'
--- dbqp/docs/randgen.rst	2012-02-04 01:22:23 +0000
+++ dbqp/docs/randgen.rst	1970-01-01 00:00:00 +0000
@@ -1,197 +0,0 @@
-**********************************
-randgen (random query generator)
-**********************************
-
-
-
-Description
-===========
-
-The randgen aka the random query generator is a database
-testing tool.  It uses a grammar-based stochastic model to represent
-some desired set of queries (to exercise the optimizer, for example) 
-and generates random queries as allowed by the grammar
-
-The primary documentation is here: http://forge.mysql.com/wiki/RandomQueryGenerator
-
-This document is intended to help the user set up their environment so that the tool
-may be used in conjunction with the dbqp.py test-runner.  The forge documentation
-contains more information on the particulars of the tool itself.
-
-Requirements
-============
-
-DBD::drizzle
--------------
-The DBD::drizzle module is required it can be found here http://launchpad.net/dbd-drizzle/
-
-Additional information for installing the module::
-
-    Prerequisites
-    ----------------
-    * Perl
-    * Drizzle (bzr branch lp:drizzle)
-    * libdrizzle (bzr branch lp:libdrizzle)
-    * C compiler
-
-    Installation
-    -------------
-    You should only have to run the following:
-
-    perl Makefile.PL --cflags=-I/usr/local/drizzle/include/ --libs=-"L/usr/local/drizzle/lib -ldrizzle"
-
-
-    Depending on where libdrizzle is installed. Also, you'll want to make 
-    sure that ldconfig has configured libdrizzle to be in your library path 
-
-Additional information may be found here: http://forge.mysql.com/wiki/RandomQueryGeneratorQuickStart
-
-Installing the randgen
-=======================
-
-The code may be branched from launchpad: bzr branch lp:randgen
-
-it also may be downloaded from here http://launchpad.net/randgen/+download
-
-That is all there is : )
-
-Randgen / dbqp tests
-====================
-
-These tests are simple .cnf files that can define a few basic variables
-that are needed to execute tests.  The most interesting section is test_servers.  It is a simple list of python lists
-Each sub-list contains a string of server options that are needed.  Each sub-list represents a server that will be started.
-Using an empty sub-list will create a server with the default options::
-
-    [test_info]
-    comment = does NOT actually test the master-slave replication yet, but it will.
-
-    [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],[--plugin-add=slave --slave.config-file=$MASTER_SERVER_SLAVE_CONFIG]]
-
-Running tests
-=========================
-
-There are several different ways to run tests using :doc:`dbqp` 's randgen mode.
-
-It should be noted that unless :option:`--force` is used, the program will
-stop execution upon encountering the first failing test. 
-:option:`--force` is recommended if you are running several tests - it will
-allow you to view all successes and failures in one run.
-
-Running individual tests
-------------------------
-If one only wants to run a few, specific tests, they may do so this way::
-
-    ./dbqp --mode=randgen --randgen-path=/path/to/randgen [OPTIONS] test1 [test2 ... testN]
-
-Running all tests within a suite
---------------------------------
-Many of the tests supplied with Drizzle are organized into suites.  
-
-The tests within drizzle/tests/randgen_tests/main are considered the 'main' suite.  
-Other suites are also subdirectories of drizzle/tests/randgen_tests.
-
-To run the tests in a specific suite::
-
-    ./dbqp --mode=randgen --randgen-path=/path/to/randgen [OPTIONS] --suite=SUITENAME
-
-Running specific tests within a suite
---------------------------------------
-To run a specific set of tests within a suite::
-
-    ./dbqp --mode=randgen --randgen-path=/path/to/randgen [OPTIONS] --suite=SUITENAME TEST1 [TEST2..TESTN]
-
-Calling tests using <suitename>.<testname> currently does not work.
-One must specify the test suite via the :option:`--suite` option.
-
-
-Running all available tests
----------------------------
-One would currently have to name all suites, but the majority of the working tests live in the main suite
-Other suites utilize more exotic server combinations and we are currently tweaking them to better integrate with the 
-dbqp system.  The slave-plugin suite does currently have a good config file for setting up simple replication setups for testing.
-To execute several suites' worth of tests::
-
-    ./dbqp --mode=randgen --randgen-path=/path/to/randgen [OPTIONS] --suite=SUITE1, SUITE2, ...SUITEN
-
-Interpreting test results
-=========================
-The output of the test runner is quite simple.  Every test should pass.
-In the event of a test failure, please take the time to file a bug here:
-*https://bugs.launchpad.net/drizzle*
-
-During a run, the program will provide the user with:
-  * test name (suite + name)
-  * test status (pass/fail/skipped)
-  * time spent executing each test
-
-At the end of a run, the program will provide the user with a listing of:
-  * how many tests were run
-  * how many tests failed
-  * percentage of passing tests
-  * a listing of failing tests
-  * total time spent executing the tests
-
-Example output::
-
-    24 Feb 2011 17:27:36 : main.outer_join_portable                                [ pass ]         7019
-    24 Feb 2011 17:27:39 : main.repeatable_read                                    [ pass ]         2764
-    24 Feb 2011 17:28:57 : main.select_stability_validator                         [ pass ]        77946
-    24 Feb 2011 17:29:01 : main.subquery                                           [ pass ]         4474
-    24 Feb 2011 17:30:52 : main.subquery_semijoin                                  [ pass ]       110355
-    24 Feb 2011 17:31:00 : main.subquery_semijoin_nested                           [ pass ]         8750
-    24 Feb 2011 17:31:03 : main.varchar                                            [ pass ]         3048
-    24 Feb 2011 17:31:03 : ================================================================================
-    24 Feb 2011 17:31:03 INFO: Test execution complete in 288 seconds
-    24 Feb 2011 17:31:03 INFO: Summary report:
-    24 Feb 2011 17:31:03 INFO: Executed 18/18 test cases, 100.00 percent
-    24 Feb 2011 17:31:03 INFO: STATUS: PASS, 18/18 test cases, 100.00 percent executed
-    24 Feb 2011 17:31:03 INFO: Spent 287 / 288 seconds on: TEST(s)
-    24 Feb 2011 17:31:03 INFO: Test execution complete
-    24 Feb 2011 17:31:03 INFO: Stopping all running servers...
-
-    
-Additional uses
-===============
-Starting a server for manual testing and (optionally) populating it
---------------------------------------------------------------------
-
-:doc:`dbqp` 's randgen mode allows a user to get a Drizzle server up and running quickly.  This can be useful for fast ad-hoc testing.
-
-To do so call::
-
-    ./dbqp --mode=randgen --randgen-path=/path/to/randgen --start-and-exit [*OPTIONS*]
-
-This will start a Drizzle server that you can connect to and query
-
-With the addition of the --gendata option, a user may utilize the randgen's gendata (table creation and population) tool
-to populate a test server.  In the following example, the test server is now populated by the 8 tables listed below::
-
-    ./dbqp --mode=randgen --randgen-path=/randgen --start-and-exit --gendata=/randgen/conf/drizzle/drizzle.zz
-    <snip>
-    24 Feb 2011 17:48:48 INFO: NAME: server0
-    24 Feb 2011 17:48:48 INFO: MASTER_PORT: 9306
-    24 Feb 2011 17:48:48 INFO: DRIZZLE_TCP_PORT: 9307
-    24 Feb 2011 17:48:48 INFO: MC_PORT: 9308
-    24 Feb 2011 17:48:48 INFO: PBMS_PORT: 9309
-    24 Feb 2011 17:48:48 INFO: RABBITMQ_NODE_PORT: 9310
-    24 Feb 2011 17:48:48 INFO: VARDIR: /home/pcrews/bzr/work/dbqp_randgen_updates/tests/workdir/testbot0/server0/var
-    24 Feb 2011 17:48:48 INFO: STATUS: 1
-    # 2011-02-24T17:48:48 Default schema: test
-    # 2011-02-24T17:48:48 Executor initialized, id GenTest::Executor::Drizzle 2011.02.2198 ()
-    # 2011-02-24T17:48:48 # Creating Drizzle table: test.A; engine: ; rows: 0 .
-    # 2011-02-24T17:48:48 # Creating Drizzle table: test.B; engine: ; rows: 0 .
-    # 2011-02-24T17:48:48 # Creating Drizzle table: test.C; engine: ; rows: 1 .
-    # 2011-02-24T17:48:48 # Creating Drizzle table: test.D; engine: ; rows: 1 .
-    # 2011-02-24T17:48:48 # Creating Drizzle table: test.AA; engine: ; rows: 10 .
-    # 2011-02-24T17:48:48 # Creating Drizzle table: test.BB; engine: ; rows: 10 .
-    # 2011-02-24T17:48:48 # Creating Drizzle table: test.CC; engine: ; rows: 100 .
-    # 2011-02-24T17:48:49 # Creating Drizzle table: test.DD; engine: ; rows: 100 .
-    24 Feb 2011 17:48:49 INFO: User specified --start-and-exit.  dbqp.py exiting and leaving servers running...
-
-
-
 
=== removed file 'dbqp/docs/sql-bench.rst'
--- dbqp/docs/sql-bench.rst	2012-02-04 01:22:23 +0000
+++ dbqp/docs/sql-bench.rst	1970-01-01 00:00:00 +0000
@@ -1,174 +0,0 @@
-**********************************
-sql-bench
-**********************************
-
-
-
-Description
-===========
-dbqp can take advantage of two testing modes offered by the sql-bench tool.
-
-The Drizzle code has a copy of this tool set in the tree and the test-runner offers two modes::
-
-    sql-bench modes
-    ---------------
-    * sqlbench - runs the entire sql-bench test suite and can take a very long time (~45 minutes)
-    * crashme - runs the crash-me tool and reports failure if any tests should not pass
-
-
-Requirements
-============
-DBD::drizzle
--------------
-The DBD::drizzle module is required it can be found here http://launchpad.net/dbd-drizzle/
-
-Additional information for installing the module::
-
-    Prerequisites
-    ----------------
-    * Perl
-    * Drizzle (bzr branch lp:drizzle)
-    * libdrizzle (bzr branch lp:libdrizzle)
-    * C compiler
-
-    Installation
-    -------------
-    You should only have to run the following:
-
-    perl Makefile.PL --cflags=-I/usr/local/drizzle/include/ --libs=-"L/usr/local/drizzle/lib -ldrizzle"
-
-
-    Depending on where libdrizzle is installed. Also, you'll want to make 
-    sure that ldconfig has configured libdrizzle to be in your library path 
-
-
-sql-bench / dbqp tests
-=======================
-
-Currently, there are only two sql-bench test cases for dbqp.  As one might expect, main.all_sqlbench_tests executes::
-
-    run-all-tests --server=drizzle --dir=$DRIZZLE_TEST_WORKDIR --log --connect-options=port=$MASTER_MYPORT --create-options=ENGINE=innodb --user=root 
-
-against a Drizzle server.  The second test case executes the crashme tool against a running server.
-
-Test cases are defined in python .cnf files and live in tests/sqlbench_tests.
-
-Running tests
-=========================
-
-NOTE:  all_sqlbench_tests can take a significant amount of time to execute (45 minutes or so on a decently provisioned laptop)
-
-There are several different ways to run tests using :doc:`dbqp` 's sql-bench mode.
-
-It should be noted that unless :option:`--force` is used, the program will
-stop execution upon encountering the first failing test. 
-:option:`--force` is recommended if you are running several tests - it will
-allow you to view all successes and failures in one run.
-
-At present, sql-bench output in a work in progress.  It does report a simple pass/fail, but we are working on alternate ways of viewing / storing the results (and for other testing modes as well)
-
-
-Running all tests within a suite
---------------------------------
-At present, there is only one test case per suite for sqlbench and crashme modes - that is all that is needed for these tools.
-To execute the sql-bench test suite::
-
-    ./dbqp --mode=sqlbench
-
-To execute the crash-me test suite::
-
-    ./dbqp --mode=crashme
-
-Interpreting test results
-=========================
-The output of the test runner is quite simple.  Every test should pass.
-In the event of a test failure, please take the time to file a bug here:
-*https://bugs.launchpad.net/drizzle*
-
-During a run, the program will provide the user with:
-  * test name (suite + name)
-  * test status (pass/fail/skipped)
-  * time spent executing each test
-
-Example sqlbench output::
-
-    20110608-135645  ===============================================================
-    20110608-135645  TEST NAME                                  [ RESULT ] TIME (ms)
-    20110608-135645  ===============================================================
-    20110608-135645  main.all_sqlbench_tests                    [ pass ]  2732007
-    20110608-135645  Test finished. You can find the result in:
-    20110608-135645  drizzle/tests/workdir/RUN-drizzle-Linux_2.6.38_9_generic_x86_64
-    20110608-135645  Benchmark DBD suite: 2.15
-    20110608-135645  Date of test:        2011-06-08 13:11:10
-    20110608-135645  Running tests on:    Linux 2.6.38-9-generic x86_64
-    20110608-135645  Arguments:           --connect-options=port=9306 --create-options=ENGINE=innodb
-    20110608-135645  Comments:
-    20110608-135645  Limits from:
-    20110608-135645  Server version:      Drizzle 2011.06.19.2325
-    20110608-135645  Optimization:        None
-    20110608-135645  Hardware:
-    20110608-135645  
-    20110608-135645  alter-table: Total time: 42 wallclock secs ( 0.06 usr  0.04 sys +  0.00 cusr  0.00 csys =  0.10 CPU)
-    20110608-135645  ATIS: Total time: 22 wallclock secs ( 4.01 usr  0.26 sys +  0.00 cusr  0.00 csys =  4.27 CPU)
-    20110608-135645  big-tables: Total time: 24 wallclock secs ( 4.16 usr  0.22 sys +  0.00 cusr  0.00 csys =  4.38 CPU)
-    20110608-135645  connect: Total time: 31 wallclock secs ( 6.81 usr  4.50 sys +  0.00 cusr  0.00 csys = 11.31 CPU)
-    20110608-135645  create: Total time: 59 wallclock secs ( 2.93 usr  1.65 sys +  0.00 cusr  0.00 csys =  4.58 CPU)
-    20110608-135645  insert: Total time: 1962 wallclock secs (270.53 usr 66.35 sys +  0.00 cusr  0.00 csys = 336.88 CPU)
-    20110608-135645  select: Total time: 560 wallclock secs (23.12 usr  4.62 sys +  0.00 cusr  0.00 csys = 27.74 CPU)
-    20110608-135645  transactions: Total time: 21 wallclock secs ( 2.43 usr  1.98 sys +  0.00 cusr  0.00 csys =  4.41 CPU)
-    20110608-135645  wisconsin: Total time: 10 wallclock secs ( 2.11 usr  0.52 sys +  0.00 cusr  0.00 csys =  2.63 CPU)
-    20110608-135645  
-    20110608-135645  All 9 test executed successfully
-    20110608-135645  
-    20110608-135645  Totals per operation:
-    20110608-135645  Operation             seconds     usr     sys     cpu   tests
-    20110608-135645  alter_table_add                       18.00    0.02    0.00    0.02     100
-    20110608-135645  alter_table_drop                      17.00    0.02    0.01    0.03      91
-    20110608-135645  connect                                2.00    1.02    0.51    1.53    2000
-    <snip>
-    20110608-135645  update_rollback                        3.00    0.26    0.23    0.49     100
-    20110608-135645  update_with_key                       73.00    6.70    5.23   11.93  300000
-    20110608-135645  update_with_key_prefix                34.00    4.45    2.30    6.75  100000
-    20110608-135645  wisc_benchmark                         2.00    1.49    0.00    1.49     114
-    20110608-135645  TOTALS                              2865.00  310.26   79.94  390.20 2974250
-    20110608-135645  
-    20110608-135645  ===============================================================
-    20110608-135645 INFO Test execution complete in 2735 seconds
-    20110608-135645 INFO Summary report:
-    20110608-135645 INFO Executed 1/1 test cases, 100.00 percent
-    20110608-135645 INFO STATUS: PASS, 1/1 test cases, 100.00 percent executed
-    20110608-135645 INFO Spent 2732 / 2735 seconds on: TEST(s)
-    20110608-135645 INFO Test execution complete
-    20110608-135645 INFO Stopping all running servers...
-
-Example crashme output::
-
-    20110608-152759  ===============================================================
-    20110608-152759  TEST NAME                                  [ RESULT ] TIME (ms)
-    20110608-152759  ===============================================================
-    20110608-152759  main.crashme                               [ fail ]   155298
-    20110608-152759  func_extra_to_days=error		# Function TO_DAYS
-    20110608-152759  ###
-    20110608-152759  ###<select to_days('1996-01-01') from crash_me_d
-    20110608-152759  ###>2450084
-    20110608-152759  ###We expected '729024' but got '2450084'
-    20110608-152759  func_odbc_timestampadd=error		# Function TIMESTAMPADD
-    20110608-152759  ###
-    20110608-152759  ###<select timestampadd(SQL_TSI_SECOND,1,'1997-01-01 00:00:00')
-    20110608-152759  ###>1997-01-01 00:00:01.000000
-    20110608-152759  ###We expected '1997-01-01 00:00:01' but got '1997-01-01 00:00:01.000000'
-    20110608-152759  ###
-    20110608-152759  ###<select {fn timestampadd(SQL_TSI_SECOND,1,{ts '1997-01-01 00:00:00'}) }
-    20110608-152759  ###>1997-01-01 00:00:01.000000
-    20110608-152759  ###We expected '1997-01-01 00:00:01' but got '1997-01-01 00:00:01.000000'
-    20110608-152759  
-    20110608-152759 ERROR Failed test.  Use --force to execute beyond the first test failure
-    20110608-152759  ===============================================================
-    20110608-152759 INFO Test execution complete in 158 seconds
-    20110608-152759 INFO Summary report:
-    20110608-152759 INFO Executed 1/1 test cases, 100.00 percent
-    20110608-152759 INFO STATUS: FAIL, 1/1 test cases, 100.00 percent executed
-    20110608-152759 INFO FAIL tests: main.crashme
-    20110608-152759 INFO Spent 155 / 158 seconds on: TEST(s)
-    20110608-152759 INFO Test execution complete
-
 
=== removed file 'dbqp/docs/sysbench.rst'
--- dbqp/docs/sysbench.rst	2012-02-04 01:22:23 +0000
+++ dbqp/docs/sysbench.rst	1970-01-01 00:00:00 +0000
@@ -1,123 +0,0 @@
-**********************************
-sysbench
-**********************************
-
-
-
-Description
-===========
-dbqp's sysbench mode allows a user to run a specific iteration of a sysbench test (eg an oltp readonly run at concurrency = 16)
-
-
-Requirements
-============
-
-The SYSBENCH command requires that the Drizzle library header be installed. Simply build Drizzle and do::
-
-    $> sudo make install
-
-This will install the right headers.
-
-The SYSBENCH command also requires installation of the drizzle-sysbench program, which can be installed from source like so::
-
-    $> bzr branch lp:~drizzle-developers/sysbench/trunk  drizzle-sysbench
-    $> cd drizzle-sysbench
-    $> ./autogen.sh && ./configure && make && sudo make install
-
-Make sure sysbench is then in your path
-
-
-sysbench / dbqp tests
-=====================
-
-A sysbench test defines a run for a particular concurrency.  There are suites for readonly and readwrite.
-They are currently broken down this way as an experiment - we are open to other ways of organizing these tests::
-
-    [test_info]
-    comment = 16 threads
-
-    [test_command]
-    command = sysbench --max-time=240 --max-requests=0 --test=oltp --db-ps-mode=disable --drizzle-table-engine=innodb --oltp-read-only=on --oltp-table-size=1000000 --drizzle-mysql=on --drizzle-user=root --drizzle-db=test --drizzle-port=$MASTER_MYPORT --drizzle-host=localhost --db-driver=drizzle --num-threads=16
-
-    [test_servers]
-    servers = [[innodb.buffer-pool-size=256M innodb.log-file-size=64M innodb.log-buffer-size=8M innodb.thread-concurrency=0 innodb.additional-mem-pool-size=16M table-open-cache=4096 table-definition-cache=4096 mysql-protocol.max-connections=2048]]
-
-Running tests
-=========================
-
-There are several different ways to run tests using :doc:`dbqp` 's sysbench mode.
-
-It should be noted that unless :option:`--force` is used, the program will
-stop execution upon encountering the first failing test. 
-:option:`--force` is recommended if you are running several tests - it will
-allow you to view all successes and failures in one run.
-
-Running individual tests
-------------------------
-If one only wants to run a few, specific tests, they may do so this way::
-
-    ./dbqp --mode=sysbench [OPTIONS] test1 [test2 ... testN]
-
-Running all tests within a suite
---------------------------------
-Many of the tests supplied with Drizzle are organized into suites.  
-
-The tests within drizzle/tests/randgen_tests/main are considered the 'main' suite.  
-Other suites are also subdirectories of drizzle/tests/randgen_tests.
-
-To run the tests in a specific suite::
-
-    ./dbqp --mode=sysbench [OPTIONS] --suite=SUITENAME
-
-Running specific tests within a suite
---------------------------------------
-To run a specific set of tests within a suite::
-
-    ./dbqp --mode=sysbench [OPTIONS] --suite=SUITENAME TEST1 [TEST2..TESTN]
-
-Calling tests using <suitename>.<testname> currently does not work.
-One must specify the test suite via the :option:`--suite` option.
-
-
-Running all available tests
----------------------------
-One would currently have to name all suites, but the majority of the working tests live in the main suite
-Other suites utilize more exotic server combinations and we are currently tweaking them to better integrate with the 
-dbqp system.  The slave-plugin suite does currently have a good config file for setting up simple replication setups for testing.
-To execute several suites' worth of tests::
-
-    ./dbqp --mode=sysbench [OPTIONS] --suite=SUITE1, SUITE2, ...SUITEN
-
-Interpreting test results
-=========================
-The output of the test runner is quite simple.  Every test should pass.
-In the event of a test failure, please take the time to file a bug here:
-*https://bugs.launchpad.net/drizzle*
-
-During a run, the program will provide the user with:
-  * test name (suite + name)
-  * test status (pass/fail/skipped)
-  * time spent executing each test
-
-Example output::
-
-    20110601-191706  ===============================================================
-    20110601-191706  TEST NAME                                  [ RESULT ] TIME (ms)
-    20110601-191706  ===============================================================
-    20110601-191706  readonly.concurrency_16                    [ pass ]   240019
-    20110601-191706  max_req_lat_ms: 21.44
-    20110601-191706  rwreqps: 4208.2
-    20110601-191706  min_req_lat_ms: 6.31
-    20110601-191706  deadlocksps: 0.0
-    20110601-191706  tps: 150.29
-    20110601-191706  avg_req_lat_ms: 6.65
-    20110601-191706  95p_req_lat_ms: 7.02
-    20110601-191706  ===============================================================
-    20110601-191706 INFO Test execution complete in 275 seconds
-    20110601-191706 INFO Summary report:
-    20110601-191706 INFO Executed 1/1 test cases, 100.00 percent
-    20110601-191706 INFO STATUS: PASS, 1/1 test cases, 100.00 percent executed
-    20110601-191706 INFO Spent 240 / 275 seconds on: TEST(s)
-    20110601-191706 INFO Test execution complete
-    20110601-191706 INFO Stopping all running servers...
-
 
=== removed file 'dbqp/docs/test-run.rst'
--- dbqp/docs/test-run.rst	2012-02-04 01:22:23 +0000
+++ dbqp/docs/test-run.rst	1970-01-01 00:00:00 +0000
@@ -1,494 +0,0 @@
-.. _test-run-label:
-
-**********************************
-test-run.pl - Drizzle testing tool
-**********************************
-
-Synopsis
-========
-
-**./test-run** [ *OPTIONS* ] [ TESTCASE ]
-
-Description
-===========
-
-:program:`test-run.pl` (aka test-run, dtr, mtr) 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.
-
-The tests use a diff-based paradigm, meaning that the test runner executes
-a test and then compares the results received with pre-recorded expected 
-results.  In the event of a test failure, the program will provide output
-highlighting the differences found between expected and actual results; this
-can be useful for troubleshooting and in bug reports.
-
-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.
-
-Running tests
-=========================
-
-There are several different ways to run tests using :program:`test-run.pl`.
-
-It should be noted that unless :option:`--force` is used, the program will
-stop execution upon encountering the first failing test. 
-:option:`--force` is recommended if you are running several tests - it will
-allow you to view all successes and failures in one run.
-
-Running individual tests
-------------------------
-If one only wants to run a few, specific tests, they may do so this way::
-
-    ./test-run [OPTIONS] test1 [test2 ... testN]
-
-Running all tests within a suite
---------------------------------
-Many of the tests supplied with Drizzle are organized into suites.  
-
-The tests within drizzle/tests/t are considered the 'main' suite.  
-Other suites are located in either drizzle/tests/suite or within the various
-directories in drizzle/plugin.  Tests for a specific plugin should live in 
-the plugin's directory - drizzle/plugin/example_plugin/tests
-
-To run the tests in a specific suite::
-
-    ./test-run [OPTIONS] --suite=SUITENAME
-
-Running specific tests within a suite
---------------------------------------
-To run a specific set of tests within a suite::
-
-    ./test-run [OPTIONS] --suite=SUITENAME TEST1 [TEST2..TESTN]
-
-Calling tests using <suitename>.<testname> currently does not work.
-One must specify the test suite via the :option:`--suite` option.
-
-
-Running all available tests
----------------------------
-Currently, the quickest way to execute all tests in all suites is
-to use 'make test' from the drizzle root.
-
-Otherwise, one should simply name all suites::
-
-    ./test-run [OPTIONS] --suite=SUITE1, SUITE2, ...SUITEN
-
-Interpreting test results
-=========================
-The output of the test runner is quite simple.  Every test should pass.
-In the event of a test failure, please take the time to file a bug here:
-*https://bugs.launchpad.net/drizzle*
-
-During a run, the program will provide the user with:
-  * test name (suite + name)
-  * test status (pass/fail/skipped)
-  * time spent executing each test
-
-At the end of a run, the program will provide the user with a listing of:
-  * how many tests were run
-  * how many tests failed
-  * percentage of passing tests
-  * a listing of failing tests
-  * total time spent executing the tests
-
-Example output::
-
-    <snip>
-    main.snowman                                                 [ pass ]       9
-    main.statement_boundaries                                    [ pass ]      17
-    main.status                                                  [ pass ]      12
-    main.strict                                                  [ pass ]      50
-    main.subselect                                               [ pass ]    6778
-    main.subselect2                                              [ pass ]      51
-    main.subselect3                                              [ fail ]
-    drizzletest: At line 621: query 'select a, (select max(b) from t1) into outfile
-    <snip>
-    --------------------------------------------------------------------------------
-    Stopping All Servers
-    Failed 10/231 tests, 95.67% were successful.
-
-    The log files in var/log may give you some hint
-    of what went wrong.
-    If you want to report this error, go to:
-	http://bugs.launchpad.net/drizzle
-    The servers were restarted 16 times
-    Spent 64.364 of 115 seconds executing testcases
-
-    drizzle-test-run in default mode: *** Failing the test(s): main.exp1 
-    main.func_str main.loaddata main.null main.outfile main.subselect3 
-    main.warnings jp.like_utf8 jp.select_utf8 jp.where_utf8
-    
-Additional uses
-===============
-Starting a server for manual testing
-------------------------------------
-
-:program:`test-run.pl` allows a user to get a Drizzle server up and running
-quickly.  This can be useful for fast ad-hoc testing.
-
-To do so call::
-
-    ./test-run --start-and-exit [*OPTIONS*]
-
-This will start a Drizzle server that you can connect to and query
-
-Starting a server against a pre-populated DATADIR
---------------------------------------------------
-
-Using :option:`--start-dirty` prevents :program:`test-run.pl` from attempting
-to initialize (clean) the datadir.  This can be useful if you want to use
-an already-populated datadir for testing.
-
-Program architecture
-====================
-
-:program:`test-run.pl` uses a simple diff-based mechanism for testing.  
-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::
-
-    main.exp1                                                    [ fail ]
-    --- drizzle/tests/r/exp1.result	2010-11-02 02:10:25.107013998 +0300
-    +++ drizzle/tests/r/exp1.reject	2010-11-02 02:10:32.017013999 +0300
-    @@ -5,4 +5,5 @@
-    a
-    1
-    2
-    +3
-    DROP TABLE t1;
-
-A test case consists of a .test and a .result file.  The .test file includes
-the various statements to be executed for a test.  The .result file lists
-the expected results for a given test file.  These files live in tests/t 
-and tests/r, respectively.  This structure is the same for all test suites.
-
-test-run.pl options
-===================
-
-The :program:`test-run.pl` tool has several available options:
-
-./test-run [ OPTIONS ] [ TESTCASE ]
-
-Options to control what engine/variation to run
------------------------------------------------
-
-.. program:: test-run
-
-.. option:: --compress
-   
-   Use the compressed protocol between client and server
-
-.. option:: --bench
-   
-   Run the benchmark suite
-
-.. option:: --small-bench
-
-   Run the benchmarks with --small-tests --small-tables
-
-Options to control directories to use
--------------------------------------
-
-.. program:: test-run
-
-.. option:: --benchdir=DIR          
-
-   The directory where the benchmark suite is stored
-   (default: ../../mysql-bench)
-  
-.. option:: --tmpdir=DIR
-
-   The directory where temporary files are stored
-   (default: ./var/tmp).
-
-.. option:: --vardir=DIR  
-         
-   The directory where files generated from the test run
-   is stored (default: ./var). Specifying a ramdisk or
-   tmpfs will speed up tests.
-
-.. option:: --mem 
-   
-   Run testsuite in "memory" using tmpfs or ramdisk
-   Attempts to find a suitable location
-   using a builtin list of standard locations
-   for tmpfs (/dev/shm)
-   The option can also be set using environment
-   variable :envvar:`DTR_MEM` =[DIR]
-
-Options to control what test suites or cases to run
----------------------------------------------------
-
-.. program:: test-run
-
-.. option:: --force                 
-   
-   Continue to run the suite after failure
-
-.. option:: --do-test=PREFIX or REGEX
-                        
-   Run test cases which name are prefixed with PREFIX
-   or fulfills REGEX
-
-.. option:: --skip-test=PREFIX or REGEX
-                        
-   Skip test cases which name are prefixed with PREFIX
-   or fulfills REGEX
-
-.. option:: --start-from=PREFIX     
-
-   Run test cases starting from test prefixed with PREFIX
-   suite[s]=NAME1,..,NAMEN Collect tests in suites from the comma separated
-   list of suite names.
-   The default is: "main,jp"
-
-.. option:: --skip-rpl              
-
-   Skip the replication test cases.
-   combination="ARG1 .. ARG2" Specify a set of "drizzled" arguments for one
-   combination.
-
-.. option:: --skip-combination      
-
-   Skip any combination options and combinations files
-
-.. option:: --repeat-test=n         
-  
-   How many times to repeat each test (default: 1)
-
-Options that specify ports
---------------------------
-
-.. program:: test-run
-
-.. option:: --master_port=PORT      
-
-   Specify the port number used by the first master
-
-.. option:: --slave_port=PORT      
-
-   Specify the port number used by the first slave
-
-.. option:: --dtr-build-thread=#    
-
-   Specify unique collection of ports. Can also be set by
-   setting the environment variable :envvar:`DTR_BUILD_THREAD`.
-
-Options for test case authoring
--------------------------------
-
-.. program:: test-run
-
-.. option:: --record TESTNAME       
-
-   (Re)genereate the result file for TESTNAME
-
-.. option:: --check-testcases       
-
-   Check testcases for sideeffects
-
-.. option:: --mark-progress         
-
-   Log line number and elapsed time to <testname>.progress
-
-Options that pass on options
-----------------------------
-
-.. program:: test-run
-
-.. option:: --drizzled=ARGS           
- 
-   Specify additional arguments to "drizzled"
-
-Options to run test on running server
--------------------------------------
-
-.. program:: test-run
-
-.. option:: --extern                
-
-   Use running server for tests
-
-.. option:: --user=USER             
-
-   User for connection to extern server
-
-Options for debugging the product
----------------------------------
-
-.. program:: test-run
-
-.. option:: --client-ddd            
-
-   Start drizzletest client in ddd
-
-.. option:: --client-debugger=NAME  
-
-   Start drizzletest in the selected debugger
-
-.. option:: --client-gdb            
-
-   Start drizzletest client in gdb
-
-.. option:: --ddd                   
-
-   Start drizzled in ddd
-
-.. option:: --debug                 
-
-   Dump trace output for all servers and client programs
-
-.. option:: --debugger=NAME         
-
-   Start drizzled in the selected debugger
-
-.. option:: --gdb                   
-
-   Start the drizzled(s) in gdb
-
-.. option:: --manual-debug          
-
-   Let user manually start drizzled in debugger, before running test(s)
-
-.. option:: --manual-gdb            
-
-   Let user manually start drizzled in gdb, before running test(s)
-
-.. option:: --manual-ddd            
-
-   Let user manually start drizzled in ddd, before running test(s)
-
-.. option:: --master-binary=PATH    
-   
-   Specify the master "drizzled" to use
-
-.. option:: --slave-binary=PATH     
-
-   Specify the slave "drizzled" to use
-
-.. option:: --strace-client         
-
-   Create strace output for drizzletest client
-
-.. option:: --max-save-core         
-
-   Limit the number of core files saved (to avoid filling up disks for 
-   heavily crashing server). Defaults to 5, set to 0 for no limit.
-
-Options for coverage, profiling etc
------------------------------------
-
-.. todo::
-   
-   .. option:: --gcov                  
-
-.. program:: test-run
-
-.. option:: --gprof                 
-
-   See online documentation on how to use it.
-
-.. option:: --valgrind              
-
-   Run the *drizzletest* and *drizzled* executables using valgrind with 
-   default options
-
-.. option:: --valgrind-all          
-   
-   Synonym for :option:`--valgrind`
-
-.. option:: --valgrind-drizzleslap  
-
-   Run "drizzleslap" with valgrind.
-
-.. option:: --valgrind-drizzletest  
-
-   Run the *drizzletest* and *drizzle_client_test* executable with valgrind
-
-.. option:: --valgrind-drizzled       
-
-   Run the "drizzled" executable with valgrind
-
-.. option:: --valgrind-options=ARGS 
-
-   Deprecated, use :option:`--valgrind-option`
-
-.. option:: --valgrind-option=ARGS  
-
-   Option to give valgrind, replaces default option(s), 
-   can be specified more then once
-
-.. option:: --valgrind-path=[EXE]   
-
-   Path to the valgrind executable
-
-.. option:: --callgrind             
-
-   Instruct valgrind to use callgrind
-
-.. option:: --massif                
-
-   Instruct valgrind to use massif
-
-Misc options
-------------
-
-.. program:: test-run
-
-.. option:: --comment=STR           
-
-   Write STR to the output
-
-.. option:: --notimer               
-
-   Don't show test case execution time
-
-.. option:: --script-debug          
-
-   Debug this script itself
-
-.. option:: --verbose               
-
-   More verbose output
-
-.. option:: --start-and-exit        
-
-   Only initialize and start the servers, using the
-   startup settings for the specified test case (if any)
-
-.. option:: --start-dirty           
-
-   Only start the servers (without initialization) for
-   the specified test case (if any)
-
-.. option:: --fast                  
-
-   Don't try to clean up from earlier runs
-
-.. option:: --reorder               
-
-   Reorder tests to get fewer server restarts
-
-.. option:: --help                  
-
-   Get this help text
-
-.. option:: --testcase-timeout=MINUTES 
-
-   Max test case run time (default 15)
-
-.. option:: --suite-timeout=MINUTES 
-
-   Max test suite run time (default 180)
-
-.. option:: --warnings | log-warnings 
-
-   Pass --log-warnings to drizzled
-
-.. option:: --sleep=SECONDS         
-
-   Passed to drizzletest, will be used as fixed sleep time
-
-
 
=== removed file 'dbqp/docs/writing_tests.rst'
--- dbqp/docs/writing_tests.rst	2012-02-04 01:22:23 +0000
+++ dbqp/docs/writing_tests.rst	1970-01-01 00:00:00 +0000
@@ -1,30 +0,0 @@
-**********************************
-Writing drizzletest test cases
-**********************************
-
-Synopsis
-========
-
-Here, we discuss various topics related to writing test cases, with a focus on features
-that allow for more complex testing scenarios.  Additional documentation for other testing
-tools will come later.
-
-Using a pre-populated datadir
-=============================
-The experimental test runner, dbqp allows for starting a server with a pre-populated datadir
-for a test case.  This is accomplished via the use of a .cnf file (versus a master.opt file)
-Over time, this will be the direction for all drizzletest cases.
-
-The .cnf file shown below tells the test-runner to use the directory drizzle/tests/std_data/backwards_compat_data
-as the datadir for the first server.  If a test uses multiple servers, the .cnf file can have additional sections ([s1]...[sN])::
-
-    [test_servers] 
-    servers = [[]]
-
-    [s0]
-    load-datadir=backwards_compat_data
-
-
-All datadirs are expected to be in tests/std_data.  If there is need for the ability to use datadirs outside of this location,
-it can be explored.
-
 
=== removed directory 'dbqp/lib'
=== removed file 'dbqp/lib/__init__.py'
=== removed directory 'dbqp/lib/modes'
=== removed file 'dbqp/lib/modes/__init__.py'
=== removed directory 'dbqp/lib/modes/dtr'
=== removed file 'dbqp/lib/modes/dtr/__init__.py'
=== removed file 'dbqp/lib/modes/dtr/dtr_test_execution.py'
--- dbqp/lib/modes/dtr/dtr_test_execution.py	2012-02-04 01:22:23 +0000
+++ dbqp/lib/modes/dtr/dtr_test_execution.py	1970-01-01 00:00:00 +0000
@@ -1,139 +0,0 @@
-#! /usr/bin/env python
-# -*- mode: python; 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 testExecutor(test_execution.testExecutor):
-    """ dtr-specific testExecutor 
-        We currently execute by sending test-case
-        data to client/drizzletest...for now
-
-    """
-  
-    def execute_testCase (self):
-        """ Execute a dtr testCase via calls to drizzletest (boo)
-            Eventually, we will replace drizzletest with pythonic
-            goodness, but we have these classes stored here for the moment
-
-        """
-        test_execution.testExecutor.execute_testCase(self)
-        self.status = 0
-
-        # generate command line
-        drizzletest_cmd = self.generate_drizzletest_call()
-
-        # call drizzletest
-        self.execute_drizzletest(drizzletest_cmd)
-
-        # analyze results
-        self.current_test_status = self.process_drizzletest_output()
-        self.set_server_status(self.current_test_status)
- 
-
-    def generate_drizzletest_call(self):
-        """ Produce the command line we use to call drizzletest
-            We have a healthy number of values, so we put this in a 
-            nice function
-
-        """
-
-        drizzletest_arguments = [ '--no-defaults'
-                                , '--silent'
-                                , '--tmpdir=%s' %(self.master_server.tmpdir)
-                                , '--logdir=%s' %(self.master_server.logdir)
-                                , '--port=%d' %(self.master_server.master_port)
-                                , '--database=test'
-                                , '--user=root'
-                                , '--password='
-                                #, '--testdir=%s' %(self.test_manager.testdir)
-                                , '--test-file=%s' %(self.current_testcase.testpath)
-                                , '--tail-lines=20'
-                                , '--timer-file=%s' %(self.master_server.timer_file)
-                                , '--result-file=%s' %(self.current_testcase.resultpath)
-                                ]
-        if self.record_flag:
-            # We want to record a new result
-            drizzletest_arguments.append('--record')
-        drizzletest_cmd = "%s %s %s" %( self.cmd_prefix
-                                      , self.master_server.code_tree.drizzletest
-                                      , " ".join(drizzletest_arguments))
-        return drizzletest_cmd
-
-    def execute_drizzletest(self, drizzletest_cmd):
-        """ 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')
-        #retcode, output = self.system_manager.execute_cmd( drizzletest_cmd
-                                                 #         , must_pass = 0 )
-        drizzletest_outfile = os.path.join(self.logdir,'drizzletest.out')
-        drizzletest_output = open(drizzletest_outfile,'w')
-        drizzletest_subproc = subprocess.Popen( drizzletest_cmd
-                                         , shell=True
-                                         , cwd=self.system_manager.testdir
-                                         , env=self.working_environment
-                                         , stdout = drizzletest_output
-                                         , stderr = subprocess.STDOUT
-                                         )
-        drizzletest_subproc.wait()
-        retcode = drizzletest_subproc.returncode     
-        execution_time = int(self.time_manager.stop(testcase_name)*1000) # millisec
-
-        drizzletest_output.close()
-        drizzletest_file = open(drizzletest_outfile,'r')
-        output = ''.join(drizzletest_file.readlines())
-        drizzletest_file.close()
-
-        self.logging.debug("drizzletest_retcode: %d" %(retcode))
-        self.current_test_retcode = retcode
-        self.current_test_output = output
-        self.current_test_exec_time = execution_time
-
-    def process_drizzletest_output(self):
-        """ Drizzletest has run, we now check out what we have """
-        retcode = self.current_test_retcode
-        if retcode == 0:
-            return 'pass'
-        elif retcode == 62 or retcode == 15872:
-            return 'skipped'
-        elif retcode == 63 or retcode == 1:
-            return 'fail'
-        else:
-            return 'fail'
-
 
=== removed file 'dbqp/lib/modes/dtr/dtr_test_management.py'
--- dbqp/lib/modes/dtr/dtr_test_management.py	2012-02-04 01:22:23 +0000
+++ dbqp/lib/modes/dtr/dtr_test_management.py	1970-01-01 00:00:00 +0000
@@ -1,495 +0,0 @@
-#! /usr/bin/env python
-# -*- mode: python; 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_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 the test-runner's dtr
-    mode. (traditional diff-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 per .test file basis
-       Attributes contain information necessary to execute / validate
-       the test file when it is executed.
- 
-    """
-    def __init__(self, system_manager, test_case=None, test_name=None, suite_name=None
-                 , suite_path=None, test_server_options=[], test_path=None, result_path=None
-                 , comment=None, master_sh=None, cnf_path=None
-                 , disable=0, innodb_test=1 
-                 , need_debug=0, debug=0):
-        self.system_manager = system_manager
-        self.logging = self.system_manager.logging
-        self.skip_keys = ['system_manager']
-        self.testcase = test_case
-        self.testname = test_name
-        self.suitename = suite_name
-        self.suitepath = suite_path
-        self.fullname = "%s.%s" %(suite_name, test_name)
-        self.testpath = test_path
-        self.resultpath = result_path
-
-        self.skip_flag = 0
-        self.timezone = "GMT-3"
-        self.component_id = "drizzled"
-        self.slave_count = 0
-        self.master_count = 1
-        self.server_options = test_server_options
-        # We will populate this in a better fashion later on
-        # as we allow .cnf files, we need to do a bit of
-        # messing about to make this work right
-        if self.server_options == [] or type(self.server_options[0]) is not list:
-            self.server_requirements=[self.server_options]
-        else:
-            self.server_requirements = self.server_options
-            self.server_options= self.server_options[0][0]
-        self.comment = comment
-        self.master_sh = master_sh
-        self.cnf_path = cnf_path
-        self.disable = disable
-        self.innodb_test  = innodb_test
-        self.need_debug = need_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 process_suite(self,suite_dir):
-        """Process a test suite.
-           This includes searching for tests in test_list and only
-           working with the named tests (all tests in suite is the default)
-           Further processing includes reading the disabled.def file
-           to know which tests to skip, processing the suite.opt file,
-           and processing the individual test cases for data relevant
-           to the rest of the test-runner
-        
-        """
-
-        self.system_manager.logging.verbose("Processing suite: %s" %(suite_dir))
-
-        # Generate our test and result files:
-        testdir = os.path.join(suite_dir, 't')
-        resultdir = os.path.join(suite_dir, 'r')
-
-        # Do basic checks to make sure this is worth further work
-        self.check_suite(suite_dir, testdir, resultdir)      
-
-        # Get suite-level options
-        suite_options = []
-        cnf_path, suite_options = self.process_suite_options(suite_dir) 
-
-        # Get the 'name' of the suite.  This can require some processing
-        # But the name is useful for reporting and whatnot
-        suite_name = self.get_suite_name(suite_dir)
-        
-        # Get the contents of the testdir and filter it accordingly
-        # This applies do-test / skip-test filters and any specific
-        # test case names        
-        testlist = self.testlist_filter(os.listdir(testdir))
-        # sort our list if no individual tests were specified
-        if not self.desired_tests:
-            testlist.sort()
-                       
-        # gather deeper information on tests we are interested in
-        if testlist:
-            # We have tests we want to process, we gather additional information
-            # that is useful at the suite level.  This includes disabled tests          
-            # Gather disabled test list.  
-            # This is used in process_test_file()
-            disabled_tests = {}
-            disabled_tests = self.process_disabled_test_file(testdir)                        
-            for test_case in testlist:
-                self.add_test(self.process_test_file(suite_dir,
-                                              suite_name, cnf_path, suite_options
-                                              , disabled_tests, testdir 
-                                              , resultdir, test_case))
-
-    def process_test_file(self, suite_dir, suite_name, suite_cnf_path, suite_options 
-                          , disabled_tests, testdir 
-                          , resultdir, test_case):
-        """ We generate / find / store all the relevant information per-test.
-            This information will be used when actually executing the test
-            We store the data in a testCase object 
-
-        """
-        
-        test_server_options = suite_options
-        test_name = test_case.replace('.test','')
-        self.system_manager.logging.verbose("Processing test: %s.%s" %(suite_name,test_name))
-
-        
-        # Fix this , create a testCase with gather_test_data() passed
-        # as the argument
-        # Ensure we pass everything we need and use it all
-        (  test_path
-         , result_file_name
-         , result_path
-         , comment
-         , master_sh
-         , cnf_path
-         , test_server_options
-         , disable
-         , innodb_test
-         , need_debug) = self.gather_test_data(test_case, test_name,
-                                 suite_name, test_server_options,testdir, 
-                                 resultdir, disabled_tests)
-        if suite_cnf_path and not cnf_path:
-            cnf_path=suite_cnf_path
-        test_case = testCase(self.system_manager, test_case, test_name, suite_name, 
-                             suite_dir, test_server_options,test_path, result_path,
-                             master_sh=master_sh, cnf_path=cnf_path, debug=self.debug)      
-        return test_case
-
-
-########################################################################
-# utility functions
-#
-# Stuff that helps us out and simplifies our main functions
-# But isn't that important unless you need to dig deep
-########################################################################
-
-    def gather_test_data(self, test_case, test_name, suite_name,
-                         test_server_options, testdir, resultdir, disabled_tests):
-        """ We gather all of the data needed to produce a testCase for
-            a given test
-
-        """
-
-        test_path = os.path.join(testdir,test_case)
-        result_file_name = test_name+'.result'       
-        result_path = self.find_result_path(resultdir, result_file_name)
-        comment = None
-        master_sh_path = test_path.replace('.test','-master.sh')
-        if os.path.exists(master_sh_path):
-            master_sh = master_sh_path 
-        else:
-            master_sh = None
-        master_opt_path = test_path.replace('.test', '-master.opt')
-        config_file_path = test_path.replace('.test', '.cnf')
-        # NOTE:  this currently makes suite level server options additive 
-        # to file-level .opt files...not sure if this is the best.
-        test_server_options = test_server_options + self.process_opt_file(
-                                                           master_opt_path)
-        # deal with .cnf files (which supercede master.opt stuff)
-        cnf_options = []
-        cnf_flag, returned_options = self.process_cnf_file(config_file_path)
-        cnf_options += returned_options
-        if cnf_flag: # we found a proper file and need to override
-            found_options = cnf_options
-        else:
-            config_file_path = None
-        (disable, comment) = self.check_if_disabled(disabled_tests, test_name)
-        innodb_test = 0
-        need_debug = 0
-        return (test_path, result_file_name, result_path, comment, master_sh, 
-                config_file_path, test_server_options, disable, innodb_test, need_debug)
-
-    def check_suite(self, suite_dir, testdir, resultdir):
-        """Handle basic checks of the suite:
-           does the suite exist?
-           is there a /t dir?
-           is there a /r dir?
-           Error and die if not
-
-        """
-        # We expect suite to be a path name, no fuzzy searching
-        if not os.path.exists(suite_dir):
-            self.system_manager.logging.error("Suite: %s does not exist" %(suite_dir))
-            sys.exit(1)
-                
-        # Ensure our test and result directories are present
-        if not os.path.exists(testdir):
-            self.system_manager.logging.error("Suite: %s does not have a 't' directory (expected location for test files)" %(suite_dir))
-            sys.exit(1)
-        if not os.path.exists(resultdir):
-            self.system_manager.logging.error("Suite: %s does not have an 'r' directory (expected location for result files)" %(suite_dir))
-            sys.exit(1)
-
-    def get_suite_name(self, suite_dir):
-        """ Get the 'name' of the suite
-            This can either be the path basename or one directory up, as
-            in the case of files in the drizzle/plugins directory
-        
-        """
-
-        # We trim any trailing path delimiters as python returns
-        # '' for basedir if the path ends that way
-        # BEGIN horrible hack to accomodate bad location of main suite : /
-        if suite_dir == self.testdir:
-            return 'main'
-        # END horrible hack : /
-        if suite_dir.endswith('/'):
-            suite_dir=suite_dir[:-1]
-        suite_dir_root,suite_dir_basename = os.path.split(suite_dir)
-        if suite_dir_basename == 'tests' or suite_dir_basename == 'drizzle-tests':
-            suite_name = os.path.basename(suite_dir_root)
-        else:
-            suite_name = suite_dir_basename
-        self.system_manager.logging.debug("Suite_name:  %s" %(suite_name))
-        return suite_name
-
-    def process_suite_options(self, suite_dir):
-        """ Process the suite.opt and master.opt files
-            that reside at the suite-level if they exist.
-            Return a list of the options found
-
-            We also process .cnf files - this
-            is currently dbqp-only and is the proper
-            way to do things :P
-
-        """
-        found_options = []
-        opt_files = ['t/master.opt','t/suite.opt']
-        for opt_file in opt_files:
-            found_options = found_options + self.process_opt_file(os.path.join(suite_dir,opt_file))
-        # We also process the suite-level .cnf file(s).  We override
-        # a master.opt file if we have a .cnf file.  There is no reason they
-        # should ever be used in conjunction and I am biased towards .cnf ; )
-        cnf_files = ['t/master.cnf']
-        cnf_options = []
-        for cnf_file in cnf_files:
-            config_file_path = os.path.join(suite_dir,cnf_file)
-            cnf_flag, returned_options = self.process_cnf_file(config_file_path)
-            cnf_options += returned_options
-        if cnf_flag: # we found a proper file and need to override
-            found_options = cnf_options
-        else:
-            config_file_path = None
-        return config_file_path, found_options
-
-    def process_disabled_test_file(self, testdir):
-        """ Checks and processes the suite's disabled.def
-            file.  This file must reside in the suite/t directory
-            It must be in the format:
-            test-name : comment (eg BugNNNN - bug on hold, test disabled)
-            In reality a test should *never* be disabled.  EVER.
-            However, we keep this as a bit of utility
-
-        """
-        disabled_tests = {}
-        disabled_def_path = os.path.join(testdir,'disabled.def')
-        if not os.path.exists(disabled_def_path):
-            return disabled_tests
-
-        try:
-            disabled_test_file = open(disabled_def_path,'r')
-        except IOError, e: 
-            self.system_manager.logging.error("Problem opening disabled.def file: %s" %(disabled_def_path))
-            sys.exit(1)
-
-        self.system_manager.logging.debug("Processing disabled.def file: %s" %(disabled_def_path))
-        disabled_bug_pattern = re.compile("[\S]+[\s]+:[\s]+[\S]")
-        
-        for line in disabled_test_file:
-            line = line.strip()
-            if not line.startswith('#'): # comment
-                if re.match(disabled_test_pattern,line):
-                    self.system_manager.logging.debug("found disabled test - %s" %(line))
-                    test_name, test_comment = line.split(':')
-                    disabled_tests[test_name.strip()]=test_comment.strip() 
-            
-        disabled_test_file.close()
-        return disabled_tests
-        
-
-    def process_opt_file(self, opt_file_path):
-        """ Process a test-run '.opt' file.
-        These files contain test and suite-specific server options
-        (ie what options the server needs to use for the test) 
-
-        Returns a list of the options (we don't really validate...yet)
-         
-        NOTE:  test-run.pl allows for server *and* system options
-        (eg timezone, slave_count, etc) in opt files.  We don't.
-        None of our tests use this and we should probably avoid it
-        We can introduce server and system .opt files or even better
-        would be to use config files as we do with drizzle-automation
-        This would allow us to specify options for several different
-        things in a single file, but in a clean and standardized manner
- 
-        """
-        found_options = []
-        if not os.path.exists(opt_file_path):
-            return found_options
-
-        try:
-            opt_file = open(opt_file_path,'r')
-        except IOError, e: 
-            self.system_manager.logging.error("Problem opening option file: %s" %(opt_file_path))
-            sys.exit(1)
-
-        self.system_manager.logging.debug("Processing opt file: %s" %(opt_file_path))
-        for line in opt_file:
-            options = line.split('--')
-            if options:
-                for option in options:
-                    if option:
-                        if 'restart' in option or '#' in option:
-                            option = 'restart'
-                        found_options.append('--%s' %(option.strip()))
-        opt_file.close()
-        return found_options
-
-    def process_cnf_file(self, cnf_file_path):
-        """ We extract meaningful information from a .cnf file
-            if it exists.  Currently limited to server allocation
-            needs
-
-        """
-
-        server_requirements = []
-        cnf_flag = 0
-        if os.path.exists(cnf_file_path):
-            cnf_flag = 1
-            config_reader = RawConfigParser()
-            config_reader.read(cnf_file_path)
-            server_requirements = self.process_server_reqs(config_reader.get('test_servers','servers'))
-        return ( cnf_flag, server_requirements )
-
-    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
-
-    def testlist_filter(self, testlist):
-        """ Filter our list of testdir contents based on several 
-            criteria.  This looks for user-specified test-cases
-            and applies the do-test and skip-test filters
-
-            Returns the list of tests that we want to execute
-            for further processing
-
-        """
-
-        # We want only .test files
-        # Possible TODO:  allow alternate test extensions
-        testlist = [test_file for test_file in testlist if test_file.endswith('.test')]
-         
-        # 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('.test'): 
-                   pass
-               else:
-                   test = test+'.test'
-               if test in testlist:
-                   tests_to_use.append(test)
-           testlist = tests_to_use
-
-        # TODO:  Allow for regex?
-        # Apply do-test filter
-        if self.dotest:
-            testlist = [test_file for test_file in testlist if test_file.startswith(self.dotest)]
-        # Apply skip-test filter
-        if self.skiptest:
-            testlist = [test_file for test_file in testlist if not test_file.startswith(self.skiptest)]
-        return testlist
-
-    def find_result_path(self, result_dir, result_file_name):
-        """ This is copied from test-run.pl dtr_cases.pl
-            If we have an engine option passed in and the 
-            path resultdir/engine/testname.result exists, that is 
-            our .result file
-        
-            Need to check if we really need this - maybe PBXT?
-
-        """
-        result_path = os.path.join(result_dir,result_file_name)
-        if self.default_engine:
-            candidate_path = os.path.join(result_dir, self.default_engine, 
-                                          result_file_name)
-            if os.path.exists(candidate_path):
-                result_path = candidate_path
-        return result_path
-
-    def check_if_disabled(self, disabled_tests, test_name):
-        """ Scan the list of disabled tests if it exists to see 
-            if the test is disabled.
-        
-        """
-   
-        if disabled_tests:
-            if test_name in disabled_tests:
-                self.system_manager.logging.debug("%s says - I'm disabled" %(test_name))
-                return (1, disabled_tests[test_name])
-        return (0,None)
-
-    def sort_testcases(self):
-        """ We sort our testcases according to the server_options they have
-            For each testcase, we sort the list of options, so if a test has
-            --plugin-add=csv --abracadabra, we would get 
-            --abracadabra --plugin-add=csv
-            
-            This results in tests that have similar options being run in order
-            this minimizes server restarts which can be costly
-
-        """
-        test_management.testManager.sort_testcases(self)
-        organizer = {}
-        ordered_list = []
-        for testcase in self.test_list:
-            key = " ".join(sorted(testcase.server_options))
-            if key in organizer:
-                organizer[key].append(testcase)
-            else:
-                organizer[key] = [testcase]
-        for value_list in organizer.values():
-            ordered_list = ordered_list + value_list
-        self.test_list = ordered_list
-        
-
-        
 
=== removed directory 'dbqp/lib/modes/native'
=== removed file 'dbqp/lib/modes/native/__init__.py'
=== removed file 'dbqp/lib/modes/native/native_test_execution.py'
--- dbqp/lib/modes/native/native_test_execution.py	2012-02-04 01:22:23 +0000
+++ dbqp/lib/modes/native/native_test_execution.py	1970-01-01 00:00:00 +0000
@@ -1,100 +0,0 @@
-#! /usr/bin/env python
-# -*- mode: python; indent-tabs-mode: nil; -*-
-# vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
-#
-# Copyright (C) 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
-
-""" native_test_execution:
-    code related to the execution of native test cases 
-    
-    We are provided access to a testManager with 
-    native-specific testCases.  
-
-"""
-
-# imports
-import os
-import re
-import imp
-import sys
-import subprocess
-import unittest
-
-import lib.test_mgmt.test_execution as test_execution
-    
-class testExecutor(test_execution.testExecutor):
-    """ native-mode-specific  executor """
-
-    def execute_testCase (self):
-        """ Execute a test module testCase
-
-        """
-        test_execution.testExecutor.execute_testCase(self)
-        self.status = 0
-
-        # execute test module
-        self.current_test_status = self.execute_test_module()
-
-        # analyze results
-        self.set_server_status(self.current_test_status)
-        self.server_manager.reset_servers(self.name)
-
-
-    def execute_test_module(self):
-        """ Execute the commandline and return the result.
-            We use subprocess as we can pass os.environ dicts and whatnot 
-
-        """
-        output_file_path = os.path.join(self.logdir,'native.out')
-        output_file = open(output_file_path,'w')
-        testcase_name = self.current_testcase.fullname
-        test_name = self.current_testcase.name
-        
-        # import our module and pass it some goodies to play with 
-        test_module = imp.load_source(test_name, self.current_testcase.test_path)
-        test_module.servers = self.current_servers
-        test_module.test_executor = self
-        test_module.server_manager = self.server_manager
-
-        # start our test
-        self.time_manager.start(testcase_name,'test')
-        self.logging.subunit_start(testcase_name)
-        suite = unittest.TestLoader().loadTestsFromTestCase(test_module.basicTest)
-        test_result =  unittest.TextTestRunner(stream=output_file, verbosity=2).run(suite)
-        execution_time = int(self.time_manager.stop(testcase_name)*1000) # millisec
-        self.current_test_retcode = test_result.wasSuccessful()
-        output_file.close()
-        output_file = open(output_file_path,'r')
-        self.current_test_output = ''.join(output_file.readlines())
-        output_file.close()
-
-        self.current_test_exec_time = execution_time
-        retval = None
-        if self.current_test_retcode:
-            if not self.verbose:
-                self.current_test_output = None
-            retval = 'pass'           
-        else:
-            retval = 'fail'
-        self.logging.subunit_stop( testcase_name
-                                 , retval 
-                                 , self.current_test_output
-                                 )
-        return retval
-
-        
 
=== removed file 'dbqp/lib/modes/native/native_test_management.py'
--- dbqp/lib/modes/native/native_test_management.py	2012-02-04 01:22:23 +0000
+++ dbqp/lib/modes/native/native_test_management.py	1970-01-01 00:00:00 +0000
@@ -1,160 +0,0 @@
-#! /usr/bin/env python
-# -*- mode: python; indent-tabs-mode: nil; -*-
-# vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
-#
-# Copyright (C) 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
-
-""" crashme_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 crashme mode
-
-"""
-
-# imports
-import os
-import re
-import sys
-import imp
-
-import lib.test_mgmt.test_management as test_management
-
-
-    
-class testCase:
-    """Holds info on a single crashme test
- 
-    """
-    def __init__( self
-                , system_manager
-                , name=None
-                , fullname = None
-                , server_requirements=[[]]
-                , comment=None
-                , cnf_path=None
-                , request_dict=None
-                , test_path = None
-                , suitename = 'native_tests'
-                , 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 = suitename
-        self.master_sh = None
-        self.comment = comment
-        self.server_requirements = server_requirements
-        self.cnf_path = cnf_path
-        self.server_requests = request_dict
-        self.test_path = test_path        
-        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, variables, system_manager):
-        super(testManager, self).__init__( variables, system_manager)
-        server_type = variables['defaultservertype']
-        if server_type == 'mysql' or server_type =='galera':  
-            server_type = 'percona'
-        self.suitepaths = [os.path.join(self.testdir,'%s_tests' %(server_type))]
-        if variables['suitelist'] is None:
-            self.suitelist = ['main']
-        else:
-            self.suitelist = variables['suitelist']
-
-    def process_suite(self,suite_dir):
-        """Process a test suite.
-           Look for tests, which are nice clean python unittest files
-        
-        """
-
-        # We know this based on how we organize native test conf files
-        suite_name = os.path.basename(suite_dir) 
-        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('_test.py')]
-
-        # 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('.py'): 
-                   pass
-               else:
-                   test = test+'.py'
-               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 """
-
-        # test_name = filename - .py...simpler
-        test_name = os.path.basename(testfile).replace('.py','')
-        test_comment = None
-        test_module = imp.load_source(test_name, testfile)
-        server_requirements = test_module.server_requirements
-        try:
-            server_requests = test_module.server_requests
-        except AttributeError, NameError:
-            server_requests = None
-        return testCase( self.system_manager
-                       , name = test_name
-                       , fullname = "%s.%s" %(suite_name, test_name)
-                       , server_requirements = server_requirements
-                       , cnf_path = None
-                       , request_dict = server_requests
-                       , test_path = testfile
-                       , debug = self.debug )
-
-
-
-    def record_test_result(self, test_case, test_status, output, exec_time):
-        """ Accept the results of an executed testCase for further
-            processing.
- 
-        """
-        if test_status not in self.executed_tests:
-            self.executed_tests[test_status] = [test_case]
-        else:
-            self.executed_tests[test_status].append(test_case)
-        # report
-        self.logging.test_report( test_case.fullname, test_status
-                                , str(exec_time), output
-                                , report_output= True)
-
 
=== removed directory 'dbqp/lib/modes/sysbench'
=== removed file 'dbqp/lib/modes/sysbench/__init__.py'
=== removed file 'dbqp/lib/modes/sysbench/sysbench_test_execution.py'
--- dbqp/lib/modes/sysbench/sysbench_test_execution.py	2012-02-04 01:22:23 +0000
+++ dbqp/lib/modes/sysbench/sysbench_test_execution.py	1970-01-01 00:00:00 +0000
@@ -1,162 +0,0 @@
-#! /usr/bin/env python
-# -*- mode: python; 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
-
-""" sysbench_test_execution:
-    code related to the execution of sysbench test cases 
-    
-    We are provided access to a testManager with 
-    sysbench-specific testCases.  
-
-"""
-
-# imports
-import os
-import re
-import sys
-import subprocess
-import commands
-
-import lib.test_mgmt.test_execution as test_execution
-
-class testExecutor(test_execution.testExecutor):
-    """ sysbench-specific testExecutor 
-        
-    """
-  
-    def execute_testCase (self):
-        """ Execute a sysbench testCase
-
-        """
-        test_execution.testExecutor.execute_testCase(self)
-        self.status = 0
-
-        # prepare the server for sysbench
-        self.prepare_sysbench()
-
-        # execute sysbench
-        self.execute_sysbench()
-
-        # analyze results
-        self.current_test_status = self.process_sysbench_output()
-        self.set_server_status(self.current_test_status)
-        self.server_manager.reset_servers(self.name)
- 
-    def prepare_sysbench(self):
-        """ Prepare the server for a sysbench run
-            We use subprocess as we can pass os.environ dicts and whatnot 
-
-        """
-      
-        sysbench_outfile = os.path.join(self.logdir,'sysbench.out')
-        sysbench_output = open(sysbench_outfile,'w')
-        sysbench_cmd = ' '.join([self.current_testcase.test_command,'prepare'])      
-        self.logging.info("Preparing database for sysbench run...")
-        self.logging.debug(sysbench_cmd)
-        sysbench_subproc = subprocess.Popen( sysbench_cmd
-                                         , shell=True
-                                         #, cwd=os.getcwd()
-                                         , env=self.working_environment
-                                         , stdout = sysbench_output
-                                         , stderr = subprocess.STDOUT
-                                         )
-        sysbench_subproc.wait()
-        retcode = sysbench_subproc.returncode
-
-        sysbench_output.close()
-        sysbench_file = open(sysbench_outfile,'r')
-        output = ''.join(sysbench_file.readlines())
-        sysbench_file.close()
-        self.logging.debug("sysbench_retcode: %d" %(retcode))
-        self.logging.debug(output)
-        if retcode:
-            self.logging.error("sysbench_prepare failed with retcode %d:" %(retcode))
-            self.logging.error(output)   
-            sys.exit(1)
-            
-
-    
-
-    def execute_sysbench(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')
-        sysbench_outfile = os.path.join(self.logdir,'sysbench.out')
-        sysbench_output = open(sysbench_outfile,'w')
-        sysbench_cmd = ' '.join([self.current_testcase.test_command, 'run'])
-        self.logging.info("Executing sysbench:  %s" %(sysbench_cmd))
-        
-        sysbench_subproc = subprocess.Popen( sysbench_cmd
-                                         , shell=True
-                                         #, cwd=self.system_manager.sysbench_path
-                                         , env=self.working_environment
-                                         , stdout = sysbench_output
-                                         , stderr = subprocess.STDOUT
-                                         )
-        sysbench_subproc.wait()
-        retcode = sysbench_subproc.returncode     
-        execution_time = int(self.time_manager.stop(testcase_name)*1000) # millisec
-
-        sysbench_output.close()
-        sysbench_file = open(sysbench_outfile,'r')
-        output = ''.join(sysbench_file.readlines())
-        self.logging.debug(output)
-        sysbench_file.close()
-
-        self.logging.debug("sysbench_retcode: %d" %(retcode))
-        self.current_test_retcode = retcode
-        self.current_test_output = output
-        self.current_test_exec_time = execution_time
-
-    def process_sysbench_output(self):
-        """ sysbench has run, we now check out what we have 
-            We also output the data from the run
-        
-        """
-        # This slice code taken from drizzle-automation's sysbench handling
-        # Slice up the output report into a matrix and insert into the DB.
-        regexes= {
-          'tps': re.compile(r".*transactions\:\s+\d+\D*(\d+\.\d+).*")
-        , 'deadlocksps': re.compile(r".*deadlocks\:\s+\d+\D*(\d+\.\d+).*")
-        , 'rwreqps': re.compile(r".*read\/write\s+requests\:\s+\d+\D*(\d+\.\d+).*")
-        , 'min_req_lat_ms': re.compile(r".*min\:\s+(\d*\.\d+)ms.*")
-        , 'max_req_lat_ms': re.compile(r".*max\:\s+(\d*\.\d+)ms.*")
-        , 'avg_req_lat_ms': re.compile(r".*avg\:\s+(\d*\.\d+)ms.*")
-        , '95p_req_lat_ms': re.compile(r".*approx.\s+95\s+percentile\:\s+(\d+\.\d+)ms.*")
-        }
-        run= {}
-        for line in self.current_test_output.split("\n"):
-            for key in regexes.keys():
-                result= regexes[key].match(line)
-                if result:
-                    run[key]= float(result.group(1)) # group(0) is entire match...
-        # we set our test output to the regex'd-up data
-        # we also make it a single string, separated by newlines
-        self.current_test_output = str(run)[1:-1].replace(',','\n').replace("'",'')
-                    
-        if self.current_test_retcode == 0:
-            return 'pass'
-        else:
-            return 'fail'
-
 
=== removed file 'dbqp/lib/modes/sysbench/sysbench_test_management.py'
--- dbqp/lib/modes/sysbench/sysbench_test_management.py	2012-02-04 01:22:23 +0000
+++ dbqp/lib/modes/sysbench/sysbench_test_management.py	1970-01-01 00:00:00 +0000
@@ -1,159 +0,0 @@
-#! /usr/bin/env python
-# -*- mode: python; 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
-
-""" sysbench_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 sysbench mode
-
-"""
-
-# 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 sysbench test
- 
-    """
-    def __init__( self, system_manager, name=None
-                , fullname = None, server_requirements=[[]]
-                , comment=None, test_command=None, cnf_path=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 = 'sysbench_tests'
-        self.master_sh = None
-        self.comment = comment
-        self.server_requirements = server_requirements
-        self.test_command = test_command
-        self.cnf_path = cnf_path
-        
-        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, variables, system_manager):
-        super(testManager, self).__init__( variables, system_manager)
-        self.suitepaths = [os.path.join(self.testdir,'sysbench_tests')]
-        if variables['suitelist'] is None:
-            self.suitelist = ['readonly']
-        else:
-            self.suitelist = variables['suitelist']
-
-    def process_suite(self,suite_dir):
-        """Process a test suite.
-           Look for sysbench tests, which are nice clean conf files
-        
-        """
-
-        # We know this based on how we organize sysbench test conf files
-        suite_name = os.path.basename(suite_dir) 
-        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
-                       , cnf_path = testfile
-                       , 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
-
-    def record_test_result(self, test_case, test_status, output, exec_time):
-        """ Accept the results of an executed testCase for further
-            processing.
- 
-        """
-        if test_status not in self.executed_tests:
-            self.executed_tests[test_status] = [test_case]
-        else:
-            self.executed_tests[test_status].append(test_case)
-        # report
-        self.logging.test_report( test_case.fullname, test_status
-                                , str(exec_time), output
-                                , report_output= True)
 
=== removed file 'dbqp/lib/modes/test_mode.py'
--- dbqp/lib/modes/test_mode.py	2012-02-04 01:22:23 +0000
+++ dbqp/lib/modes/test_mode.py	1970-01-01 00:00:00 +0000
@@ -1,68 +0,0 @@
-#! /usr/bin/env python
-# -*- mode: python; 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
-
-"""test_mode.py
-   code for dealing with testing modes
-   A given mode should have a systemInitializer, testManager, and testExecutor
-   that define how to setup, manage, and execute test cases
-
-"""
-
-# imports
-import sys
-
-def handle_mode(variables, system_manager):
-    """ Deals with the 'mode' option and returns
-        the appropriate code objects for the test-runner to play with
-
-    """
-
-    test_mode = variables['mode'].strip()
-    system_manager.logging.info("Using testing mode: %s" %test_mode)
-
-    if 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: # we expect something from dbqp_modes
-        supported_modes = [ 'dtr'
-                          , 'randgen'
-                          , 'sysbench'
-                          , 'sqlbench'
-                          , 'crashme'
-                          , 'native'
-                          ]
-        if test_mode not in supported_modes:
-            system_manager.logging.error("invalid mode argument: %s" %test_mode)
-            sys.exit(1)
-        
-        mgmt_module = "lib.modes.%s.%s_test_management" %(test_mode, test_mode)
-        tmp = __import__(mgmt_module, globals(), locals(), ['testManager'], -1)
-        testManager = tmp.testManager
-
-        exec_module = "%s.%s_test_execution" %(test_mode, test_mode)
-        tmp = __import__(exec_module, globals(), locals(), ['testExecutor'], -1)
-        testExecutor = tmp.testExecutor        
-
-    test_manager = testManager( variables, system_manager )
-    return (test_manager, testExecutor)
-
 
=== removed directory 'dbqp/lib/opts'
=== removed file 'dbqp/lib/opts/__init__.py'
=== removed file 'dbqp/lib/opts/test_run_options.py'
--- dbqp/lib/opts/test_run_options.py	2012-02-04 01:22:23 +0000
+++ dbqp/lib/opts/test_run_options.py	1970-01-01 00:00:00 +0000
@@ -1,556 +0,0 @@
-#! /usr/bin/env python
-# -*- mode: python; 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
-
-
-
-"""Processes command line options for Drizzle test-runner"""
-
-import os
-import sys
-import copy
-import exceptions
-import optparse
-
-# functions
-def comma_list_split(option, opt, value, parser):
-    """Callback for splitting input expected in list form"""
-    cur_list = getattr(parser.values, option.dest,[])
-    input_list = value.split(',')
-    # this is a hack to work with make target - we
-    # don't deal with a dangling ',' in our list
-    if '' in input_list:
-        input_list.remove('')
-    if cur_list:
-        value_list = cur_list + input_list 
-    else:
-        value_list = input_list 
-    setattr(parser.values, option.dest, value_list)
-
-def get_abspath(option, opt, value, parser):
-    """ Utility function to make sure we have absolute paths
-        if the user supplies values
-
-    """
-    the_path = os.path.abspath(value)
-    setattr(parser.values, option.dest, the_path)
-
-def organize_options(args, test_cases):
-    """Put our arguments in a nice dictionary
-       We use option.dest as dictionary key
-       item = supplied input
- ['
-    """
-    variables = {}
-    # we make a copy as the python manual on vars
-    # says we shouldn't alter the dictionary returned
-    # by vars() - could affect symbol table?
-    variables = copy.copy(vars(args))
-    variables['test_cases']= test_cases
-    # This code should become a function once
-    # enough thought has been given to it
-    if variables['manualgdb']:
-        variables['gdb']=True
-    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' or variables['gendatafile']:
-        print "Setting --no-secure-file-priv=True for randgen usage..."
-        variables['nosecurefilepriv']=True
-    if variables['mode'] == 'cleanup':
-        print "Setting --start-dirty=True for cleanup mode..."
-        variables['startdirty']=True
-    if variables['libeatmydata'] and os.path.exists(variables['libeatmydatapath']):
-        # We are using libeatmydata vs. shared mem for server speedup
-        print "Using libeatmydata at %s.  Setting --no-shm / not using shared memory for testing..." %(variables['libeatmydatapath'])
-        variables['noshm']=True
-    return variables
-
-def populate_defaults(variables, basedir_default):
-    """ We fill in any default values that need
-        to be put in post-parsing
-
-    """
-    if not variables['basedir']:
-        # We populate this value with the default now
-        # it allows us to have a default and have user
-        # supplied opts to override them
-        variables['basedir'].append(basedir_default)
-    return variables
-
-def handle_user_opts(variables, basedir_default, testdir_default, suitepaths_default):
-    """ Some variables are dependent upon default values
-        We do the probably hacky thing of going through
-        and updating them accordingly
-
-        We make the assumption / decision that only
-        the first basedir value supplied should
-        be applicable when searching for tests
-
-    """
-    master_basedir = os.path.abspath(variables['basedir'][0].split(':type:')[0])
-    if master_basedir != basedir_default:
-        new_path = os.path.join(master_basedir, 'plugin')
-        search_path = os.path.join(basedir_default,'plugin')
-        tmp = variables['suitepaths']
-        tmp[tmp.index(search_path)] = new_path
-        variables['suitepaths'] = tmp
-    if variables['testdir'] != testdir_default:
-        new_path = os.path.join(variables['testdir'],'suite')
-        search_path = os.path.join(testdir_default,'suite')
-        tmp = variables['suitepaths']
-        tmp[tmp.index(search_path)] = new_path
-        variables['suitepaths'] = tmp
-    return variables
-
-
-# Create the CLI option parser
-parser= optparse.OptionParser(version='%prog (database quality platform aka project steve austin) version 0.1.1')
-
-# set some default values
-testdir_default = os.path.abspath(os.getcwd())
-workdir_default = os.path.join(testdir_default,'workdir')
-clientbindir_default = os.path.abspath(os.path.join(testdir_default,'../client'))
-basedir_default = os.path.dirname(testdir_default)
-server_type_default = 'galera'
-valgrind_suppression_default = os.path.join(testdir_default,'valgrind.supp')
-suitepaths_default = [ os.path.join(basedir_default,'plugin')
-                     , os.path.join(testdir_default,'suite')
-                     ]
-randgen_path_default = os.path.join(testdir_default,'randgen')
-subunit_file_default = os.path.join(workdir_default,'test_results.subunit')
-
-
-config_control_group = optparse.OptionGroup(parser, 
-                     "Configuration controls - allows you to specify a file with a number of options already specified")
-config_control_group.add_option(
-   "--sys_config_file"
-    , dest="sysconfigfilepath"
-    , action='store'
-    , default=None # We want to have a file that will be our default defaults file...
-    , help="The file that specifies system configuration specs for dbqp to execute tests (not yet implemented)"
-    )
-parser.add_option_group(config_control_group)
-
-
-system_control_group = optparse.OptionGroup(parser, 
-                         "Options for the test-runner itself - defining the system under test and how to execute tests")
-
-system_control_group.add_option(
-      "--force"
-    , dest="force"
-    , action="store_true"
-    , default=False
-    , help="Set this to continue test execution beyond the first failed test"
-    )
-
-system_control_group.add_option(
-       "--start-and-exit"
-     , dest="startandexit"
-     , action="store_true"
-     , default=False
-     , help="Spin up the server(s) for the first specified test then exit (will leave servers running)"
-     )
-
-system_control_group.add_option(
-       "--verbose"
-     , dest="verbose"
-     , action="store_true"
-     , default = False
-     , help="Produces extensive output about test-runner state.  Distinct from --debug"
-     )
-   
-system_control_group.add_option(
-       "--debug"
-     , dest="debug"
-     , action="store_true"
-     , default = False
-     , help="Provide internal-level debugging output.  Distinct from --verbose"
-     )
-
-system_control_group.add_option(
-       "--mode"
-     , dest="mode"
-     , default="native"
-     , help="Testing mode.  We currently support dtr, randgen, sysbench, sqlbench, crashme and cleanup modes.  See docs for further details about individual modes [%default]"
-     )
-
-system_control_group.add_option(
-       "--record"
-     , dest="record"
-     , action="store_true"
-     , default=False
-     , help="Record a testcase result (if the testing mode supports it) [%default]"
-     )
-
-system_control_group.add_option(
-       "--fast"
-     , dest="fast"
-     , action="store_true"
-     , default=False
-     , help="Don't try to cleanup from earlier runs (currently just a placeholder) [%default]"
-     )
-   
-parser.add_option_group(system_control_group)
-
-test_control_group = optparse.OptionGroup(parser, 
-                         "Options for controlling which tests are executed")
-
-test_control_group.add_option(
-    "--suite"
-  , dest="suitelist"
-  , type='string'
-  , action="callback"
-  , callback=comma_list_split
-  , help="The name of the suite containing tests we want. Can accept comma-separated list (with no spaces).  Additional --suite args are appended to existing list     [autosearch]"
-  )
-
-test_control_group.add_option(
-    "--suitepath"
-  , dest="suitepaths"
-  , type='string'
-  , action="append"
-  , default = suitepaths_default
-  , help="The path containing the suite(s) you wish to execute.  Use one --suitepath for each suite you want to use. [%default]"
-  )
-
-test_control_group.add_option(
-    "--do-test"
-  , dest="dotest"
-  , type='string'
-  , default = None
-  , help="input can either be a prefix or a regex. Will only execute tests that match the provided pattern"
-  )
-
-test_control_group.add_option(
-    "--skip-test"
-  , dest="skiptest"
-  , type='string'
-  , default = None
-  , help = "input can either be a prefix or a regex.  Will exclude tests that match the provided pattern"
-  )
-
-test_control_group.add_option(
-    "--reorder"
-  , dest="reorder"
-  , action="store_true"
-  , default=False
-  , help = "sort the testcases so that they are executed optimally for the given mode [%default]"
-  )
-
-test_control_group.add_option(
-    "--repeat"
-  , dest="repeat"
-  , type='int'
-  , action="store"
-  , default=1
-  , help = "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 [%default]"
-  )
-
-parser.add_option_group(test_control_group)
-
-# test subject control group
-# terrible name for options tht define the server / code
-# that is under test
-
-# find some default values
-# assume we are in-tree testing in general and operating from root/test(?)
-testdir_default = os.path.abspath(os.getcwd())
-
-basedir_default = os.path.split(testdir_default)[0]
-
-test_subject_control_group = optparse.OptionGroup(parser,
-                                 "Options for defining the code that will be under test")
-
-test_subject_control_group.add_option(
-    "--basedir"
-  , dest="basedir"
-  , type='string'
-  , default = []
-  , action="append"
-  , help = "Pass this argument to signal to the test-runner that this is an in-tree test.  We automatically set a number of variables relative to the argument (client-bindir, serverdir, testdir) [%basedir_default]"
-  )
-
-test_subject_control_group.add_option(
-    "--default-server-type"
-  , dest="defaultservertype"
-  , type='string'
-  , default = server_type_default
-  , action='store'
-  , help = "Defines what we consider to be the default server type.  We assume a server is default type unless specified otherwise. [%default]"
-  )
-
-test_subject_control_group.add_option(
-    "--serverdir"
-  , dest="serverpath"
-  , type='string'
-  , action="callback"
-  , callback=get_abspath
-  , help = "Path to the server executable.  [%default]"
-  )
-
-test_subject_control_group.add_option(
-    "--client-bindir"
-  , dest="clientbindir"
-  , type = 'string'
-  , action="callback"
-  , callback=get_abspath
-  , help = "Path to the directory containing client program binaries for use in testing [%default]"
-  )
-
-
-test_subject_control_group.add_option(
-    "--default-storage-engine"
-   , dest="defaultengine"
-   , default = 'innodb'
-   , help="Start drizzled using the specified engine [%default]"
-   )    
-
-
-parser.add_option_group(test_subject_control_group)
-# end test subject control group
-
-# environment options
-
-environment_control_group = optparse.OptionGroup(parser, 
-                            "Options for defining the testing environment")
-
-environment_control_group.add_option(
-    "--testdir"
-  , dest="testdir"
-  , type = 'string'
-  , default = testdir_default
-  , action="callback"
-  , callback=get_abspath
-  , help = "Path to the test dir, containing additional files for test execution. [%default]"
-  )
-
-environment_control_group.add_option(
-    "--workdir"
-  , dest="workdir"
-  , type='string'
-  , default = workdir_default
-  , action="callback"
-  , callback=get_abspath
-  , help = "Path to the directory test-run will use to store generated files and directories. [%default]"
-  )
-
-environment_control_group.add_option(
-    "--top-srcdir"
-  , dest="topsrcdir"
-  , type='string'
-  , default = basedir_default
-  , help = "build option [%default]"
-  )
-
-environment_control_group.add_option(
-    "--top-builddir"
-  , dest="topbuilddir"
-  , type='string'
-  , default = basedir_default
-  , help = "build option [%default]"
-  )
-
-environment_control_group.add_option(
-    "--no-shm"
-  , dest="noshm"
-  , action='store_true'
-  , default=False
-  , help = "By default, we symlink workdir to a location in shm.  Use this flag to not symlink [%default]"
-  )
-
-environment_control_group.add_option(
-    "--libeatmydata"
-  , dest="libeatmydata"
-  , action='store_true'
-  , default=False
-  , help = "We use libeatmydata (if available) to disable fsyncs and speed up test execution.  Implies --no-shm"
-  )
-
-environment_control_group.add_option(
-    "--libeatmydata-path"
-  , dest="libeatmydatapath"
-  , action='store'
-  , default='/usr/local/lib/libeatmydata.so'
-  , help = "Path to the libeatmydata install you want to use [%default]"
-  )
-
-environment_control_group.add_option(
-    "--start-dirty"
-  , dest="startdirty"
-  , action='store_true'
-  , default=False
-  , help = "Don't try to clean up working directories before test execution [%default]"
-  )
-
-environment_control_group.add_option(
-    "--no-secure-file-priv"
-  , dest = "nosecurefilepriv"
-  , action='store_true'
-  , default=False
-  , help = "Turn off the use of --secure-file-priv=vardir for started servers"
-  )
-
-environment_control_group.add_option(
-       "--randgen-path"
-     , dest="randgenpath"
-     , action='store'
-     , default=randgen_path_default
-     , help = "The path to a randgen installation that can be used to execute randgen-based tests"
-     )
-
-environment_control_group.add_option(
-       "--innobackupex-path"
-     , dest="innobackupexpath"
-     , action='store'
-     , default=None
-     , help = "The path to the innobackupex script that facilitates the use of Xtrabackup"
-     )
-
-environment_control_group.add_option(
-      "--xtrabackup-path"
-    , dest="xtrabackuppath"
-    , action='store'
-    , default=None
-    , help = "The path the xtrabackup binary to be tested"
-    )
-
-environment_control_group.add_option(
-      "--wsrep-provider-path"
-   , dest="wsrepprovider"
-   , action='store'
-   , default='/usr/lib/galera/libgalera_smm.so'
-   , help = "The path to a wsrep provider library for use with mysql"
-   )
-
-environment_control_group.add_option(
-      "--cluster-cnf"
-    , dest="clustercnf"
-    , action='store'
-    , default=None
-    , help = "The path to a config file defining a running cluster (node info)"
-    )
-
-environment_control_group.add_option(
-      "--subunit-outfile"
-    , dest="subunitoutfile"
-    , action='store'
-    , default=subunit_file_default
-    , help = "File path where subunit output will be logged [%default]"
-    )
-
-parser.add_option_group(environment_control_group)
-# end environment control group
-
-option_passing_group = optparse.OptionGroup(parser,
-                      "Options to pass options on to the server")
-
-option_passing_group.add_option(
-"--drizzled"
-  , dest="drizzledoptions"
-  , type='string'
-  , action='append' 
-  , default = []
-  , help = "Pass additional options to the server.  Will be passed to all servers for all tests (mostly for --start-and-exit)"
-  )
-
-parser.add_option_group(option_passing_group)
-# end option passing group
-
-analysis_control_group = optparse.OptionGroup(parser, 
-                            "Options for defining the tools we use for code analysis (valgrind, gprof, gcov, etc)")
-
-analysis_control_group.add_option(
-    "--valgrind"
-  , dest="valgrind"
-  , action='store_true'
-  , default = False
-  , help = "Run drizzletest and drizzled executables using valgrind with default options [%default]"
-  )
-
-analysis_control_group.add_option(
-    "--valgrind-option"
-  , dest="valgrindarglist"
-  , type='string'
-  , action="append"
-  , help = "Pass an option to valgrind (overrides/removes default valgrind options)"
-  )
-
-analysis_control_group.add_option(
-    "--valgrind-suppressions"
-  , dest="valgrindsuppressions"
-  , type='string'
-  , action='store'
-  , default = valgrind_suppression_default
-  , help = "Point at a valgrind suppression file [%default]"
-  )
-
-analysis_control_group.add_option(
-    "--helgrind"
-  , dest="helgrind"
-  , action='store_true'
-  , default=False
-  , help="Use the helgrind tool for valgrind.  Implies / will auto-use --valgrind"
-  )
-
-parser.add_option_group(analysis_control_group)
-
-debugger_control_group = optparse.OptionGroup(parser,
-                           "Options for controlling the use of debuggers with test execution")
-
-debugger_control_group.add_option(
-    "--gdb"
-  , dest="gdb"
-  , action='store_true'
-  , default=False
-  , help="Start the drizzled server(s) in gdb"
-  )
-
-debugger_control_group.add_option(
-    "--manual-gdb"
-  , dest="manualgdb"
-  , action='store_true'
-  , default=False
-  , help="Allows you to start the drizzled server(s) in gdb manually (in another window, etc)"
-  )
-
-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()
-
-variables = {}
-variables = organize_options(args, test_cases)
-variables = populate_defaults(variables, basedir_default)
-variables = handle_user_opts(variables, basedir_default, testdir_default, suitepaths_default)
-
 
=== removed directory 'dbqp/lib/server_mgmt'
=== removed file 'dbqp/lib/server_mgmt/__init__.py'
=== removed file 'dbqp/lib/server_mgmt/drizzled.py'
--- dbqp/lib/server_mgmt/drizzled.py	2012-02-04 01:22:23 +0000
+++ dbqp/lib/server_mgmt/drizzled.py	1970-01-01 00:00:00 +0000
@@ -1,227 +0,0 @@
-#! /usr/bin/env python
-# -*- mode: python; 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
-
-
-""" drizzled.py:  code to allow a serverManager
-    to provision and start up a drizzled server object
-    for test execution
-
-"""
-
-# imports
-import os
-from lib.server_mgmt.server import Server
-
-class drizzleServer(Server):
-    """ represents a drizzle server, its possessions
-        (datadir, ports, etc), and methods for controlling
-        and querying it
-
-        TODO: create a base server class that contains
-              standard methods from which we can inherit
-              Currently there are definitely methods / attr
-              which are general
-
-    """
-
-    def __init__( self, name, server_manager, code_tree, default_storage_engine
-                , server_options, requester, workdir_root):
-        super(drizzleServer, self).__init__( name
-                                           , server_manager
-                                           , code_tree
-                                           , default_storage_engine
-                                           , server_options
-                                           , requester
-                                           , workdir_root)
-        self.preferred_base_port = 9306
-                
-        # client files
-        self.drizzledump = self.code_tree.drizzledump
-        self.drizzle_client = self.code_tree.drizzle_client
-        self.drizzleimport = self.code_tree.drizzleimport
-        self.drizzleslap = self.code_tree.drizzleslap
-        self.server_path = self.code_tree.drizzle_server
-        self.drizzle_client_path = self.code_tree.drizzle_client
-        self.schemawriter = self.code_tree.schemawriter
-        self.trx_reader = self.code_tree.trx_reader
-
-        # Get our ports
-        self.port_block = self.system_manager.port_manager.get_port_block( self.name
-                                                                         , self.preferred_base_port
-                                                                         , 6 )
-        self.master_port = self.port_block[0]
-        self.drizzle_tcp_port = self.port_block[1]
-        self.mc_port = self.port_block[2]
-        self.pbms_port = self.port_block[3]
-        self.rabbitmq_node_port = self.port_block[4]
-        self.json_server_port = self.port_block[5]
-
-        # Generate our working directories
-        self.dirset = {'var_%s' %(self.name): {'std_data_ln':( os.path.join(self.code_tree.testdir,'std_data'))
-                                               ,'log':None
-                                               ,'run':None
-                                               ,'tmp':None
-                                               ,'master-data': {'local': { 'test':None
-                                                                         , 'mysql':None
-                                                                         }
-                                                               }
-                                               }  
-                      }
-        self.workdir = self.system_manager.create_dirset( workdir_root
-                                                        , self.dirset)
-        self.vardir = self.workdir
-        self.tmpdir = os.path.join(self.vardir,'tmp')
-        self.rundir = os.path.join(self.vardir,'run')
-        self.logdir = os.path.join(self.vardir,'log')
-        self.datadir = os.path.join(self.vardir,'master-data')
-
-        self.error_log = os.path.join(self.logdir,('%s.err' %(self.name)))
-        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
-        if self.no_secure_file_priv:
-            self.secure_file_string = ''
-        else:
-            self.secure_file_string = "--secure-file-priv='%s'" %(self.vardir)
-        self.user_string = '--user=root'
-
-        self.initialize_databases()
-        self.take_db_snapshot()
-
-        self.logging.debug_class(self)
-
-    def report(self):
-        """ We print out some general useful info """
-        report_values = [ 'name'
-                        , 'master_port'
-                        , 'drizzle_tcp_port'
-                        , 'mc_port'
-                        , 'pbms_port'
-                        , 'rabbitmq_node_port'
-                        , 'vardir'
-                        , 'status'
-                        ]
-        self.logging.info("%s server:" %(self.owner))
-        for key in report_values:
-          value = vars(self)[key] 
-          self.logging.info("%s: %s" %(key.upper(), value))
-
-    def get_start_cmd(self):
-        """ Return the command string that will start up the server 
-            as desired / intended
- 
-        """
-
-        server_args = [ self.process_server_options()
-                      , "--mysql-protocol.port=%d" %(self.master_port)
-                      , "--mysql-protocol.connect-timeout=60"
-                      , "--innodb.data-file-path=ibdata1:20M:autoextend"
-                      , "--sort-buffer-size=256K"
-                      , "--max-heap-table-size=1M"
-                      , "--mysql-unix-socket-protocol.path=%s" %(self.socket_file)
-                      , "--pid-file=%s" %(self.pid_file)
-                      , "--drizzle-protocol.port=%d" %(self.drizzle_tcp_port)
-                      , "--default-storage-engine=%s" %(self.default_storage_engine)
-                      , "--datadir=%s" %(self.datadir)
-                      , "--tmpdir=%s" %(self.tmpdir)
-                      , self.secure_file_string
-                      , self.user_string
-                      ]
-
-        if self.gdb:
-            server_args.append('--gdb')
-            return self.system_manager.handle_gdb_reqs(self, server_args)
-        else:
-            return "%s %s %s & " % ( self.cmd_prefix
-                                   , self.server_path
-                                   , " ".join(server_args)
-                                   )
-
-
-    def get_stop_cmd(self):
-        """ Return the command that will shut us down """
-        
-        return "%s --user=root --port=%d --connect-timeout=5 --silent --password= --shutdown " %(self.drizzle_client_path, self.master_port)
-           
-
-    def get_ping_cmd(self):
-        """Return the command string that will 
-           ping / check if the server is alive 
-
-        """
-
-        return "%s --ping --port=%d --user=root" % (self.drizzle_client_path, self.master_port)
-
-    def is_started(self):
-        """ Determine if the server is up and running - 
-            this may vary from server type to server type
-
-        """
-
-        # 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 = [ "[master1]"
-                     , "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()
-
-
-
-
-                  
-
-
-
-
- 
-         
-
-
-
-
 
=== removed file 'dbqp/lib/server_mgmt/galera.py'
--- dbqp/lib/server_mgmt/galera.py	2012-02-04 01:22:23 +0000
+++ dbqp/lib/server_mgmt/galera.py	1970-01-01 00:00:00 +0000
@@ -1,334 +0,0 @@
-#! /usr/bin/env python
-# -*- mode: python; 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
-
-
-""" mysqld.py:  code to allow a serverManager
-    to provision and start up a mysqld server object
-    for test execution
-
-"""
-
-# imports
-import os
-import sys
-import time
-import subprocess
-
-from ConfigParser import RawConfigParser
-
-from lib.server_mgmt.server import Server
-
-class mysqlServer(Server):
-    """ represents a mysql server, its possessions
-        (datadir, ports, etc), and methods for controlling
-        and querying it
-
-        TODO: create a base server class that contains
-              standard methods from which we can inherit
-              Currently there are definitely methods / attr
-              which are general
-
-    """
-
-    def __init__( self, name, server_manager, code_tree, default_storage_engine
-                , server_options, requester, workdir_root):
-        super(mysqlServer, self).__init__( name
-                                           , server_manager
-                                           , code_tree
-                                           , default_storage_engine
-                                           , server_options
-                                           , requester
-                                           , workdir_root)
-        self.preferred_base_port = 9306
-        
-        # client files
-        self.mysqldump = self.code_tree.mysqldump
-        self.mysqladmin = self.code_tree.mysqladmin
-        self.mysql_client = self.code_tree.mysql_client
-        self.mysqlimport = self.code_tree.mysqlimport
-        self.mysqlslap = self.code_tree.mysqlslap
-        self.mysql_upgrade = self.code_tree.mysql_upgrade
-        self.server_path = self.code_tree.mysql_server
-        self.mysql_client_path = self.code_tree.mysql_client
-
-        # galera-specific info
-        self.wsrep_cluster_addr=''
-      
-        # important stuff
-        self.langdir = self.code_tree.langdir
-        self.charsetdir = self.code_tree.charsetdir
-        self.bootstrap_file = self.code_tree.bootstrap_path
-        self.bootstrap_cmd = None
-
-        # Get our ports
-        self.port_block = self.system_manager.port_manager.get_port_block( self.name
-                                                                         , self.preferred_base_port
-                                                                         , 3 )
-        self.master_port = self.port_block[0]
-        self.galera_listen_port = self.port_block[1]
-        self.galera_recv_port = self.port_block[2]
-
-        # Generate our working directories
-        self.dirset = { 'var_%s' %(self.name): {'std_data_ln':( os.path.join(self.code_tree.testdir,'std_data'))
-                                               ,'log':None
-                                               ,'run':None
-                                               ,'tmp':None
-                                               ,'master-data': { 'test':None
-                                                               , 'mysql':None
-                                                               }
-                                               }  
-                      }
-        self.workdir = self.system_manager.create_dirset( workdir_root
-                                                        , self.dirset)
-        self.vardir = self.workdir
-        self.tmpdir = os.path.join(self.vardir,'tmp')
-        self.rundir = os.path.join(self.vardir,'run')
-        self.logdir = os.path.join(self.vardir,'log')
-        self.std_data = os.path.join(self.vardir,'std_data_ln')
-        self.datadir = os.path.join(self.vardir,'master-data')
-
-        self.error_log = os.path.join(self.logdir,('error.log' ))
-        self.bootstrap_log = os.path.join(self.logdir,('bootstrap.log'))
-        self.pid_file = os.path.join(self.rundir,('my.pid'))
-        self.socket_file = os.path.join(self.vardir, ('my.sock'))
-        self.timer_file = os.path.join(self.logdir,('timer'))
-        self.general_log_file = os.path.join(self.logdir,'mysqld.log')
-        self.slow_query_log_file = os.path.join(self.logdir,'mysqld-slow.log')
-        self.cnf_file = os.path.join(self.vardir,'my.cnf')
-
-        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
-        if self.no_secure_file_priv:
-            self.secure_file_string = ''
-        else:
-            self.secure_file_string = "--secure-file-priv='%s'" %(self.vardir)
-        self.user_string = '--user=root'
-
-        self.initialize_databases()
-        self.take_db_snapshot()
-
-        self.logging.debug_class(self)
-
-
-    def report(self):
-        """ We print out some general useful info """
-        report_values = [ 'name'
-                        , 'master_port'
-                        , 'galera_listen_port'
-                        , 'galera_recv_port'
-                        , 'socket_file'
-                        , 'vardir'
-                        , 'status'
-                        ]
-        self.logging.info("%s server:" %(self.owner))
-        for key in report_values:
-          value = vars(self)[key] 
-          self.logging.info("%s: %s" %(key.upper(), value))
-
-    def initialize_databases(self):
-        """ Do the voodoo required to have a working database setup.
-            For MySQL, this is calling the server with the 
-            --bootstrap argument.  We generate the bootstrap
-            file during codeTree intialization as the file is standard for
-            all MySQL servers that are spawned from a single codeTree
-
-        """
-  
-        # generate the bootstrap startup command
-        if not self.bootstrap_cmd:
-            mysqld_args = [ "--no-defaults"
-                          , "--bootstrap"
-                          , "--basedir=%s" %(self.code_tree.basedir)
-                          , "--datadir=%s" %(self.datadir)
-                          , "--loose-skip-falcon"
-                          , "--loose-skip-ndbcluster"
-                          , "--tmpdir=%s" %(self.tmpdir)
-                          , "--core-file"
-                          , "--lc-messages-dir=%s" %(self.langdir)
-                          , "--character-sets-dir=%s" %(self.charsetdir)
-                          ]
-            # We add server_path into the mix this way as we
-            # may alter how we store / handle server args later
-            mysqld_args.insert(0,self.server_path)
-            self.bootstrap_cmd = " ".join(mysqld_args)
-        # execute our command
-        bootstrap_log = open(self.bootstrap_log,'w')
-        # open our bootstrap file
-        bootstrap_in = open(self.bootstrap_file,'r')
-        bootstrap_subproc = subprocess.Popen( self.bootstrap_cmd
-                                            , shell=True
-                                            , stdin=bootstrap_in
-                                            , stdout=bootstrap_log
-                                            , stderr=bootstrap_log
-                                            )
-        bootstrap_subproc.wait()
-        bootstrap_in.close()
-        bootstrap_log.close()
-        bootstrap_retcode = bootstrap_subproc.returncode
-        if bootstrap_retcode:
-            self.logging.error("Received retcode: %s executing command: %s"
-                               %(bootstrap_retcode, self.bootstrap_cmd))
-            self.logging.error("Check the bootstrap log: %s" %(self.bootstrap_log))
-            sys.exit(1)
-
-
-    def get_start_cmd(self):
-        """ Return the command string that will start up the server 
-            as desired / intended
- 
-        """
-
-        # we need to do some wsrep voodoo for galera rpl to work
-        self.ip_address = self.system_manager.get_ip_address() 
-        self.listen_addr_string = "?gmcast.listen_addr=tcp://127.0.0.1:%d" %(self.galera_listen_port)
-        # test for wsrep_provider argument
-        wsrep_provider_string ='' 
-        if self.system_manager.wsrep_provider_path:
-            wsrep_provider_string = "--wsrep_provider=%s" %(self.system_manager.wsrep_provider_path)
-        # handle wsrep_cluster_address argument
-        wsrep_cluster_string ="--wsrep_cluster_address='gcomm://%s%s'" %( self.wsrep_cluster_addr
-                                                                        , self.listen_addr_string) 
-        for server_opt in self.server_options:
-            if server_opt.startswith("--wsrep_cluster_address="):
-                # we have a user-specified value, so we don't
-                # try to insert something
-                wsrep_cluster_string = '' 
-                # check to see if they have specified a listen port
-                # we want to use our own, so we have a better idea of
-                # what is going on
-                if '?gmcast.listen_addr' in server_opt:
-                    pass
-                else:
-                    server_opt = server_opt.strip()+ listen_addr
-        server_args = [ self.process_server_options()
-                      , "%s" %(wsrep_cluster_string)
-                      , "%s" %(wsrep_provider_string)
-                      , "--wsrep_debug=ON"
-                      , "--wsrep_provider_options='ist.recv_addr=%s:%d'" %(self.ip_address, self.galera_recv_port)
-                      , "--wsrep_sst_receive_address='127.0.0.1:%d'" %( self.master_port)
-                      , "--wsrep_sst_auth='root:'"
-                      , "--wsrep_node_name='node%d'" %(self.galera_listen_port)
-                      , "--bind-address=0.0.0.0" 
-                      , "--innodb_locks_unsafe_for_binlog=1"
-                      , "--open-files-limit=1024"
-                      , "--query-cache-size=0"
-                      , "--local-infile"
-                      , "--character-set-server=latin1"
-                      , "--connect-timeout=60"
-                      , "--log-bin-trust-function-creators=1"
-                      , "--key_buffer_size=1M"
-                      , "--sort_buffer=256K"
-                      , "--max_heap_table_size=1M"
-                      , "--loose-innodb_data_file_path=ibdata1:10M:autoextend"
-                      , "--loose-innodb_buffer_pool_size=8M"
-                      , "--loose-innodb_write_io_threads=2"
-                      , "--loose-innodb_read_io_threads=2"
-                      , "--loose-innodb_log_buffer_size=1M"
-                      , "--loose-innodb_log_file_size=5M"
-                      , "--loose-innodb_additional_mem_pool_size=1M"
-                      , "--loose-innodb_log_files_in_group=2"
-                      , "--loose-innodb_lock_wait_timeout=9999999"
-                      , "--slave-net-timeout=120"
-                      , "--log-bin=%s" %(os.path.join(self.logdir,"mysqld-bin"))
-                      , "--binlog-direct-non-transactional-updates"
-                      , "--general_log=1"
-                      , "--general_log_file=%s" %(self.general_log_file)
-                      , "--slow_query_log=1"
-                      , "--slow_query_log_file=%s" %(self.slow_query_log_file)
-                      , "--basedir=%s" %(self.code_tree.basedir)
-                      , "--datadir=%s" %(self.datadir)
-                      , "--tmpdir=%s"  %(self.tmpdir)
-                      , "--character-sets-dir=%s" %(self.charsetdir)
-                      , "--lc-messages-dir=%s" %(self.langdir)
-                      , "--port=%d" %(self.master_port)
-                      , "--socket=%s" %(self.socket_file)
-                      , "--pid-file=%s" %(self.pid_file)
-                      , "--default-storage-engine=%s" %(self.default_storage_engine)
-                      # server-id maybe needs fixing, but we want to avoid
-                      # the server-id=0 and no replication thing...
-                      , "--server-id=%d" %(self.get_numeric_server_id()+1)
-                      , self.secure_file_string
-                      , self.user_string
-                      ]
-        self.gen_cnf_file(server_args)
-
-        if self.gdb:
-            server_args.append('--gdb')
-            return self.system_manager.handle_gdb_reqs(self, server_args)
-        else:
-            return "%s %s %s & " % ( self.cmd_prefix
-                                   , self.server_path
-                                   , " ".join(server_args)
-                                   )
-
-
-    def get_stop_cmd(self):
-        """ Return the command that will shut us down """
-        
-        return "%s --no-defaults --user=root --port=%d --host=127.0.0.1 --protocol=tcp shutdown " %(self.mysqladmin, self.master_port)
-           
-
-    def get_ping_cmd(self):
-        """Return the command string that will 
-           ping / check if the server is alive 
-
-        """
-
-        return '%s --no-defaults --user=root --port=%d --host=127.0.0.1 --protocol=tcp ping' % (self.mysqladmin, self.master_port)
-
-    def is_started(self):
-        """ Determine if the server is up and running - 
-            this may vary from server type to server type
-
-        """
-
-        # 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 gen_cnf_file(self, server_args):
-        """ We generate a .cnf file for the server based
-            on the arguments.  We currently don't use
-            this for much, but xtrabackup uses it, so 
-            we must produce one.  This could also be
-            helpful for testing / etc
-
-        """
-
-        config_file = open(self.cnf_file,'w')
-        config_file.write('[mysqld]') 
-        for server_arg in server_args:
-            # We currently have a list of string values
-            # We need to remove any '--' stuff 
-            server_arg = server_arg.replace('--','')+'\n'
-            config_file.write(server_arg)
-        config_file.close() 
-
-    def set_master(self, master_server):
-        """ We update things so that we use the provided master_server
-            as our reference point for a new cluster / etc
-
-        """
-
-        self.wsrep_cluster_addr = '127.0.0.1:%d' %(master_server.galera_listen_port)
 
=== removed file 'dbqp/lib/server_mgmt/mysqld.py'
--- dbqp/lib/server_mgmt/mysqld.py	2012-02-04 01:22:23 +0000
+++ dbqp/lib/server_mgmt/mysqld.py	1970-01-01 00:00:00 +0000
@@ -1,295 +0,0 @@
-#! /usr/bin/env python
-# -*- mode: python; 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
-
-
-""" mysqld.py:  code to allow a serverManager
-    to provision and start up a mysqld server object
-    for test execution
-
-"""
-
-# imports
-import os
-import sys
-import time
-import subprocess
-
-from ConfigParser import RawConfigParser
-
-from lib.server_mgmt.server import Server
-
-class mysqlServer(Server):
-    """ represents a mysql server, its possessions
-        (datadir, ports, etc), and methods for controlling
-        and querying it
-
-        TODO: create a base server class that contains
-              standard methods from which we can inherit
-              Currently there are definitely methods / attr
-              which are general
-
-    """
-
-    def __init__( self, name, server_manager, code_tree, default_storage_engine
-                , server_options, requester, workdir_root):
-        super(mysqlServer, self).__init__( name
-                                           , server_manager
-                                           , code_tree
-                                           , default_storage_engine
-                                           , server_options
-                                           , requester
-                                           , workdir_root)
-        self.preferred_base_port = 9306
-        
-        # client files
-        self.mysqldump = self.code_tree.mysqldump
-        self.mysqladmin = self.code_tree.mysqladmin
-        self.mysql_client = self.code_tree.mysql_client
-        self.mysqlimport = self.code_tree.mysqlimport
-        self.mysqlslap = self.code_tree.mysqlslap
-        self.mysql_upgrade = self.code_tree.mysql_upgrade
-        self.server_path = self.code_tree.mysql_server
-        self.mysql_client_path = self.code_tree.mysql_client
-      
-        # important stuff
-        self.langdir = self.code_tree.langdir
-        self.charsetdir = self.code_tree.charsetdir
-        self.bootstrap_file = self.code_tree.bootstrap_path
-        self.bootstrap_cmd = None
-
-        # Get our ports
-        self.port_block = self.system_manager.port_manager.get_port_block( self.name
-                                                                         , self.preferred_base_port
-                                                                         , 1 )
-        self.master_port = self.port_block[0]
-
-        # Generate our working directories
-        self.dirset = { 'var_%s' %(self.name): {'std_data_ln':( os.path.join(self.code_tree.testdir,'std_data'))
-                                               ,'log':None
-                                               ,'run':None
-                                               ,'tmp':None
-                                               ,'master-data': { 'test':None
-                                                               , 'mysql':None
-                                                               }
-                                               }  
-                      }
-        self.workdir = self.system_manager.create_dirset( workdir_root
-                                                        , self.dirset)
-        self.vardir = self.workdir
-        self.tmpdir = os.path.join(self.vardir,'tmp')
-        self.rundir = os.path.join(self.vardir,'run')
-        self.logdir = os.path.join(self.vardir,'log')
-        self.std_data = os.path.join(self.vardir,'std_data_ln')
-        self.datadir = os.path.join(self.vardir,'master-data')
-
-        self.error_log = os.path.join(self.logdir,('%s.err' %(self.name)))
-        self.bootstrap_log = os.path.join(self.logdir,('bootstrap.log'))
-        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'))
-        self.general_log_file = os.path.join(self.logdir,'mysqld.log')
-        self.slow_query_log_file = os.path.join(self.logdir,'mysqld-slow.log')
-        self.cnf_file = os.path.join(self.vardir,'my.cnf')
-
-        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
-        if self.no_secure_file_priv:
-            self.secure_file_string = ''
-        else:
-            self.secure_file_string = "--secure-file-priv='%s'" %(self.vardir)
-        self.user_string = '--user=root'
-
-        self.initialize_databases()
-        self.take_db_snapshot()
-
-        self.logging.debug_class(self)
-
-
-    def report(self):
-        """ We print out some general useful info """
-        report_values = [ 'name'
-                        , 'master_port'
-                        , 'socket_file'
-                        , 'vardir'
-                        , 'status'
-                        ]
-        self.logging.info("%s server:" %(self.owner))
-        for key in report_values:
-          value = vars(self)[key] 
-          self.logging.info("%s: %s" %(key.upper(), value))
-
-    def initialize_databases(self):
-        """ Do the voodoo required to have a working database setup.
-            For MySQL, this is calling the server with the 
-            --bootstrap argument.  We generate the bootstrap
-            file during codeTree intialization as the file is standard for
-            all MySQL servers that are spawned from a single codeTree
-
-        """
-  
-        # generate the bootstrap startup command
-        if not self.bootstrap_cmd:
-            mysqld_args = [ "--no-defaults"
-                          , "--bootstrap"
-                          , "--basedir=%s" %(self.code_tree.basedir)
-                          , "--datadir=%s" %(self.datadir)
-                          , "--loose-skip-falcon"
-                          , "--loose-skip-ndbcluster"
-                          , "--tmpdir=%s" %(self.tmpdir)
-                          , "--core-file"
-                          , "--lc-messages-dir=%s" %(self.langdir)
-                          , "--character-sets-dir=%s" %(self.charsetdir)
-                          ]
-            # We add server_path into the mix this way as we
-            # may alter how we store / handle server args later
-            mysqld_args.insert(0,self.server_path)
-            self.bootstrap_cmd = " ".join(mysqld_args)
-        # execute our command
-        bootstrap_log = open(self.bootstrap_log,'w')
-        # open our bootstrap file
-        bootstrap_in = open(self.bootstrap_file,'r')
-        bootstrap_subproc = subprocess.Popen( self.bootstrap_cmd
-                                            , shell=True
-                                            , stdin=bootstrap_in
-                                            , stdout=bootstrap_log
-                                            , stderr=bootstrap_log
-                                            )
-        bootstrap_subproc.wait()
-        bootstrap_in.close()
-        bootstrap_log.close()
-        bootstrap_retcode = bootstrap_subproc.returncode
-        if bootstrap_retcode:
-            self.logging.error("Received retcode: %s executing command: %s"
-                               %(bootstrap_retcode, self.bootstrap_cmd))
-            self.logging.error("Check the bootstrap log: %s" %(self.bootstrap_log))
-            sys.exit(1)
-
-
-    def get_start_cmd(self):
-        """ Return the command string that will start up the server 
-            as desired / intended
- 
-        """
-
-        server_args = [ self.process_server_options()
-                      , "--open-files-limit=1024"
-                      , "--local-infile"
-                      , "--character-set-server=latin1"
-                      , "--connect-timeout=60"
-                      , "--log-bin-trust-function-creators=1"
-                      , "--key_buffer_size=1M"
-                      , "--sort_buffer=256K"
-                      , "--max_heap_table_size=1M"
-                      , "--loose-innodb_data_file_path=ibdata1:10M:autoextend"
-                      , "--loose-innodb_buffer_pool_size=8M"
-                      , "--loose-innodb_write_io_threads=2"
-                      , "--loose-innodb_read_io_threads=2"
-                      , "--loose-innodb_log_buffer_size=1M"
-                      , "--loose-innodb_log_file_size=5M"
-                      , "--loose-innodb_additional_mem_pool_size=1M"
-                      , "--loose-innodb_log_files_in_group=2"
-                      , "--slave-net-timeout=120"
-                      , "--log-bin=%s" %(os.path.join(self.logdir,"mysqld-bin"))
-                      , "--loose-enable-performance-schema"
-                      , "--loose-performance-schema-max-mutex-instances=10000"
-                      , "--loose-performance-schema-max-rwlock-instances=10000"
-                      , "--loose-performance-schema-max-table-instances=500"
-                      , "--loose-performance-schema-max-table-handles=1000"
-                      , "--binlog-direct-non-transactional-updates"
-                      , "--loose-enable-performance-schema"
-                      , "--general_log=1"
-                      , "--general_log_file=%s" %(self.general_log_file)
-                      , "--slow_query_log=1"
-                      , "--slow_query_log_file=%s" %(self.slow_query_log_file)
-                      , "--basedir=%s" %(self.code_tree.basedir)
-                      , "--datadir=%s" %(self.datadir)
-                      , "--tmpdir=%s"  %(self.tmpdir)
-                      , "--character-sets-dir=%s" %(self.charsetdir)
-                      , "--lc-messages-dir=%s" %(self.langdir)
-                      , "--ssl-ca=%s" %(os.path.join(self.std_data,'cacert.pem'))
-                      , "--ssl-cert=%s" %(os.path.join(self.std_data,'server-cert.pem'))
-                      , "--ssl-key=%s" %(os.path.join(self.std_data,'server-key.pem'))
-                      , "--port=%d" %(self.master_port)
-                      , "--socket=%s" %(self.socket_file)
-                      , "--pid-file=%s" %(self.pid_file)
-                      , "--default-storage-engine=%s" %(self.default_storage_engine)
-                      # server-id maybe needs fixing, but we want to avoid
-                      # the server-id=0 and no replication thing...
-                      , "--server-id=%d" %(self.get_numeric_server_id()+1)
-                      , self.secure_file_string
-                      , self.user_string
-                      ]
-        self.gen_cnf_file(server_args)
-
-        if self.gdb:
-            server_args.append('--gdb')
-            return self.system_manager.handle_gdb_reqs(self, server_args)
-        else:
-            return "%s %s %s & " % ( self.cmd_prefix
-                                   , self.server_path
-                                   , " ".join(server_args)
-                                   )
-
-
-    def get_stop_cmd(self):
-        """ Return the command that will shut us down """
-        
-        return "%s --no-defaults --user=root --port=%d --host=127.0.0.1 --protocol=tcp shutdown " %(self.mysqladmin, self.master_port)
-           
-
-    def get_ping_cmd(self):
-        """Return the command string that will 
-           ping / check if the server is alive 
-
-        """
-
-        return '%s --no-defaults --user=root --port=%d --host=127.0.0.1 --protocol=tcp ping' % (self.mysqladmin, self.master_port)
-
-    def is_started(self):
-        """ Determine if the server is up and running - 
-            this may vary from server type to server type
-
-        """
-
-        # 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 gen_cnf_file(self, server_args):
-        """ We generate a .cnf file for the server based
-            on the arguments.  We currently don't use
-            this for much, but xtrabackup uses it, so 
-            we must produce one.  This could also be
-            helpful for testing / etc
-
-        """
-
-        config_file = open(self.cnf_file,'w')
-        config_file.write('[mysqld]') 
-        for server_arg in server_args:
-            # We currently have a list of string values
-            # We need to remove any '--' stuff 
-            server_arg = server_arg.replace('--','')+'\n'
-            config_file.write(server_arg)
-        config_file.close() 
 
=== removed file 'dbqp/lib/server_mgmt/percona.py'
--- dbqp/lib/server_mgmt/percona.py	2012-02-04 01:22:23 +0000
+++ dbqp/lib/server_mgmt/percona.py	1970-01-01 00:00:00 +0000
@@ -1,273 +0,0 @@
-#! /usr/bin/env python
-# -*- mode: python; 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
-
-
-""" mysqld.py:  code to allow a serverManager
-    to provision and start up a mysqld server object
-    for test execution
-
-"""
-
-# imports
-import os
-import sys
-import subproc
-
-
-from lib.server_mgmt.server import Server
-
-class mysqlServer(Server):
-    """ represents a mysql server, its possessions
-        (datadir, ports, etc), and methods for controlling
-        and querying it
-
-        TODO: create a base server class that contains
-              standard methods from which we can inherit
-              Currently there are definitely methods / attr
-              which are general
-
-    """
-
-    def __init__( self, name, server_manager, code_tree, default_storage_engine
-                , server_options, requester, workdir_root):
-        super(mysqlServer, self).__init__( name
-                                           , server_manager
-                                           , code_tree
-                                           , default_storage_engine
-                                           , server_options
-                                           , requester
-                                           , workdir_root)
-        self.preferred_base_port = 9306
-        
-        # client files
-        self.mysqldump = self.code_tree.mysqldump
-        self.mysqladmin = self.code_tree.mysqladmin
-        self.mysql_client = self.code_tree.mysql_client
-        self.mysqlimport = self.code_tree.mysqlimport
-        self.mysqlslap = self.code_tree.mysqlslap
-        self.server_path = self.code_tree.mysql_server
-        self.mysql_client_path = self.code_tree.mysql_client
-      
-        # important stuff
-        self.langdir = self.code_tree.langdir
-        self.charsetdir = self.code_tree.charsetdir
-        self.bootstrap_file = self.code_tree.bootstrap_path
-        self.bootstrap_cmd = None
-
-        # Get our ports
-        self.port_block = self.system_manager.port_manager.get_port_block( self.name
-                                                                         , self.preferred_base_port
-                                                                         , 1 )
-        self.master_port = self.port_block[0]
-
-        # Generate our working directories
-        self.dirset = { self.name : { 'var': {'std_data_ln':( os.path.join(self.code_tree.testdir,'std_data'))
-                                             ,'log':None
-                                             ,'run':None
-                                             ,'tmp':None
-                                             ,'master-data': {'local': { 'test':None
-                                                                       , 'mysql':None
-                                                                       }
-                                                             }
-                                             }  
-                                    } 
-                      }
-        self.workdir = self.system_manager.create_dirset( workdir_root
-                                                        , self.dirset)
-        self.vardir = os.path.join(self.workdir,'var')
-        self.tmpdir = os.path.join(self.vardir,'tmp')
-        self.rundir = os.path.join(self.vardir,'run')
-        self.logdir = os.path.join(self.vardir,'log')
-        self.std_data = os.path.join(self.vardir,'std_data_ln')
-        self.datadir = os.path.join(self.vardir,'master-data')
-
-        self.error_log = os.path.join(self.logdir,('%s.err' %(self.name)))
-        self.bootstrap_log = os.path.join(self.logdir,('bootstrap.log'))
-        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'))
-        self.general_log_file = os.path.join(self.logdir,'mysqld.log')
-        self.slow_query_log_file = os.path.join(self.logdir,'mysqld-slow.log')
-
-        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
-        if self.no_secure_file_priv:
-            self.secure_file_string = ''
-        else:
-            self.secure_file_string = "--secure-file-priv='%s'" %(self.vardir)
-        self.user_string = '--user=root'
-
-        self.initialize_databases()
-        self.take_db_snapshot()
-
-        self.logging.debug_class(self)
-
-    def report(self):
-        """ We print out some general useful info """
-        report_values = [ 'name'
-                        , 'master_port'
-                        , 'socket_file'
-                        , 'vardir'
-                        , 'status'
-                        ]
-        self.logging.info("%s server:" %(self.owner))
-        for key in report_values:
-          value = vars(self)[key] 
-          self.logging.info("%s: %s" %(key.upper(), value))
-
-    def initialize_databases(self):
-        """ Do the voodoo required to have a working database setup.
-            For MySQL, this is calling the server with the 
-            --bootstrap argument.  We generate the bootstrap
-            file during codeTree intialization as the file is standard for
-            all MySQL servers that are spawned from a single codeTree
-
-        """
-
-        # generate the bootstrap startup command
-        if not self.bootstrap_cmd:
-            mysqld_args = [ "--no-defaults"
-                          , "--bootstrap"
-                          , "--basedir=%s" %(self.code_tree.basedir)
-                          , "--datadir=%s" %(self.datadir)
-                          , "--loose-skip-falcon"
-                          , "--loose-skip-ndbcluster"
-                          , "--tmpdir=%s" %(self.tmpdir)
-                          , "--core-file"
-                          , "--lc-messages-dir=%s" %(self.langdir)
-                          , "--character-sets-dir=%s" %(self.charsetdir)
-                          ]
-            # We add server_path into the mix this way as we
-            # may alter how we store / handle server args later
-            mysqld_args = [self.server_path].append(mysqld_args)
-            self.bootstrap_cmd = " ".join(mysqld_args)
-        # execute our command
-        bootstrap_subproc = subprocess.Popen( self.bootstrap_cmd
-                                            , shell=True
-                                            , stdout=self.bootstrap_log
-                                            , stderr=self.bootstrap_log
-                                            )
-        bootstrap_subproc.wait()
-        bootstrap_retcode = bootstrap_subproc.returncode
-        if bootstrap_retcode:
-            self.logging.error("Received retcode: %s executing command: %s"
-                               %(bootstrap_retcode, self.bootstrap_cmd))
-            self.logging.error("Check the bootstrap log: %s" %(self.bootstrap_log))
-            sys.exit(1)
-
-
-    def get_start_cmd(self):
-        """ Return the command string that will start up the server 
-            as desired / intended
- 
-        """
-
-        server_args = [ self.process_server_options()
-                      , "--open-files-limit=1024"
-                      , "--local-infile"
-                      , "--character-set-server=latin1"
-                      , "--connect-timeout=60"
-                      , "--log-bin-trust-function-creators=1"
-                      , "--key_buffer_size=1M"
-                      , "--sort_buffer=256K"
-                      , "--max_heap_table_size=1M"
-                      , "--query-cache-size=0"
-                      , "--loose-innodb_data_file_path=ibdata1:10M:autoextend"
-                      , "--loose-innodb_buffer_pool_size=32M"
-                      , "--loose-innodb_write_io_threads=2"
-                      , "--loose-innodb_read_io_threads=2"
-                      , "--loose-innodb_log_buffer_size=1M"
-                      , "--loose-innodb_log_file_size=5M"
-                      , "--loose-innodb_additional_mem_pool_size=1M"
-                      , "--loose-innodb_log_files_in_group=2"
-                      , "--slave-net-timeout=120"
-                      , "--log-bin=mysqld-bin"
-                      , "--loose-enable-performance-schema"
-                      , "--loose-performance-schema-max-mutex-instances=10000"
-                      , "--loose-performance-schema-max-rwlock-instances=10000"
-                      , "--loose-performance-schema-max-table-instances=500"
-                      , "--loose-performance-schema-max-table-handles=1000"
-                      , "--binlog-direct-non-transactional-updates"
-                      , "--loose-enable-performance-schema"
-                      , "--log-bin=master-bin"
-                      , "--general_log=1"
-                      , "--general_log_file=%s" %(self.general_log_file)
-                      , "--slow_query_log=1"
-                      , "--slow_query_log_file=%s" %(self.slow_query_log_file)
-                      , "--basedir=%s" %(self.codetree.basedir)
-                      , "--datadir=%s" %(self.datadir)
-                      , "--tmpdir=%s"  %(self.tmpdir)
-                      , "--character-sets-dir=%s" %(self.charsetdir)
-                      , "--lc-messages-dir=%s" %(self.langdir)
-                      , "--ssl-ca=%s" %(os.path.join(self.std_data,'cacert.pem'))
-                      , "--ssl-cert=%s" %(os.path.join(self.std_data,'server-cert.pem'))
-                      , "--ssl-key=%s" %(os.path.join(self.std_data,'server-key.pem'))
-                      , "--port=%d" %(self.master_port)
-                      , "--mysql-protocol.connect-timeout=60"
-                      , "--innodb.data-file-path=ibdata1:20M:autoextend"
-                      , "--sort-buffer-size=256K"
-                      , "--max-heap-table-size=1M"
-                      , "--socket=%s" %(self.socket_file)
-                      , "--pid-file=%s" %(self.pid_file)
-                      , "--default-storage-engine=%s" %(self.default_storage_engine)
-                      , "--server-id=%d" %(self.get_numeric_server_id)
-                      , self.secure_file_string
-                      , self.user_string
-                      ]
-
-        if self.gdb:
-            server_args.append('--gdb')
-            return self.system_manager.handle_gdb_reqs(self, server_args)
-        else:
-            return "%s %s %s & " % ( self.cmd_prefix
-                                   , self.server_path
-                                   , " ".join(server_args)
-                                   )
-
-
-    def get_stop_cmd(self):
-        """ Return the command that will shut us down """
-        
-        return "%s --user=root --port=%d --connect-timeout=5 --silent --password= --shutdown " %(self.mysql_admin, self.master_port)
-           
-
-    def get_ping_cmd(self):
-        """Return the command string that will 
-           ping / check if the server is alive 
-
-        """
-
-        return '%s --port=%d --user=root -hlocalhost --protocol=tcp -e ""' % (self.mysql_client_path, self.master_port)
-
-    def is_started(self):
-        """ Determine if the server is up and running - 
-            this may vary from server type to server type
-
-        """
-
-        # 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)
-
-
 
=== removed file 'dbqp/lib/server_mgmt/server.py'
--- dbqp/lib/server_mgmt/server.py	2012-02-04 01:22:23 +0000
+++ dbqp/lib/server_mgmt/server.py	1970-01-01 00:00:00 +0000
@@ -1,170 +0,0 @@
-#! /usr/bin/env python
-# -*- mode: python; 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
-                , code_tree
-                , 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.code_tree = code_tree
-        self.type = self.code_tree.type
-        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
-        self.pid = None
-        self.ip_address = '127.0.0.1'
-        self.need_reset = False
-
-    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 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 "You need to implement is_started"
-
-    def get_start_cmd(self):
-        """ Return the command the server_manager can use to start me """
-
-        return "You need to implement get_start_cmd"
-
-    def get_stop_cmd(self):
-        """ Return the command the server_manager can use to stop me """
-
-        return "You need to implement get_stop_cmd"
-
-    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 "You need to implement get_ping_cmd"
-
-    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
-        self.need_reset = False
-
-    def get_numeric_server_id(self):
-        """ Return the integer value of server-id
-            Mainly for mysql / percona, but may be useful elsewhere
- 
-        """
-
-        return int(self.name.split(self.server_manager.server_base_name)[1])
-
 
=== removed file 'dbqp/lib/server_mgmt/server_management.py'
--- dbqp/lib/server_mgmt/server_management.py	2012-02-04 01:22:23 +0000
+++ dbqp/lib/server_mgmt/server_management.py	1970-01-01 00:00:00 +0000
@@ -1,611 +0,0 @@
-#! /usr/bin/env python
-# -*- mode: python; 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_management.py
-   code for dealing with apportioning servers
-   to suit the needs of the tests and executors
-
-"""
-# imports
-import thread
-import time
-import os
-import subprocess
-from ConfigParser import RawConfigParser
-
-class serverManager:
-    """ code that handles the server objects
-        We use this to track, do mass actions, etc
-        Single point of contact for this business
-
-    """
-
-    def __init__(self, system_manager, variables):
-        self.skip_keys = [ 'system_manager'
-                         , 'env_manager'
-                         , 'code_manager'
-                         , 'logging'
-                         , 'gdb'
-                         ]
-        self.debug = variables['debug']
-        self.verbose = variables['verbose']
-        self.initial_run = 1
-        # we try this to shorten things - will see how this works
-        self.server_base_name = 's'
-        self.no_secure_file_priv = variables['nosecurefilepriv']
-        self.system_manager = system_manager
-        self.code_manager = system_manager.code_manager
-        self.env_manager = system_manager.env_manager
-        self.logging = system_manager.logging
-        self.gdb  = self.system_manager.gdb
-        self.default_storage_engine = variables['defaultengine']
-        self.default_server_type = variables['defaultservertype']
-        self.user_server_opts = variables['drizzledoptions']
-        self.servers = {}
-
-        self.mutex = thread.allocate_lock()
-        self.timer_increment = .5
-        self.libeatmydata = variables['libeatmydata']
-        self.libeatmydata_path = variables['libeatmydatapath']
-
-        self.logging.info("Using default-storage-engine: %s" %(self.default_storage_engine))
-
-        self.logging.debug_class(self)
-
-    def request_servers( self, requester 
-                       , workdir, cnf_path
-                       , server_requests
-                       , 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.
-
-            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
-    
-        """
-
-        # Make sure our server is in a decent state, if the last test
-        # failed, then we reset the server
-        self.check_server_status(requester)
-        
-        # Make sure we have the proper number of servers for this requester
-        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
-                                      , cnf_path
-                                      , server_requests
-                                      , server_requirements)
-
-        # Fire our servers up
-        bad_start = self.start_servers( requester, working_environ
-                                      , expect_fail)
- 
-        # Return them to the requester
-        return (self.get_server_list(requester), bad_start)