~drizzle-trunk/drizzle/development

#! /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])

    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.split(testdir_default)[0]

server_type_default = 'drizzle'

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')

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="dtr"

     , 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"

     )

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]"

  )

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)