use strict;

use warnings;

BEGIN {

# Check that mysql-test-run.pl is started from mysql-test/

unless ( -f "mysql-test-run.pl" )

{

print "**** ERROR **** ",

"You must start mysql-test-run from the mysql-test/ directory\n";

exit(1);

}

# Check that lib exist

unless ( -d "lib/" )

{

print "**** ERROR **** ",

"Could not find the lib/ directory \n";

exit(1);

}

}

BEGIN {

# Check backward compatibility support

# By setting the environment variable MTR_VERSION

# it's possible to use a previous version of

# mysql-test-run.pl

my $version= $ENV{MTR_VERSION} || 2;

if ( $version == 1 )

{

print "=======================================================\n";

print " WARNING: Using mysql-test-run.pl version 1! \n";

print "=======================================================\n";

# Should use exec() here on *nix but this appears not to work on Windows

exit(system($^X, "lib/v1/mysql-test-run.pl", @ARGV) >> 8);

}

elsif ( $version == 2 )

{

# This is the current version, just continue

;

}

else

{

print "ERROR: Version $version of mysql-test-run does not exist!\n";

exit(1);

}

}

use lib "lib";

use Cwd;

use Getopt::Long;

use My::File::Path; # Patched version of File::Path

use File::Basename;

use File::Copy;

use File::Find;

use File::Temp qw/tempdir/;

use File::Spec::Functions qw/splitdir/;

use My::Platform;

use My::SafeProcess;

use My::ConfigFactory;

use My::Options;

use My::Find;

use My::SysInfo;

use My::CoreDump;

use mtr_cases;

use mtr_report;

use mtr_match;

use mtr_unique;

use mtr_results;

use IO::Socket::INET;

use IO::Select;

require "lib/mtr_process.pl";

require "lib/mtr_io.pl";

require "lib/mtr_gcov.pl";

require "lib/mtr_gprof.pl";

require "lib/mtr_misc.pl";

$SIG{INT}= sub { mtr_error("Got ^C signal"); };

our $mysql_version_id;

my $mysql_version_extra;

our $glob_mysql_test_dir;

our $basedir;

our $bindir;

our $path_charsetsdir;

our $path_client_bindir;

our $path_client_libdir;

our $path_language;

our $path_current_testlog;

our $path_testlog;

our $default_vardir;

our $opt_vardir; # Path to use for var/ dir

my $path_vardir_trace; # unix formatted opt_vardir for trace files

my $opt_tmpdir; # Path to use for tmp/ dir

my $opt_tmpdir_pid;

my $opt_start;

my $opt_start_dirty;

my $opt_start_exit;

my $start_only;

my $auth_plugin; # the path to the authentication test plugin

END {

if ( defined $opt_tmpdir_pid and $opt_tmpdir_pid == $$ )

{

if (!$opt_start_exit)

{

# Remove the tempdir this process has created

mtr_verbose("Removing tmpdir $opt_tmpdir");

rmtree($opt_tmpdir);

}

else

{

mtr_warning("tmpdir $opt_tmpdir should be removed after the server has finished");

}

}

}

sub env_or_val($$) { defined $ENV{$_[0]} ? $ENV{$_[0]} : $_[1] }

my $path_config_file; # The generated config file, var/my.cnf

our $opt_vs_config = $ENV{'MTR_VS_CONFIG'};

my $DEFAULT_SUITES= "main,sys_vars,binlog,federated,rpl,innodb,innodb_fts,innodb_zip,perfschema,funcs_1,opt_trace,parts,auth_sec,rds";

my $opt_suites;

our $opt_verbose= 0; # Verbose output, enable with --verbose

our $exe_mysql;

our $exe_mysql_plugin;

our $exe_mysqladmin;

our $exe_mysqltest;

our $exe_libtool;

our $exe_mysql_embedded;

our $opt_big_test= 0;

our @opt_combinations;

our @opt_extra_mysqld_opt;

our @opt_mysqld_envs;

my $opt_stress;

my $opt_compress;

my $opt_ssl;

my $opt_skip_ssl;

my @opt_skip_test_list;

our $opt_ssl_supported;

my $opt_ps_protocol;

my $opt_sp_protocol;

my $opt_cursor_protocol;

my $opt_view_protocol;

my $opt_trace_protocol;

my $opt_explain_protocol;

my $opt_json_explain_protocol;

our $opt_debug;

my $debug_d= "d";

my $opt_debug_common;

our $opt_debug_server;

our @opt_cases; # The test cases names in argv

our $opt_embedded_server;

our $opt_ctest= env_or_val(MTR_UNIT_TESTS => -1);

our $opt_ctest_report;

my $ctest_report;

my %opts_extern;

sub using_extern { return (keys %opts_extern > 0);};

our $opt_fast= 0;

our $opt_force;

our $opt_mem= $ENV{'MTR_MEM'};

our $opt_clean_vardir= $ENV{'MTR_CLEAN_VARDIR'};

our $opt_gcov;

our $opt_gcov_exe= "gcov";

our $opt_gcov_err= "mysql-test-gcov.err";

our $opt_gcov_msg= "mysql-test-gcov.msg";

our $opt_gprof;

our %gprof_dirs;

our $glob_debugger= 0;

our $opt_gdb;

our $opt_client_gdb;

my $opt_boot_gdb;

our $opt_dbx;

our $opt_client_dbx;

my $opt_boot_dbx;

our $opt_ddd;

our $opt_client_ddd;

my $opt_boot_ddd;

our $opt_manual_gdb;

our $opt_manual_lldb;

our $opt_manual_dbx;

our $opt_manual_ddd;

our $opt_manual_debug;

our $opt_debugger;

our $opt_client_debugger;

my $config; # The currently running config

my $current_config_name; # The currently running config file template

our @opt_experimentals;

our $experimental_test_cases= [];

my $baseport;

my $opt_build_thread= $ENV{'MTR_BUILD_THREAD'} || "auto";

my $opt_port_base= $ENV{'MTR_PORT_BASE'} || "auto";

my $build_thread= 0;

my $opt_record;

my $opt_report_features;

our $opt_resfile= $ENV{'MTR_RESULT_FILE'} || 0;

my $opt_skip_core;

our $opt_check_testcases= 1;

my $opt_mark_progress;

my $opt_max_connections;

our $opt_report_times= 0;

my $opt_sleep;

my $opt_testcase_timeout= $ENV{MTR_TESTCASE_TIMEOUT} || 15; # minutes

my $opt_suite_timeout = $ENV{MTR_SUITE_TIMEOUT} || 300; # minutes

my $opt_shutdown_timeout= $ENV{MTR_SHUTDOWN_TIMEOUT} || 10; # seconds

my $opt_start_timeout = $ENV{MTR_START_TIMEOUT} || 180; # seconds

sub suite_timeout { return $opt_suite_timeout * 60; };

my $opt_wait_all;

my $opt_user_args;

my $opt_repeat= 1;

my $opt_retry= 3;

my $opt_retry_failure= env_or_val(MTR_RETRY_FAILURE => 2);

my $opt_reorder= 1;

my $opt_force_restart= 0;

my $opt_strace_client;

my $opt_strace_server;

our $opt_user = "root";

our $opt_valgrind= 0;

my $opt_valgrind_mysqld= 0;

my $opt_valgrind_mysqltest= 0;

my @default_valgrind_args= ("--show-reachable=yes");

my @valgrind_args;

my $opt_valgrind_path;

my $valgrind_reports= 0;

my $opt_callgrind;

my %mysqld_logs;

my $opt_debug_sync_timeout= 600; # Default timeout for WAIT_FOR actions.

sub testcase_timeout ($) {

my ($tinfo)= @_;

if (exists $tinfo->{'case-timeout'}) {

# Return test specific timeout if *longer* that the general timeout

my $test_to= $tinfo->{'case-timeout'};

$test_to*= 10 if $opt_valgrind;

return $test_to * 60 if $test_to > $opt_testcase_timeout;

}

return $opt_testcase_timeout * 60;

}

sub check_timeout ($) { return testcase_timeout($_[0]) / 10; }

our $opt_warnings= 1;

our $ndbcluster_enabled= 0;

my $opt_include_ndbcluster= 0;

my $opt_skip_ndbcluster= 0;

my $exe_ndbd;

my $exe_ndbmtd;

my $exe_ndb_mgmd;

my $exe_ndb_waiter;

my $exe_ndb_mgm;

our $debug_compiled_binaries;

our %mysqld_variables;

my $source_dist= 0;

my $opt_max_save_core= env_or_val(MTR_MAX_SAVE_CORE => 5);

my $opt_max_save_datadir= env_or_val(MTR_MAX_SAVE_DATADIR => 20);

my $opt_max_test_fail= env_or_val(MTR_MAX_TEST_FAIL => 10);

my $opt_parallel= $ENV{MTR_PARALLEL} || 1;

select(STDOUT);

$| = 1; # Automatically flush STDOUT

main();

sub main {

# Default, verbosity on

report_option('verbose', 0);

# This is needed for test log evaluation in "gen-build-status-page"

# in all cases where the calling tool does not log the commands

# directly before it executes them, like "make test-force-pl" in RPM builds.

mtr_report("Logging: $0 ", join(" ", @ARGV));

command_line_setup();

# --help will not reach here, so now it's safe to assume we have binaries

My::SafeProcess::find_bin();

if ( $opt_gcov ) {

gcov_prepare($basedir);

}

if (!$opt_suites) {

$opt_suites= $DEFAULT_SUITES;

}

mtr_report("Using suites: $opt_suites") unless @opt_cases;

init_timers();

mtr_report("Collecting tests...");

my $tests= collect_test_cases($opt_reorder, $opt_suites, \@opt_cases, \@opt_skip_test_list);

mark_time_used('collect');

if ( $opt_report_features ) {

# Put "report features" as the first test to run

my $tinfo = My::Test->new

(

name => 'report_features',

# No result_file => Prints result

path => 'include/report-features.test',

template_path => "include/default_my.cnf",

master_opt => [],

slave_opt => [],

);

unshift(@$tests, $tinfo);

}

initialize_servers();

#######################################################################

my $num_tests= @$tests;

if ( $opt_parallel eq "auto" ) {

# Try to find a suitable value for number of workers

my $sys_info= My::SysInfo->new();

$opt_parallel= $sys_info->num_cpus();

for my $limit (2000, 1500, 1000, 500){

$opt_parallel-- if ($sys_info->min_bogomips() < $limit);

}

my $max_par= $ENV{MTR_MAX_PARALLEL} || 8;

$opt_parallel= $max_par if ($opt_parallel > $max_par);

$opt_parallel= $num_tests if ($opt_parallel > $num_tests);

$opt_parallel= 1 if (IS_WINDOWS and $sys_info->isvm());

$opt_parallel= 1 if ($opt_parallel < 1);

mtr_report("Using parallel: $opt_parallel");

}

$ENV{MTR_PARALLEL} = $opt_parallel;

if ($opt_parallel > 1 && ($opt_start_exit || $opt_stress)) {

mtr_warning("Parallel cannot be used with --start-and-exit or --stress\n" .

"Setting parallel to 1");

$opt_parallel= 1;

}

# Create server socket on any free port

my $server = new IO::Socket::INET

(

LocalAddr => 'localhost',

Proto => 'tcp',

Listen => $opt_parallel,

);

mtr_error("Could not create testcase server port: $!") unless $server;

my $server_port = $server->sockport();

if ($opt_resfile) {

resfile_init("$opt_vardir/mtr-results.txt");

print_global_resfile();

}

# --------------------------------------------------------------------------

# Read definitions from include/plugin.defs

#

read_plugin_defs("include/plugin.defs");

# Also read from any plugin local or suite specific plugin.defs

for (glob "$basedir/plugin/*/tests/mtr/plugin.defs".

" $basedir/internal/plugin/*/tests/mtr/plugin.defs".

" suite/*/plugin.defs") {

read_plugin_defs($_);

}

# Simplify reference to semisync plugins

$ENV{'SEMISYNC_PLUGIN_OPT'}= $ENV{'SEMISYNC_MASTER_PLUGIN_OPT'};

# Create child processes

my %children;

for my $child_num (1..$opt_parallel){

my $child_pid= My::SafeProcess::Base::_safe_fork();

if ($child_pid == 0){

$server= undef; # Close the server port in child

$tests= {}; # Don't need the tests list in child

# Use subdir of var and tmp unless only one worker

if ($opt_parallel > 1) {

set_vardir("$opt_vardir/$child_num");

$opt_tmpdir= "$opt_tmpdir/$child_num";

}

init_timers();

run_worker($server_port, $child_num);

exit(1);

}

$children{$child_pid}= 1;

}

#######################################################################

mtr_report();

mtr_print_thick_line();

mtr_print_header($opt_parallel > 1);

mark_time_used('init');

my $completed= run_test_server($server, $tests, $opt_parallel);

exit(0) if $opt_start_exit;

# Send Ctrl-C to any children still running

kill("INT", keys(%children));

if (!IS_WINDOWS) {

# Wait for children to exit

foreach my $pid (keys %children)

{

my $ret_pid= waitpid($pid, 0);

if ($ret_pid != $pid){

mtr_report("Unknown process $ret_pid exited");

}

else {

delete $children{$ret_pid};

}

}

}

if ( not $completed ) {

mtr_error("Test suite aborted");

}

if ( @$completed != $num_tests){

if ($opt_force){

# All test should have been run, print any that are still in $tests

#foreach my $test ( @$tests ){

# $test->print_test();

#}

}

# Not all tests completed, failure

mtr_report();

mtr_report("Only ", int(@$completed), " of $num_tests completed.");

mtr_error("Not all tests completed");

}

mark_time_used('init');

push @$completed, run_ctest() if $opt_ctest;

if ($opt_valgrind) {

# Create minimalistic "test" for the reporting

my $tinfo = My::Test->new

(

name => 'valgrind_report',

);

# Set dummy worker id to align report with normal tests

$tinfo->{worker} = 0 if $opt_parallel > 1;

if ($valgrind_reports) {

$tinfo->{result}= 'MTR_RES_FAILED';

$tinfo->{comment}= "Valgrind reported failures at shutdown, see above";

$tinfo->{failures}= 1;

} else {

$tinfo->{result}= 'MTR_RES_PASSED';

}

mtr_report_test($tinfo);

push @$completed, $tinfo;

}

mtr_print_line();

if ( $opt_gcov ) {

gcov_collect($bindir, $opt_gcov_exe,

$opt_gcov_msg, $opt_gcov_err);

}

if ($ctest_report) {

print "$ctest_report\n";

mtr_print_line();

}

print_total_times($opt_parallel) if $opt_report_times;

mtr_report_stats("Completed", $completed);

remove_vardir_subs() if $opt_clean_vardir;

exit(0);

}

sub run_test_server ($$$) {

my ($server, $tests, $childs) = @_;

my $num_saved_cores= 0; # Number of core files saved in vardir/log/ so far.

my $num_saved_datadir= 0; # Number of datadirs saved in vardir/log/ so far.

my $num_failed_test= 0; # Number of tests failed so far

# Scheduler variables

my $max_ndb= $ENV{MTR_MAX_NDB} || $childs / 2;

$max_ndb = $childs if $max_ndb > $childs;

$max_ndb = 1 if $max_ndb < 1;

my $num_ndb_tests= 0;

my $completed= [];

my %running;

my $result;

my $exe_mysqld= find_mysqld($basedir) || ""; # Used as hint to CoreDump

my $suite_timeout= start_timer(suite_timeout());

my $s= IO::Select->new();

$s->add($server);

while (1) {

mark_time_used('admin');

my @ready = $s->can_read(1); # Wake up once every second

mark_time_idle();

foreach my $sock (@ready) {

if ($sock == $server) {

# New client connected

my $child= $sock->accept();

mtr_verbose("Client connected");

$s->add($child);

print $child "HELLO\n";

}

else {

my $line= <$sock>;

if (!defined $line) {

# Client disconnected

mtr_verbose("Child closed socket");

$s->remove($sock);

if (--$childs == 0){

return $completed;

}

next;

}

chomp($line);

if ($line eq 'TESTRESULT'){

$result= My::Test::read_test($sock);

# $result->print_test();

# Report test status

mtr_report_test($result);

if ( $result->is_failed() ) {

# Save the workers "savedir" in var/log

my $worker_savedir= $result->{savedir};

my $worker_savename= basename($worker_savedir);

my $savedir= "$opt_vardir/log/$worker_savename";

if ($opt_max_save_datadir > 0 &&

$num_saved_datadir >= $opt_max_save_datadir)

{

mtr_report(" - skipping '$worker_savedir/'");

rmtree($worker_savedir);

}

else {

mtr_report(" - saving '$worker_savedir/' to '$savedir/'");

rename($worker_savedir, $savedir);

# Move any core files from e.g. mysqltest

foreach my $coref (glob("core*"), glob("*.dmp"))

{

mtr_report(" - found '$coref', moving it to '$savedir'");

move($coref, $savedir);

}

if ($opt_max_save_core > 0) {

# Limit number of core files saved

find({ no_chdir => 1,

wanted => sub {

my $core_file= $File::Find::name;

my $core_name= basename($core_file);

# Name beginning with core, not ending in .gz

if (($core_name =~ /^core/ and $core_name !~ /\.gz$/)

or (IS_WINDOWS and $core_name =~ /\.dmp$/)){

# Ending with .dmp

mtr_report(" - found '$core_name'",

"($num_saved_cores/$opt_max_save_core)");

My::CoreDump->show($core_file, $exe_mysqld, $opt_parallel);

if ($num_saved_cores >= $opt_max_save_core) {

mtr_report(" - deleting it, already saved",

"$opt_max_save_core");

unlink("$core_file");

} else {

mtr_compress_file($core_file) unless @opt_cases;

}

++$num_saved_cores;

}

}

},

$savedir);

}

}

resfile_print_test();

$num_saved_datadir++;

$num_failed_test++ unless ($result->{retries} ||

$result->{exp_fail});

if ( !$opt_force ) {

# Test has failed, force is off

push(@$completed, $result);

return $completed unless $result->{'dont_kill_server'};

# Prevent kill of server, to get valgrind report

print $sock "BYE\n";

next;

}

elsif ($opt_max_test_fail > 0 and

$num_failed_test >= $opt_max_test_fail) {

push(@$completed, $result);

mtr_report_stats("Too many failed", $completed, 1);

mtr_report("Too many tests($num_failed_test) failed!",

"Terminating...");

return undef;

}

}

resfile_print_test();

# Retry test run after test failure

my $retries= $result->{retries} || 2;

my $test_has_failed= $result->{failures} || 0;

if ($test_has_failed and $retries <= $opt_retry){

# Test should be run one more time unless it has failed

# too many times already

my $tname= $result->{name};

my $failures= $result->{failures};

if ($opt_retry > 1 and $failures >= $opt_retry_failure){

mtr_report("\nTest $tname has failed $failures times,",

"no more retries!\n");

}

else {

mtr_report("\nRetrying test $tname, ".

"attempt($retries/$opt_retry)...\n");

#saving the log file as filename.failed in case of retry

if ( $result->is_failed() ) {

my $worker_logdir= $result->{savedir};

my $log_file_name=dirname($worker_logdir)."/".$result->{shortname}.".log";

rename $log_file_name,$log_file_name.".failed";

}

delete($result->{result});

$result->{retries}= $retries+1;

$result->write_test($sock, 'TESTCASE');

next;

}

}

# Repeat test $opt_repeat number of times

my $repeat= $result->{repeat} || 1;

# Don't repeat if test was skipped

if ($repeat < $opt_repeat && $result->{'result'} ne 'MTR_RES_SKIPPED')

{

$result->{retries}= 0;

$result->{rep_failures}++ if $result->{failures};

$result->{failures}= 0;

delete($result->{result});

$result->{repeat}= $repeat+1;

$result->write_test($sock, 'TESTCASE');

next;

}

# Remove from list of running

mtr_error("'", $result->{name},"' is not known to be running")

unless delete $running{$result->key()};

# Update scheduler variables

$num_ndb_tests-- if ($result->{ndb_test});

# Save result in completed list

push(@$completed, $result);

}

elsif ($line eq 'START'){

; # Send first test

}

elsif ($line =~ /^SPENT/) {

add_total_times($line);

}

elsif ($line eq 'VALGREP' && $opt_valgrind) {

$valgrind_reports= 1;

}

else {

mtr_error("Unknown response: '$line' from client");

}

# Find next test to schedule

# - Try to use same configuration as worker used last time

# - Limit number of parallel ndb tests

my $next;

my $second_best;

for(my $i= 0; $i <= @$tests; $i++)

{

my $t= $tests->[$i];

last unless defined $t;

if (run_testcase_check_skip_test($t)){

# Move the test to completed list

#mtr_report("skip - Moving test $i to completed");

push(@$completed, splice(@$tests, $i, 1));

# Since the test at pos $i was taken away, next

# test will also be at $i -> redo

redo;

}

# Limit number of parallell NDB tests

if ($t->{ndb_test} and $num_ndb_tests >= $max_ndb){

#mtr_report("Skipping, num ndb is already at max, $num_ndb_tests");

next;

}

# Second best choice is the first that does not fulfill

# any of the above conditions

if (!defined $second_best){

#mtr_report("Setting second_best to $i");

$second_best= $i;

}

# Smart allocation of next test within this thread.

if ($opt_reorder and $opt_parallel > 1 and defined $result)

{

my $wid= $result->{worker};

# Reserved for other thread, try next

next if (defined $t->{reserved} and $t->{reserved} != $wid);

if (! defined $t->{reserved})

{

# Force-restart not relevant when comparing *next* test

$t->{criteria} =~ s/force-restart$/no-restart/;

my $criteria= $t->{criteria};

# Reserve similar tests for this worker, but not too many

my $maxres= (@$tests - $i) / $opt_parallel + 1;

for (my $j= $i+1; $j <= $i + $maxres; $j++)

{

my $tt= $tests->[$j];

last unless defined $tt;

last if $tt->{criteria} ne $criteria;

$tt->{reserved}= $wid;

}

}

}

# At this point we have found next suitable test

$next= splice(@$tests, $i, 1);

last;

}

# Use second best choice if no other test has been found

if (!$next and defined $second_best){

#mtr_report("Take second best choice $second_best");

mtr_error("Internal error, second best too large($second_best)")

if $second_best > $#$tests;

$next= splice(@$tests, $second_best, 1);

delete $next->{reserved};

}

if ($next) {

# We don't need this any more

delete $next->{criteria};

$next->write_test($sock, 'TESTCASE');

$running{$next->key()}= $next;

$num_ndb_tests++ if ($next->{ndb_test});

}

else {

# No more test, tell child to exit

#mtr_report("Saying BYE to child");

print $sock "BYE\n";

}

}

}

# ----------------------------------------------------

# Check if test suite timer expired

# ----------------------------------------------------

if ( has_expired($suite_timeout) )

{

mtr_report_stats("Timeout", $completed, 1);

mtr_report("Test suite timeout! Terminating...");

return undef;

}

}

}

sub run_worker ($) {

my ($server_port, $thread_num)= @_;

$SIG{INT}= sub { exit(1); };

# Connect to server

my $server = new IO::Socket::INET

(

PeerAddr => 'localhost',

PeerPort => $server_port,

Proto => 'tcp'

);

mtr_error("Could not connect to server at port $server_port: $!")

unless $server;

# --------------------------------------------------------------------------

# Set worker name

# --------------------------------------------------------------------------

report_option('name',"worker[$thread_num]");

# --------------------------------------------------------------------------

# Set different ports per thread

# --------------------------------------------------------------------------

set_build_thread_ports($thread_num);

# --------------------------------------------------------------------------

# Turn off verbosity in workers, unless explicitly specified

# --------------------------------------------------------------------------

report_option('verbose', undef) if ($opt_verbose == 0);

environment_setup();

# Read hello from server which it will send when shared

# resources have been setup

my $hello= <$server>;

setup_vardir();

check_running_as_root();

if ( using_extern() ) {

create_config_file_for_extern(%opts_extern);

}

# Ask server for first test

print $server "START\n";

mark_time_used('init');

while (my $line= <$server>){

chomp($line);

if ($line eq 'TESTCASE'){

my $test= My::Test::read_test($server);

#$test->print_test();

# Clear comment and logfile, to avoid

# reusing them from previous test

delete($test->{'comment'});

delete($test->{'logfile'});

# A sanity check. Should this happen often we need to look at it.

if (defined $test->{reserved} && $test->{reserved} != $thread_num) {

my $tres= $test->{reserved};

mtr_warning("Test reserved for w$tres picked up by w$thread_num");

}

$test->{worker} = $thread_num if $opt_parallel > 1;

run_testcase($test);

#$test->{result}= 'MTR_RES_PASSED';

# Send it back, now with results set

#$test->print_test();

$test->write_test($server, 'TESTRESULT');

mark_time_used('restart');

}

elsif ($line eq 'BYE'){

mtr_report("Server said BYE");

stop_all_servers($opt_shutdown_timeout);

mark_time_used('restart');

my $valgrind_reports= 0;

if ($opt_valgrind_mysqld) {

$valgrind_reports= valgrind_exit_reports();

print $server "VALGREP\n" if $valgrind_reports;

}

if ( $opt_gprof ) {

gprof_collect (find_mysqld($basedir), keys %gprof_dirs);

}

mark_time_used('admin');

print_times_used($server, $thread_num);

exit($valgrind_reports);

}

else {

mtr_error("Could not understand server, '$line'");

}

}

stop_all_servers();

exit(1);

}

sub ignore_option {

my ($opt, $value)= @_;

mtr_report("Ignoring option '$opt'");

}

sub set_vardir {

my ($vardir)= @_;

$opt_vardir= $vardir;

$path_vardir_trace= $opt_vardir;

# Chop off any "c:", DBUG likes a unix path ex: c:/src/... => /src/...

$path_vardir_trace=~ s/^\w://;

# Location of my.cnf that all clients use

$path_config_file= "$opt_vardir/my.cnf";

$path_testlog= "$opt_vardir/log/mysqltest.log";

$path_current_testlog= "$opt_vardir/log/current_test";

}

sub print_global_resfile {

resfile_global("start_time", isotime $^T);

resfile_global("user_id", $<);

resfile_global("embedded-server", $opt_embedded_server ? 1 : 0);

resfile_global("ps-protocol", $opt_ps_protocol ? 1 : 0);

resfile_global("sp-protocol", $opt_sp_protocol ? 1 : 0);

resfile_global("view-protocol", $opt_view_protocol ? 1 : 0);

resfile_global("cursor-protocol", $opt_cursor_protocol ? 1 : 0);

resfile_global("ssl", $opt_ssl ? 1 : 0);

resfile_global("compress", $opt_compress ? 1 : 0);

resfile_global("parallel", $opt_parallel);

resfile_global("check-testcases", $opt_check_testcases ? 1 : 0);

resfile_global("mysqld", \@opt_extra_mysqld_opt);

resfile_global("debug", $opt_debug ? 1 : 0);

resfile_global("gcov", $opt_gcov ? 1 : 0);

resfile_global("gprof", $opt_gprof ? 1 : 0);

resfile_global("valgrind", $opt_valgrind ? 1 : 0);

resfile_global("callgrind", $opt_callgrind ? 1 : 0);