mirror of
https://github.com/MariaDB/server.git
synced 2025-01-16 12:02:42 +01:00
3648 lines
99 KiB
Perl
Executable file
3648 lines
99 KiB
Perl
Executable file
#!/usr/bin/perl
|
|
# -*- cperl -*-
|
|
|
|
#
|
|
##############################################################################
|
|
#
|
|
# mysql-test-run.pl
|
|
#
|
|
# Tool used for executing a suite of .test files
|
|
#
|
|
# See the "MySQL Test framework manual" for more information
|
|
# http://dev.mysql.com/doc/mysqltest/en/index.html
|
|
#
|
|
# Please keep the test framework tools identical in all versions!
|
|
#
|
|
##############################################################################
|
|
|
|
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);
|
|
}
|
|
|
|
# Include settings that control how the script behaves
|
|
require "lib/mtr_settings.pl";
|
|
}
|
|
|
|
|
|
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::Temp qw / tempdir /;
|
|
use My::SafeProcess;
|
|
use My::ConfigFactory;
|
|
use mtr_cases;
|
|
|
|
our $is_win32_perl= ($^O eq "MSWin32"); # ActiveState Win32 Perl
|
|
our $is_cygwin= ($^O eq "cygwin"); # Cygwin Perl
|
|
our $is_win32= ($is_win32_perl or $is_cygwin);
|
|
|
|
require "lib/mtr_process.pl";
|
|
require "lib/mtr_io.pl";
|
|
require "lib/mtr_gcov.pl";
|
|
require "lib/mtr_report.pl";
|
|
require "lib/mtr_match.pl";
|
|
require "lib/mtr_misc.pl";
|
|
require "lib/mtr_unique.pl";
|
|
|
|
$SIG{INT}= sub { mtr_error("Got ^C signal"); };
|
|
|
|
our $mysql_version_id;
|
|
our $glob_mysql_test_dir;
|
|
our $basedir;
|
|
|
|
our $path_charsetsdir;
|
|
our $path_client_bindir;
|
|
our $path_language;
|
|
our $path_timefile;
|
|
our $path_current_test_log;
|
|
|
|
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 $path_config_file; # The generated config file, var/my.cnf
|
|
|
|
# Visual Studio produces executables in different sub-directories based on the
|
|
# configuration used to build them. To make life easier, an environment
|
|
# variable or command-line option may be specified to control which set of
|
|
# executables will be used by the test suite.
|
|
our $opt_vs_config = $ENV{'MTR_VS_CONFIG'};
|
|
|
|
our $opt_suites= DEFAULT_SUITES;
|
|
|
|
our $opt_verbose= 0; # Verbose output, enable with --verbose
|
|
|
|
my $exe_mysqld;
|
|
our $exe_mysql;
|
|
our $exe_mysqladmin;
|
|
our $exe_mysqltest;
|
|
our $exe_ndbd;
|
|
our $exe_ndb_mgmd= "";
|
|
our $exe_libtool;
|
|
|
|
our $opt_big_test= 0;
|
|
|
|
our @opt_combinations;
|
|
|
|
our @opt_extra_mysqld_opt;
|
|
|
|
our $opt_compress;
|
|
our $opt_ssl;
|
|
our $opt_skip_ssl;
|
|
our $opt_ssl_supported;
|
|
our $opt_ps_protocol;
|
|
our $opt_sp_protocol;
|
|
our $opt_cursor_protocol;
|
|
our $opt_view_protocol;
|
|
|
|
our $opt_debug;
|
|
our @opt_cases; # The test cases names in argv
|
|
my $opt_embedded_server;
|
|
|
|
# Options used when connecting to an already running server
|
|
my %opts_extern;
|
|
sub using_extern { return (keys %opts_extern > 0);};
|
|
|
|
our $opt_fast= 0;
|
|
our $opt_force;
|
|
our $opt_reorder= 0;
|
|
our $opt_mem= $ENV{'MTR_MEM'};
|
|
|
|
our $opt_gcov;
|
|
our $opt_gcov_err;
|
|
our $opt_gcov_msg;
|
|
|
|
our $glob_debugger= 0;
|
|
our $opt_gdb;
|
|
our $opt_client_gdb;
|
|
our $opt_ddd;
|
|
our $opt_client_ddd;
|
|
our $opt_manual_gdb;
|
|
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
|
|
|
|
my $opt_baseport;
|
|
my $opt_mtr_build_thread= $ENV{'MTR_BUILD_THREAD'} || "auto";
|
|
|
|
my $opt_record;
|
|
my $opt_report_features;
|
|
our $opt_check_testcases;
|
|
my $opt_mark_progress;
|
|
|
|
my $opt_sleep;
|
|
|
|
my $opt_testcase_timeout= 15; # 15 minutes
|
|
my $opt_suite_timeout = 180; # 3 hours
|
|
my $opt_shutdown_timeout= 10; # 10 seconds
|
|
my $opt_start_timeout = 30; # 30 seconds
|
|
|
|
my $opt_start;
|
|
my $opt_start_dirty;
|
|
|
|
my $opt_strace_client;
|
|
|
|
our $opt_timer= 1;
|
|
|
|
our $opt_user;
|
|
|
|
my $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 $opt_callgrind;
|
|
|
|
our $opt_warnings= 1;
|
|
|
|
our $opt_skip_ndbcluster= 0;
|
|
our $opt_skip_ndbcluster_slave= 0;
|
|
our $opt_with_ndbcluster= 0;
|
|
our $glob_ndbcluster_supported= 0;
|
|
our $opt_ndb_extra_test= 0;
|
|
our $opt_skip_master_binlog= 0;
|
|
our $opt_skip_slave_binlog= 0;
|
|
|
|
our $exe_ndb_mgm="";
|
|
our $exe_ndb_waiter;
|
|
our $path_ndb_tools_dir= "";
|
|
our $path_ndb_examples_dir= "";
|
|
our $exe_ndb_example= "";
|
|
our $path_ndb_testrun_log;
|
|
|
|
our $path_sql_dir;
|
|
|
|
our $debug_compiled_binaries;
|
|
|
|
our %mysqld_variables;
|
|
|
|
my $source_dist= 0;
|
|
|
|
our $opt_max_save_core= 5;
|
|
my $num_saved_cores= 0; # Number of core files saved in vardir/log/ so far.
|
|
|
|
select(STDOUT);
|
|
$| = 1; # Automatically flush STDOUT
|
|
|
|
main();
|
|
|
|
sub main {
|
|
|
|
command_line_setup();
|
|
|
|
mtr_report("Checking supported features...");
|
|
|
|
check_ndbcluster_support(\%mysqld_variables);
|
|
check_ssl_support(\%mysqld_variables);
|
|
check_debug_support(\%mysqld_variables);
|
|
|
|
executable_setup();
|
|
|
|
environment_setup();
|
|
|
|
if ( $opt_gcov )
|
|
{
|
|
gcov_prepare();
|
|
}
|
|
|
|
# Figure out which tests we are going to run
|
|
mtr_report("Collecting tests...");
|
|
my $tests= collect_test_cases($opt_suites);
|
|
|
|
initialize_servers();
|
|
|
|
if ( $opt_report_features ) {
|
|
# Put "report features" as the first test to run
|
|
my $tinfo = {};
|
|
$tinfo->{'name'} = 'report_features';
|
|
$tinfo->{'result_file'} = undef; # Prints result
|
|
$tinfo->{'path'} = 'include/report-features.test';
|
|
$tinfo->{'master_opt'} = [];
|
|
$tinfo->{'slave_opt'} = [];
|
|
unshift(@$tests, $tinfo);
|
|
}
|
|
|
|
if ( using_extern() ) {
|
|
create_config_file_for_extern(%opts_extern);
|
|
}
|
|
|
|
run_tests($tests);
|
|
|
|
exit(0);
|
|
}
|
|
|
|
|
|
sub ignore_option {
|
|
my ($opt, $value)= @_;
|
|
print "Ignoring option '$opt'\n";
|
|
}
|
|
|
|
sub command_line_setup {
|
|
my $opt_comment;
|
|
my $opt_usage;
|
|
|
|
# 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));
|
|
|
|
# Read the command line options
|
|
# Note: Keep list, and the order, in sync with usage at end of this file
|
|
Getopt::Long::Configure("pass_through");
|
|
GetOptions(
|
|
# Control what engine/variation to run
|
|
'embedded-server' => \$opt_embedded_server,
|
|
'ps-protocol' => \$opt_ps_protocol,
|
|
'sp-protocol' => \$opt_sp_protocol,
|
|
'view-protocol' => \$opt_view_protocol,
|
|
'cursor-protocol' => \$opt_cursor_protocol,
|
|
'ssl|with-openssl' => \$opt_ssl,
|
|
'skip-ssl' => \$opt_skip_ssl,
|
|
'compress' => \$opt_compress,
|
|
'with-ndbcluster|ndb' => \$opt_with_ndbcluster,
|
|
'vs-config' => \$opt_vs_config,
|
|
|
|
# Config file to use as template for all tests
|
|
'defaults-file=s' => \&collect_option,
|
|
# Extra config file to append to all generated configs
|
|
'defaults-extra-file=s' => \&collect_option,
|
|
|
|
# Control what test suites or cases to run
|
|
'force' => \$opt_force,
|
|
'with-ndbcluster-only' => \&collect_option,
|
|
'skip-ndbcluster|skip-ndb' => \$opt_skip_ndbcluster,
|
|
'skip-ndbcluster-slave|skip-ndb-slave'
|
|
=> \$opt_skip_ndbcluster_slave,
|
|
'ndb-extra-test' => \$opt_ndb_extra_test,
|
|
'skip-master-binlog' => \$opt_skip_master_binlog,
|
|
'skip-slave-binlog' => \$opt_skip_slave_binlog,
|
|
'suite|suites=s' => \$opt_suites,
|
|
'skip-rpl' => \&collect_option,
|
|
'skip-test=s' => \&collect_option,
|
|
'do-test=s' => \&collect_option,
|
|
'start-from=s' => \&collect_option,
|
|
'big-test' => \$opt_big_test,
|
|
'combination=s' => \@opt_combinations,
|
|
'skip-combination' => \&collect_option,
|
|
|
|
'skip-im' => \&ignore_option,
|
|
|
|
# Specify ports
|
|
'build-thread|mtr-build-thread=i' => \$opt_mtr_build_thread,
|
|
|
|
# Test case authoring
|
|
'record' => \$opt_record,
|
|
'check-testcases' => \$opt_check_testcases,
|
|
'mark-progress' => \$opt_mark_progress,
|
|
|
|
# Extra options used when starting mysqld
|
|
'mysqld=s' => \@opt_extra_mysqld_opt,
|
|
|
|
# Run test on running server
|
|
'extern=s' => \%opts_extern, # Append to hash
|
|
|
|
# Debugging
|
|
'debug' => \$opt_debug,
|
|
'gdb' => \$opt_gdb,
|
|
'client-gdb' => \$opt_client_gdb,
|
|
'manual-gdb' => \$opt_manual_gdb,
|
|
'manual-debug' => \$opt_manual_debug,
|
|
'ddd' => \$opt_ddd,
|
|
'client-ddd' => \$opt_client_ddd,
|
|
'manual-ddd' => \$opt_manual_ddd,
|
|
'debugger=s' => \$opt_debugger,
|
|
'client-debugger=s' => \$opt_client_debugger,
|
|
'strace-client:s' => \$opt_strace_client,
|
|
'max-save-core=i' => \$opt_max_save_core,
|
|
|
|
# Coverage, profiling etc
|
|
'gcov' => \$opt_gcov,
|
|
'valgrind|valgrind-all' => \$opt_valgrind,
|
|
'valgrind-mysqltest' => \$opt_valgrind_mysqltest,
|
|
'valgrind-mysqld' => \$opt_valgrind_mysqld,
|
|
'valgrind-options=s' => sub {
|
|
my ($opt, $value)= @_;
|
|
# Deprecated option unless it's what we know pushbuild uses
|
|
if ($value eq "--gen-suppressions=all --show-reachable=yes") {
|
|
push(@valgrind_args, $_) for (split(' ', $value));
|
|
return;
|
|
}
|
|
die("--valgrind-options=s is deprecated. Use ",
|
|
"--valgrind-option=s, to be specified several",
|
|
" times if necessary");
|
|
},
|
|
'valgrind-option=s' => \@valgrind_args,
|
|
'valgrind-path=s' => \$opt_valgrind_path,
|
|
'callgrind' => \$opt_callgrind,
|
|
|
|
# Directories
|
|
'tmpdir=s' => \$opt_tmpdir,
|
|
'vardir=s' => \$opt_vardir,
|
|
'mem' => \$opt_mem,
|
|
|
|
# Misc
|
|
'report-features' => \$opt_report_features,
|
|
'comment=s' => \$opt_comment,
|
|
'fast' => \$opt_fast,
|
|
'reorder' => \$opt_reorder,
|
|
'enable-disabled' => \&collect_option,
|
|
'verbose+' => \$opt_verbose,
|
|
'sleep=i' => \$opt_sleep,
|
|
'start-dirty' => \$opt_start_dirty,
|
|
'start' => \$opt_start,
|
|
'print-testcases' => \&collect_option,
|
|
# TODO 'repeat'
|
|
# TODO 'retry'
|
|
'timer!' => \$opt_timer,
|
|
'user=s' => \$opt_user,
|
|
'testcase-timeout=i' => \$opt_testcase_timeout,
|
|
'suite-timeout=i' => \$opt_suite_timeout,
|
|
'shutdown-timeout=i' => \$opt_shutdown_timeout,
|
|
'warnings!' => \$opt_warnings,
|
|
|
|
'help|h' => \$opt_usage,
|
|
) or usage("Can't read options");
|
|
|
|
usage("") if $opt_usage;
|
|
|
|
if ( -d "../sql" )
|
|
{
|
|
$source_dist= 1;
|
|
}
|
|
|
|
# Find the absolute path to the test directory
|
|
$glob_mysql_test_dir= cwd();
|
|
if ( $is_cygwin )
|
|
{
|
|
# Windows programs like 'mysqld' needs Windows paths
|
|
$glob_mysql_test_dir= `cygpath -m "$glob_mysql_test_dir"`;
|
|
chomp($glob_mysql_test_dir);
|
|
}
|
|
|
|
# In most cases, the base directory we find everything relative to,
|
|
# is the parent directory of the "mysql-test" directory. For source
|
|
# distributions, TAR binary distributions and some other packages.
|
|
$basedir= dirname($glob_mysql_test_dir);
|
|
|
|
# In the RPM case, binaries and libraries are installed in the
|
|
# default system locations, instead of having our own private base
|
|
# directory. And we install "/usr/share/mysql-test". Moving up one
|
|
# more directory relative to "mysql-test" gives us a usable base
|
|
# directory for RPM installs.
|
|
if ( ! $source_dist and ! -d "$basedir/bin" )
|
|
{
|
|
$basedir= dirname($basedir);
|
|
}
|
|
|
|
# --------------------------------------------------------------------------
|
|
# Check mtr_build_thread and calculate baseport
|
|
# --------------------------------------------------------------------------
|
|
set_mtr_build_thread_ports($opt_mtr_build_thread);
|
|
|
|
#
|
|
# Find the mysqld executable to be able to find the mysqld version
|
|
# number as early as possible
|
|
#
|
|
|
|
# Look for the client binaries directory
|
|
$path_client_bindir= mtr_path_exists("$basedir/client_release",
|
|
"$basedir/client_debug",
|
|
vs_config_dirs('client', ''),
|
|
"$basedir/client",
|
|
"$basedir/bin");
|
|
|
|
# Look for language files and charsetsdir, use same share
|
|
my $path_share= mtr_path_exists("$basedir/share/mysql",
|
|
"$basedir/sql/share",
|
|
"$basedir/share");
|
|
|
|
$path_language= mtr_path_exists("$path_share/english");
|
|
$path_charsetsdir= mtr_path_exists("$path_share/charsets");
|
|
|
|
# Look for SQL scripts directory
|
|
if ( mtr_file_exists("$path_share/mysql_system_tables.sql") ne "")
|
|
{
|
|
# The SQL scripts are in path_share
|
|
$path_sql_dir= $path_share;
|
|
}
|
|
else
|
|
{
|
|
$path_sql_dir= mtr_path_exists("$basedir/share",
|
|
"$basedir/scripts");
|
|
}
|
|
|
|
$exe_mysqld= mtr_exe_exists (vs_config_dirs('sql', 'mysqld'),
|
|
vs_config_dirs('sql', 'mysqld-debug'),
|
|
"$basedir/sql/mysqld",
|
|
"$path_client_bindir/mysqld-max-nt",
|
|
"$path_client_bindir/mysqld-max",
|
|
"$path_client_bindir/mysqld-nt",
|
|
"$path_client_bindir/mysqld",
|
|
"$path_client_bindir/mysqld-debug",
|
|
"$path_client_bindir/mysqld-max",
|
|
"$basedir/libexec/mysqld",
|
|
"$basedir/bin/mysqld",
|
|
"$basedir/sbin/mysqld");
|
|
|
|
# Use the mysqld found above to find out what features are available
|
|
collect_mysqld_features();
|
|
|
|
if ( $opt_comment )
|
|
{
|
|
mtr_report();
|
|
mtr_print_thick_line('#');
|
|
mtr_report("# $opt_comment");
|
|
mtr_print_thick_line('#');
|
|
}
|
|
|
|
foreach my $arg ( @ARGV )
|
|
{
|
|
if ( $arg =~ /^--skip-/ )
|
|
{
|
|
push(@opt_extra_mysqld_opt, $arg);
|
|
}
|
|
elsif ( $arg =~ /^--$/ )
|
|
{
|
|
# It is an effect of setting 'pass_through' in option processing
|
|
# that the lone '--' separating options from arguments survives,
|
|
# simply ignore it.
|
|
}
|
|
elsif ( $arg =~ /^-/ )
|
|
{
|
|
usage("Invalid option \"$arg\"");
|
|
}
|
|
else
|
|
{
|
|
push(@opt_cases, $arg);
|
|
}
|
|
}
|
|
|
|
# --------------------------------------------------------------------------
|
|
# Find out type of logging that are being used
|
|
# --------------------------------------------------------------------------
|
|
foreach my $arg ( @opt_extra_mysqld_opt )
|
|
{
|
|
if ( $arg =~ /binlog[-_]format=(\S+)/ )
|
|
{
|
|
# Save this for collect phase
|
|
collect_option('binlog-format', $1);
|
|
mtr_report("Using binlog format '$1'");
|
|
}
|
|
}
|
|
|
|
|
|
# --------------------------------------------------------------------------
|
|
# Find out default storage engine being used(if any)
|
|
# --------------------------------------------------------------------------
|
|
foreach my $arg ( @opt_extra_mysqld_opt )
|
|
{
|
|
if ( $arg =~ /default-storage-engine=(\S+)/ )
|
|
{
|
|
# Save this for collect phase
|
|
collect_option('default-storage-engine', $1);
|
|
mtr_report("Using default engine '$1'")
|
|
}
|
|
}
|
|
|
|
# --------------------------------------------------------------------------
|
|
# Check if we should speed up tests by trying to run on tmpfs
|
|
# --------------------------------------------------------------------------
|
|
if ( defined $opt_mem )
|
|
{
|
|
mtr_error("Can't use --mem and --vardir at the same time ")
|
|
if $opt_vardir;
|
|
mtr_error("Can't use --mem and --tmpdir at the same time ")
|
|
if $opt_tmpdir;
|
|
|
|
# Search through list of locations that are known
|
|
# to be "fast disks" to list to find a suitable location
|
|
# Use --mem=<dir> as first location to look.
|
|
my @tmpfs_locations= ($opt_mem, "/dev/shm", "/tmp");
|
|
|
|
foreach my $fs (@tmpfs_locations)
|
|
{
|
|
if ( -d $fs )
|
|
{
|
|
$opt_mem= "$fs/var";
|
|
$opt_mem .= $opt_mtr_build_thread if $opt_mtr_build_thread;
|
|
last;
|
|
}
|
|
}
|
|
}
|
|
|
|
# --------------------------------------------------------------------------
|
|
# Set the "var/" directory, as it is the base for everything else
|
|
# --------------------------------------------------------------------------
|
|
$default_vardir= "$glob_mysql_test_dir/var";
|
|
if ( ! $opt_vardir )
|
|
{
|
|
$opt_vardir= $default_vardir;
|
|
}
|
|
elsif ( $mysql_version_id < 50000 and
|
|
$opt_vardir ne $default_vardir)
|
|
{
|
|
# Version 4.1 and --vardir was specified
|
|
# Only supported as a symlink from var/
|
|
# by setting up $opt_mem that symlink will be created
|
|
if ( ! $is_win32 )
|
|
{
|
|
# Only platforms that have native symlinks can use the vardir trick
|
|
$opt_mem= $opt_vardir;
|
|
mtr_report("Using 4.1 vardir trick");
|
|
}
|
|
|
|
$opt_vardir= $default_vardir;
|
|
}
|
|
|
|
$path_vardir_trace= $opt_vardir;
|
|
# Chop off any "c:", DBUG likes a unix path ex: c:/src/... => /src/...
|
|
$path_vardir_trace=~ s/^\w://;
|
|
|
|
# We make the path absolute, as the server will do a chdir() before usage
|
|
unless ( $opt_vardir =~ m,^/, or
|
|
($is_win32 and $opt_vardir =~ m,^[a-z]:/,i) )
|
|
{
|
|
# Make absolute path, relative test dir
|
|
$opt_vardir= "$glob_mysql_test_dir/$opt_vardir";
|
|
}
|
|
|
|
# Location of my.cnf that all clients use
|
|
$path_config_file= "$opt_vardir/my.cnf";
|
|
|
|
# --------------------------------------------------------------------------
|
|
# Set tmpdir
|
|
# --------------------------------------------------------------------------
|
|
$opt_tmpdir= "$opt_vardir/tmp" unless $opt_tmpdir;
|
|
$opt_tmpdir =~ s,/+$,,; # Remove ending slash if any
|
|
|
|
# --------------------------------------------------------------------------
|
|
# fast option
|
|
# --------------------------------------------------------------------------
|
|
if ($opt_fast){
|
|
$opt_shutdown_timeout= 0; # Kill processes instead of nice shutdown
|
|
}
|
|
|
|
# --------------------------------------------------------------------------
|
|
# Record flag
|
|
# --------------------------------------------------------------------------
|
|
if ( $opt_record and ! @opt_cases )
|
|
{
|
|
mtr_error("Will not run in record mode without a specific test case");
|
|
}
|
|
|
|
# --------------------------------------------------------------------------
|
|
# Embedded server flag
|
|
# --------------------------------------------------------------------------
|
|
if ( $opt_embedded_server )
|
|
{
|
|
$opt_embedded_server= 1;
|
|
if ( $is_win32 )
|
|
{
|
|
# Add the location for libmysqld.dll to the path.
|
|
my $separator= ";";
|
|
my $lib_mysqld=
|
|
mtr_path_exists(vs_config_dirs('libmysqld',''));
|
|
if ( $is_cygwin )
|
|
{
|
|
$lib_mysqld= `cygpath "$lib_mysqld"`;
|
|
chomp($lib_mysqld);
|
|
$separator= ":";
|
|
}
|
|
$ENV{'PATH'}= "$ENV{'PATH'}".$separator.$lib_mysqld;
|
|
}
|
|
$opt_skip_ndbcluster= 1; # Turn off use of NDB cluster
|
|
$opt_skip_ssl= 1; # Turn off use of SSL
|
|
|
|
# Turn off use of bin log
|
|
push(@opt_extra_mysqld_opt, "--skip-log-bin");
|
|
|
|
if ( using_extern() )
|
|
{
|
|
mtr_error("Can't use --extern with --embedded-server");
|
|
}
|
|
}
|
|
|
|
# --------------------------------------------------------------------------
|
|
# Big test flags
|
|
# --------------------------------------------------------------------------
|
|
if ( $opt_big_test )
|
|
{
|
|
$ENV{'BIG_TEST'}= 1;
|
|
}
|
|
|
|
# --------------------------------------------------------------------------
|
|
# Gcov flag
|
|
# --------------------------------------------------------------------------
|
|
if ( $opt_gcov and ! $source_dist )
|
|
{
|
|
mtr_error("Coverage test needs the source - please use source dist");
|
|
}
|
|
|
|
# --------------------------------------------------------------------------
|
|
# Check debug related options
|
|
# --------------------------------------------------------------------------
|
|
if ( $opt_gdb || $opt_client_gdb || $opt_ddd || $opt_client_ddd ||
|
|
$opt_manual_gdb || $opt_manual_ddd || $opt_manual_debug ||
|
|
$opt_debugger || $opt_client_debugger )
|
|
{
|
|
# Indicate that we are using debugger
|
|
$glob_debugger= 1;
|
|
if ( using_extern() )
|
|
{
|
|
mtr_error("Can't use --extern when using debugger");
|
|
}
|
|
}
|
|
|
|
# --------------------------------------------------------------------------
|
|
# Check valgrind arguments
|
|
# --------------------------------------------------------------------------
|
|
if ( $opt_valgrind or $opt_valgrind_path or @valgrind_args)
|
|
{
|
|
mtr_report("Turning on valgrind for all executables");
|
|
$opt_valgrind= 1;
|
|
$opt_valgrind_mysqld= 1;
|
|
$opt_valgrind_mysqltest= 1;
|
|
|
|
# Increase the timeouts when running with valgrind
|
|
$opt_testcase_timeout*= 10;
|
|
$opt_suite_timeout*= 6;
|
|
$opt_start_timeout*= 10;
|
|
|
|
}
|
|
elsif ( $opt_valgrind_mysqld )
|
|
{
|
|
mtr_report("Turning on valgrind for mysqld(s) only");
|
|
$opt_valgrind= 1;
|
|
}
|
|
elsif ( $opt_valgrind_mysqltest )
|
|
{
|
|
mtr_report("Turning on valgrind for mysqltest and mysql_client_test only");
|
|
$opt_valgrind= 1;
|
|
}
|
|
|
|
if ( $opt_callgrind )
|
|
{
|
|
mtr_report("Turning on valgrind with callgrind for mysqld(s)");
|
|
$opt_valgrind= 1;
|
|
$opt_valgrind_mysqld= 1;
|
|
|
|
# Set special valgrind options unless options passed on command line
|
|
push(@valgrind_args, "--trace-children=yes")
|
|
unless @valgrind_args;
|
|
}
|
|
|
|
if ( $opt_valgrind )
|
|
{
|
|
# Set valgrind_options to default unless already defined
|
|
push(@valgrind_args, @default_valgrind_args)
|
|
unless @valgrind_args;
|
|
|
|
mtr_report("Running valgrind with options \"",
|
|
join(" ", @valgrind_args), "\"");
|
|
}
|
|
|
|
if ( ! $opt_user )
|
|
{
|
|
$opt_user= "root"; # We want to do FLUSH xxx commands
|
|
}
|
|
|
|
# On QNX, /tmp/dir/master.sock and /tmp/dir//master.sock seem to be
|
|
# considered different, so avoid the extra slash (/) in the socket
|
|
# paths.
|
|
my $sockdir = $opt_tmpdir;
|
|
$sockdir =~ s|/+$||;
|
|
|
|
# On some operating systems, there is a limit to the length of a
|
|
# UNIX domain socket's path far below PATH_MAX, so try to avoid long
|
|
# socket path names.
|
|
$sockdir = tempdir(CLEANUP => 0) if ( length($sockdir) >= 70 );
|
|
|
|
$path_timefile= "$opt_vardir/log/mysqltest-time";
|
|
$path_current_test_log= "$opt_vardir/log/current_test";
|
|
$path_ndb_testrun_log= "$opt_vardir/log/ndb_testrun.log";
|
|
|
|
}
|
|
|
|
|
|
#
|
|
# To make it easier for different devs to work on the same host,
|
|
# an environment variable can be used to control all ports. A small
|
|
# number is to be used, 0 - 16 or similar.
|
|
#
|
|
# Note the MASTER_MYPORT has to be set the same in all 4.x and 5.x
|
|
# versions of this script, else a 4.0 test run might conflict with a
|
|
# 5.1 test run, even if different MTR_BUILD_THREAD is used. This means
|
|
# all port numbers might not be used in this version of the script.
|
|
#
|
|
# Also note the limitation of ports we are allowed to hand out. This
|
|
# differs between operating systems and configuration, see
|
|
# http://www.ncftp.com/ncftpd/doc/misc/ephemeral_ports.html
|
|
# But a fairly safe range seems to be 5001 - 32767
|
|
#
|
|
sub set_mtr_build_thread_ports($) {
|
|
my $mtr_build_thread= shift || 0;
|
|
|
|
if ( lc($mtr_build_thread) eq 'auto' ) {
|
|
print "Requesting build thread... ";
|
|
$mtr_build_thread=
|
|
mtr_require_unique_id_and_wait("/tmp/mysql-test-ports", 200, 299);
|
|
print "got ".$mtr_build_thread."\n";
|
|
}
|
|
$opt_mtr_build_thread= $mtr_build_thread;
|
|
$ENV{MTR_BUILD_THREAD}= $mtr_build_thread;
|
|
|
|
# Calculate baseport
|
|
$opt_baseport= $mtr_build_thread * 10 + 10000;
|
|
if ( $opt_baseport < 5001 or $opt_baseport + 9 >= 32767 )
|
|
{
|
|
mtr_error("MTR_BUILD_THREAD number results in a port",
|
|
"outside 5001 - 32767",
|
|
"($opt_baseport - $opt_baseport + 9)");
|
|
}
|
|
|
|
mtr_report("Using MR_BUILD_THREAD $opt_mtr_build_thread,",
|
|
"with reserved ports $opt_baseport..".($opt_baseport+9));
|
|
|
|
}
|
|
|
|
|
|
sub collect_mysqld_features {
|
|
my $found_variable_list_start= 0;
|
|
my $tmpdir= tempdir(CLEANUP => 0); # Directory removed by this function
|
|
|
|
#
|
|
# Execute "mysqld --no-defaults --help --verbose" to get a
|
|
# list of all features and settings
|
|
#
|
|
# --no-defaults and --skip-grant-tables are to avoid loading
|
|
# system-wide configs and plugins
|
|
#
|
|
# --datadir must exist, mysqld will chdir into it
|
|
#
|
|
my $list= `$exe_mysqld --no-defaults --datadir=$tmpdir --language=$path_language --skip-grant-tables --verbose --help`;
|
|
|
|
foreach my $line (split('\n', $list))
|
|
{
|
|
# First look for version
|
|
if ( !$mysql_version_id )
|
|
{
|
|
# Look for version
|
|
my $exe_name= basename($exe_mysqld);
|
|
mtr_verbose("exe_name: $exe_name");
|
|
if ( $line =~ /^\S*$exe_name\s\sVer\s([0-9]*)\.([0-9]*)\.([0-9]*)/ )
|
|
{
|
|
#print "Major: $1 Minor: $2 Build: $3\n";
|
|
$mysql_version_id= $1*10000 + $2*100 + $3;
|
|
#print "mysql_version_id: $mysql_version_id\n";
|
|
mtr_report("MySQL Version $1.$2.$3");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (!$found_variable_list_start)
|
|
{
|
|
# Look for start of variables list
|
|
if ( $line =~ /[\-]+\s[\-]+/ )
|
|
{
|
|
$found_variable_list_start= 1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
# Put variables into hash
|
|
if ( $line =~ /^([\S]+)[ \t]+(.*?)\r?$/ )
|
|
{
|
|
# print "$1=\"$2\"\n";
|
|
$mysqld_variables{$1}= $2;
|
|
}
|
|
else
|
|
{
|
|
# The variable list is ended with a blank line
|
|
if ( $line =~ /^[\s]*$/ )
|
|
{
|
|
last;
|
|
}
|
|
else
|
|
{
|
|
# Send out a warning, we should fix the variables that has no
|
|
# space between variable name and it's value
|
|
# or should it be fixed width column parsing? It does not
|
|
# look like that in function my_print_variables in my_getopt.c
|
|
mtr_warning("Could not parse variable list line : $line");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
rmtree($tmpdir);
|
|
mtr_error("Could not find version of MySQL") unless $mysql_version_id;
|
|
mtr_error("Could not find variabes list") unless $found_variable_list_start;
|
|
|
|
}
|
|
|
|
|
|
sub executable_setup_ndb () {
|
|
|
|
# Look for ndb tols and binaries
|
|
my $ndb_path= mtr_file_exists("$basedir/ndb",
|
|
"$basedir/storage/ndb",
|
|
"$basedir/bin");
|
|
|
|
$exe_ndbd=
|
|
mtr_exe_maybe_exists("$ndb_path/src/kernel/ndbd",
|
|
"$ndb_path/ndbd");
|
|
$exe_ndb_mgm=
|
|
mtr_exe_maybe_exists("$ndb_path/src/mgmclient/ndb_mgm",
|
|
"$ndb_path/ndb_mgm");
|
|
$exe_ndb_mgmd=
|
|
mtr_exe_maybe_exists("$ndb_path/src/mgmsrv/ndb_mgmd",
|
|
"$ndb_path/ndb_mgmd");
|
|
$exe_ndb_waiter=
|
|
mtr_exe_maybe_exists("$ndb_path/tools/ndb_waiter",
|
|
"$ndb_path/ndb_waiter");
|
|
|
|
# May not exist
|
|
$path_ndb_tools_dir= mtr_file_exists("$ndb_path/tools",
|
|
"$ndb_path");
|
|
# May not exist
|
|
$path_ndb_examples_dir=
|
|
mtr_file_exists("$ndb_path/ndbapi-examples",
|
|
"$ndb_path/examples");
|
|
# May not exist
|
|
$exe_ndb_example=
|
|
mtr_file_exists("$path_ndb_examples_dir/ndbapi_simple/ndbapi_simple");
|
|
|
|
return ( $exe_ndbd eq "" or
|
|
$exe_ndb_mgm eq "" or
|
|
$exe_ndb_mgmd eq "" or
|
|
$exe_ndb_waiter eq "");
|
|
}
|
|
|
|
|
|
sub executable_setup () {
|
|
|
|
#
|
|
# Check if libtool is available in this distribution/clone
|
|
# we need it when valgrinding or debugging non installed binary
|
|
# Otherwise valgrind will valgrind the libtool wrapper or bash
|
|
# and gdb will not find the real executable to debug
|
|
#
|
|
if ( -x "../libtool")
|
|
{
|
|
$exe_libtool= "../libtool";
|
|
if ($opt_valgrind or $glob_debugger)
|
|
{
|
|
mtr_report("Using \"$exe_libtool\" when running valgrind or debugger");
|
|
}
|
|
}
|
|
|
|
|
|
# Look for the client binaries
|
|
$exe_mysqladmin= mtr_exe_exists("$path_client_bindir/mysqladmin");
|
|
$exe_mysql= mtr_exe_exists("$path_client_bindir/mysql");
|
|
|
|
if ( ! $opt_skip_ndbcluster and executable_setup_ndb()) {
|
|
mtr_warning("Could not find all required ndb binaries, " .
|
|
"all ndb tests will fail, use --skip-ndbcluster to " .
|
|
"skip testing it.");
|
|
|
|
foreach my $cluster ( clusters()) {
|
|
$cluster->{"executable_setup_failed"}= 1;
|
|
}
|
|
}
|
|
|
|
# Look for mysqltest executable
|
|
if ( $opt_embedded_server )
|
|
{
|
|
$exe_mysqltest=
|
|
mtr_exe_exists(vs_config_dirs('libmysqld/examples','mysqltest_embedded'),
|
|
"$basedir/libmysqld/examples/mysqltest_embedded",
|
|
"$path_client_bindir/mysqltest_embedded");
|
|
}
|
|
else
|
|
{
|
|
$exe_mysqltest= mtr_exe_exists("$path_client_bindir/mysqltest");
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
sub client_debug_arg($$) {
|
|
my ($args, $client_name)= @_;
|
|
|
|
if ( $opt_debug ) {
|
|
mtr_add_arg($args,
|
|
"--debug=d:t:A,%s/log/%s.trace",
|
|
$path_vardir_trace, $client_name)
|
|
}
|
|
}
|
|
|
|
|
|
sub mysql_fix_arguments () {
|
|
|
|
return "" if ( $is_win32 );
|
|
|
|
my $exe=
|
|
mtr_script_exists("$basedir/scripts/mysql_fix_privilege_tables",
|
|
"$path_client_bindir/mysql_fix_privilege_tables");
|
|
my $args;
|
|
mtr_init_args(\$args);
|
|
mtr_add_arg($args, "--defaults-file=%s", $path_config_file);
|
|
|
|
mtr_add_arg($args, "--basedir=", $basedir);
|
|
mtr_add_arg($args, "--bindir=", $path_client_bindir);
|
|
mtr_add_arg($args, "--verbose");
|
|
return mtr_args2str($exe, @$args);
|
|
}
|
|
|
|
|
|
sub client_arguments ($) {
|
|
my $client_name= shift;
|
|
my $client_exe= mtr_exe_exists("$path_client_bindir/$client_name");
|
|
|
|
my $args;
|
|
mtr_init_args(\$args);
|
|
mtr_add_arg($args, "--defaults-file=%s", $path_config_file);
|
|
client_debug_arg($args, $client_name);
|
|
return mtr_args2str($client_exe, @$args);
|
|
}
|
|
|
|
|
|
sub mysqlslap_arguments () {
|
|
my $exe= mtr_exe_maybe_exists("$path_client_bindir/mysqlslap");
|
|
if ( $exe eq "" ) {
|
|
# mysqlap was not found
|
|
|
|
if (defined $mysql_version_id and $mysql_version_id >= 50100 ) {
|
|
mtr_error("Could not find the mysqlslap binary");
|
|
}
|
|
return ""; # Don't care about mysqlslap
|
|
}
|
|
|
|
my $args;
|
|
mtr_init_args(\$args);
|
|
mtr_add_arg($args, "--defaults-file=%s", $path_config_file);
|
|
client_debug_arg($args, "mysqlslap");
|
|
return mtr_args2str($exe, @$args);
|
|
}
|
|
|
|
|
|
sub mysqldump_arguments ($) {
|
|
my($group_suffix) = @_;
|
|
my $exe= mtr_exe_exists("$path_client_bindir/mysqldump");
|
|
|
|
my $args;
|
|
mtr_init_args(\$args);
|
|
mtr_add_arg($args, "--defaults-file=%s", $path_config_file);
|
|
mtr_add_arg($args, "--defaults-group-suffix=_%s", $group_suffix);
|
|
client_debug_arg($args, "mysqldump-$group_suffix");
|
|
return mtr_args2str($exe, @$args);
|
|
}
|
|
|
|
|
|
sub mysql_client_test_arguments(){
|
|
my $exe;
|
|
# mysql_client_test executable may _not_ exist
|
|
if ( $opt_embedded_server ) {
|
|
$exe= mtr_exe_maybe_exists(
|
|
vs_config_dirs('libmysqld/examples','mysql_client_test_embedded'),
|
|
"$basedir/libmysqld/examples/mysql_client_test_embedded");
|
|
} else {
|
|
$exe= mtr_exe_maybe_exists(vs_config_dirs('tests', 'mysql_client_test'),
|
|
"$basedir/tests/mysql_client_test",
|
|
"$basedir/bin/mysql_client_test");
|
|
}
|
|
|
|
my $args;
|
|
mtr_init_args(\$args);
|
|
if ( $opt_valgrind_mysqltest ) {
|
|
valgrind_arguments($args, \$exe);
|
|
}
|
|
mtr_add_arg($args, "--defaults-file=%s", $path_config_file);
|
|
mtr_add_arg($args, "--testcase");
|
|
mtr_add_arg($args, "--vardir=$opt_vardir");
|
|
client_debug_arg($args,"mysql_client_test");
|
|
|
|
return mtr_args2str($exe, @$args);
|
|
}
|
|
|
|
|
|
#
|
|
# Set environment to be used by childs of this process for
|
|
# things that are constant during the whole lifetime of mysql-test-run
|
|
#
|
|
sub environment_setup {
|
|
|
|
umask(022);
|
|
|
|
my @ld_library_paths;
|
|
|
|
# --------------------------------------------------------------------------
|
|
# Setup LD_LIBRARY_PATH so the libraries from this distro/clone
|
|
# are used in favor of the system installed ones
|
|
# --------------------------------------------------------------------------
|
|
if ( $source_dist )
|
|
{
|
|
push(@ld_library_paths, "$basedir/libmysql/.libs/",
|
|
"$basedir/libmysql_r/.libs/",
|
|
"$basedir/zlib.libs/");
|
|
}
|
|
else
|
|
{
|
|
push(@ld_library_paths, "$basedir/lib");
|
|
}
|
|
|
|
# --------------------------------------------------------------------------
|
|
# Add the path where libndbclient can be found
|
|
# --------------------------------------------------------------------------
|
|
if ( $glob_ndbcluster_supported )
|
|
{
|
|
push(@ld_library_paths, "$basedir/storage/ndb/src/.libs");
|
|
}
|
|
|
|
# --------------------------------------------------------------------------
|
|
# Add the path where mysqld will find udf_example.so
|
|
# --------------------------------------------------------------------------
|
|
my $lib_udf_example=
|
|
mtr_file_exists(vs_config_dirs('sql', 'udf_example.dll'),
|
|
"$basedir/sql/.libs/udf_example.so",);
|
|
|
|
if ( $lib_udf_example )
|
|
{
|
|
push(@ld_library_paths, dirname($lib_udf_example));
|
|
}
|
|
|
|
$ENV{'UDF_EXAMPLE_LIB'}=
|
|
($lib_udf_example ? basename($lib_udf_example) : "");
|
|
$ENV{'UDF_EXAMPLE_LIB_OPT'}=
|
|
($lib_udf_example ? "--plugin_dir=" . dirname($lib_udf_example) : "");
|
|
|
|
# --------------------------------------------------------------------------
|
|
# Add the path where mysqld will find ha_example.so
|
|
# --------------------------------------------------------------------------
|
|
if ($mysql_version_id >= 50100) {
|
|
my $lib_example_plugin=
|
|
mtr_file_exists(vs_config_dirs('storage/example', 'ha_example.dll'),
|
|
"$basedir/storage/example/.libs/ha_example.so",);
|
|
$ENV{'EXAMPLE_PLUGIN'}=
|
|
($lib_example_plugin ? basename($lib_example_plugin) : "");
|
|
$ENV{'EXAMPLE_PLUGIN_OPT'}=
|
|
($lib_example_plugin ?
|
|
"--plugin_dir=" . dirname($lib_example_plugin) : "");
|
|
}
|
|
|
|
# --------------------------------------------------------------------------
|
|
# Valgrind need to be run with debug libraries otherwise it's almost
|
|
# impossible to add correct supressions, that means if "/usr/lib/debug"
|
|
# is available, it should be added to
|
|
# LD_LIBRARY_PATH
|
|
#
|
|
# But pthread is broken in libc6-dbg on Debian <= 3.1 (see Debian
|
|
# bug 399035, http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=399035),
|
|
# so don't change LD_LIBRARY_PATH on that platform.
|
|
# --------------------------------------------------------------------------
|
|
my $debug_libraries_path= "/usr/lib/debug";
|
|
my $deb_version;
|
|
if ( $opt_valgrind and -d $debug_libraries_path and
|
|
(! -e '/etc/debian_version' or
|
|
($deb_version=
|
|
mtr_grab_file('/etc/debian_version')) !~ /^[0-9]+\.[0-9]$/ or
|
|
$deb_version > 3.1 ) )
|
|
{
|
|
push(@ld_library_paths, $debug_libraries_path);
|
|
}
|
|
|
|
$ENV{'LD_LIBRARY_PATH'}= join(":", @ld_library_paths,
|
|
$ENV{'LD_LIBRARY_PATH'} ?
|
|
split(':', $ENV{'LD_LIBRARY_PATH'}) : ());
|
|
mtr_debug("LD_LIBRARY_PATH: $ENV{'LD_LIBRARY_PATH'}");
|
|
|
|
$ENV{'DYLD_LIBRARY_PATH'}= join(":", @ld_library_paths,
|
|
$ENV{'DYLD_LIBRARY_PATH'} ?
|
|
split(':', $ENV{'DYLD_LIBRARY_PATH'}) : ());
|
|
mtr_debug("DYLD_LIBRARY_PATH: $ENV{'DYLD_LIBRARY_PATH'}");
|
|
|
|
# The environment variable used for shared libs on AIX
|
|
$ENV{'SHLIB_PATH'}= join(":", @ld_library_paths,
|
|
$ENV{'SHLIB_PATH'} ?
|
|
split(':', $ENV{'SHLIB_PATH'}) : ());
|
|
mtr_debug("SHLIB_PATH: $ENV{'SHLIB_PATH'}");
|
|
|
|
# The environment variable used for shared libs on hp-ux
|
|
$ENV{'LIBPATH'}= join(":", @ld_library_paths,
|
|
$ENV{'LIBPATH'} ?
|
|
split(':', $ENV{'LIBPATH'}) : ());
|
|
mtr_debug("LIBPATH: $ENV{'LIBPATH'}");
|
|
|
|
$ENV{'CHARSETSDIR'}= $path_charsetsdir;
|
|
$ENV{'UMASK'}= "0660"; # The octal *string*
|
|
$ENV{'UMASK_DIR'}= "0770"; # The octal *string*
|
|
|
|
#
|
|
# MySQL tests can produce output in various character sets
|
|
# (especially, ctype_xxx.test). To avoid confusing Perl
|
|
# with output which is incompatible with the current locale
|
|
# settings, we reset the current values of LC_ALL and LC_CTYPE to "C".
|
|
# For details, please see
|
|
# Bug#27636 tests fails if LC_* variables set to *_*.UTF-8
|
|
#
|
|
$ENV{'LC_ALL'}= "C";
|
|
$ENV{'LC_CTYPE'}= "C";
|
|
|
|
$ENV{'LC_COLLATE'}= "C";
|
|
$ENV{'USE_RUNNING_SERVER'}= using_extern();
|
|
$ENV{'MYSQL_TEST_DIR'}= $glob_mysql_test_dir;
|
|
$ENV{'MYSQLTEST_VARDIR'}= $opt_vardir;
|
|
$ENV{'DEFAULT_MASTER_PORT'}= $mysqld_variables{'master-port'} || 3306;
|
|
|
|
# ----------------------------------------------------
|
|
# Setup env for NDB
|
|
# ----------------------------------------------------
|
|
$ENV{'NDB_MGM'}= $exe_ndb_mgm;
|
|
$ENV{'NDB_EXTRA_TEST'}= $opt_ndb_extra_test;
|
|
$ENV{'NDB_TOOLS_DIR'}= $path_ndb_tools_dir;
|
|
$ENV{'NDB_TOOLS_OUTPUT'}= $path_ndb_testrun_log;
|
|
$ENV{'NDB_EXAMPLES_DIR'}= $path_ndb_examples_dir;
|
|
$ENV{'NDB_EXAMPLES_BINARY'}= $exe_ndb_example;
|
|
$ENV{'NDB_EXAMPLES_OUTPUT'}= $path_ndb_testrun_log;
|
|
|
|
# ----------------------------------------------------
|
|
# mysql clients
|
|
# ----------------------------------------------------
|
|
$ENV{'MYSQL_CHECK'}= client_arguments("mysqlcheck");
|
|
$ENV{'MYSQL_DUMP'}= mysqldump_arguments(".1");
|
|
$ENV{'MYSQL_DUMP_SLAVE'}= mysqldump_arguments(".2");
|
|
$ENV{'MYSQL_SLAP'}= mysqlslap_arguments();
|
|
$ENV{'MYSQL_IMPORT'}= client_arguments("mysqlimport");
|
|
$ENV{'MYSQL_SHOW'}= client_arguments("mysqlshow");
|
|
$ENV{'MYSQL_BINLOG'}= client_arguments("mysqlbinlog");
|
|
$ENV{'MYSQL'}= client_arguments("mysql");
|
|
$ENV{'MYSQL_UPGRADE'}= client_arguments("mysql_upgrade");
|
|
$ENV{'MYSQLADMIN'}= mtr_native_path($exe_mysqladmin);
|
|
$ENV{'MYSQL_CLIENT_TEST'}= mysql_client_test_arguments();
|
|
$ENV{'MYSQL_FIX_SYSTEM_TABLES'}= mysql_fix_arguments();
|
|
$ENV{'EXE_MYSQL'}= $exe_mysql;
|
|
|
|
# ----------------------------------------------------
|
|
# bug25714 executable may _not_ exist in
|
|
# some versions, test using it should be skipped
|
|
# ----------------------------------------------------
|
|
my $exe_bug25714=
|
|
mtr_exe_maybe_exists(vs_config_dirs('tests', 'bug25714'),
|
|
"$basedir/tests/bug25714");
|
|
$ENV{'MYSQL_BUG25714'}= mtr_native_path($exe_bug25714);
|
|
|
|
# ----------------------------------------------------
|
|
# mysql_fix_privilege_tables.sql
|
|
# ----------------------------------------------------
|
|
my $file_mysql_fix_privilege_tables=
|
|
mtr_file_exists("$basedir/scripts/mysql_fix_privilege_tables.sql",
|
|
"$basedir/share/mysql_fix_privilege_tables.sql");
|
|
$ENV{'MYSQL_FIX_PRIVILEGE_TABLES'}= $file_mysql_fix_privilege_tables;
|
|
|
|
# ----------------------------------------------------
|
|
# my_print_defaults
|
|
# ----------------------------------------------------
|
|
my $exe_my_print_defaults=
|
|
mtr_exe_exists(vs_config_dirs('extra', 'my_print_defaults'),
|
|
"$path_client_bindir/my_print_defaults",
|
|
"$basedir/extra/my_print_defaults");
|
|
$ENV{'MYSQL_MY_PRINT_DEFAULTS'}= mtr_native_path($exe_my_print_defaults);
|
|
|
|
# ----------------------------------------------------
|
|
# perror
|
|
# ----------------------------------------------------
|
|
my $exe_perror= mtr_exe_exists(vs_config_dirs('extra', 'perror'),
|
|
"$basedir/extra/perror",
|
|
"$path_client_bindir/perror");
|
|
$ENV{'MY_PERROR'}= mtr_native_path($exe_perror);
|
|
|
|
# Create an environment variable to make it possible
|
|
# to detect that valgrind is being used from test cases
|
|
$ENV{'VALGRIND_TEST'}= $opt_valgrind;
|
|
|
|
}
|
|
|
|
|
|
|
|
#
|
|
# Remove var and any directories in var/ created by previous
|
|
# tests
|
|
#
|
|
sub remove_stale_vardir () {
|
|
|
|
mtr_report("Removing old var directory...");
|
|
|
|
# Safety!
|
|
mtr_error("No, don't remove the vardir when running with --extern")
|
|
if using_extern();
|
|
|
|
mtr_verbose("opt_vardir: $opt_vardir");
|
|
if ( $opt_vardir eq $default_vardir )
|
|
{
|
|
#
|
|
# Running with "var" in mysql-test dir
|
|
#
|
|
if ( -l $opt_vardir)
|
|
{
|
|
# var is a symlink
|
|
|
|
if ( $opt_mem and readlink($opt_vardir) eq $opt_mem )
|
|
{
|
|
# Remove the directory which the link points at
|
|
mtr_verbose("Removing " . readlink($opt_vardir));
|
|
rmtree(readlink($opt_vardir));
|
|
|
|
# Remove the "var" symlink
|
|
mtr_verbose("unlink($opt_vardir)");
|
|
unlink($opt_vardir);
|
|
}
|
|
elsif ( $opt_mem )
|
|
{
|
|
# Just remove the "var" symlink
|
|
mtr_report(" - WARNING: Removing '$opt_vardir' symlink it's wrong");
|
|
|
|
mtr_verbose("unlink($opt_vardir)");
|
|
unlink($opt_vardir);
|
|
}
|
|
else
|
|
{
|
|
# Some users creates a soft link in mysql-test/var to another area
|
|
# - allow it, but remove all files in it
|
|
|
|
mtr_report(" - WARNING: Using the 'mysql-test/var' symlink");
|
|
|
|
# Make sure the directory where it points exist
|
|
mtr_error("The destination for symlink $opt_vardir does not exist")
|
|
if ! -d readlink($opt_vardir);
|
|
|
|
foreach my $bin ( glob("$opt_vardir/*") )
|
|
{
|
|
mtr_verbose("Removing bin $bin");
|
|
rmtree($bin);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
# Remove the entire "var" dir
|
|
mtr_verbose("Removing $opt_vardir/");
|
|
rmtree("$opt_vardir/");
|
|
}
|
|
|
|
if ( $opt_mem )
|
|
{
|
|
# A symlink from var/ to $opt_mem will be set up
|
|
# remove the $opt_mem dir to assure the symlink
|
|
# won't point at an old directory
|
|
mtr_verbose("Removing $opt_mem");
|
|
rmtree($opt_mem);
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
#
|
|
# Running with "var" in some other place
|
|
#
|
|
|
|
# Remove the var/ dir in mysql-test dir if any
|
|
# this could be an old symlink that shouldn't be there
|
|
mtr_verbose("Removing $default_vardir");
|
|
rmtree($default_vardir);
|
|
|
|
# Remove the "var" dir
|
|
mtr_verbose("Removing $opt_vardir/");
|
|
rmtree("$opt_vardir/");
|
|
}
|
|
}
|
|
|
|
|
|
|
|
#
|
|
# Create var and the directories needed in var
|
|
#
|
|
sub setup_vardir() {
|
|
mtr_report("Creating var directory...");
|
|
|
|
if ( $opt_vardir eq $default_vardir )
|
|
{
|
|
#
|
|
# Running with "var" in mysql-test dir
|
|
#
|
|
if ( -l $opt_vardir )
|
|
{
|
|
# it's a symlink
|
|
|
|
# Make sure the directory where it points exist
|
|
mtr_error("The destination for symlink $opt_vardir does not exist")
|
|
if ! -d readlink($opt_vardir);
|
|
}
|
|
elsif ( $opt_mem )
|
|
{
|
|
# Runinng with "var" as a link to some "memory" location, normally tmpfs
|
|
mtr_verbose("Creating $opt_mem");
|
|
mkpath($opt_mem);
|
|
|
|
mtr_report(" - symlinking 'var' to '$opt_mem'");
|
|
symlink($opt_mem, $opt_vardir);
|
|
}
|
|
}
|
|
|
|
if ( ! -d $opt_vardir )
|
|
{
|
|
mtr_verbose("Creating $opt_vardir");
|
|
mkpath($opt_vardir);
|
|
}
|
|
|
|
# Ensure a proper error message if vardir couldn't be created
|
|
unless ( -d $opt_vardir and -w $opt_vardir )
|
|
{
|
|
mtr_error("Writable 'var' directory is needed, use the " .
|
|
"'--vardir=<path>' option");
|
|
}
|
|
|
|
mkpath("$opt_vardir/log");
|
|
mkpath("$opt_vardir/run");
|
|
mkpath("$opt_vardir/tmp");
|
|
mkpath($opt_tmpdir) if $opt_tmpdir ne "$opt_vardir/tmp";
|
|
|
|
# copy all files from std_data into var/std_data
|
|
# and make them writable
|
|
copytree("$glob_mysql_test_dir/std_data", "$opt_vardir/std_data");
|
|
|
|
# Remove old log files
|
|
foreach my $name (glob("r/*.progress r/*.log r/*.warnings"))
|
|
{
|
|
unlink($name);
|
|
}
|
|
}
|
|
|
|
|
|
#
|
|
# Check if running as root
|
|
# i.e a file can be read regardless what mode we set it to
|
|
#
|
|
sub check_running_as_root () {
|
|
my $test_file= "$opt_vardir/test_running_as_root.txt";
|
|
mtr_tofile($test_file, "MySQL");
|
|
chmod(oct("0000"), $test_file);
|
|
|
|
my $result="";
|
|
if (open(FILE,"<",$test_file))
|
|
{
|
|
$result= join('', <FILE>);
|
|
close FILE;
|
|
}
|
|
|
|
# Some filesystems( for example CIFS) allows reading a file
|
|
# although mode was set to 0000, but in that case a stat on
|
|
# the file will not return 0000
|
|
my $file_mode= (stat($test_file))[2] & 07777;
|
|
|
|
$ENV{'MYSQL_TEST_ROOT'}= "NO";
|
|
mtr_verbose("result: $result, file_mode: $file_mode");
|
|
if ($result eq "MySQL" && $file_mode == 0)
|
|
{
|
|
mtr_warning("running this script as _root_ will cause some " .
|
|
"tests to be skipped");
|
|
$ENV{'MYSQL_TEST_ROOT'}= "YES";
|
|
}
|
|
|
|
chmod(oct("0755"), $test_file);
|
|
unlink($test_file);
|
|
}
|
|
|
|
|
|
sub check_ssl_support ($) {
|
|
my $mysqld_variables= shift;
|
|
|
|
if ($opt_skip_ssl)
|
|
{
|
|
mtr_report(" - skipping SSL");
|
|
$opt_ssl_supported= 0;
|
|
$opt_ssl= 0;
|
|
return;
|
|
}
|
|
|
|
if ( ! $mysqld_variables->{'ssl'} )
|
|
{
|
|
if ( $opt_ssl)
|
|
{
|
|
mtr_error("Couldn't find support for SSL");
|
|
return;
|
|
}
|
|
mtr_report(" - skipping SSL, mysqld not compiled with SSL");
|
|
$opt_ssl_supported= 0;
|
|
$opt_ssl= 0;
|
|
return;
|
|
}
|
|
mtr_report(" - SSL connections supported");
|
|
$opt_ssl_supported= 1;
|
|
}
|
|
|
|
|
|
sub check_debug_support ($) {
|
|
my $mysqld_variables= shift;
|
|
|
|
if ( ! $mysqld_variables->{'debug'} )
|
|
{
|
|
#mtr_report(" - binaries are not debug compiled");
|
|
$debug_compiled_binaries= 0;
|
|
|
|
if ( $opt_debug )
|
|
{
|
|
mtr_error("Can't use --debug, binaries does not support it");
|
|
}
|
|
return;
|
|
}
|
|
mtr_report(" - binaries are debug compiled");
|
|
$debug_compiled_binaries= 1;
|
|
}
|
|
|
|
|
|
#
|
|
# Helper function to handle configuration-based subdirectories which Visual
|
|
# Studio uses for storing binaries. If opt_vs_config is set, this returns
|
|
# a path based on that setting; if not, it returns paths for the default
|
|
# /release/ and /debug/ subdirectories.
|
|
#
|
|
# $exe can be undefined, if the directory itself will be used
|
|
#
|
|
sub vs_config_dirs ($$) {
|
|
my ($path_part, $exe) = @_;
|
|
|
|
$exe = "" if not defined $exe;
|
|
|
|
# Don't look in these dirs when not on windows
|
|
return () unless $is_win32;
|
|
|
|
if ($opt_vs_config)
|
|
{
|
|
return ("$basedir/$path_part/$opt_vs_config/$exe");
|
|
}
|
|
|
|
return ("$basedir/$path_part/release/$exe",
|
|
"$basedir/$path_part/relwithdebinfo/$exe",
|
|
"$basedir/$path_part/debug/$exe");
|
|
}
|
|
|
|
|
|
sub check_ndbcluster_support ($) {
|
|
my $mysqld_variables= shift;
|
|
|
|
if ($opt_skip_ndbcluster)
|
|
{
|
|
mtr_report(" - skipping ndbcluster");
|
|
$opt_skip_ndbcluster_slave= 1;
|
|
return;
|
|
}
|
|
|
|
if ( ! $mysqld_variables{'ndb-connectstring'} )
|
|
{
|
|
mtr_report(" - skipping ndbcluster, mysqld not compiled with ndbcluster");
|
|
$opt_skip_ndbcluster= 1;
|
|
$opt_skip_ndbcluster_slave= 1;
|
|
return;
|
|
}
|
|
|
|
$glob_ndbcluster_supported= 1;
|
|
mtr_report(" - using ndbcluster when necessary, mysqld supports it");
|
|
|
|
if ( $mysql_version_id < 50100 )
|
|
{
|
|
# Slave cluster is not supported until 5.1
|
|
$opt_skip_ndbcluster_slave= 1;
|
|
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
sub ndbcluster_wait_started($$){
|
|
my $cluster= shift;
|
|
my $ndb_waiter_extra_opt= shift;
|
|
my $path_waitlog= join('/', $opt_vardir, $cluster->name(), "ndb_waiter.log");
|
|
|
|
my $args;
|
|
mtr_init_args(\$args);
|
|
mtr_add_arg($args, "--defaults-file=%s", $path_config_file);
|
|
mtr_add_arg($args, "--defaults-group-suffix=%s", $cluster->suffix());
|
|
mtr_add_arg($args, "--timeout=60");
|
|
|
|
if ($ndb_waiter_extra_opt)
|
|
{
|
|
mtr_add_arg($args, "$ndb_waiter_extra_opt");
|
|
}
|
|
|
|
# Start the ndb_waiter which will connect to the ndb_mgmd
|
|
# and poll it for state of the ndbd's, will return when
|
|
# all nodes in the cluster is started
|
|
|
|
my $res= My::SafeProcess->run
|
|
(
|
|
name => "ndb_waiter ".$cluster->name(),
|
|
path => $exe_ndb_waiter,
|
|
args => \$args,
|
|
output => $path_waitlog,
|
|
error => $path_waitlog,
|
|
append => 1,
|
|
);
|
|
|
|
# Check that ndb_mgmd(s) are still alive
|
|
foreach my $ndb_mgmd ( in_cluster($cluster, ndb_mgmds()) )
|
|
{
|
|
my $proc= $ndb_mgmd->{proc};
|
|
if ( ! $proc->wait_one(0) )
|
|
{
|
|
mtr_warning("$proc died");
|
|
return 2;
|
|
}
|
|
}
|
|
|
|
# Check that all started ndbd(s) are still alive
|
|
foreach my $ndbd ( in_cluster($cluster, ndbds()) )
|
|
{
|
|
my $proc= $ndbd->{proc};
|
|
next unless defined $proc;
|
|
if ( ! $proc->wait_one(0) )
|
|
{
|
|
mtr_warning("$proc died");
|
|
return 3;
|
|
}
|
|
}
|
|
|
|
if ($res)
|
|
{
|
|
mtr_verbose("ndbcluster_wait_started failed");
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
sub ndb_mgmd_wait_started($) {
|
|
my ($cluster)= @_;
|
|
|
|
my $retries= 100;
|
|
while ($retries)
|
|
{
|
|
my $result= ndbcluster_wait_started($cluster, "--no-contact");
|
|
if ($result == 0)
|
|
{
|
|
# ndb_mgmd is started
|
|
mtr_verbose("ndb_mgmd is started");
|
|
return 0;
|
|
}
|
|
elsif ($result > 1)
|
|
{
|
|
mtr_warning("Cluster process failed while waiting for start");
|
|
return $result;
|
|
}
|
|
|
|
mtr_milli_sleep(100);
|
|
$retries--;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
|
|
sub ndb_mgmd_start ($$) {
|
|
my ($cluster, $ndb_mgmd)= @_;
|
|
|
|
mtr_verbose("ndb_mgmd_start");
|
|
|
|
my $dir= $ndb_mgmd->value("DataDir");
|
|
mkpath($dir) unless -d $dir;
|
|
|
|
my $args;
|
|
mtr_init_args(\$args);
|
|
mtr_add_arg($args, "--defaults-file=%s", $path_config_file);
|
|
mtr_add_arg($args, "--defaults-group-suffix=%s", $cluster->suffix());
|
|
mtr_add_arg($args, "--mycnf");
|
|
mtr_add_arg($args, "--nodaemon");
|
|
|
|
my $path_ndb_mgmd_log= "$dir/ndb_mgmd.log";
|
|
|
|
$ndb_mgmd->{'proc'}= My::SafeProcess->new
|
|
(
|
|
name => $ndb_mgmd->after('cluster_config.'),
|
|
path => $exe_ndb_mgmd,
|
|
args => \$args,
|
|
output => $path_ndb_mgmd_log,
|
|
error => $path_ndb_mgmd_log,
|
|
append => 1,
|
|
verbose => $opt_verbose,
|
|
);
|
|
mtr_verbose("Started $ndb_mgmd->{proc}");
|
|
|
|
# FIXME Should not be needed
|
|
# Unfortunately the cluster nodes will fail to start
|
|
# if ndb_mgmd has not started properly
|
|
if (ndb_mgmd_wait_started($cluster))
|
|
{
|
|
mtr_warning("Failed to wait for start of ndb_mgmd");
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
sub ndbd_start {
|
|
my ($cluster, $ndbd)= @_;
|
|
|
|
mtr_verbose("ndbd_start");
|
|
|
|
my $dir= $ndbd->value("DataDir");
|
|
mkpath($dir) unless -d $dir;
|
|
|
|
my $args;
|
|
mtr_init_args(\$args);
|
|
mtr_add_arg($args, "--defaults-file=%s", $path_config_file);
|
|
mtr_add_arg($args, "--defaults-group-suffix=%s", $cluster->suffix());
|
|
mtr_add_arg($args, "--nodaemon");
|
|
|
|
# > 5.0 { 'character-sets-dir' => \&fix_charset_dir },
|
|
|
|
|
|
my $path_ndbd_log= "$dir/ndbd.log";
|
|
my $proc= My::SafeProcess->new
|
|
(
|
|
name => $ndbd->after('cluster_config.'),
|
|
path => $exe_ndbd,
|
|
args => \$args,
|
|
output => $path_ndbd_log,
|
|
error => $path_ndbd_log,
|
|
append => 1,
|
|
verbose => $opt_verbose,
|
|
);
|
|
mtr_verbose("Started $proc");
|
|
|
|
$ndbd->{proc}= $proc;
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
sub ndbcluster_start ($) {
|
|
my $cluster= shift;
|
|
|
|
mtr_verbose("ndbcluster_start '".$cluster->name()."'");
|
|
|
|
foreach my $ndb_mgmd ( in_cluster($cluster, ndb_mgmds()) )
|
|
{
|
|
next if started($ndb_mgmd);
|
|
ndb_mgmd_start($cluster, $ndb_mgmd);
|
|
}
|
|
|
|
foreach my $ndbd ( in_cluster($cluster, ndbds()) )
|
|
{
|
|
next if started($ndbd);
|
|
ndbd_start($cluster, $ndbd);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
#
|
|
# Run the collected tests
|
|
#
|
|
my $suite_timeout_proc;
|
|
sub run_tests {
|
|
my ($tests)= @_;
|
|
|
|
mtr_report();
|
|
mtr_print_thick_line();
|
|
mtr_print_header();
|
|
|
|
$suite_timeout_proc= My::SafeProcess->timer($opt_suite_timeout* 60);
|
|
foreach my $tinfo ( @$tests )
|
|
{
|
|
if (run_testcase_check_skip_test($tinfo))
|
|
{
|
|
next;
|
|
}
|
|
|
|
run_testcase($tinfo);
|
|
}
|
|
# Kill the test suite timer
|
|
$suite_timeout_proc->kill();
|
|
|
|
mtr_print_line();
|
|
|
|
stop_all_servers();
|
|
|
|
if ( $opt_gcov )
|
|
{
|
|
gcov_collect(); # collect coverage information
|
|
}
|
|
|
|
mtr_report_stats($tests);
|
|
|
|
}
|
|
|
|
|
|
sub create_config_file_for_extern {
|
|
my %opts=
|
|
(
|
|
socket => '/tmp/mysqld.sock',
|
|
port => 3306,
|
|
user => 'test',
|
|
password => '',
|
|
@_
|
|
);
|
|
|
|
mtr_report("Creating my.cnf file for extern server...");
|
|
my $F= IO::File->new($path_config_file, "w")
|
|
or mtr_error("Can't write to $path_config_file: $!");
|
|
|
|
print $F "[client]\n";
|
|
while (my ($option, $value)= each( %opts )) {
|
|
print $F "$option= $value\n";
|
|
mtr_report(" $option= $value");
|
|
}
|
|
|
|
print $F <<EOF
|
|
|
|
# binlog reads from [client] and [mysqlbinlog]
|
|
[mysqlbinlog]
|
|
character-sets-dir= $path_charsetsdir
|
|
|
|
# mysql_fix_privilege_tables.sh don't read from [client]
|
|
[mysql_fix_privilege_tables]
|
|
socket = $opts{'socket'}
|
|
port = $opts{'port'}
|
|
user = $opts{'user'}
|
|
password = $opts{'password'}
|
|
|
|
|
|
EOF
|
|
;
|
|
|
|
$F= undef; # Close file
|
|
}
|
|
|
|
|
|
#
|
|
# Kill processes left from previous runs, normally
|
|
# there should be none so make sure to warn
|
|
# if there is one
|
|
#
|
|
sub kill_leftovers ($) {
|
|
my $rundir= shift;
|
|
return unless ( -d $rundir );
|
|
|
|
mtr_report("Checking leftover processes...");
|
|
|
|
# Scan the "run" directory for process id's to kill
|
|
opendir(RUNDIR, $rundir)
|
|
or mtr_error("kill_leftovers, can't open dir \"$rundir\": $!");
|
|
while ( my $elem= readdir(RUNDIR) )
|
|
{
|
|
# Only read pid from files that end with .pid
|
|
if ( $elem =~ /.*[.]pid$/ )
|
|
{
|
|
my $pidfile= "$rundir/$elem";
|
|
next unless -f $pidfile;
|
|
my $pid= mtr_fromfile($pidfile);
|
|
unlink($pidfile);
|
|
unless ($pid=~ /^(\d+)/){
|
|
# The pid was not a valid number
|
|
mtr_warning("Got invalid pid '$pid' from '$elem'");
|
|
next;
|
|
}
|
|
mtr_report(" - found old pid $pid in '$elem', killing it...");
|
|
|
|
my $ret= kill(9, $pid);
|
|
if ($ret == 0) {
|
|
mtr_report(" process did not exist!");
|
|
next;
|
|
}
|
|
|
|
my $check_counter= 100;
|
|
while ($ret > 0 and $check_counter--) {
|
|
mtr_milli_sleep(100);
|
|
$ret= kill(0, $pid);
|
|
}
|
|
mtr_report($check_counter ? " ok!" : " failed!");
|
|
}
|
|
else
|
|
{
|
|
mtr_warning("Found non pid file '$elem' in '$rundir'")
|
|
if -f "$rundir/$elem";
|
|
}
|
|
}
|
|
closedir(RUNDIR);
|
|
}
|
|
|
|
#
|
|
# Check that all the ports that are going to
|
|
# be used are free
|
|
#
|
|
sub check_ports_free
|
|
{
|
|
my @ports_to_check;
|
|
for ($opt_baseport..$opt_baseport+9){
|
|
push(@ports_to_check, $_);
|
|
}
|
|
mtr_report("Checking ports...");
|
|
# print "@ports_to_check\n";
|
|
foreach my $port (@ports_to_check){
|
|
if (mtr_ping_port($port)){
|
|
mtr_report(" - 'localhost:$port' was not free");
|
|
return 1; # One port was not free
|
|
}
|
|
}
|
|
|
|
return 0; # All ports free
|
|
}
|
|
|
|
|
|
sub initialize_servers {
|
|
|
|
if ( using_extern() )
|
|
{
|
|
# Running against an already started server, if the specified
|
|
# vardir does not already exist it should be created
|
|
if ( ! -d $opt_vardir )
|
|
{
|
|
setup_vardir();
|
|
}
|
|
else
|
|
{
|
|
mtr_verbose("No need to create '$opt_vardir' it already exists");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
# Kill leftovers from previous run
|
|
# using any pidfiles found in var/run
|
|
kill_leftovers("$opt_vardir/run");
|
|
|
|
if (check_ports_free()){
|
|
# Some port was not free(which one has already been printed)
|
|
mtr_error("Some port(s) was not free")
|
|
}
|
|
|
|
if ( ! $opt_start_dirty )
|
|
{
|
|
remove_stale_vardir();
|
|
setup_vardir();
|
|
|
|
mysql_install_db();
|
|
}
|
|
}
|
|
check_running_as_root();
|
|
|
|
mtr_log_init("$opt_vardir/log/mysql-test-run.log");
|
|
}
|
|
|
|
|
|
#
|
|
# Copy the reference database into selected datadir
|
|
#
|
|
sub copy_install_db ($) {
|
|
my $path_data_dir= shift;
|
|
|
|
# Don't install over another db
|
|
mtr_error("There is already an installed db in '$path_data_dir'")
|
|
if -d $path_data_dir;
|
|
|
|
# copy the installed db into place
|
|
copytree("$opt_vardir/install.db", $path_data_dir);
|
|
}
|
|
|
|
|
|
sub mysql_install_db {
|
|
my $data_dir= "$opt_vardir/install.db";
|
|
|
|
mtr_report("Installing system database...");
|
|
|
|
my $args;
|
|
mtr_init_args(\$args);
|
|
mtr_add_arg($args, "--no-defaults");
|
|
mtr_add_arg($args, "--bootstrap");
|
|
mtr_add_arg($args, "--basedir=%s", $basedir);
|
|
mtr_add_arg($args, "--datadir=%s", $data_dir);
|
|
mtr_add_arg($args, "--loose-skip-innodb");
|
|
mtr_add_arg($args, "--loose-skip-ndbcluster");
|
|
mtr_add_arg($args, "--tmpdir=.");
|
|
mtr_add_arg($args, "--core-file");
|
|
|
|
if ( $opt_debug )
|
|
{
|
|
mtr_add_arg($args, "--debug=d:t:i:A,%s/log/bootstrap.trace",
|
|
$path_vardir_trace);
|
|
}
|
|
|
|
mtr_add_arg($args, "--language=%s", $path_language);
|
|
mtr_add_arg($args, "--character-sets-dir=%s", $path_charsetsdir);
|
|
|
|
# If DISABLE_GRANT_OPTIONS is defined when the server is compiled (e.g.,
|
|
# configure --disable-grant-options), mysqld will not recognize the
|
|
# --bootstrap or --skip-grant-tables options. The user can set
|
|
# MYSQLD_BOOTSTRAP to the full path to a mysqld which does accept
|
|
# --bootstrap, to accommodate this.
|
|
my $exe_mysqld_bootstrap = $ENV{'MYSQLD_BOOTSTRAP'} || $exe_mysqld;
|
|
|
|
# ----------------------------------------------------------------------
|
|
# export MYSQLD_BOOTSTRAP_CMD variable containing <path>/mysqld <args>
|
|
# ----------------------------------------------------------------------
|
|
$ENV{'MYSQLD_BOOTSTRAP_CMD'}= "$exe_mysqld_bootstrap " . join(" ", @$args);
|
|
|
|
# ----------------------------------------------------------------------
|
|
# Create the bootstrap.sql file
|
|
# ----------------------------------------------------------------------
|
|
my $bootstrap_sql_file= "$opt_vardir/tmp/bootstrap.sql";
|
|
|
|
# Use the mysql database for system tables
|
|
mtr_tofile($bootstrap_sql_file, "use mysql");
|
|
|
|
# Add the offical mysql system tables
|
|
# for a production system
|
|
mtr_appendfile_to_file("$path_sql_dir/mysql_system_tables.sql",
|
|
$bootstrap_sql_file);
|
|
|
|
# Add the mysql system tables initial data
|
|
# for a production system
|
|
mtr_appendfile_to_file("$path_sql_dir/mysql_system_tables_data.sql",
|
|
$bootstrap_sql_file);
|
|
|
|
# Add test data for timezone - this is just a subset, on a real
|
|
# system these tables will be populated either by mysql_tzinfo_to_sql
|
|
# or by downloading the timezone table package from our website
|
|
mtr_appendfile_to_file("$path_sql_dir/mysql_test_data_timezone.sql",
|
|
$bootstrap_sql_file);
|
|
|
|
# Fill help tables, just an empty file when running from bk repo
|
|
# but will be replaced by a real fill_help_tables.sql when
|
|
# building the source dist
|
|
mtr_appendfile_to_file("$path_sql_dir/fill_help_tables.sql",
|
|
$bootstrap_sql_file);
|
|
|
|
# Remove anonymous users
|
|
mtr_tofile($bootstrap_sql_file,
|
|
"DELETE FROM mysql.user where user= '';");
|
|
|
|
# Log bootstrap command
|
|
my $path_bootstrap_log= "$opt_vardir/log/bootstrap.log";
|
|
mtr_tofile($path_bootstrap_log,
|
|
"$exe_mysqld_bootstrap " . join(" ", @$args) . "\n");
|
|
|
|
# Create directories mysql and test
|
|
mkpath("$data_dir/mysql");
|
|
mkpath("$data_dir/test");
|
|
|
|
if ( My::SafeProcess->run
|
|
(
|
|
name => "bootstrap",
|
|
path => $exe_mysqld_bootstrap,
|
|
args => \$args,
|
|
input => $bootstrap_sql_file,
|
|
output => $path_bootstrap_log,
|
|
error => $path_bootstrap_log,
|
|
append => 1,
|
|
) != 0)
|
|
{
|
|
mtr_error("Error executing mysqld --bootstrap\n" .
|
|
"Could not install system database from $bootstrap_sql_file\n" .
|
|
"see $path_bootstrap_log for errors");
|
|
}
|
|
}
|
|
|
|
|
|
sub run_testcase_check_skip_test($)
|
|
{
|
|
my ($tinfo)= @_;
|
|
|
|
# ----------------------------------------------------------------------
|
|
# If marked to skip, just print out and return.
|
|
# Note that a test case not marked as 'skip' can still be
|
|
# skipped later, because of the test case itself in cooperation
|
|
# with the mysqltest program tells us so.
|
|
# ----------------------------------------------------------------------
|
|
|
|
if ( $tinfo->{'skip'} )
|
|
{
|
|
mtr_report_test_skipped($tinfo);
|
|
return 1;
|
|
}
|
|
|
|
if ($tinfo->{'ndb_test'})
|
|
{
|
|
foreach my $cluster ( clusters() )
|
|
{
|
|
# If test needs this cluster, check binaries was found ok
|
|
if ( $cluster->{'executable_setup_failed'} )
|
|
{
|
|
$tinfo->{comment}=
|
|
"Failed to find cluster binaries";
|
|
mtr_report_test_failed($tinfo);
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
sub dynamic_binlog_format_switch {
|
|
my ($tinfo, $mysqld)= @_;
|
|
|
|
my $sql= "include/set_binlog_format_".$tinfo->{binlog_format_switch}.".sql";
|
|
my $args;
|
|
mtr_init_args(\$args);
|
|
mtr_add_arg($args, "--defaults-file=%s", $path_config_file);
|
|
mtr_add_arg($args, "--defaults-group-suffix=%s", $mysqld->after('mysqld'));
|
|
my $res= My::SafeProcess->run
|
|
(
|
|
name => "switch binlog format ".$mysqld->name(),
|
|
path => $exe_mysql,
|
|
args => \$args,
|
|
input => $sql,
|
|
);
|
|
|
|
if ($res != 0)
|
|
{
|
|
mtr_error("Failed to switch binlog format");
|
|
}
|
|
}
|
|
|
|
sub do_before_run_mysqltest($)
|
|
{
|
|
my $tinfo= shift;
|
|
|
|
# Remove old files produced by mysqltest
|
|
my $base_file= mtr_match_extension($tinfo->{'result_file'},
|
|
"result"); # Trim extension
|
|
unlink("$base_file.reject");
|
|
unlink("$base_file.progress");
|
|
unlink("$base_file.log");
|
|
unlink("$base_file.warnings");
|
|
|
|
if ( $mysql_version_id < 50000 ) {
|
|
# Set environment variable NDB_STATUS_OK to 1
|
|
# if script decided to run mysqltest cluster _is_ installed ok
|
|
$ENV{'NDB_STATUS_OK'} = "1";
|
|
} elsif ( $mysql_version_id < 50100 ) {
|
|
# Set environment variable NDB_STATUS_OK to YES
|
|
# if script decided to run mysqltest cluster _is_ installed ok
|
|
$ENV{'NDB_STATUS_OK'} = "YES";
|
|
}
|
|
}
|
|
|
|
|
|
sub run_check_testcase_all($$)
|
|
{
|
|
my ($tinfo, $mode)= @_;
|
|
my $result;
|
|
|
|
foreach my $mysqld ( mysqlds() )
|
|
{
|
|
if ( defined $mysqld->{'proc'} )
|
|
{
|
|
if (run_check_testcase($tinfo, $mode, $mysqld))
|
|
{
|
|
# Check failed, mark the test case with that info
|
|
$tinfo->{'check_testcase_failed'}= 1;
|
|
$result= 1;
|
|
}
|
|
}
|
|
}
|
|
return $result;
|
|
}
|
|
|
|
|
|
sub mark_log {
|
|
my ($log, $tinfo)= @_;
|
|
my $log_msg= "CURRENT_TEST: $tinfo->{name}\n";
|
|
mtr_tofile($log, $log_msg);
|
|
}
|
|
|
|
|
|
sub find_testcase_skipped_reason($)
|
|
{
|
|
my ($tinfo)= @_;
|
|
|
|
# Set default message
|
|
$tinfo->{'comment'}= "Detected by testcase(no log file)";
|
|
|
|
# Open mysqltest-time(the mysqltest log file)
|
|
my $F= IO::File->new($path_timefile)
|
|
or return;
|
|
my $reason;
|
|
|
|
while ( my $line= <$F> )
|
|
{
|
|
# Look for "reason: <reason for skipping test>"
|
|
if ( $line =~ /reason: (.*)/ )
|
|
{
|
|
$reason= $1;
|
|
}
|
|
}
|
|
|
|
if ( ! $reason )
|
|
{
|
|
mtr_warning("Could not find reason for skipping test in $path_timefile");
|
|
$reason= "Detected by testcase(reason unknown) ";
|
|
}
|
|
$tinfo->{'comment'}= $reason;
|
|
}
|
|
|
|
|
|
# Return timezone value of tinfo or default value
|
|
sub timezone {
|
|
my ($tinfo)= @_;
|
|
return $tinfo->{timezone} || "GMT-3";
|
|
}
|
|
|
|
|
|
# Storage for changed environment variables
|
|
my %old_env;
|
|
|
|
#
|
|
# Run a single test case
|
|
#
|
|
sub run_testcase ($) {
|
|
my $tinfo= shift;
|
|
|
|
mtr_verbose("Running test:", $tinfo->{name});
|
|
|
|
# -------------------------------------------------------
|
|
# Init variables that can change between each test case
|
|
# -------------------------------------------------------
|
|
my $timezone= timezone($tinfo);
|
|
$ENV{'TZ'}= $timezone;
|
|
mtr_verbose("Setting timezone: $timezone");
|
|
|
|
if ( ! using_extern() )
|
|
{
|
|
my @restart= servers_need_restart($tinfo);
|
|
if ( @restart != 0) {
|
|
stop_servers($tinfo, @restart );
|
|
}
|
|
|
|
if ( started(all_servers()) == 0 )
|
|
{
|
|
# Restore old ENV
|
|
while (my ($option, $value)= each( %old_env )) {
|
|
if (defined $value){
|
|
mtr_verbose("Restoring $option to $value");
|
|
$ENV{$option}= $value;
|
|
} else {
|
|
mtr_verbose("Removing $option");
|
|
delete($ENV{$option});
|
|
}
|
|
}
|
|
%old_env= ();
|
|
|
|
mtr_verbose("Generating my.cnf from '$tinfo->{template_path}'");
|
|
|
|
# Generate new config file from template
|
|
$config= My::ConfigFactory->new_config
|
|
( {
|
|
basedir => $basedir,
|
|
template_path => $tinfo->{template_path},
|
|
extra_template_path => $tinfo->{extra_template_path},
|
|
vardir => $opt_vardir,
|
|
tmpdir => $opt_tmpdir,
|
|
baseport => $opt_baseport,
|
|
#hosts => [ 'host1', 'host2' ],
|
|
user => $opt_user,
|
|
password => '',
|
|
ssl => $opt_ssl_supported,
|
|
}
|
|
);
|
|
|
|
# Write the new my.cnf
|
|
$config->save($path_config_file);
|
|
|
|
# Remember current config so a restart can occur when a test need
|
|
# to use a different one
|
|
$current_config_name= $tinfo->{template_path};
|
|
|
|
#
|
|
# Set variables in the ENV section
|
|
#
|
|
foreach my $option ($config->options_in_group("ENV"))
|
|
{
|
|
# Save old value to restore it before next time
|
|
$old_env{$option->name()}= $ENV{$option->name()};
|
|
|
|
mtr_verbose($option->name(), "=",$option->value());
|
|
$ENV{$option->name()}= $option->value();
|
|
}
|
|
}
|
|
|
|
# Write start of testcase to log
|
|
mark_log($path_current_test_log, $tinfo);
|
|
|
|
if (start_servers($tinfo))
|
|
{
|
|
report_failure_and_restart($tinfo);
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
# --------------------------------------------------------------------
|
|
# If --start or --start-dirty given, stop here to let user manually
|
|
# run tests
|
|
# ----------------------------------------------------------------------
|
|
if ( $opt_start or $opt_start_dirty )
|
|
{
|
|
mtr_report("\nServers started, sleeping");
|
|
sleep(1) while (1);
|
|
exit(0);
|
|
}
|
|
|
|
my $test_timeout_proc= My::SafeProcess->timer($opt_testcase_timeout * 60);
|
|
|
|
do_before_run_mysqltest($tinfo);
|
|
|
|
if ( $opt_check_testcases )
|
|
{
|
|
run_check_testcase_all($tinfo, "before")
|
|
}
|
|
|
|
my $test= start_mysqltest($tinfo);
|
|
|
|
while (1)
|
|
{
|
|
my $proc= My::SafeProcess->wait_any();
|
|
unless ( defined $proc )
|
|
{
|
|
mtr_error("wait_any failed");
|
|
}
|
|
mtr_verbose("Got $proc");
|
|
|
|
# ----------------------------------------------------
|
|
# Stop the test case timer
|
|
# ----------------------------------------------------
|
|
$test_timeout_proc->kill();
|
|
|
|
# ----------------------------------------------------
|
|
# Was it the test program that exited
|
|
# ----------------------------------------------------
|
|
if ($proc eq $test)
|
|
{
|
|
my $res= $test->exit_status();
|
|
|
|
if ( $res == 0 )
|
|
{
|
|
mtr_report_test_passed($tinfo, $opt_timer);
|
|
|
|
if ( $opt_check_testcases )
|
|
{
|
|
if (run_check_testcase_all($tinfo, "after"))
|
|
{
|
|
# Stop all servers that are known to be running
|
|
stop_all_servers();
|
|
mtr_report("Resuming tests...\n");
|
|
}
|
|
}
|
|
}
|
|
elsif ( $res == 62 )
|
|
{
|
|
# Testcase itself tell us to skip this one
|
|
$tinfo->{skip_detected_by_test}= 1;
|
|
# Try to get reason from mysqltest.log
|
|
find_testcase_skipped_reason($tinfo);
|
|
mtr_report_test_skipped($tinfo);
|
|
}
|
|
elsif ( $res == 65 )
|
|
{
|
|
# Testprogram killed by signal
|
|
$tinfo->{comment}=
|
|
"testprogram crashed(returned code $res)";
|
|
report_failure_and_restart($tinfo);
|
|
}
|
|
elsif ( $res == 1 )
|
|
{
|
|
# Test case failure reported by mysqltest
|
|
report_failure_and_restart($tinfo);
|
|
}
|
|
else
|
|
{
|
|
# mysqltest failed, probably crashed
|
|
$tinfo->{comment}=
|
|
"mysqltest failed with unexpected return code $res";
|
|
report_failure_and_restart($tinfo);
|
|
}
|
|
|
|
# Save info from this testcase run to mysqltest.log
|
|
my $path_mysqltest_log= "$opt_vardir/log/mysqltest.log";
|
|
mtr_appendfile_to_file($path_current_test_log, $path_mysqltest_log)
|
|
if -f $path_current_test_log;
|
|
mtr_appendfile_to_file($path_timefile, $path_mysqltest_log)
|
|
if -f $path_timefile;
|
|
|
|
# Remove the file that mysqltest writes info to
|
|
unlink($path_timefile);
|
|
# Remove the file that mysql-test-run writes info to
|
|
unlink($path_current_test_log);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
# ----------------------------------------------------
|
|
# Check if it was an expected crash
|
|
# ----------------------------------------------------
|
|
if ( check_expected_crash_and_restart($proc) )
|
|
{
|
|
next;
|
|
}
|
|
|
|
# ----------------------------------------------------
|
|
# It's not mysqltest that has exited, kill it
|
|
# ----------------------------------------------------
|
|
$test->kill();
|
|
|
|
# ----------------------------------------------------
|
|
# Check if it was a server that died
|
|
# ----------------------------------------------------
|
|
if ( grep($proc eq $_, started(all_servers())) )
|
|
{
|
|
# Server failed, probably crashed
|
|
$tinfo->{comment}=
|
|
"Server failed during test run";
|
|
|
|
report_failure_and_restart($tinfo);
|
|
return;
|
|
}
|
|
|
|
# ----------------------------------------------------
|
|
# Check if testcase timer expired
|
|
# ----------------------------------------------------
|
|
if ( $proc eq $test_timeout_proc )
|
|
{
|
|
mtr_report("Test case timeout!");
|
|
$tinfo->{'timeout'}= 1; # Mark as timeout
|
|
report_failure_and_restart($tinfo);
|
|
return;
|
|
}
|
|
|
|
# ----------------------------------------------------
|
|
# Check if test suite timer expired
|
|
# ----------------------------------------------------
|
|
if ( $proc eq $suite_timeout_proc )
|
|
{
|
|
mtr_report("Test suite timeout! Terminating...");
|
|
exit(1);
|
|
}
|
|
|
|
mtr_error("Unhandled process $proc exited");
|
|
}
|
|
}
|
|
|
|
|
|
#
|
|
# Loop through our list of processes and look for and entry
|
|
# with the provided pid, if found check for the file indicating
|
|
# expected crash and restart it.
|
|
#
|
|
sub check_expected_crash_and_restart {
|
|
my ($proc)= @_;
|
|
|
|
foreach my $mysqld ( mysqlds() )
|
|
{
|
|
next unless ( $mysqld->{proc} eq $proc );
|
|
|
|
# Check if crash expected by looking at the .expect file
|
|
# in var/tmp
|
|
my $expect_file= "$opt_vardir/tmp/".$mysqld->name().".expect";
|
|
if ( -f $expect_file )
|
|
{
|
|
mtr_verbose("Crash was expected, file $expect_file exists");
|
|
# Start server with same settings as last time
|
|
mysqld_start($mysqld, $mysqld->{'started_opts'});
|
|
unlink($expect_file);
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
# Not an expected crash
|
|
return 0;
|
|
}
|
|
|
|
|
|
#
|
|
# Save any interesting files in the data_dir
|
|
# before the data dir is removed.
|
|
#
|
|
sub save_files_after_test_failure($$) {
|
|
my $test_name= shift;
|
|
my $data_dir= shift;
|
|
my $save_name= "$opt_vardir/log/$test_name";
|
|
|
|
# Look for core files
|
|
foreach my $core_file ( glob("$data_dir/core*") )
|
|
{
|
|
last if $opt_max_save_core > 0 && $num_saved_cores >= $opt_max_save_core;
|
|
my $core_name= basename($core_file);
|
|
mtr_report(" - saving '$core_name'");
|
|
mkpath($save_name) if ! -d $save_name;
|
|
rename("$core_file", "$save_name/$core_name");
|
|
++$num_saved_cores;
|
|
}
|
|
}
|
|
|
|
|
|
sub after_test_failure ($) {
|
|
my $test_name= shift;
|
|
|
|
mtr_report("Cleaning datadirs...");
|
|
|
|
foreach my $mysqld ( mysqlds() )
|
|
{
|
|
my $data_dir= $mysqld->value('datadir');
|
|
my $name= basename($data_dir);
|
|
save_files_after_test_failure($test_name, $data_dir);
|
|
mtr_debug("Removing '$data_dir'");
|
|
rmtree($data_dir);
|
|
}
|
|
|
|
# Remove the ndb_*_fs dirs for all ndbd nodes
|
|
# forcing a clean start of ndb next time
|
|
foreach my $cluster ( clusters() )
|
|
{
|
|
foreach my $ndbd ( ndbds($cluster) )
|
|
{
|
|
my $datadir= $ndbd->value('DataDir');
|
|
foreach my $fs_dir ( glob("$datadir/ndb_*_fs") ) {
|
|
if (-d $fs_dir) {
|
|
rmtree($fs_dir);
|
|
mtr_debug("Removing '$fs_dir'");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
sub report_failure_and_restart ($) {
|
|
my $tinfo= shift;
|
|
|
|
mtr_report_test_failed($tinfo, $path_timefile);
|
|
print "\n";
|
|
if ( $opt_force )
|
|
{
|
|
# Stop all servers that are known to be running
|
|
stop_all_servers();
|
|
|
|
after_test_failure($tinfo->{'name'});
|
|
mtr_report("Resuming tests...\n");
|
|
return;
|
|
}
|
|
mtr_error("Test '$tinfo->{'name'}' failed.",
|
|
"To continue, re-run with '--force'");
|
|
}
|
|
|
|
|
|
sub run_sh_script {
|
|
my ($script)= @_;
|
|
|
|
return 0 unless defined $script;
|
|
|
|
mtr_verbose("Running '$script'");
|
|
my $ret= system("/bin/sh $script") >> 8;
|
|
return $ret;
|
|
}
|
|
|
|
|
|
sub mysqld_stop {
|
|
my $mysqld= shift or die "usage: mysqld_stop(<mysqld>)";
|
|
|
|
my $args;
|
|
mtr_init_args(\$args);
|
|
|
|
mtr_add_arg($args, "--no-defaults");
|
|
mtr_add_arg($args, "--user=%s", $opt_user);
|
|
mtr_add_arg($args, "--password=");
|
|
mtr_add_arg($args, "--port=%d", $mysqld->value('port'));
|
|
mtr_add_arg($args, "--host=%s", $mysqld->value('#host'));
|
|
mtr_add_arg($args, "--connect_timeout=20");
|
|
mtr_add_arg($args, "--protocol=tcp");
|
|
|
|
mtr_add_arg($args, "shutdown");
|
|
|
|
My::SafeProcess->run
|
|
(
|
|
name => "mysqladmin shutdown ".$mysqld->name(),
|
|
path => $exe_mysqladmin,
|
|
args => \$args,
|
|
error => "/dev/null",
|
|
|
|
);
|
|
}
|
|
|
|
|
|
sub mysqld_arguments ($$$) {
|
|
my $args= shift;
|
|
my $mysqld= shift;
|
|
my $extra_opt= shift;
|
|
|
|
my $prefix= ""; # If mysqltest server arg
|
|
if ( $opt_embedded_server )
|
|
{
|
|
$prefix= "--server-arg=";
|
|
}
|
|
|
|
mtr_add_arg($args, "%s--defaults-file=%s", $prefix, $path_config_file);
|
|
mtr_add_arg($args, "--defaults-group-suffix=%s", $mysqld->after('mysqld'));
|
|
|
|
# When mysqld is run by a root user(euid is 0), it will fail
|
|
# to start unless we specify what user to run as, see BUG#30630
|
|
my $euid= $>;
|
|
if (!$is_win32 and $euid == 0 and
|
|
(grep(/^--user/, @$extra_opt, @opt_extra_mysqld_opt)) == 0) {
|
|
mtr_add_arg($args, "%s--user=root", $prefix);
|
|
}
|
|
|
|
if ( $opt_valgrind_mysqld )
|
|
{
|
|
mtr_add_arg($args, "%s--skip-safemalloc", $prefix);
|
|
|
|
if ( $mysql_version_id < 50100 )
|
|
{
|
|
mtr_add_arg($args, "%s--skip-bdb", $prefix);
|
|
}
|
|
}
|
|
|
|
if ( $mysql_version_id >= 50106 )
|
|
{
|
|
# Turn on logging to both tables and file
|
|
mtr_add_arg($args, "%s--log-output=table,file", $prefix);
|
|
}
|
|
|
|
# Check if "extra_opt" contains skip-log-bin
|
|
my $skip_binlog= grep(/^(--|--loose-)skip-log-bin/,
|
|
@$extra_opt, @opt_extra_mysqld_opt);
|
|
|
|
if ( $opt_debug )
|
|
{
|
|
mtr_add_arg($args, "%s--debug=d:t:i:A,%s/log/%s.trace",
|
|
$prefix, $path_vardir_trace, $mysqld->name());
|
|
}
|
|
|
|
# Indicate to mysqld it will be debugged in debugger
|
|
if ( $glob_debugger )
|
|
{
|
|
mtr_add_arg($args, "%s--gdb", $prefix);
|
|
}
|
|
|
|
my $found_skip_core= 0;
|
|
foreach my $arg ( @opt_extra_mysqld_opt, @$extra_opt )
|
|
{
|
|
# Allow --skip-core-file to be set in <testname>-[master|slave].opt file
|
|
if ($arg eq "--skip-core-file")
|
|
{
|
|
$found_skip_core= 1;
|
|
}
|
|
elsif ($skip_binlog and mtr_match_prefix($arg, "--binlog-format"))
|
|
{
|
|
; # Dont add --binlog-format when running without binlog
|
|
}
|
|
else
|
|
{
|
|
mtr_add_arg($args, "%s%s", $prefix, $arg);
|
|
}
|
|
}
|
|
if ( !$found_skip_core )
|
|
{
|
|
mtr_add_arg($args, "%s%s", $prefix, "--core-file");
|
|
}
|
|
|
|
if ( $is_win32 ){
|
|
mtr_add_arg($args, "%s--log-error=%s", $prefix, $mysqld->{"path_myerr"});
|
|
}
|
|
|
|
return $args;
|
|
}
|
|
|
|
|
|
sub mysqld_start ($$) {
|
|
my $mysqld= shift;
|
|
my $extra_opt= shift;
|
|
|
|
my $exe= $exe_mysqld;
|
|
my $wait_for_pid_file= 1;
|
|
|
|
mtr_error("Internal error: mysqld should never be started for embedded")
|
|
if $opt_embedded_server;
|
|
|
|
my $args;
|
|
mtr_init_args(\$args);
|
|
|
|
if ( $opt_valgrind_mysqld )
|
|
{
|
|
valgrind_arguments($args, \$exe);
|
|
}
|
|
|
|
mysqld_arguments($args,$mysqld,$extra_opt);
|
|
|
|
if ( $opt_gdb || $opt_manual_gdb )
|
|
{
|
|
gdb_arguments(\$args, \$exe, $mysqld->name());
|
|
}
|
|
elsif ( $opt_ddd || $opt_manual_ddd )
|
|
{
|
|
ddd_arguments(\$args, \$exe, $mysqld->name());
|
|
}
|
|
elsif ( $opt_debugger )
|
|
{
|
|
debugger_arguments(\$args, \$exe, $mysqld->name());
|
|
}
|
|
elsif ( $opt_manual_debug )
|
|
{
|
|
print "\nStart $mysqld->name() in your debugger\n" .
|
|
"dir: $glob_mysql_test_dir\n" .
|
|
"exe: $exe\n" .
|
|
"args: " . join(" ", @$args) . "\n\n" .
|
|
"Waiting ....\n";
|
|
|
|
# Indicate the exe should not be started
|
|
$exe= undef;
|
|
}
|
|
else
|
|
{
|
|
# Default to not wait until pid file has been created
|
|
$wait_for_pid_file= 0;
|
|
}
|
|
|
|
# Remove the old pidfile if any
|
|
unlink($mysqld->value('pid-file'));
|
|
|
|
my $output= $mysqld->value('log-error');
|
|
if ( $opt_valgrind and $opt_debug )
|
|
{
|
|
# When both --valgrind and --debug is selected, send
|
|
# all output to the trace file, making it possible to
|
|
# see the exact location where valgrind complains
|
|
$output= "$opt_vardir/log/".$mysqld->name().".trace";
|
|
}
|
|
|
|
if ( defined $exe )
|
|
{
|
|
$mysqld->{'proc'}= My::SafeProcess->new
|
|
(
|
|
name => $mysqld->name(),
|
|
path => $exe,
|
|
args => \$args,
|
|
output => $output,
|
|
error => $output,
|
|
append => 1,
|
|
verbose => $opt_verbose,
|
|
host => undef,
|
|
shutdown => sub { mysqld_stop($mysqld) },
|
|
);
|
|
mtr_verbose("Started $mysqld->{proc}");
|
|
}
|
|
|
|
if ( $wait_for_pid_file &&
|
|
!sleep_until_file_created($mysqld->value('pid-file'),
|
|
$opt_start_timeout,
|
|
$mysqld->{'proc'}))
|
|
{
|
|
mtr_error("Failed to start mysqld $mysqld->name()");
|
|
}
|
|
|
|
# Remember options used when starting
|
|
$mysqld->{'started_opts'}= $extra_opt;
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
sub stop_all_servers () {
|
|
|
|
mtr_report("Stopping all servers...");
|
|
|
|
# Kill all started servers
|
|
My::SafeProcess::shutdown(0, # shutdown timeout 0 => kill
|
|
started(all_servers()));
|
|
|
|
# Mark servers as stopped
|
|
map($_->{proc}= undef, all_servers());
|
|
|
|
}
|
|
|
|
|
|
|
|
# Find out if server should be restarted for this test
|
|
sub server_need_restart {
|
|
my ($tinfo, $server)= @_;
|
|
|
|
if ( using_extern() )
|
|
{
|
|
mtr_verbose("No restart: using extern");
|
|
return 0;
|
|
}
|
|
|
|
if ( $opt_embedded_server )
|
|
{
|
|
mtr_verbose("No start or restart for embedded server");
|
|
return 0;
|
|
}
|
|
|
|
if ( $tinfo->{'force_restart'} ) {
|
|
mtr_verbose("Restart: forced in .opt file");
|
|
return 1;
|
|
}
|
|
|
|
if ( $tinfo->{template_path} ne $current_config_name)
|
|
{
|
|
mtr_verbose("Restart: using different config file");
|
|
return 1;
|
|
}
|
|
|
|
if ( $tinfo->{'master_sh'} || $tinfo->{'slave_sh'} )
|
|
{
|
|
mtr_verbose("Restart: script to run");
|
|
return 1;
|
|
}
|
|
|
|
if ( ! started($server) )
|
|
{
|
|
mtr_verbose("Restart: not started");
|
|
return 1;
|
|
}
|
|
|
|
my $started_tinfo= $server->{'started_tinfo'};
|
|
if ( defined $started_tinfo )
|
|
{
|
|
|
|
# Check if timezone of test that server was started
|
|
# with differs from timezone of next test
|
|
if ( timezone($started_tinfo) ne timezone($tinfo) )
|
|
{
|
|
mtr_verbose("Restart: Different timezone");
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
my $is_mysqld= grep ($server eq $_, mysqlds());
|
|
if ($is_mysqld)
|
|
{
|
|
|
|
# Check that running process was started with same options
|
|
# as the current test requires
|
|
my $extra_opt= get_extra_opt($server, $tinfo);
|
|
my $started_opts= $server->{'started_opts'};
|
|
if (defined $started_opts and $extra_opt and
|
|
! mtr_same_opts($started_opts, $extra_opt) )
|
|
{
|
|
# TODO Use a list to find all options that can be set dynamically
|
|
|
|
# Check if diff is binlog format only
|
|
# and the next test has $binlog_format_switch set
|
|
my @diff_opts= mtr_diff_opts($started_opts, $extra_opt);
|
|
if (@diff_opts == 2 and
|
|
$diff_opts[0] =~/^--binlog-format=/ and
|
|
$diff_opts[1] =~/^--binlog-format=/ and
|
|
defined $tinfo->{binlog_format_switch})
|
|
{
|
|
mtr_verbose("Using dynamic switch of binlog format from ",
|
|
$diff_opts[0],"to", $diff_opts[1]);
|
|
dynamic_binlog_format_switch($tinfo, $server);
|
|
}
|
|
else
|
|
{
|
|
mtr_verbose("Restart: running with different options '" .
|
|
join(" ", @{$extra_opt}) . "' != '" .
|
|
join(" ", @{$server->{'started_opts'}}) . "'" );
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
# Default, no restart
|
|
return 0;
|
|
}
|
|
|
|
|
|
sub servers_need_restart($) {
|
|
my ($tinfo)= @_;
|
|
return grep { server_need_restart($tinfo, $_); } all_servers();
|
|
}
|
|
|
|
|
|
|
|
#
|
|
# Return list of specific servers
|
|
# - there is no servers in an empty config
|
|
#
|
|
sub _like { return $config ? $config->like($_[0]) : (); }
|
|
sub mysqlds { return _like('mysqld.'); }
|
|
sub ndbds { return _like('cluster_config.ndbd.');}
|
|
sub ndb_mgmds { return _like('cluster_config.ndb_mgmd.'); }
|
|
sub clusters { return _like('mysql_cluster.'); }
|
|
sub all_servers { return ( mysqlds(), ndb_mgmds(), ndbds() ); }
|
|
|
|
|
|
#
|
|
# Filter a list of servers and return only those that are part
|
|
# of the specified cluster
|
|
#
|
|
sub in_cluster {
|
|
my ($cluster)= shift;
|
|
# Return only processes for a specific cluster
|
|
return grep { $_->suffix() eq $cluster->suffix() } @_;
|
|
}
|
|
|
|
|
|
|
|
#
|
|
# Filter a list of servers and return the SafeProcess
|
|
# for only those that are started or stopped
|
|
#
|
|
sub started { return grep(defined $_, map($_->{proc}, @_)); }
|
|
sub stopped { return grep(!defined $_, map($_->{proc}, @_)); }
|
|
|
|
|
|
sub get_extra_opt {
|
|
my ($mysqld, $tinfo)= @_;
|
|
|
|
return
|
|
$mysqld->option("#!use-slave-opt") ?
|
|
$tinfo->{slave_opt} : $tinfo->{master_opt};
|
|
}
|
|
|
|
|
|
sub stop_servers($$) {
|
|
my ($tinfo, @servers)= @_;
|
|
|
|
# Remember if we restarted for this test case (count restarts)
|
|
$tinfo->{'restarted'}= 1;
|
|
|
|
if ( join('|', @servers) eq join('|', all_servers()) )
|
|
{
|
|
# All servers are going down, use some kind of order to
|
|
# avoid too many warnings in the log files
|
|
|
|
mtr_verbose("All servers are going down");
|
|
|
|
# mysqld processes
|
|
My::SafeProcess::shutdown( $opt_shutdown_timeout, started(mysqlds()) );
|
|
|
|
# cluster processes
|
|
My::SafeProcess::shutdown( $opt_shutdown_timeout,
|
|
started(ndbds(), ndb_mgmds()) );
|
|
}
|
|
else
|
|
{
|
|
# Stop only some servers
|
|
My::SafeProcess::shutdown( $opt_shutdown_timeout,
|
|
started(@servers) );
|
|
}
|
|
|
|
foreach my $server (@servers)
|
|
{
|
|
# Remove datadir
|
|
if ( $server->option('#!remove-datadir') )
|
|
{
|
|
my $datadir= $server->value('datadir');
|
|
mtr_debug("Removing '$datadir'");
|
|
rmtree($datadir);
|
|
}
|
|
|
|
# Mark server as stopped
|
|
$server->{proc}= undef;
|
|
|
|
# Forget history
|
|
delete $server->{'started_tinfo'};
|
|
delete $server->{'started_opts'};
|
|
delete $server->{'started_cnf'};
|
|
}
|
|
}
|
|
|
|
|
|
#
|
|
# start_servers
|
|
#
|
|
# Start servers not already started
|
|
#
|
|
# RETURN
|
|
# 0 OK
|
|
# 1 Start failed
|
|
#
|
|
sub start_servers($) {
|
|
my ($tinfo)= @_;
|
|
|
|
# Start clusters
|
|
foreach my $cluster ( clusters() )
|
|
{
|
|
ndbcluster_start($cluster);
|
|
}
|
|
|
|
# Start mysqlds
|
|
foreach my $mysqld ( mysqlds() )
|
|
{
|
|
if ( $mysqld->{proc} )
|
|
{
|
|
# Already started
|
|
|
|
# Write start of testcase to log file
|
|
mark_log($mysqld->value('log-error'), $tinfo);
|
|
|
|
next;
|
|
}
|
|
|
|
my $datadir= $mysqld->value('datadir');
|
|
|
|
# Don't delete anything if starting dirty
|
|
if (!$opt_start_dirty)
|
|
{
|
|
my @options= ('log-bin', 'relay-log');
|
|
|
|
foreach my $option_name ( @options ) {
|
|
next unless $mysqld->option($option_name);
|
|
|
|
my $value= $mysqld->value($option_name);
|
|
|
|
foreach my $file ( glob("$datadir/$value*") )
|
|
{
|
|
#print "removing: $file\n";
|
|
mtr_debug("Removing '$file'");
|
|
unlink($file);
|
|
}
|
|
}
|
|
|
|
# Remove old master.info and relay-log.info files
|
|
# from the servers datadir
|
|
unlink("$datadir/master.info");
|
|
unlink("$datadir/relay-log.info");
|
|
}
|
|
|
|
# Copy datadir from installed system db
|
|
copy_install_db($datadir) unless -d $datadir;
|
|
|
|
# Write start of testcase to log file
|
|
mark_log($mysqld->value('log-error'), $tinfo);
|
|
|
|
# Run <tname>-master.sh
|
|
if ($mysqld->option('#!run-master-sh') and
|
|
run_sh_script($tinfo->{master_sh}) )
|
|
{
|
|
$tinfo->{'comment'}= "Failed to execute '$tinfo->{master_sh}'";
|
|
return 1;
|
|
}
|
|
|
|
# Run <tname>-slave.sh
|
|
if ($mysqld->option('#!run-slave-sh') and
|
|
run_sh_script($tinfo->{slave_sh}))
|
|
{
|
|
$tinfo->{'comment'}= "Failed to execute '$tinfo->{slave_sh}'";
|
|
return 1;
|
|
}
|
|
|
|
my $extra_opt= get_extra_opt($mysqld, $tinfo);
|
|
mysqld_start($mysqld,$extra_opt);
|
|
|
|
# Save this test case information, so next can examine it
|
|
$mysqld->{'started_tinfo'}= $tinfo;
|
|
}
|
|
|
|
# Wait for clusters to start
|
|
foreach my $cluster ( clusters() )
|
|
{
|
|
if (ndbcluster_wait_started($cluster, ""))
|
|
{
|
|
# failed to start
|
|
$tinfo->{'comment'}= "Start of '".$cluster->name()."' cluster failed";
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
# Wait for mysqlds to start
|
|
foreach my $mysqld ( mysqlds() )
|
|
{
|
|
if (sleep_until_file_created($mysqld->value('pid-file'),
|
|
$opt_start_timeout,
|
|
$mysqld->{'proc'}) == 0) {
|
|
$tinfo->{comment}=
|
|
"Failed to start ".$mysqld->name();
|
|
return 1;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
#
|
|
# Run include/check-testcase.test
|
|
# Before a testcase, run in record mode and save result file to var/tmp
|
|
# After testcase, run and compare with the recorded file, they should be equal!
|
|
#
|
|
# RETURN VALUE
|
|
# 0 OK
|
|
# 1 Check failed
|
|
#
|
|
sub run_check_testcase ($$$) {
|
|
my $tinfo= shift;
|
|
my $mode= shift;
|
|
my $mysqld= shift;
|
|
|
|
my $name= "check-".$mysqld->name();
|
|
my $tname= $tinfo->{name};
|
|
|
|
my $args;
|
|
mtr_init_args(\$args);
|
|
|
|
mtr_add_arg($args, "--no-defaults");
|
|
mtr_add_arg($args, "--silent");
|
|
mtr_add_arg($args, "--skip-safemalloc");
|
|
mtr_add_arg($args, "--tmpdir=%s", $opt_tmpdir);
|
|
mtr_add_arg($args, "--character-sets-dir=%s", $path_charsetsdir);
|
|
|
|
mtr_add_arg($args, "--socket=%s", $mysqld->value('socket'));
|
|
mtr_add_arg($args, "--port=%d", $mysqld->value('port'));
|
|
mtr_add_arg($args, "--database=test");
|
|
mtr_add_arg($args, "--user=%s", $opt_user);
|
|
mtr_add_arg($args, "--password=");
|
|
|
|
mtr_add_arg($args, "--result-file=%s", "$opt_vardir/tmp/$name.result");
|
|
mtr_add_arg($args, "--test-file=%s", "include/check-testcase.test");
|
|
|
|
if ( $mode eq "before" )
|
|
{
|
|
mtr_add_arg($args, "--record");
|
|
}
|
|
my $errfile= "$opt_vardir/tmp/$name.err";
|
|
my $res= My::SafeProcess->run
|
|
(
|
|
name => $name,
|
|
path => $exe_mysqltest,
|
|
error => $errfile,
|
|
args => \$args,
|
|
);
|
|
|
|
if ( $mode eq "after" and $res == 1 )
|
|
{
|
|
mtr_report("\nThe check of testcase '$tname' failed, this is the\n",
|
|
"diff between before and after:\n");
|
|
# Test failed, display the report mysqltest has created
|
|
mtr_printfile("$opt_vardir/tmp/$name.err");
|
|
}
|
|
elsif ( $res )
|
|
{
|
|
mtr_report("\nCould not execute 'check-testcase' $mode testcase '$tname':");
|
|
mtr_printfile("$opt_vardir/tmp/$name.err");
|
|
mtr_report();
|
|
}
|
|
return $res;
|
|
}
|
|
|
|
|
|
sub run_mysqltest ($) {
|
|
my $proc= start_mysqltest(@_);
|
|
$proc->wait();
|
|
}
|
|
|
|
|
|
sub start_mysqltest ($) {
|
|
my ($tinfo)= @_;
|
|
my $exe= $exe_mysqltest;
|
|
my $args;
|
|
|
|
mtr_init_args(\$args);
|
|
|
|
mtr_add_arg($args, "--defaults-file=%s", $path_config_file);
|
|
mtr_add_arg($args, "--silent");
|
|
mtr_add_arg($args, "--skip-safemalloc");
|
|
mtr_add_arg($args, "--tmpdir=%s", $opt_tmpdir);
|
|
mtr_add_arg($args, "--character-sets-dir=%s", $path_charsetsdir);
|
|
mtr_add_arg($args, "--logdir=%s/log", $opt_vardir);
|
|
|
|
# Log line number and time for each line in .test file
|
|
mtr_add_arg($args, "--mark-progress")
|
|
if $opt_mark_progress;
|
|
|
|
mtr_add_arg($args, "--database=test");
|
|
|
|
if ( $opt_ps_protocol )
|
|
{
|
|
mtr_add_arg($args, "--ps-protocol");
|
|
}
|
|
|
|
if ( $opt_sp_protocol )
|
|
{
|
|
mtr_add_arg($args, "--sp-protocol");
|
|
}
|
|
|
|
if ( $opt_view_protocol )
|
|
{
|
|
mtr_add_arg($args, "--view-protocol");
|
|
}
|
|
|
|
if ( $opt_cursor_protocol )
|
|
{
|
|
mtr_add_arg($args, "--cursor-protocol");
|
|
}
|
|
|
|
if ( $opt_strace_client )
|
|
{
|
|
$exe= $opt_strace_client || "strace";
|
|
mtr_add_arg($args, "-o");
|
|
mtr_add_arg($args, "%s/log/mysqltest.strace", $opt_vardir);
|
|
mtr_add_arg($args, "$exe_mysqltest");
|
|
}
|
|
|
|
if ( $opt_timer )
|
|
{
|
|
mtr_add_arg($args, "--timer-file=%s/log/timer", $opt_vardir);
|
|
}
|
|
|
|
if ( $opt_compress )
|
|
{
|
|
mtr_add_arg($args, "--compress");
|
|
}
|
|
|
|
if ( $opt_sleep )
|
|
{
|
|
mtr_add_arg($args, "--sleep=%d", $opt_sleep);
|
|
}
|
|
|
|
client_debug_arg($args, "mysqltest");
|
|
|
|
if ( $opt_ssl )
|
|
{
|
|
# Turn on SSL for _all_ test cases if option --ssl was used
|
|
mtr_add_arg($args, "--ssl");
|
|
}
|
|
elsif ( $opt_ssl_supported )
|
|
{
|
|
mtr_add_arg($args, "--skip-ssl");
|
|
}
|
|
|
|
|
|
# ----------------------------------------------------------------------
|
|
# export MYSQL_TEST variable containing <path>/mysqltest <args>
|
|
# ----------------------------------------------------------------------
|
|
$ENV{'MYSQL_TEST'}=
|
|
mtr_native_path($exe_mysqltest) . " " . join(" ", @$args);
|
|
|
|
# ----------------------------------------------------------------------
|
|
# Add arguments that should not go into the MYSQL_TEST env var
|
|
# ----------------------------------------------------------------------
|
|
if ( $opt_valgrind_mysqltest )
|
|
{
|
|
# Prefix the Valgrind options to the argument list.
|
|
# We do this here, since we do not want to Valgrind the nested invocations
|
|
# of mysqltest; that would mess up the stderr output causing test failure.
|
|
my @args_saved = @$args;
|
|
mtr_init_args(\$args);
|
|
valgrind_arguments($args, \$exe);
|
|
mtr_add_arg($args, "%s", $_) for @args_saved;
|
|
}
|
|
|
|
mtr_add_arg($args, "--test-file=%s", $tinfo->{'path'});
|
|
|
|
# Number of lines of resut to include in failure report
|
|
mtr_add_arg($args, "--tail-lines=20");
|
|
|
|
if ( defined $tinfo->{'result_file'} ) {
|
|
mtr_add_arg($args, "--result-file=%s", $tinfo->{'result_file'});
|
|
}
|
|
|
|
if ( $opt_record )
|
|
{
|
|
mtr_add_arg($args, "--record");
|
|
}
|
|
|
|
if ( $opt_client_gdb )
|
|
{
|
|
gdb_arguments(\$args, \$exe, "client");
|
|
}
|
|
elsif ( $opt_client_ddd )
|
|
{
|
|
ddd_arguments(\$args, \$exe, "client");
|
|
}
|
|
elsif ( $opt_client_debugger )
|
|
{
|
|
debugger_arguments(\$args, \$exe, "client");
|
|
}
|
|
|
|
|
|
my $proc= My::SafeProcess->new
|
|
(
|
|
name => "mysqltest",
|
|
path => $exe,
|
|
args => \$args,
|
|
error => $path_timefile,
|
|
verbose => $opt_verbose,
|
|
);
|
|
mtr_verbose("Started $proc");
|
|
return $proc;
|
|
}
|
|
|
|
|
|
#
|
|
# Modify the exe and args so that program is run in gdb in xterm
|
|
#
|
|
sub gdb_arguments {
|
|
my $args= shift;
|
|
my $exe= shift;
|
|
my $type= shift;
|
|
|
|
# Write $args to gdb init file
|
|
my $str= join(" ", @$$args);
|
|
my $gdb_init_file= "$opt_tmpdir/gdbinit.$type";
|
|
|
|
# Remove the old gdbinit file
|
|
unlink($gdb_init_file);
|
|
|
|
if ( $type eq "client" )
|
|
{
|
|
# write init file for client
|
|
mtr_tofile($gdb_init_file,
|
|
"set args $str\n" .
|
|
"break main\n");
|
|
}
|
|
else
|
|
{
|
|
# write init file for mysqld
|
|
mtr_tofile($gdb_init_file,
|
|
"set args $str\n" .
|
|
"break mysql_parse\n" .
|
|
"commands 1\n" .
|
|
"disable 1\n" .
|
|
"end\n" .
|
|
"run");
|
|
}
|
|
|
|
if ( $opt_manual_gdb )
|
|
{
|
|
print "\nTo start gdb for $type, type in another window:\n";
|
|
print "gdb -cd $glob_mysql_test_dir -x $gdb_init_file $$exe\n";
|
|
|
|
# Indicate the exe should not be started
|
|
$$exe= undef;
|
|
return;
|
|
}
|
|
|
|
$$args= [];
|
|
mtr_add_arg($$args, "-title");
|
|
mtr_add_arg($$args, "$type");
|
|
mtr_add_arg($$args, "-e");
|
|
|
|
if ( $exe_libtool )
|
|
{
|
|
mtr_add_arg($$args, $exe_libtool);
|
|
mtr_add_arg($$args, "--mode=execute");
|
|
}
|
|
|
|
mtr_add_arg($$args, "gdb");
|
|
mtr_add_arg($$args, "-x");
|
|
mtr_add_arg($$args, "$gdb_init_file");
|
|
mtr_add_arg($$args, "$$exe");
|
|
|
|
$$exe= "xterm";
|
|
}
|
|
|
|
|
|
#
|
|
# Modify the exe and args so that program is run in ddd
|
|
#
|
|
sub ddd_arguments {
|
|
my $args= shift;
|
|
my $exe= shift;
|
|
my $type= shift;
|
|
|
|
# Write $args to ddd init file
|
|
my $str= join(" ", @$$args);
|
|
my $gdb_init_file= "$opt_tmpdir/gdbinit.$type";
|
|
|
|
# Remove the old gdbinit file
|
|
unlink($gdb_init_file);
|
|
|
|
if ( $type eq "client" )
|
|
{
|
|
# write init file for client
|
|
mtr_tofile($gdb_init_file,
|
|
"set args $str\n" .
|
|
"break main\n");
|
|
}
|
|
else
|
|
{
|
|
# write init file for mysqld
|
|
mtr_tofile($gdb_init_file,
|
|
"file $$exe\n" .
|
|
"set args $str\n" .
|
|
"break mysql_parse\n" .
|
|
"commands 1\n" .
|
|
"disable 1\n" .
|
|
"end");
|
|
}
|
|
|
|
if ( $opt_manual_ddd )
|
|
{
|
|
print "\nTo start ddd for $type, type in another window:\n";
|
|
print "ddd -cd $glob_mysql_test_dir -x $gdb_init_file $$exe\n";
|
|
|
|
# Indicate the exe should not be started
|
|
$$exe= undef;
|
|
return;
|
|
}
|
|
|
|
my $save_exe= $$exe;
|
|
$$args= [];
|
|
if ( $exe_libtool )
|
|
{
|
|
$$exe= $exe_libtool;
|
|
mtr_add_arg($$args, "--mode=execute");
|
|
mtr_add_arg($$args, "ddd");
|
|
}
|
|
else
|
|
{
|
|
$$exe= "ddd";
|
|
}
|
|
mtr_add_arg($$args, "--command=$gdb_init_file");
|
|
mtr_add_arg($$args, "$save_exe");
|
|
}
|
|
|
|
|
|
#
|
|
# Modify the exe and args so that program is run in the selected debugger
|
|
#
|
|
sub debugger_arguments {
|
|
my $args= shift;
|
|
my $exe= shift;
|
|
my $debugger= $opt_debugger || $opt_client_debugger;
|
|
|
|
if ( $debugger =~ /vcexpress|vc|devenv/ )
|
|
{
|
|
# vc[express] /debugexe exe arg1 .. argn
|
|
|
|
# Add /debugexe and name of the exe before args
|
|
unshift(@$$args, "/debugexe");
|
|
unshift(@$$args, "$$exe");
|
|
|
|
# Set exe to debuggername
|
|
$$exe= $debugger;
|
|
|
|
}
|
|
elsif ( $debugger =~ /windbg/ )
|
|
{
|
|
# windbg exe arg1 .. argn
|
|
|
|
# Add name of the exe before args
|
|
unshift(@$$args, "$$exe");
|
|
|
|
# Set exe to debuggername
|
|
$$exe= $debugger;
|
|
|
|
}
|
|
elsif ( $debugger eq "dbx" )
|
|
{
|
|
# xterm -e dbx -r exe arg1 .. argn
|
|
|
|
unshift(@$$args, $$exe);
|
|
unshift(@$$args, "-r");
|
|
unshift(@$$args, $debugger);
|
|
unshift(@$$args, "-e");
|
|
|
|
$$exe= "xterm";
|
|
|
|
}
|
|
else
|
|
{
|
|
mtr_error("Unknown argument \"$debugger\" passed to --debugger");
|
|
}
|
|
}
|
|
|
|
|
|
#
|
|
# Modify the exe and args so that program is run in valgrind
|
|
#
|
|
sub valgrind_arguments {
|
|
my $args= shift;
|
|
my $exe= shift;
|
|
|
|
if ( $opt_callgrind)
|
|
{
|
|
mtr_add_arg($args, "--tool=callgrind");
|
|
mtr_add_arg($args, "--base=$opt_vardir/log");
|
|
}
|
|
else
|
|
{
|
|
mtr_add_arg($args, "--tool=memcheck"); # From >= 2.1.2 needs this option
|
|
mtr_add_arg($args, "--alignment=8");
|
|
mtr_add_arg($args, "--leak-check=yes");
|
|
mtr_add_arg($args, "--num-callers=16");
|
|
mtr_add_arg($args, "--suppressions=%s/valgrind.supp", $glob_mysql_test_dir)
|
|
if -f "$glob_mysql_test_dir/valgrind.supp";
|
|
}
|
|
|
|
# Add valgrind options, can be overriden by user
|
|
mtr_add_arg($args, '%s', $_) for (@valgrind_args);
|
|
|
|
mtr_add_arg($args, $$exe);
|
|
|
|
$$exe= $opt_valgrind_path || "valgrind";
|
|
|
|
if ($exe_libtool)
|
|
{
|
|
# Add "libtool --mode-execute" before the test to execute
|
|
# if running in valgrind(to avoid valgrinding bash)
|
|
unshift(@$args, "--mode=execute", $$exe);
|
|
$$exe= $exe_libtool;
|
|
}
|
|
}
|
|
|
|
|
|
#
|
|
# Usage
|
|
#
|
|
sub usage ($) {
|
|
my $message= shift;
|
|
|
|
if ( $message )
|
|
{
|
|
print STDERR "$message\n";
|
|
}
|
|
|
|
print <<HERE;
|
|
|
|
$0 [ OPTIONS ] [ TESTCASE ]
|
|
|
|
Options to control what engine/variation to run
|
|
|
|
embedded-server Use the embedded server, i.e. no mysqld daemons
|
|
ps-protocol Use the binary protocol between client and server
|
|
cursor-protocol Use the cursor protocol between client and server
|
|
(implies --ps-protocol)
|
|
view-protocol Create a view to execute all non updating queries
|
|
sp-protocol Create a stored procedure to execute all queries
|
|
compress Use the compressed protocol between client and server
|
|
ssl Use ssl protocol between client and server
|
|
skip-ssl Dont start server with support for ssl connections
|
|
ndb|with-ndbcluster Use cluster as default table type
|
|
vs-config Visual Studio configuration used to create executables
|
|
(default: MTR_VS_CONFIG environment variable)
|
|
|
|
config|defaults-file=<config template> Use fixed config template for all
|
|
tests
|
|
extra_defaults_file=<config template> Extra config template to add to
|
|
all generated configs
|
|
|
|
Options to control directories to use
|
|
benchdir=DIR The directory where the benchmark suite is stored
|
|
(default: ../../mysql-bench)
|
|
tmpdir=DIR The directory where temporary files are stored
|
|
(default: ./var/tmp).
|
|
vardir=DIR The directory where files generated from the test run
|
|
is stored (default: ./var). Specifying a ramdisk or
|
|
tmpfs will speed up tests.
|
|
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 MTR_MEM=[DIR]
|
|
|
|
Options to control what test suites or cases to run
|
|
|
|
force Continue to run the suite after failure
|
|
with-ndbcluster-only Run only tests that include "ndb" in the filename
|
|
skip-ndb[cluster] Skip all tests that need cluster
|
|
skip-ndb[cluster]-slave Skip all tests that need a slave cluster
|
|
ndb-extra Run extra tests from ndb directory
|
|
do-test=PREFIX or REGEX
|
|
Run test cases which name are prefixed with PREFIX
|
|
or fulfills REGEX
|
|
skip-test=PREFIX or REGEX
|
|
Skip test cases which name are prefixed with PREFIX
|
|
or fulfills REGEX
|
|
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: "$opt_suites"
|
|
skip-rpl Skip the replication test cases.
|
|
big-test Set the environment variable BIG_TEST, which can be
|
|
checked from test cases.
|
|
|
|
Options that specify ports
|
|
|
|
mtr-build-thread=# Specify unique number to calculate port number(s) from.
|
|
build-thread=# Can be set in environment variable MTR_BUILD_THREAD.
|
|
Set MTR_BUILD_THREAD="auto" to automatically aquire
|
|
a build thread id that is unique to current host
|
|
|
|
Options for test case authoring
|
|
|
|
record TESTNAME (Re)genereate the result file for TESTNAME
|
|
check-testcases Check testcases for sideeffects
|
|
mark-progress Log line number and elapsed time to <testname>.progress
|
|
|
|
Options that pass on options
|
|
|
|
mysqld=ARGS Specify additional arguments to "mysqld"
|
|
|
|
Options to run test on running server
|
|
|
|
extern option=value Run only the tests against an already started server
|
|
the options to use for connection to the extern server
|
|
must be specified using name-value pair notation
|
|
For example:
|
|
./$0 --extern socket=/tmp/mysqld.sock
|
|
|
|
user=USER User for connection to extern server
|
|
socket=PATH Socket for connection to extern server
|
|
|
|
Options for debugging the product
|
|
|
|
client-ddd Start mysqltest client in ddd
|
|
client-debugger=NAME Start mysqltest in the selected debugger
|
|
client-gdb Start mysqltest client in gdb
|
|
ddd Start mysqld in ddd
|
|
debug Dump trace output for all servers and client programs
|
|
debugger=NAME Start mysqld in the selected debugger
|
|
gdb Start the mysqld(s) in gdb
|
|
manual-debug Let user manually start mysqld in debugger, before
|
|
running test(s)
|
|
manual-gdb Let user manually start mysqld in gdb, before running
|
|
test(s)
|
|
manual-ddd Let user manually start mysqld in ddd, before running
|
|
test(s)
|
|
strace-client=[path] Create strace output for mysqltest client, optionally
|
|
specifying name and path to the trace program to use.
|
|
Example: $0 --strace-client=ktrace
|
|
max-save-core Limit the number of core files saved (to avoid filling
|
|
up disks for heavily crashing server). Defaults to
|
|
$opt_max_save_core, set to 0 for no limit.
|
|
|
|
Options for valgrind
|
|
|
|
valgrind Run the "mysqltest" and "mysqld" executables using
|
|
valgrind with default options
|
|
valgrind-all Synonym for --valgrind
|
|
valgrind-mysqltest Run the "mysqltest" and "mysql_client_test" executable
|
|
with valgrind
|
|
valgrind-mysqld Run the "mysqld" executable with valgrind
|
|
valgrind-options=ARGS Deprecated, use --valgrind-option
|
|
valgrind-option=ARGS Option to give valgrind, replaces default option(s),
|
|
can be specified more then once
|
|
valgrind-path=[EXE] Path to the valgrind executable
|
|
callgrind Instruct valgrind to use callgrind
|
|
|
|
Misc options
|
|
|
|
comment=STR Write STR to the output
|
|
notimer Don't show test case execution time
|
|
verbose More verbose output(use multiple times for even more)
|
|
start Only initialize and start the servers, using the
|
|
startup settings for the first specified test case
|
|
Example:
|
|
$0 --start alias &
|
|
start-dirty Only start the servers (without initialization) for
|
|
the first specified test case
|
|
fast Run as fast as possible, dont't wait for servers
|
|
to shutdown etc.
|
|
reorder Reorder tests to get fewer server restarts
|
|
help Get this help text
|
|
|
|
testcase-timeout=MINUTES Max test case run time (default $opt_testcase_timeout)
|
|
suite-timeout=MINUTES Max test suite run time (default $opt_suite_timeout)
|
|
shutdown-timeout=SECONDS Max number of seconds to wait for server shutdown
|
|
before killing servers (default $opt_shutdown_timeout)
|
|
warnings Scan the log files for warnings. Use --nowarnings
|
|
to turn off.
|
|
|
|
sleep=SECONDS Passed to mysqltest, will be used as fixed sleep time
|
|
|
|
HERE
|
|
exit(1);
|
|
|
|
}
|
|
|