Merge lp:~kalebral-deactivatedaccount/drizzle-automation/bench-config-name into lp:drizzle-automation

[Lee Bieber]

[Lee Bieber (kalebral-deactivatedaccount)]

change -sysbench-config option to -bench-config-name to be generic for all benchmarks. Drizzleslap, dbt2 and sqlbench now require this option and a configuration file.

Note still need to change sysbench to use the util.loadConfigFile and rename the table sysbench_config to be bench_config. That will be phase 2 after this initial change is approved and merged

[lp:~kalebral-deactivatedaccount/drizzle-automation/bench-config-name]

129. By lbieber <lbieber@orisndriz01> on 2010-01-07

clean up drizzleslap.cnf

130. By Lee Bieber <email address hidden> on 2010-01-11

change sysbench to use util.loadConfigFile instead of having its own version

=== modified file 'drizzle/automation/config/automation.cnf'
--- drizzle/automation/config/automation.cnf	2010-01-04 18:23:17 +0000
+++ drizzle/automation/config/automation.cnf	2010-01-11 06:21:15 +0000
@@ -40,52 +40,14 @@
 rsync_dir= drizzle.org:web/doxygen/
 
 [dbt2]
-dbt2_config_name= dbt2
-# location of the dbt2 code
-dbt2_home= /home/drizzle/repos/dbt2-0.40
-# location of generated data
-dbt2_data_dir= /home/drizzle/repos/dbt2-0.40/data
-# number of data warehouses
-dbt2_warehouses= 10
-# number of connections
-dbt2_connections= 2,4,8,16,32,64,128,256,512,1024
-# time to run the tests
-dbt2_time= 300
+
 # Email recipients to receive a text regression report on completion of a run. Comma separated.
 report_email= [e-mail]
 
 [drizzleslap]
-drizzleslap_config_name= drizzleslap
-common_options= --number-int-cols=2 --number-char-cols=3 --auto-generate-sql
-concurrency= 1,100,200,300,400,500,600,700,800,900,1000,1100,1200
-engine= innodb
-iterations= 10
+# Email recipients to receive a text regression report on completion of a run. Comma separated.
 report_email= [e-mail]
 
-[drizzleslap_tests]
-guid= --auto-generate-sql-guid-primary --auto-generate-sql-load-type=write --number-of-queries=100000 --engine=innodb
-guid-scale= --auto-generate-sql-guid-primary --auto-generate-sql-load-type=write --auto-generate-sql-execute-number=1000 --engine=innodb
-key=  --auto-generate-sql-add-autoincrement --auto-generate-sql-load-type=key --number-of-queries=100000 --engine=innodb
-key-scale= --auto-generate-sql-add-autoincrement --auto-generate-sql-load-type=key --auto-generate-sql-execute-number=1000 --engine=innodb
-mixed= --auto-generate-sql-add-autoincrement --auto-generate-sql-load-type=mixed --number-of-queries=100000 --engine=innodb
-mixed-commit= --auto-generate-sql-add-autoincrement --auto-generate-sql-load-type=mixed --number-of-queries=100000 --commit=8 --engine=innodb
-mixed-commit-scale= --auto-generate-sql-add-autoincrement --auto-generate-sql-load-type=mixed --auto-generate-sql-execute-number=1000 --commit=8 --engine=innodb
-mixed-scale= --auto-generate-sql-add-autoincrement --auto-generate-sql-load-type=mixed --auto-generate-sql-execute-number=1000 --engine=innodb
-scan= --auto-generate-sql-add-autoincrement --auto-generate-sql-load-type=read --number-of-queries=100000 --engine=innodb
-scan-scale= --auto-generate-sql-add-autoincrement --auto-generate-sql-load-type=read --auto-generate-sql-execute-number=1000 --engine=innodb
-update= --auto-generate-sql-add-autoincrement --auto-generate-sql-load-type=update --number-of-queries=100000 --auto-generate-sql-write-number=50000 --engine=innodb
-update-commit=  --auto-generate-sql-add-autoincrement --auto-generate-sql-load-type=update --number-of-queries=100000 --auto-generate-sql-write-number=50000 --commit=8 --engine=innodb
-update-commit-scale= --auto-generate-sql-add-autoincrement --auto-generate-sql-load-type=update --auto-generate-sql-execute-number=1000  --auto-generate-sql-write-number=50000 --commit=8 --engine=innodb
-update-scale= --auto-generate-sql-add-autoincrement --auto-generate-sql-load-type=update --auto-generate-sql-execute-number=1000 --auto-generate-sql-write-number=50000 --engine=innodb
-write= --auto-generate-sql-add-autoincrement --auto-generate-sql-load-type=write --number-of-queries=100000 --engine=innodb
-write-commit= --auto-generate-sql-add-autoincrement --auto-generate-sql-load-type=write --number-of-queries=100000 --commit=8 --engine=innodb
-write-commit-scale= --auto-generate-sql-add-autoincrement --auto-generate-sql-load-type=write --auto-generate-sql-execute-number=1000 --commit=8 --engine=innodb
-write-scale= --auto-generate-sql-add-autoincrement --auto-generate-sql-load-type=write --auto-generate-sql-execute-number=1000 --engine=innodb
-write_bh= --auto-generate-sql-add-autoincrement --auto-generate-sql-load-type=write --number-of-queries=100000 --engine=blackhole
-write-scale_bh= --auto-generate-sql-add-autoincrement --auto-generate-sql-load-type=write --auto-generate-sql-execute-number=1000 --engine=blackhole
-guid_bh= --auto-generate-sql-guid-primary --auto-generate-sql-load-type=write --number-of-queries=100000 --engine=blackhole
-guid-scale_bh= --auto-generate-sql-guid-primary --auto-generate-sql-load-type=write --auto-generate-sql-execute-number=1000 --engine=blackhole
-
 [lcov]
 
 # Directories queried during GCOV/LCOV code coverage
@@ -115,10 +77,6 @@
 
 [sqlbench]
 
-# configuration name for use in sysbench_config table
-sqlbench_config_name= sqlbench
-# location of the sql bench repository
-sqlbench_home= /home/drizzle/repos/sql-bench
 # Email recipients to receive a text regression report on completion of
 # a sqlbench run. Comma separated.
 report_email= [e-mail]

=== added directory 'drizzle/automation/config/dbt2'
=== added file 'drizzle/automation/config/dbt2/dbt2.cnf'
--- drizzle/automation/config/dbt2/dbt2.cnf	1970-01-01 00:00:00 +0000
+++ drizzle/automation/config/dbt2/dbt2.cnf	2010-01-11 06:21:15 +0000
@@ -0,0 +1,16 @@
+[run]
+
+# location of the dbt2 code
+dbt2_home= /home/drizzle/repos/dbt2
+
+# location of generated data
+dbt2_data_dir= /home/drizzle/repos/dbt2/data_dir
+
+# number of data warehouses
+dbt2_warehouses= 10
+
+# number of connections
+dbt2_connections= 2,4,8,16,32,64,128,256,512,1024
+
+# time to run the tests
+dbt2_time= 300

=== added directory 'drizzle/automation/config/drizzleslap'
=== added file 'drizzle/automation/config/drizzleslap/drizzleslap.cnf'
--- drizzle/automation/config/drizzleslap/drizzleslap.cnf	1970-01-01 00:00:00 +0000
+++ drizzle/automation/config/drizzleslap/drizzleslap.cnf	2010-01-11 06:21:15 +0000
@@ -0,0 +1,29 @@
+[run]
+common_options= --number-int-cols=2 --number-char-cols=3 --auto-generate-sql
+concurrency= 1,100,200,300,400,500,600,700,800,900,1000,1100,1200
+engine= innodb
+iterations= 10
+
+[drizzleslap_tests]
+guid= --auto-generate-sql-guid-primary --auto-generate-sql-load-type=write --number-of-queries=100000 --engine=innodb
+guid-scale= --auto-generate-sql-guid-primary --auto-generate-sql-load-type=write --auto-generate-sql-execute-number=1000 --engine=innodb
+key=  --auto-generate-sql-add-autoincrement --auto-generate-sql-load-type=key --number-of-queries=100000 --engine=innodb
+key-scale= --auto-generate-sql-add-autoincrement --auto-generate-sql-load-type=key --auto-generate-sql-execute-number=1000 --engine=innodb
+mixed= --auto-generate-sql-add-autoincrement --auto-generate-sql-load-type=mixed --number-of-queries=100000 --engine=innodb
+mixed-commit= --auto-generate-sql-add-autoincrement --auto-generate-sql-load-type=mixed --number-of-queries=100000 --commit=8 --engine=innodb
+mixed-commit-scale= --auto-generate-sql-add-autoincrement --auto-generate-sql-load-type=mixed --auto-generate-sql-execute-number=1000 --commit=8 --engine=innodb
+mixed-scale= --auto-generate-sql-add-autoincrement --auto-generate-sql-load-type=mixed --auto-generate-sql-execute-number=1000 --engine=innodb
+scan= --auto-generate-sql-add-autoincrement --auto-generate-sql-load-type=read --number-of-queries=100000 --engine=innodb
+scan-scale= --auto-generate-sql-add-autoincrement --auto-generate-sql-load-type=read --auto-generate-sql-execute-number=1000 --engine=innodb
+update= --auto-generate-sql-add-autoincrement --auto-generate-sql-load-type=update --number-of-queries=100000 --auto-generate-sql-write-number=50000 --engine=innodb
+update-commit=  --auto-generate-sql-add-autoincrement --auto-generate-sql-load-type=update --number-of-queries=100000 --auto-generate-sql-write-number=50000 --commit=8 --engine=innodb
+update-commit-scale= --auto-generate-sql-add-autoincrement --auto-generate-sql-load-type=update --auto-generate-sql-execute-number=1000  --auto-generate-sql-write-number=50000 --commit=8 --engine=innodb
+update-scale= --auto-generate-sql-add-autoincrement --auto-generate-sql-load-type=update --auto-generate-sql-execute-number=1000 --auto-generate-sql-write-number=50000 --engine=innodb
+write= --auto-generate-sql-add-autoincrement --auto-generate-sql-load-type=write --number-of-queries=100000 --engine=innodb
+write-commit= --auto-generate-sql-add-autoincrement --auto-generate-sql-load-type=write --number-of-queries=100000 --commit=8 --engine=innodb
+write-commit-scale= --auto-generate-sql-add-autoincrement --auto-generate-sql-load-type=write --auto-generate-sql-execute-number=1000 --commit=8 --engine=innodb
+write-scale= --auto-generate-sql-add-autoincrement --auto-generate-sql-load-type=write --auto-generate-sql-execute-number=1000 --engine=innodb
+write_bh= --auto-generate-sql-add-autoincrement --auto-generate-sql-load-type=write --number-of-queries=100000 --engine=blackhole
+write-scale_bh= --auto-generate-sql-add-autoincrement --auto-generate-sql-load-type=write --auto-generate-sql-execute-number=1000 --engine=blackhole
+guid_bh= --auto-generate-sql-guid-primary --auto-generate-sql-load-type=write --number-of-queries=100000 --engine=blackhole
+guid-scale_bh= --auto-generate-sql-guid-primary --auto-generate-sql-load-type=write --auto-generate-sql-execute-number=1000 --engine=blackhole

=== added directory 'drizzle/automation/config/sqlbench'
=== added file 'drizzle/automation/config/sqlbench/sqlbench.cnf'
--- drizzle/automation/config/sqlbench/sqlbench.cnf	1970-01-01 00:00:00 +0000
+++ drizzle/automation/config/sqlbench/sqlbench.cnf	2010-01-11 06:21:15 +0000
@@ -0,0 +1,4 @@
+[run]
+
+# location of the sql bench repository
+sqlbench_home= /home/drizzle/repos/sql-bench

=== modified file 'drizzle/automation/dbt2/run.py'
--- drizzle/automation/dbt2/run.py	2009-12-22 21:04:47 +0000
+++ drizzle/automation/dbt2/run.py	2010-01-11 06:21:15 +0000
@@ -83,7 +83,7 @@
   working_dir= variables['working_dir']
   server_name= variables['server']
   run_date= datetime.datetime.now().isoformat()
-  config_name= variables['dbt2']['dbt2_config_name']
+  bench_config_name= variables['bench_config_name']
 
   os.chdir(working_dir)
 
@@ -157,13 +157,16 @@
   util.get_profile_options(server,variables['profiler'])
 
   run_id= util.getNextRunId()
-  config_id= util.getConfigId(config_name)
+  config_id= util.getConfigId(bench_config_name)
   
+  # load the configuration file
+  dbt2_config_variables= util.loadConfigFile("dbt2", bench_config_name)
+
   # location of dbt2 tools and scripts
-  dbt2_home= variables['dbt2']['dbt2_home']
+  dbt2_home= dbt2_config_variables['run']['dbt2_home']
   bzr_revision= variables['bzr_revision']
-  test_time= variables['dbt2']['dbt2_time']
-  warehouses= variables['dbt2']['dbt2_warehouses']
+  test_time= dbt2_config_variables['run']['dbt2_time']
+  warehouses= dbt2_config_variables['run']['dbt2_warehouses']
 
   # location where test results are stored
   output_dirname= ('dbt2-%s' % (bzr_revision))
@@ -172,7 +175,7 @@
     os.mkdir(output_dirname)
 
   # load data into database
-  cmd= "%s/scripts/drizzle/drizzle_load_db.sh --path %s --verbose --drizzle_path %s" % (dbt2_home, variables['dbt2']['dbt2_data_dir'],  os.path.join(working_dir, 'client/drizzle'))
+  cmd= "%s/bin/drizzle/dbt2-drizzle-load-db --path %s --verbose --drizzle_path %s" % (dbt2_home, dbt2_config_variables['run']['dbt2_data_dir'],  os.path.join(working_dir, 'client/drizzle'))
   logging.info("Loading data.... ")
   logging.info("%s " % cmd)
   (retcode, output)= commands.getstatusoutput(cmd)
@@ -181,11 +184,11 @@
     sys.exit(1)
 
   # get list of connections to run with
-  connection_levels= [int(x) for x in variables['dbt2']['dbt2_connections'].split(",")]
+  connection_levels= [int(x) for x in dbt2_config_variables['run']['dbt2_connections'].split(",")]
   
   # run the tests
   for connections in connection_levels: 
-    cmd= "%s/scripts/drizzle/drizzle_run.sh --connections %d --time %d  --warehouses %d --verbose --output-base %s --run-number %s" % (dbt2_home, connections, int(test_time), int(warehouses), output_dirname, connections)
+    cmd= "%s/bin/drizzle/dbt2-drizzle-run --connections %d --time %d  --warehouses %d --verbose --output-base %s --run-number %s" % (dbt2_home, connections, int(test_time), int(warehouses), output_dirname, connections)
     logging.info("Running %s " % cmd)
     (retcode, output)= commands.getstatusoutput(cmd)
     if not retcode == 0:
@@ -207,7 +210,7 @@
   # send email report
   if variables['with_email_report'] is True:
     import drizzle.automation.reports.dbt2 as reports
-    email_text= reports.getDbt2Report(working_dir, config_name, run_id, run_date, server_name, variables['bzr_branch'], bzr_revision)
+    email_text= reports.getDbt2Report(working_dir, bench_config_name, run_id, run_date, server_name, variables['bzr_branch'], bzr_revision)
     logging.info("Sending email...")
     # bug https://bugs.launchpad.net/launchpad/+bug/419562 - need to use registered launchpad name for from
     #from_string= ('%s <[e-mail]>' % socket.gethostname())

=== modified file 'drizzle/automation/drizzleslap/run.py'
--- drizzle/automation/drizzleslap/run.py	2009-12-08 19:39:50 +0000
+++ drizzle/automation/drizzleslap/run.py	2010-01-11 06:21:15 +0000
@@ -100,7 +100,7 @@
   working_dir= variables['working_dir']
   server_name= variables['server']
   run_date= datetime.datetime.now().isoformat()
-  config_name= variables['drizzleslap']['drizzleslap_config_name']
+  bench_config_name= variables['bench_config_name']
 
   os.chdir(working_dir)
 
@@ -170,17 +170,20 @@
     sys.exit(1)
 
   run_id= util.getNextRunId()
-  config_id= util.getConfigId(config_name)
+  config_id= util.getConfigId(bench_config_name)
+
+  # load the configuration file
+  drizzleslap_config_variables= util.loadConfigFile("drizzleslap", bench_config_name)
 
   # get the list of tests that are specified
   # in the configuration file in the drizzleslap_tests section
-  list_of_tests= variables['drizzleslap_tests']
+  list_of_tests= drizzleslap_config_variables['drizzleslap_tests']
 
   # csv file name includes the bzr version number /tmp/drizzleslap-1172.csv
   csv_file= ("/tmp/drizzleslap-%s.csv" % (variables['bzr_revision']))
-  common_options= variables['drizzleslap']['common_options']
-  concurrency = variables['drizzleslap']['concurrency']
-  iterations= variables['drizzleslap']['iterations']
+  common_options= drizzleslap_config_variables['run']['common_options']
+  concurrency = drizzleslap_config_variables['run']['concurrency']
+  iterations= drizzleslap_config_variables['run']['iterations']
 
   # remove csv file to start fresh
   if os.path.exists(csv_file):
@@ -229,7 +232,7 @@
   # send email report
   if variables['with_email_report'] is True:
     import drizzle.automation.reports.drizzleslap as reports
-    email_text= reports.getDrizzleslapReport(working_dir, config_name, run_id, run_date, server_name, variables['bzr_branch'], int(variables['bzr_revision']))
+    email_text= reports.getDrizzleslapReport(working_dir, bench_config_name, run_id, run_date, server_name, variables['bzr_branch'], int(variables['bzr_revision']))
     logging.info("Sending email...")
     # bug https://bugs.launchpad.net/launchpad/+bug/419562 - need to use registered launchpad name for from
     #from_string= ('%s <[e-mail]>' % socket.gethostname())

=== modified file 'drizzle/automation/lib/options.py'
--- drizzle/automation/lib/options.py	2009-12-22 21:04:47 +0000
+++ drizzle/automation/lib/options.py	2010-01-11 06:21:15 +0000
@@ -68,6 +68,10 @@
 
 # Add non-grouped options...
 parser.add_option(
+    "--bench-config-name"
+  , help="DBT2/DRIZZLESLAP/SYSBENCH/SQLBENCH command only. Sets the bench configuration to use."
+  )
+parser.add_option(
     "--dry-run"
   , action="store_true"
   , default= False
@@ -144,7 +148,7 @@
     "--with-email-report"
   , action="store_true"
   , default= False
-  , help="DBT2/DRIZZLESLAP/SQLBENCH/SYSBENCH/REPORT command only.  Sends a text report to those recipients in [dbt2][sqlbench][sysbench][drizzleslap][report_email] configuration variable."
+  , help="DBT2/DRIZZLESLAP/SQLBENCH/SYSBENCH REPORT command.  Sends a text report to those recipients in [dbt2][sqlbench][sysbench][drizzleslap][report_email] configuration variable."
   )
 parser.add_option(
     "--with-show-status"
@@ -196,14 +200,6 @@
 )
 parser.add_option_group(group)
 
-# Add all the SYSBENCH-COMMAND-specific options
-group= optparse.OptionGroup(parser, "Options when running the SYSBENCH command")
-
-group.add_option(
-  "--sysbench-config"
-  , help="SYSBENCH command only.  Sets the bench configuration to run."
-  )
-parser.add_option_group(group)
 
 # Add all the MySQL Sandbox-mode-specific options
 group= optparse.OptionGroup(parser, "Options when running reports")
@@ -367,19 +363,20 @@
       os.environ['LD_PRELOAD']= variables['ld_preload']
       logging.info("LD_PRELOAD is set to %s\n" % variables['ld_preload'])
 
-    # For benchmarks with sysbench, we require that a configuration file
-    # for the sysbench options is supplied at runtime...
-    if variables['command'] == 'sysbench':
-      # Check to ensure we have a sysbench_config value...
-      bench_config= supplied.sysbench_config
-      if bench_config is None:
-        logging.error("The --sysbench-config CLI option is required when running the BENCH command. Exiting.")
+    # For dbt2, drizzleslap, sqlbench and sysbench, we require that 
+    # a configuration file with options is supplied at runtime...
+    command_to_run= variables['command']
+    if command_to_run in ['dbt2','drizzleslap','sqlbench','sysbench']:
+      # Check to ensure we have a bench_config value...
+      bench_config_name= supplied.bench_config_name
+      if bench_config_name is None:
+        logging.error("The --bench-config-name CLI option is required when running the %s command. Exiting." % command_to_run)
         sys.exit(1)
       else:
-        variables['sysbench_config']= bench_config
+        variables['bench_config_name']= bench_config_name
 
     # Ensure reports have a report name specified
-    if variables['command'] == 'report':
+    if command_to_run == 'report':
       report_name= supplied.report_name
       if report_name is None:
         logging.error("The --report-name CLI option is required when running the REPORT command. Exiting.")
@@ -387,14 +384,14 @@
       else:
         variables['report_name']= report_name
         
-        # Check to ensure we have a sysbench_config value for the sysbench report
-        if report_name == 'sysbench':
-          bench_config= supplied.sysbench_config
-          if bench_config is None:
-            logging.error("The --sysbench-config CLI option is required when running the BENCH command. Exiting.")
+        # Check to ensure we have a bench_config value for the specified report
+        if report_name in ['dbt2','drizzleslap','sqlbench','sysbench']:
+          bench_config_name= supplied.bench_config_name
+          if bench_config_name is None:
+            logging.error("The --bench-config CLI option is required when running the %s command. Exiting." % command_to_run)
             sys.exit(1)
           else:
-            variables['sysbench_config']= bench_config
+            variables['bench_config_name']= bench_config_name
 
     return variables
 

=== modified file 'drizzle/automation/lib/util.py'
--- drizzle/automation/lib/util.py	2009-12-17 17:18:18 +0000
+++ drizzle/automation/lib/util.py	2010-01-11 06:21:15 +0000
@@ -27,6 +27,7 @@
 """Just some useful functions"""
 
 import textwrap
+import os
 import types
 from drizzle.automation.lib import logging
 from drizzle.automation.lib import db
@@ -86,7 +87,7 @@
   
   db.execute_sql(sql)
 
-def getConfigId(config_name):
+def getConfigId(bench_config_name):
   """Returns the integer ID of the configuration name used in this run."""
 
   # If we have not already done so, we query the local DB for the ID
@@ -94,16 +95,16 @@
   # a new record in the sysbench_config table and return the newly generated
   # identifier.
 
-  sql= "SELECT config_id FROM sysbench_config WHERE name = '%s'" % config_name
+  sql= "SELECT config_id FROM sysbench_config WHERE name = '%s'" % bench_config_name
 
   from drizzle.automation.lib import db
   result= db.get_select(sql)
     
   if len(result) == 0:
     # Insert a new record for this config and return the new ID...
-    sql= "INSERT INTO sysbench_config (config_id, name) VALUES (NULL, '%s')" % config_name
+    sql= "INSERT INTO sysbench_config (config_id, name) VALUES (NULL, '%s')" % bench_config_name
     db.execute_sql(sql)
-    return getConfigId(config_name)
+    return getConfigId(bench_config_name)
   else:
     config_id= int(result[0][0])
 
@@ -124,7 +125,7 @@
   return new_run_id
 
 # Find the specific last run_id which corresponds to the revision and branch ...
-def getLastRunId(config_name, server_name, bzr_branch, bzr_revision):
+def getLastRunId(bench_config_name, server_name, bzr_branch, bzr_revision):
 
   version= bzr_branch + '-' + str(bzr_revision)
 
@@ -139,7 +140,7 @@
 ORDER BY run_id DESC
 LIMIT 1
 """ % (
-        config_name
+        bench_config_name
       , server_name
       , version
       )
@@ -170,3 +171,42 @@
     server.setProfiler(profiler)
     server.start()
 
+# Finds and parses the configuration file for the supplied config name
+# A configuration file containing benchmark program and server
+# parameters is required.  If the --bench-config=NAME is a relative
+# filename, we search in /etc/drizzle-automation/sysbench/ for a
+# file called NAME.cnf
+def loadConfigFile(benchmark_name, bench_config_name):
+
+  logging.info("Loading configuration for config name %s." % bench_config_name)
+  bench_config_variables= {}
+
+  locations=[]
+  bench_config_file= bench_config_name
+  if not bench_config_file.endswith(".cnf"):
+    bench_config_file= bench_config_file + ".cnf"
+
+  if not bench_config_file.startswith(os.path.sep):
+    # Assume all relative config files are in /etc/drizzle-automation/sysbench/
+    locations.append(os.path.join(os.path.sep, "etc", "drizzle-automation", benchmark_name, bench_config_file))
+    locations.append(os.path.expanduser(os.path.join("~", ".drizzle-automation", benchmark_name, bench_config_file)))
+  else:
+    locations.append(bench_config_file)
+
+  bench_config_file_found=False
+  for test_bench_config_file in locations:
+    if os.path.exists(test_bench_config_file):
+      bench_config_file_found=True
+  if not bench_config_file_found:
+    logging.error("Specified configuration file not found: \"%s\". Exiting." % bench_config_file)
+    sys.exit(1)
+
+  import ConfigParser
+  parser= ConfigParser.RawConfigParser()
+  parser.read(locations)
+  for sec in parser.sections():
+    bench_config_variables[sec]= {}
+    for k,v in parser.items(sec):
+      bench_config_variables[sec][k]= v
+
+  return bench_config_variables

=== modified file 'drizzle/automation/reports/__init__.py'
--- drizzle/automation/reports/__init__.py	2009-11-16 21:25:20 +0000
+++ drizzle/automation/reports/__init__.py	2010-01-11 06:21:15 +0000
@@ -27,4 +27,4 @@
 
 __copyright__= "Copyright 2009 Sun Microsystems"
 
-__all__= ['sysbench','sqlbench','drizzleslap','run']
+__all__= ['dbt2', 'drizzleslap', 'sqlbench','sysbench','run']

=== modified file 'drizzle/automation/reports/dbt2.py'
--- drizzle/automation/reports/dbt2.py	2010-01-05 16:27:22 +0000
+++ drizzle/automation/reports/dbt2.py	2010-01-11 06:21:15 +0000
@@ -38,11 +38,11 @@
   i.connections
 , ROUND(AVG(i.tpm),2) AS tpm
 , IF (AVG(i.tpm) >= agg.avg_tpm
-  , CONCAT('-', ROUND(((AVG(i.tpm) - agg.avg_tpm) / agg.avg_tpm) * 100, 2), '%%')
-  , CONCAT('+', ROUND(((agg.avg_tpm- AVG(i.tpm)) / agg.avg_tpm) * 100, 2), '%%')
+  , CONCAT('+', ROUND(((AVG(i.tpm) - agg.avg_tpm) / agg.avg_tpm) * 100, 2), '%%')
+  , CONCAT('-', ROUND(((agg.avg_tpm - AVG(i.tpm)) / agg.avg_tpm) * 100, 2), '%%')
   ) as pct_diff_from_avg
-, ROUND(agg.avg_tpm- (AVG(i.tpm)), 2) AS diff_from_avg
-, IF(ABS(agg.avg_tpm- AVG(i.tpm)) <= agg.stddev_tpm
+, ROUND((AVG(i.tpm) - agg.avg_tpm), 2) AS diff_from_avg
+, IF(ABS(AVG(i.tpm) - agg.avg_tpm) <= agg.stddev_tpm
   , 'within norms'
   , 'outside norms'
   ) as is_normal
@@ -97,7 +97,7 @@
 """
   return report_text
 
-def getDbt2Report(working_dir, dbt2_config_name, run_id, run_date, server_name, bzr_branch, bzr_revision):
+def getDbt2Report(working_dir, bench_config_name, run_id, run_date, server_name, bzr_branch, bzr_revision):
   """Returns a textual report of the regression over a series of runs"""
 
   # Find the revision comment from BZR
@@ -135,7 +135,7 @@
 ORDER BY run_id DESC
 LIMIT 20
 """ % (
-        dbt2_config_name
+        bench_config_name
       , server_name
       , bzr_branch
       , run_id
@@ -189,11 +189,11 @@
   i.connections
 , ROUND(AVG(i.tpm),2) AS tpm
 , IF (AVG(i.tpm) >= agg.avg_tpm
-  , CONCAT('-', ROUND(((AVG(i.tpm) - agg.avg_tpm) / agg.avg_tpm) * 100, 2), '%%')
-  , CONCAT('+', ROUND(((agg.avg_tpm- AVG(i.tpm)) / agg.avg_tpm) * 100, 2), '%%')
+  , CONCAT('+', ROUND(((AVG(i.tpm) - agg.avg_tpm) / agg.avg_tpm) * 100, 2), '%%')
+  , CONCAT('-', ROUND(((agg.avg_tpm- AVG(i.tpm)) / agg.avg_tpm) * 100, 2), '%%')
   ) as pct_diff_from_avg
-, ROUND((agg.avg_tpm- AVG(i.tpm)), 2) AS diff_from_avg
-, IF(ABS(agg.avg_tpm- AVG(i.tpm)) <= agg.stddev_tpm
+, ROUND((AVG(i.tpm) - agg.avg_tpm), 2) AS diff_from_avg
+, IF(ABS(AVG(i.tpm) - agg.avg_tpm) <= agg.stddev_tpm
   , 'within norms'
   , 'outside norms'
   ) as is_normal
@@ -224,7 +224,7 @@
 GROUP BY i.connections
 ORDER BY i.connections
       """ % (
-        dbt2_config_name
+        bench_config_name
       , server_name
       , bzr_branch
       , run_id

=== modified file 'drizzle/automation/reports/drizzleslap.py'
--- drizzle/automation/reports/drizzleslap.py	2009-12-08 19:39:50 +0000
+++ drizzle/automation/reports/drizzleslap.py	2010-01-11 06:21:15 +0000
@@ -99,7 +99,7 @@
 
   return report_text
 
-def getDrizzleslapReport(working_dir, drizzleslap_config_name, run_id, run_date, server_name, bzr_branch, bzr_revision):
+def getDrizzleslapReport(working_dir, bench_config_name, run_id, run_date, server_name, bzr_branch, bzr_revision):
   """Returns a textual report of the results over a series of runs"""
 
   # Find the revision comment from BZR
@@ -139,7 +139,7 @@
 ORDER BY run_id DESC
 LIMIT 20
 """ % (
-        drizzleslap_config_name
+        bench_config_name
       , server_name
       , bzr_branch
       , run_id
@@ -228,7 +228,7 @@
 GROUP BY i.engine_name, i.test_name, i.concurrency
 ORDER BY i.engine_name, i.test_name, i.concurrency
       """ % (
-        drizzleslap_config_name
+        bench_config_name
       , server_name
       , bzr_branch
       , run_id

=== modified file 'drizzle/automation/reports/run.py'
--- drizzle/automation/reports/run.py	2009-12-22 21:04:47 +0000
+++ drizzle/automation/reports/run.py	2010-01-11 06:21:15 +0000
@@ -59,13 +59,12 @@
     logging.error("The report option requires the --bzr-revision, --bzr-branch CLI options to be supplied. Exiting.")
     return False
 
-  if report_name == 'sysbench':
-    # For sysbench We need a config file, a server, a revision, and a branch
-    try:
-      sysbench_config= variables['sysbench_config']
-    except KeyError:
-      logging.error("The sysbench report requires the --sysbench-config, --bzr-revision, --bzr-branch CLI options to be supplied. Exiting.")
-      return False
+  # For reports, we need a config file, a server, a revision, and a branch
+  try:
+    bench_config_name= variables['bench_config_name']
+  except KeyError:
+    logging.error("The %s report requires the --bench-config-name, --bzr-revision, --bzr-branch CLI options to be supplied. Exiting." % report_name)
+    return False
 
   try:
     server_name= variables['server']
@@ -74,62 +73,62 @@
 
   if report_name == 'sysbench':
     import drizzle.automation.reports.sysbench as reports
-    run_id= util.getLastRunId(variables['sysbench_config'], server_name, variables['bzr_branch'], int(variables['bzr_revision']))
+    run_id= util.getLastRunId(bench_config_name, server_name, variables['bzr_branch'], int(variables['bzr_revision']))
     if run_id is None:
       logging.error("Could not find the last run ID for config %s, server %s, branch %s at revision %s. Exiting."
          % (
-              sysbench_config_name
+              bench_config_name
             , server_name
             , variables['bzr_branch']
             , variables['bzr_revision']
            ))
       sys.exit(1)
-    report_text= reports.getSysbenchRegressionReportForRunId(run_id, sysbench_config, server_name, variables['bzr_branch'], int(variables['bzr_revision']))
+    report_text= reports.getSysbenchRegressionReportForRunId(run_id, bench_config_name, server_name, variables['bzr_branch'], int(variables['bzr_revision']))
     email_or_display_report(variables['with_email_report'], variables['sysbench']['report_email'], 'SYSBENCH', report_text, bzr_revision, run_id)
 
   elif report_name == 'sqlbench':
     import drizzle.automation.reports.sqlbench as reports
-    run_id= util.getLastRunId(variables['sqlbench']['sqlbench_config_name'], server_name, variables['bzr_branch'], int(variables['bzr_revision']))
+    run_id= util.getLastRunId(bench_config_name, server_name, variables['bzr_branch'], int(variables['bzr_revision']))
     if run_id is None:
       logging.error("Could not find the last run ID for config %s, server %s, branch %s at revision %s. Exiting."
          % (
-              variables['sqlbench']['sqlbench_config_name']
+              bench_config_name
             , server_name
             , variables['bzr_branch']
             , variables['bzr_revision']
            ))
       sys.exit(1)
-    report_text= reports.getSqlbenchReport(None, variables['sqlbench']['sqlbench_config_name'], run_id, 'N/A', server_name, variables['bzr_branch'], int(variables['bzr_revision']), variables['engine'])
+    report_text= reports.getSqlbenchReport(None, bench_config_name, run_id, 'N/A', server_name, variables['bzr_branch'], int(variables['bzr_revision']), variables['engine'])
     email_or_display_report(variables['with_email_report'], variables['sqlbench']['report_email'], 'SQLBENCH', report_text, bzr_revision, run_id)
 
   elif report_name == 'drizzleslap':
     import drizzle.automation.reports.drizzleslap as reports
-    run_id= util.getLastRunId(variables['drizzleslap']['drizzleslap_config_name'], server_name, variables['bzr_branch'], int(variables['bzr_revision']))
+    run_id= util.getLastRunId(bench_config_name, server_name, variables['bzr_branch'], int(variables['bzr_revision']))
     if run_id is None:
       logging.error("Could not find the last run ID for config %s, server %s, branch %s at revision %s. Exiting."
          % (
-              variables['drizzleslap']['drizzleslap_config_name']
+              bench_config_name
             , server_name
             , variables['bzr_branch']
             , variables['bzr_revision']
            ))
       sys.exit(1)
-    report_text= reports.getDrizzleslapReport(None, variables['drizzleslap']['drizzleslap_config_name'], run_id, 'N/A', server_name, variables['bzr_branch'], int(variables['bzr_revision']))
+    report_text= reports.getDrizzleslapReport(None, bench_config_name, run_id, 'N/A', server_name, variables['bzr_branch'], int(variables['bzr_revision']))
     email_or_display_report(variables['with_email_report'], variables['drizzleslap']['report_email'], 'DRIZZLESLAP', report_text, bzr_revision, run_id)
 
   elif report_name == 'dbt2':
     import drizzle.automation.reports.dbt2 as reports
-    run_id= util.getLastRunId(variables['dbt2']['dbt2_config_name'], server_name, variables['bzr_branch'], int(variables['bzr_revision']))
+    run_id= util.getLastRunId(bench_config_name, server_name, variables['bzr_branch'], int(variables['bzr_revision']))
     if run_id is None:
       logging.error("Could not find the last run ID for config %s, server %s, branch %s at revision %s. Exiting."
          % (
-              variables['dbt2']['dbt2_config_name']
+              bench_config_name
             , server_name
             , variables['bzr_branch']
             , variables['bzr_revision']
            ))
       sys.exit(1)
-    report_text= reports.getDbt2Report(None, variables['dbt2']['dbt2_config_name'], run_id, 'N/A', server_name, variables['bzr_branch'], int(variables['bzr_revision']))
+    report_text= reports.getDbt2Report(None, bench_config_name, run_id, 'N/A', server_name, variables['bzr_branch'], int(variables['bzr_revision']))
     email_or_display_report(variables['with_email_report'], variables['dbt2']['report_email'], 'DBT2', report_text, bzr_revision, run_id)
 
   else: 

=== modified file 'drizzle/automation/reports/sqlbench.py'
--- drizzle/automation/reports/sqlbench.py	2009-12-22 21:04:47 +0000
+++ drizzle/automation/reports/sqlbench.py	2010-01-11 06:21:15 +0000
@@ -98,7 +98,7 @@
 """
   return report_text
 
-def getSqlbenchReport(working_dir, sqlbench_config_name, run_id, run_date, server_name, bzr_branch, bzr_revision, storage_engine):
+def getSqlbenchReport(working_dir, bench_config_name, run_id, run_date, server_name, bzr_branch, bzr_revision, storage_engine):
   """Returns a textual report of the regression over a series of runs"""
 
   # Find the revision comment from BZR
@@ -136,7 +136,7 @@
 ORDER BY run_id DESC
 LIMIT 20
 """ % (
-        sqlbench_config_name
+        bench_config_name
       , server_name
       , bzr_branch
       , run_id
@@ -228,7 +228,7 @@
 GROUP BY i.engine, i.operation_name
 ORDER BY i.engine, i.operation_name
       """ % (
-        sqlbench_config_name
+        bench_config_name
       , server_name
       , bzr_branch
       , run_id

=== modified file 'drizzle/automation/reports/sysbench.py'
--- drizzle/automation/reports/sysbench.py	2009-11-23 19:16:20 +0000
+++ drizzle/automation/reports/sysbench.py	2010-01-11 06:21:15 +0000
@@ -30,7 +30,7 @@
 import socket
 import commands
 
-def get5and20RevisionRanges(sysbench_config, server_name, bzr_branch, run_id):
+def get5and20RevisionRanges(bench_config_name, server_name, bzr_branch, run_id):
   """Return a tuple with 2 ranges of run_id values for the last 5 and 20 runs"""
   sql= """
 SELECT 
@@ -44,7 +44,7 @@
 ORDER BY run_id DESC
 LIMIT 20
 """ % (
-        sysbench_config
+        bench_config_name
       , server_name
       , bzr_branch
       , run_id
@@ -105,7 +105,7 @@
       )
   return db.get_select(sql)
 
-def getAllRegressionForBranchAndConfig(sysbench_config, server_name, bzr_branch, run_id):
+def getAllRegressionForBranchAndConfig(bench_config_name, server_name, bzr_branch, run_id):
   sql= """
 SELECT 
   i.concurrency
@@ -146,7 +146,7 @@
 GROUP BY i.concurrency
 ORDER BY i.concurrency
       """ % (
-        sysbench_config
+        bench_config_name
       , server_name
       , bzr_branch
       , run_id
@@ -154,10 +154,10 @@
 
   return db.get_select(sql)
 
-def getSysbenchRegressionReportForRunId(run_id, sysbench_config, server_name, bzr_branch, bzr_revision):
+def getSysbenchRegressionReportForRunId(run_id, bench_config_name, server_name, bzr_branch, bzr_revision):
   """Returns a textual report of the regression over a series of runs given a supplied run ID"""
   
-  (last_5_revs, last_20_revs)= get5and20RevisionRanges(sysbench_config, server_name, bzr_branch, run_id)
+  (last_5_revs, last_20_revs)= get5and20RevisionRanges(bench_config_name, server_name, bzr_branch, run_id)
   
   report_text= """=========================================================================================================
 REGRESSION REPORT
@@ -175,7 +175,7 @@
 """ % (
     socket.gethostname()
   , run_id
-  , sysbench_config
+  , bench_config_name
   , server_name
   , bzr_branch
   , int(bzr_revision)
@@ -214,14 +214,14 @@
 =========================================================================================================
 """
 
-  results= getAllRegressionForBranchAndConfig(sysbench_config, server_name, bzr_branch, run_id)
+  results= getAllRegressionForBranchAndConfig(bench_config_name, server_name, bzr_branch, run_id)
   for result in results:
     report_text= report_text + "%-6s %9s %15s %10s %14s %10s %10s %10s %10s\n" % tuple(result)
   report_text= report_text + "========================================================================================================="
 
   return report_text
 
-def getSysbenchRegressionReport(working_dir, sysbench_config, run_id, run_date, server_name, bzr_branch, bzr_revision):
+def getSysbenchRegressionReport(working_dir, bench_config_name, run_id, run_date, server_name, bzr_branch, bzr_revision):
   """Returns a textual report of the regression over a series of runs"""
 
   # Find the revision comment from BZR
@@ -243,7 +243,7 @@
   else:
     full_commentary= None
   
-  (last_5_revs, last_20_revs)= get5and20RevisionRanges(sysbench_config, server_name, bzr_branch, run_id)
+  (last_5_revs, last_20_revs)= get5and20RevisionRanges(bench_config_name, server_name, bzr_branch, run_id)
   
   report_text= """=========================================================================================================
 REGRESSION REPORT
@@ -263,7 +263,7 @@
     socket.gethostname()
   , run_id
   , run_date
-  , sysbench_config
+  , bench_config_name
   , server_name
   , bzr_branch
   , int(bzr_revision)
@@ -301,7 +301,7 @@
 =========================================================================================================
 """
 
-  results= getAllRegressionForBranchAndConfig(sysbench_config, server_name, bzr_branch, run_id)
+  results= getAllRegressionForBranchAndConfig(bench_config_name, server_name, bzr_branch, run_id)
   for result in results:
     report_text= report_text + "%-6s %9s %15s %10s %14s %10s %10s %10s %10s\n" % tuple(result)
   report_text= report_text + "========================================================================================================="

=== modified file 'drizzle/automation/runner.py'
--- drizzle/automation/runner.py	2009-12-22 21:04:47 +0000
+++ drizzle/automation/runner.py	2010-01-11 06:21:15 +0000
@@ -49,7 +49,7 @@
   If we wanted to run the "sysbench" command against this branch for revisions
   r930 through r932, we could call the drizzle-automation script like so:
 
-  $> drizzle-automation --sysbench-config=some_benchmark_config --bzr-branch=trunk --r930..932 sysbench
+  $> drizzle-automation --bench-config=some_benchmark_config --bzr-branch=trunk --r930..932 sysbench
 
   This would create 3 sandboxes:
 

=== modified file 'drizzle/automation/sqlbench/run.py'
--- drizzle/automation/sqlbench/run.py	2009-12-22 21:04:47 +0000
+++ drizzle/automation/sqlbench/run.py	2010-01-11 06:21:15 +0000
@@ -86,11 +86,8 @@
   working_dir= variables['working_dir']
   run_date= datetime.datetime.now().isoformat()
   server_name= variables['server']
-  # need the location where the sqlbench repository is located
-  sqlbench_home= variables['sqlbench']['sqlbench_home']
-  # the name of the script to run 
-  # sqlbench_config_name is set to "sqlbench" for now
-  sqlbench_config_name= variables['sqlbench']['sqlbench_config_name']
+  # name of the configuration file to use
+  bench_config_name= variables['bench_config_name']
   os.chdir(working_dir)
 
   # For BZR mode, the "version" of the server (used in identifying the 
@@ -160,7 +157,13 @@
     sys.exit(1)
 
   run_id= util.getNextRunId()
-  config_id= util.getConfigId(sqlbench_config_name)
+  config_id= util.getConfigId(bench_config_name)
+
+  # load the configuration file
+  sqlbench_config_variables= util.loadConfigFile("sqlbench", bench_config_name)
+
+  # need the location where the sqlbench repository is located
+  sqlbench_home= sqlbench_config_variables['run']['sqlbench_home']
 
   try:
     storage_engine= variables['engine']
@@ -197,7 +200,7 @@
   # send email report
   if variables['with_email_report'] is True:
     import drizzle.automation.reports.sqlbench as reports
-    email_text= reports.getSqlbenchReport(working_dir, sqlbench_config_name, run_id, run_date, server_name, variables['bzr_branch'], int(variables['bzr_revision']), storage_engine)
+    email_text= reports.getSqlbenchReport(working_dir, bench_config_name, run_id, run_date, server_name, variables['bzr_branch'], int(variables['bzr_revision']), storage_engine)
     logging.info("Sending email...")
     # bug https://bugs.launchpad.net/launchpad/+bug/419562 - need to use registered launchpad name for from
     #from_string= ('%s <[e-mail]>' % socket.gethostname())

=== modified file 'drizzle/automation/sysbench/run.py'
--- drizzle/automation/sysbench/run.py	2009-12-17 17:18:18 +0000
+++ drizzle/automation/sysbench/run.py	2010-01-11 06:21:15 +0000
@@ -59,7 +59,7 @@
         , concurrency
         , variable_name
         , value
-        ) VALUES ('%s', '%s', '%s', %d, %d, '%s', %d)""" % (server_version, sysbench_config, run_date, int(concurrency), name, value)
+        ) VALUES ('%s', '%s', '%s', %d, %d, '%s', %d)""" % (server_version, bench_config_name, run_date, int(concurrency), name, value)
       db.execute_sql(sql)
     except:
       continue
@@ -118,80 +118,35 @@
 
 class Sysbench:
 
-  def __init__(self, config_name, server_name, server_port):
+  def __init__(self, bench_config_name, server_name, server_port):
     self._bench_cmd= "sysbench"
-    self._config_name= config_name
+    self._bench_config_name= bench_config_name
     self._config_id= None
     self._server_name= server_name
     self._server_port= server_port
-    self.loadConfigFile()
-
-  def loadConfigFile(self):
-    """Finds and parses the configuration file for the supplied config name"""
-    # A configuration file containing benchmark program and server
-    # parameters is required.  If the --sysbench-config=NAME is a relative
-    # filename, we search in /etc/drizzle-automation/sysbench/ for a
-    # file called NAME.cnf
-
-    logging.info("Loading sysbench configuration for config name %s." % self._config_name)
-    sysbench_variables= {} # This is what we return to the caller
-
-    locations=[]
-    config_file= self._config_name
-    if not config_file.endswith(".cnf"):
-      config_file= config_file + ".cnf"
-
-    if not config_file.startswith(os.path.sep):
-      # Assume all relative config files are in /etc/drizzle-automation/sysbench/
-      locations.append(os.path.join(os.path.sep, "etc", "drizzle-automation", "sysbench", config_file))
-      locations.append(os.path.expanduser(os.path.join("~", ".drizzle-automation", "sysbench", config_file)))
-    else:
-      locations.append(config_file)
-
-    config_file_found=False
-    for test_config_file in locations:
-      if os.path.exists(test_config_file):
-        config_file_found=True
-    if not config_file_found:
-      logging.error("Specified sysbench configuration file not found: \"%s\". Exiting." % config_file)
-      sys.exit(1)
-
-    import ConfigParser
-    parser= ConfigParser.RawConfigParser()
-    parser.read(locations)
-    for sec in parser.sections():
-      sysbench_variables[sec]= {}
-      for k,v in parser.items(sec):
-        sysbench_variables[sec][k]= v
-
-    self._config_variables= sysbench_variables
-    self.setRunOptions(sysbench_variables['sysbench'])
-
-    if 'build' in sysbench_variables.keys():
-      self.setBuildOptions(sysbench_variables['build'])
-
-  def getConcurrencyLevels(self):
+
+  def getConcurrencyLevels(self, sysbench_config_variables, bench_config_name):
     """Returns a sequence of concurrency levels this sysbench will run"""
     try:
-      concurrency_levels= [int(x) for x in self._config_variables['run']['concurrency'].split(",")]
+      concurrency_levels= [int(x) for x in sysbench_config_variables['run']['concurrency'].split(",")]
       return concurrency_levels
     except KeyError:
-      logging.error("concurrency is required in configuration section [run] for %s. Exiting." % self._config_name)
+      logging.error("concurrency is required in configuration section [run] for %s. Exiting." % bench_config_name)
       sys.exit(1)
 
-  def getIterations(self):
+  def getIterations(self, sysbench_config_variables, bench_config_name):
     """Returns the number of iterations this sysbench will run"""
     try:
-      iterations= int(self._config_variables['run']['iterations'])
+      iterations= int(sysbench_config_variables['run']['iterations'])
       return iterations
     except KeyError:
-      logging.error("iterations is required in configuration section [run] for %s. Exiting." % self._config_name)
+      logging.error("iterations is required in configuration section [run] for %s. Exiting." % bench_config_name)
       sys.exit(1)
 
-  def getServerOptions(self, server_name):
+  def getServerOptions(self, sysbench_config_variables, server_name):
     """Returns a dictionary of server-specific options loaded from sysbench config file"""
-    if server_name in self._config_variables.keys():
-      return self._config_variables[server_name]
+    if server_name in sysbench_config_variables.keys():
+      return sysbench_config_variables[server_name]
     else:
       logging.warning("Did not find any variables in sysbench config file for server section %s" % server_name)
       return {}
@@ -303,7 +258,7 @@
   # we are benchmarking.
 
   working_dir= variables['working_dir']
-  sysbench_config= variables['sysbench_config']
+  bench_config_name= variables['bench_config_name']
   run_date= datetime.datetime.now().isoformat()
 
   server_name= variables['server']
@@ -350,7 +305,13 @@
   client= client_adapter(variables['working_dir'], server.getPort())
 
   # Initialize sysbench runner instance and load config file
-  sysbench= Sysbench(sysbench_config, server_name, server.getPort())
+  sysbench= Sysbench(bench_config_name, server_name, server.getPort())
+
+  sysbench_config_variables= util.loadConfigFile("sysbench", bench_config_name)
+  sysbench.setRunOptions(sysbench_config_variables['sysbench'])
+
+  if 'build' in sysbench_config_variables.keys():
+    sysbench.setBuildOptions(sysbench_config_variables['build'])
 
   # The sysbench configuration file can specify configure and make options
   # which is why we delay building until this point, which is after the 
@@ -364,7 +325,7 @@
     builder.build(variables['force_build'])
   
   # Set the startup options of the server from the sysbench configuration file
-  server.setStartOptions(sysbench.getServerOptions(server_name))
+  server.setStartOptions(sysbench.getServerOptions(sysbench_config_variables, server_name))
 
   server.stopAll()
 
@@ -385,10 +346,10 @@
   # under the profiler now that the database is prepared
   util.get_profile_options(server,variables['profiler'])
 
-  concurrency_levels= sysbench.getConcurrencyLevels()
-  iterations= sysbench.getIterations()
+  concurrency_levels= sysbench.getConcurrencyLevels(sysbench_config_variables, bench_config_name)
+  iterations= sysbench.getIterations(sysbench_config_variables, bench_config_name)
   run_id= util.getNextRunId()
-  config_id= util.getConfigId(sysbench_config)
+  config_id= util.getConfigId(bench_config_name)
 
   # Run the benchmarks for the specified config
   for concurrency in concurrency_levels:
@@ -398,7 +359,7 @@
         logging.warning("Server not running. Re-starting...")
         server.start()
 
-      logging.info("Running sysbench config %s for concurrency at %d - iteration %d." % (sysbench_config, concurrency, iteration))
+      logging.info("Running sysbench config %s for concurrency at %d - iteration %d." % (bench_config_name, concurrency, iteration))
 
       result= sysbench.run(concurrency)
 
@@ -431,7 +392,7 @@
 
   if variables['with_email_report'] is True:
     import drizzle.automation.reports.sysbench as reports
-    email_text= reports.getSysbenchRegressionReport(working_dir, sysbench_config, run_id, run_date, server_name, variables['bzr_branch'], int(variables['bzr_revision']))
+    email_text= reports.getSysbenchRegressionReport(working_dir, bench_config_name, run_id, run_date, server_name, variables['bzr_branch'], int(variables['bzr_revision']))
     # bug https://bugs.launchpad.net/launchpad/+bug/419562 - need to use registered launchpad name for from
     #from_string= ('%s <[e-mail]>' % socket.gethostname())
     from_string= ('%s <[e-mail]>' % socket.gethostname())