~drizzle-trunk/drizzle/development : revision 1819.2.1

22

#

23

# - To make this Perl script easy to alter even for those that not

24

# code Perl that often, keeep the coding style as close as possible to

25

# the C/C++ MySQL coding standard.

25

# the C/C++ drizzle coding standard.

26

#

27

# - All lists of arguments to send to commands are Perl lists/arrays,

28

# not strings we append args to. Within reason, most string

29

# concatenation for arguments should be avoided.

30

#

31

# - Functions defined in the main program are not to be prefixed,

32

# functions in "library files" are to be prefixed with "mtr_" (for

33

# Mysql-Test-Run). There are some exceptions, code that fits best in

32

# functions in "library files" are to be prefixed with "dtr_" (for

33

# Drizzle-Test-Run). There are some exceptions, code that fits best in

34

# the main program, but are put into separate files to avoid

35

# clutter, may be without prefix.

36

#

52

# A nice way to trace the execution of this script while debugging

53

# is to use the Devel::Trace package found at

54

# "http://www.plover.com/~mjd/perl/Trace/" and run this script like

55

# "perl -d:Trace drizzle-test-run.pl"

55

# "perl -d:Trace test-run.pl"

56

#

57

58

77

select(STDOUT);

78

$| = 1; # Automatically flush STDOUT

79

80

require "mtr_cases.pl";

81

require "mtr_process.pl";

82

require "mtr_timer.pl";

83

require "mtr_io.pl";

84

require "mtr_gcov.pl";

85

require "mtr_gprof.pl";

86

require "mtr_report.pl";

87

require "mtr_match.pl";

88

require "mtr_misc.pl";

89

require "mtr_stress.pl";

90

require "mtr_unique.pl";

80

require "dtr_cases.pl";

81

require "dtr_process.pl";

82

require "dtr_timer.pl";

83

require "dtr_io.pl";

84

require "dtr_gcov.pl";

85

require "dtr_gprof.pl";

86

require "dtr_report.pl";

87

require "dtr_match.pl";

88

require "dtr_misc.pl";

89

require "dtr_stress.pl";

90

require "dtr_unique.pl";

91

92

$Devel::Trace::TRACE= 1;

93

100

# Misc global variables

101

our $drizzle_version_id;

102

our $glob_suite_path= undef;

103

our $glob_mysql_test_dir= undef;

104

our $glob_mysql_bench_dir= undef;

103

our $glob_drizzle_test_dir= undef;

104

our $glob_drizzle_bench_dir= undef;

105

our $glob_scriptname= undef;

106

our $glob_timers= undef;

107

our @glob_test_mode;

138

139

our $opt_repeat_test= 1;

140

141

our $exe_master_mysqld;

141

our $exe_master_drizzled;

142

our $exe_drizzle;

143

our $exe_drizzle_client_test;

144

our $exe_bug25714;

148

our $exe_drizzleimport;

149

our $exe_drizzle_fix_system_tables;

150

our $exe_drizzletest;

151

our $exe_slave_mysqld;

151

our $exe_slave_drizzled;

152

our $exe_perror;

153

our $lib_udf_example;

154

our $lib_example_plugin;

161

our @opt_combinations;

162

our $opt_skip_combination;

163

164

our @opt_extra_mysqld_opt;

164

our @opt_extra_drizzled_opt;

165

166

our $opt_compress;

167

177

our $opt_force;

178

our $opt_reorder= 0;

179

our $opt_enable_disabled;

180

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

180

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

181

182

our $opt_gcov;

183

our $opt_gcov_err;

196

our $opt_manual_ddd;

197

our $opt_manual_debug;

198

# Magic number -69.4 results in traditional test ports starting from 9306.

199

our $opt_mtr_build_thread=-69.4;

199

our $opt_dtr_build_thread=-69.4;

200

our $opt_debugger;

201

our $opt_client_debugger;

202

241

our $opt_user;

242

243

my $opt_valgrind= 0;

244

my $opt_valgrind_mysqld= 0;

244

my $opt_valgrind_drizzled= 0;

245

my $opt_valgrind_drizzletest= 0;

246

my $opt_valgrind_drizzleslap= 0;

247

my @default_valgrind_args= ("--show-reachable=yes --malloc-fill=0xDEADBEEF --free-fill=0xDEADBEEF");

269

our $used_default_engine;

270

our $debug_compiled_binaries;

271

272

our %mysqld_variables;

272

our %drizzled_variables;

273

274

my $source_dist= 0;

275

286

sub main ();

287

sub initial_setup ();

288

sub command_line_setup ();

289

sub set_mtr_build_thread_ports($);

289

sub set_dtr_build_thread_ports($);

290

sub datadir_list_setup ();

291

sub executable_setup ();

292

sub environment_setup ();

294

sub remove_stale_vardir ();

295

sub setup_vardir ();

296

sub check_running_as_root();

297

sub mysqld_wait_started($);

297

sub drizzled_wait_started($);

298

sub run_benchmarks ($);

299

sub initialize_servers ();

300

sub mysql_install_db ();

300

sub drizzle_install_db ();

301

sub copy_install_db ($$);

302

sub run_testcase ($);

303

sub run_testcase_stop_servers ($$$);

306

sub report_failure_and_restart ($);

307

sub do_before_start_master ($);

308

sub do_before_start_slave ($);

309

sub mysqld_start ($$$);

310

sub mysqld_arguments ($$$$);

309

sub drizzled_start ($$$);

310

sub drizzled_arguments ($$$$);

311

sub stop_all_servers ();

312

sub run_drizzletest ($);

313

sub collapse_path ($);

326

327

command_line_setup();

328

329

check_debug_support(\%mysqld_variables);

329

check_debug_support(\%drizzled_variables);

330

331

executable_setup();

332

367

{

368

my $extra_suite= $extra_suites{$dir};

369

if (defined $extra_suite){

370

mtr_report("Found extra suite: $extra_suite");

370

dtr_report("Found extra suite: $extra_suite");

371

$opt_suites= "$extra_suite,$opt_suites";

372

last;

373

}

386

# Count max number of slaves used by a test case

387

if ( $test->{slave_num} > $max_slave_num) {

388

$max_slave_num= $test->{slave_num};

389

mtr_error("Too many slaves") if $max_slave_num > 3;

389

dtr_error("Too many slaves") if $max_slave_num > 3;

390

}

391

392

# Count max number of masters used by a test case

393

if ( $test->{master_num} > $max_master_num) {

394

$max_master_num= $test->{master_num};

395

mtr_error("Too many masters") if $max_master_num > 2;

396

mtr_error("Too few masters") if $max_master_num < 1;

395

dtr_error("Too many masters") if $max_master_num > 2;

396

dtr_error("Too few masters") if $max_master_num < 1;

397

}

398

}

399

$use_innodb||= $test->{'innodb_test'};

408

run_tests($tests);

409

}

410

411

mtr_exit(0);

411

dtr_exit(0);

412

}

413

414

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

419

420

#

421

# When an option is no longer used by this program, it must be explicitly

422

# ignored or else it will be passed through to mysqld. GetOptions will call

422

# ignored or else it will be passed through to drizzled. GetOptions will call

423

# this subroutine once for each such option on the command line. See

424

# Getopt::Long documentation.

425

#

437

my $opt_comment;

438

439

# If so requested, we try to avail ourselves of a unique build thread number.

440

if ( $ENV{'MTR_BUILD_THREAD'} ) {

441

if ( lc($ENV{'MTR_BUILD_THREAD'}) eq 'auto' ) {

440

if ( $ENV{'DTR_BUILD_THREAD'} ) {

441

if ( lc($ENV{'DTR_BUILD_THREAD'}) eq 'auto' ) {

442

print "Requesting build thread... ";

443

$ENV{'MTR_BUILD_THREAD'} = mtr_require_unique_id_and_wait("/tmp/mysql-test-ports", 200, 299);

444

print "got ".$ENV{'MTR_BUILD_THREAD'}."\n";

443

$ENV{'DTR_BUILD_THREAD'} = dtr_require_unique_id_and_wait("/tmp/drizzle-test-ports", 200, 299);

444

print "got ".$ENV{'DTR_BUILD_THREAD'}."\n";

445

}

446

}

447

448

if ( $ENV{'MTR_BUILD_THREAD'} )

448

if ( $ENV{'DTR_BUILD_THREAD'} )

449

{

450

set_mtr_build_thread_ports($ENV{'MTR_BUILD_THREAD'});

450

set_dtr_build_thread_ports($ENV{'DTR_BUILD_THREAD'});

451

}

452

453

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

459

# Note: Keep list, and the order, in sync with usage at end of this file

460

461

# Options that are no longer used must still be processed, because all

462

# unprocessed options are passed directly to mysqld. The user will be

462

# unprocessed options are passed directly to drizzled. The user will be

463

# warned that the option is being ignored.

464

#

465

# Put the complete option string here. For example, to remove the --suite

489

'master_port=i' => \$opt_master_myport,

490

'slave_port=i' => \$opt_slave_myport,

491

'memc_port=i' => \$opt_memc_myport,

492

'mtr-build-thread=i' => \$opt_mtr_build_thread,

492

'dtr-build-thread=i' => \$opt_dtr_build_thread,

493

494

# Test case authoring

495

'record' => \$opt_record,

496

'check-testcases' => \$opt_check_testcases,

497

'mark-progress' => \$opt_mark_progress,

498

499

# Extra options used when starting mysqld

500

'mysqld=s' => \@opt_extra_mysqld_opt,

499

# Extra options used when starting drizzled

500

'drizzled=s' => \@opt_extra_drizzled_opt,

501

'engine=s' => \$opt_engine,

502

503

# Run test on running server

520

'debugger=s' => \$opt_debugger,

521

'client-debugger=s' => \$opt_client_debugger,

522

'strace-client' => \$opt_strace_client,

523

'master-binary=s' => \$exe_master_mysqld,

524

'slave-binary=s' => \$exe_slave_mysqld,

523

'master-binary=s' => \$exe_master_drizzled,

524

'slave-binary=s' => \$exe_slave_drizzled,

525

'max-save-core=i' => \$opt_max_save_core,

526

527

# Coverage, profiling etc

530

'valgrind|valgrind-all' => \$opt_valgrind,

531

'valgrind-drizzletest' => \$opt_valgrind_drizzletest,

532

'valgrind-drizzleslap' => \$opt_valgrind_drizzleslap,

533

'valgrind-mysqld' => \$opt_valgrind_mysqld,

533

'valgrind-drizzled' => \$opt_valgrind_drizzled,

534

'valgrind-options=s' => sub {

535

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

536

# Deprecated option unless it's what we know pushbuild uses

565

'top-srcdir=s' => \$opt_top_srcdir,

566

'suitepath=s' => \$opt_suitepath,

567

'testdir=s' => \$opt_testdir,

568

'benchdir=s' => \$glob_mysql_bench_dir,

568

'benchdir=s' => \$glob_drizzle_bench_dir,

569

'mem' => \$opt_mem,

570

571

# Misc

602

603

$glob_scriptname= basename($0);

604

605

if ($opt_mtr_build_thread != 0)

605

if ($opt_dtr_build_thread != 0)

606

{

607

set_mtr_build_thread_ports($opt_mtr_build_thread)

607

set_dtr_build_thread_ports($opt_dtr_build_thread)

608

}

609

elsif ($ENV{'MTR_BUILD_THREAD'})

609

elsif ($ENV{'DTR_BUILD_THREAD'})

610

{

611

$opt_mtr_build_thread= $ENV{'MTR_BUILD_THREAD'};

611

$opt_dtr_build_thread= $ENV{'DTR_BUILD_THREAD'};

612

}

613

614

if ( -d "../drizzled" )

619

# Find the absolute path to the test directory

620

if ( ! $opt_testdir )

621

{

622

$glob_mysql_test_dir= cwd();

622

$glob_drizzle_test_dir= cwd();

623

}

624

else

625

{

626

$glob_mysql_test_dir= $opt_testdir;

626

$glob_drizzle_test_dir= $opt_testdir;

627

}

628

$default_vardir= "$glob_mysql_test_dir/var";

629

$default_top_srcdir= "$glob_mysql_test_dir/..";

630

$default_top_builddir= "$glob_mysql_test_dir/..";

628

$default_vardir= "$glob_drizzle_test_dir/var";

629

$default_top_srcdir= "$glob_drizzle_test_dir/..";

630

$default_top_builddir= "$glob_drizzle_test_dir/..";

631

632

if ( ! $opt_suitepath )

633

{

634

$glob_suite_path= "$glob_mysql_test_dir/../plugin";

634

$glob_suite_path= "$glob_drizzle_test_dir/../plugin";

635

}

636

else

637

{

638

$glob_suite_path= $opt_suitepath;

639

}

640

# In most cases, the base directory we find everything relative to,

641

# is the parent directory of the "mysql-test" directory. For source

641

# is the parent directory of the "drizzle-test" directory. For source

642

# distributions, TAR binary distributions and some other packages.

643

$glob_basedir= dirname($glob_mysql_test_dir);

643

$glob_basedir= dirname($glob_drizzle_test_dir);

644

645

# In the RPM case, binaries and libraries are installed in the

646

# default system locations, instead of having our own private base

647

# directory. And we install "/usr/share/mysql-test". Moving up one

648

# more directory relative to "mysql-test" gives us a usable base

647

# directory. And we install "/usr/share/drizzle-test". Moving up one

648

# more directory relative to "drizzle-test" gives us a usable base

649

# directory for RPM installs.

650

if ( ! $source_dist and ! -d "$glob_basedir/bin" )

651

{

663

$glob_builddir="..";

664

}

665

666

# Expect mysql-bench to be located adjacent to the source tree, by default

667

$glob_mysql_bench_dir= "$glob_basedir/../mysql-bench"

668

unless defined $glob_mysql_bench_dir;

669

$glob_mysql_bench_dir= undef

670

unless -d $glob_mysql_bench_dir;

666

# Expect drizzle-bench to be located adjacent to the source tree, by default

667

$glob_drizzle_bench_dir= "$glob_basedir/../drizzle-bench"

668

unless defined $glob_drizzle_bench_dir;

669

$glob_drizzle_bench_dir= undef

670

unless -d $glob_drizzle_bench_dir;

671

672

$glob_timers= mtr_init_timers();

672

$glob_timers= dtr_init_timers();

673

674

#

675

# Find the drizzled executable to be able to find the drizzled version

677

#

678

679

# Look for the client binaries directory

680

$path_client_bindir= mtr_path_exists("$glob_builddir/client",

680

$path_client_bindir= dtr_path_exists("$glob_builddir/client",

681

"$glob_basedir/client",

682

"$glob_basedir/bin");

683

684

if (!$opt_extern)

685

{

686

$exe_drizzled= mtr_exe_exists ("$glob_basedir/drizzled/drizzled",

686

$exe_drizzled= dtr_exe_exists ("$glob_basedir/drizzled/drizzled",

687

"$path_client_bindir/drizzled",

688

"$glob_basedir/libexec/drizzled",

689

"$glob_basedir/bin/drizzled",

691

"$glob_builddir/drizzled/drizzled");

692

693

# Use the drizzled found above to find out what features are available

694

collect_mysqld_features();

694

collect_drizzled_features();

695

}

696

else

697

{

698

$mysqld_variables{'port'}= 4427;

698

$drizzled_variables{'port'}= 4427;

699

}

700

701

if (!$opt_engine)

715

{

716

if ( $arg =~ /^--skip-/ )

717

{

718

push(@opt_extra_mysqld_opt, $arg);

718

push(@opt_extra_drizzled_opt, $arg);

719

}

720

elsif ( $arg =~ /^--$/ )

721

{

736

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

737

# Find out default storage engine being used(if any)

738

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

739

foreach my $arg ( @opt_extra_mysqld_opt )

739

foreach my $arg ( @opt_extra_drizzled_opt )

740

{

741

if ( $arg =~ /default-storage-engine=(\S+)/ )

742

{

743

$used_default_engine= $1;

744

}

745

}

746

mtr_report("Using default engine '$used_default_engine'")

746

dtr_report("Using default engine '$used_default_engine'")

747

if defined $used_default_engine;

748

749

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

751

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

752

if ( defined $opt_mem )

753

{

754

mtr_error("Can't use --mem and --vardir at the same time ")

754

dtr_error("Can't use --mem and --vardir at the same time ")

755

if $opt_vardir;

756

mtr_error("Can't use --mem and --tmpdir at the same time ")

756

dtr_error("Can't use --mem and --tmpdir at the same time ")

757

if $opt_tmpdir;

758

759

# Search through list of locations that are known

765

{

766

if ( -d $fs )

767

{

768

mtr_report("Using tmpfs in $fs");

768

dtr_report("Using tmpfs in $fs");

769

$opt_mem= "$fs/var";

770

$opt_mem .= $opt_mtr_build_thread if $opt_mtr_build_thread;

770

$opt_mem .= $opt_dtr_build_thread if $opt_dtr_build_thread;

771

last;

772

}

773

}

816

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

817

if ( $opt_record and ! @opt_cases )

818

{

819

mtr_error("Will not run in record mode without a specific test case");

819

dtr_error("Will not run in record mode without a specific test case");

820

}

821

822

if ( $opt_record )

837

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

838

if ( $opt_gcov and ! $source_dist )

839

{

840

mtr_error("Coverage test needs the source - please use source dist");

840

dtr_error("Coverage test needs the source - please use source dist");

841

}

842

843

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

851

$glob_debugger= 1;

852

if ( $opt_extern )

853

{

854

mtr_error("Can't use --extern when using debugger");

854

dtr_error("Can't use --extern when using debugger");

855

}

856

}

857

858

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

859

# Check if special exe was selected for master or slave

860

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

861

$exe_master_mysqld= $exe_master_mysqld || $exe_drizzled;

862

$exe_slave_mysqld= $exe_slave_mysqld || $exe_drizzled;

861

$exe_master_drizzled= $exe_master_drizzled || $exe_drizzled;

862

$exe_slave_drizzled= $exe_slave_drizzled || $exe_drizzled;

863

864

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

865

# Check valgrind arguments

866

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

867

if ( $opt_valgrind or $opt_valgrind_path or @valgrind_args)

868

{

869

mtr_report("Turning on valgrind for all executables");

869

dtr_report("Turning on valgrind for all executables");

870

$opt_valgrind= 1;

871

$opt_valgrind_mysqld= 1;

871

$opt_valgrind_drizzled= 1;

872

$opt_valgrind_drizzletest= 1;

873

}

874

elsif ( $opt_valgrind_mysqld )

874

elsif ( $opt_valgrind_drizzled )

875

{

876

mtr_report("Turning on valgrind for mysqld(s) only");

876

dtr_report("Turning on valgrind for drizzled(s) only");

877

$opt_valgrind= 1;

878

}

879

elsif ( $opt_valgrind_drizzletest )

880

{

881

mtr_report("Turning on valgrind for drizzletest and drizzle_client_test only");

881

dtr_report("Turning on valgrind for drizzletest and drizzle_client_test only");

882

$opt_valgrind= 1;

883

}

884

elsif ( $opt_valgrind_drizzleslap )

885

{

886

mtr_report("Turning on valgrind for drizzleslap only");

886

dtr_report("Turning on valgrind for drizzleslap only");

887

$opt_valgrind= 1;

888

}

889

890

if ( $opt_callgrind )

891

{

892

mtr_report("Turning on valgrind with callgrind for mysqld(s)");

892

dtr_report("Turning on valgrind with callgrind for drizzled(s)");

893

$opt_valgrind= 1;

894

$opt_valgrind_mysqld= 1;

894

$opt_valgrind_drizzled= 1;

895

896

# Set special valgrind options unless options passed on command line

897

push(@valgrind_args, "--trace-children=yes")

900

901

if ( $opt_massif )

902

{

903

mtr_report("Valgrind with Massif tool for drizzled(s)");

903

dtr_report("Valgrind with Massif tool for drizzled(s)");

904

$opt_valgrind= 1;

905

$opt_valgrind_mysqld= 1;

905

$opt_valgrind_drizzled= 1;

906

}

907

908

if ( $opt_valgrind )

911

push(@valgrind_args, @default_valgrind_args)

912

unless @valgrind_args;

913

914

mtr_report("Running valgrind with options \"",

914

dtr_report("Running valgrind with options \"",

915

join(" ", @valgrind_args), "\"");

916

}

917

1041

warn("Currenty broken --extern");

1042

1043

# Setup master->[0] with the settings for the extern server

1044

$master->[0]->{'path_sock'}= $opt_socket ? $opt_socket : "/tmp/mysql.sock";

1045

mtr_report("Using extern server at '$master->[0]->{path_sock}'");

1044

$master->[0]->{'path_sock'}= $opt_socket ? $opt_socket : "/tmp/drizzle.sock";

1045

dtr_report("Using extern server at '$master->[0]->{path_sock}'");

1046

}

1047

else

1048

{

1049

mtr_error("--socket can only be used in combination with --extern")

1049

dtr_error("--socket can only be used in combination with --extern")

1050

if $opt_socket;

1051

}

1052

1062

# When both --valgrind and --debug is selected, send

1063

# all output to the trace file, making it possible to

1064

# see the exact location where valgrind complains

1065

foreach my $mysqld (@{$master}, @{$slave})

1065

foreach my $drizzled (@{$master}, @{$slave})

1066

{

1067

my $sidx= $mysqld->{idx} ? "$mysqld->{idx}" : "";

1068

$mysqld->{path_myerr}=

1069

"$opt_vardir/log/" . $mysqld->{type} . "$sidx.trace";

1067

my $sidx= $drizzled->{idx} ? "$drizzled->{idx}" : "";

1068

$drizzled->{path_myerr}=

1069

"$opt_vardir/log/" . $drizzled->{type} . "$sidx.trace";

1070

}

1071

}

1072

}

1104

#

1105

# Note the MASTER_MYPORT has to be set the same in all 4.x and 5.x

1106

# versions of this script, else a 4.0 test run might conflict with a

1107

# 5.1 test run, even if different MTR_BUILD_THREAD is used. This means

1107

# 5.1 test run, even if different DTR_BUILD_THREAD is used. This means

1108

# all port numbers might not be used in this version of the script.

1109

#

1110

# Also note the limitation of ports we are allowed to hand out. This

1113

# But a fairly safe range seems to be 5001 - 32767

1114

#

1115

1116

sub set_mtr_build_thread_ports($) {

1117

my $mtr_build_thread= shift;

1116

sub set_dtr_build_thread_ports($) {

1117

my $dtr_build_thread= shift;

1118

1119

if ( lc($mtr_build_thread) eq 'auto' ) {

1119

if ( lc($dtr_build_thread) eq 'auto' ) {

1120

print "Requesting build thread... ";

1121

$ENV{'MTR_BUILD_THREAD'} = $mtr_build_thread = mtr_require_unique_id_and_wait("/tmp/mysql-test-ports", 200, 299);

1122

print "got ".$mtr_build_thread."\n";

1121

$ENV{'DTR_BUILD_THREAD'} = $dtr_build_thread = dtr_require_unique_id_and_wait("/tmp/drizzle-test-ports", 200, 299);

1122

print "got ".$dtr_build_thread."\n";

1123

}

1124

1125

$mtr_build_thread= (($mtr_build_thread * 10) % 2000) - 1000;

1125

$dtr_build_thread= (($dtr_build_thread * 10) % 2000) - 1000;

1126

1127

# Up to two masters, up to three slaves

1128

# A magic value in command_line_setup depends on these equations.

1129

$opt_master_myport= gimme_a_good_port($mtr_build_thread + 9000); # and 1

1129

$opt_master_myport= gimme_a_good_port($dtr_build_thread + 9000); # and 1

1130

1131

1132

$opt_slave_myport= gimme_a_good_port($opt_master_myport + 2); # and 3 4

1134

1135

if ( $opt_master_myport < 5001 or $opt_master_myport + 10 >= 32767 )

1136

{

1137

mtr_error("MTR_BUILD_THREAD number results in a port",

1137

dtr_error("DTR_BUILD_THREAD number results in a port",

1138

"outside 5001 - 32767",

1139

"($opt_master_myport - $opt_master_myport + 10)");

1140

}

1163

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

1164

1165

1166

sub collect_mysqld_features () {

1166

sub collect_drizzled_features () {

1167

my $found_variable_list_start= 0;

1168

my $tmpdir= tempdir(CLEANUP => 0); # Directory removed by this function

1169

1183

{

1184

# Look for version

1185

my $exe_name= basename($exe_drizzled);

1186

mtr_verbose("exe_name: $exe_name");

1186

dtr_verbose("exe_name: $exe_name");

1187

if ( $line =~ /^\S*$exe_name\s\sVer\s([0-9]*)\.([0-9]*)\.([0-9]*)/ )

1188

{

1189

#print "Major: $1 Minor: $2 Build: $3\n";

1190

$drizzle_version_id= $1*10000 + $2*100 + $3;

1191

#print "drizzle_version_id: $drizzle_version_id\n";

1192

mtr_report("Drizzle Version $1.$2.$3");

1192

dtr_report("Drizzle Version $1.$2.$3");

1193

}

1194

}

1195

}

1196

rmtree($tmpdir);

1197

mtr_error("Could not find version of Drizzle") unless $drizzle_version_id;

1197

dtr_error("Could not find version of Drizzle") unless $drizzle_version_id;

1198

1199

}

1200

1201

1202

sub run_query($$) {

1203

my ($mysqld, $query)= @_;

1203

my ($drizzled, $query)= @_;

1204

1205

my $args;

1206

mtr_init_args(\$args);

1206

dtr_init_args(\$args);

1207

1208

mtr_add_arg($args, "--no-defaults");

1209

mtr_add_arg($args, "--skip-stack-trace");

1210

mtr_add_arg($args, "--user=%s", $opt_user);

1211

mtr_add_arg($args, "--port=%d", $mysqld->{'port'});

1212

mtr_add_arg($args, "--silent"); # Tab separated output

1213

mtr_add_arg($args, "-e '%s'", $query);

1208

dtr_add_arg($args, "--no-defaults");

1209

dtr_add_arg($args, "--skip-stack-trace");

1210

dtr_add_arg($args, "--user=%s", $opt_user);

1211

dtr_add_arg($args, "--port=%d", $drizzled->{'port'});

1212

dtr_add_arg($args, "--silent"); # Tab separated output

1213

dtr_add_arg($args, "-e '%s'", $query);

1214

1215

my $cmd= "$exe_drizzle " . join(' ', @$args);

1216

mtr_verbose("cmd: $cmd");

1216

dtr_verbose("cmd: $cmd");

1217

return `$cmd`;

1218

}

1219

1220

1221

sub collect_mysqld_features_from_running_server ()

1221

sub collect_drizzled_features_from_running_server ()

1222

{

1223

my $list= run_query($master->[0], "use mysql; SHOW VARIABLES");

1223

my $list= run_query($master->[0], "use drizzle; SHOW VARIABLES");

1224

1225

foreach my $line (split('\n', $list))

1226

{

1228

if ( $line =~ /^([\S]+)[ \t]+(.*?)\r?$/ )

1229

{

1230

print "$1=\"$2\"\n";

1231

$mysqld_variables{$1}= $2;

1231

$drizzled_variables{$1}= $2;

1232

}

1233

}

1234

}

1246

$exe_libtool= "../libtool";

1247

if ($opt_valgrind or $glob_debugger)

1248

{

1249

mtr_report("Using \"$exe_libtool\" when running valgrind or debugger");

1249

dtr_report("Using \"$exe_libtool\" when running valgrind or debugger");

1250

}

1251

}

1252

1254

$exe_perror= "perror";

1255

1256

# Look for the client binaries

1257

$exe_drizzledump= mtr_exe_exists("$path_client_bindir/drizzledump");

1258

$exe_drizzleimport= mtr_exe_exists("$path_client_bindir/drizzleimport");

1259

$exe_drizzle= mtr_exe_exists("$path_client_bindir/drizzle");

1257

$exe_drizzledump= dtr_exe_exists("$path_client_bindir/drizzledump");

1258

$exe_drizzleimport= dtr_exe_exists("$path_client_bindir/drizzleimport");

1259

$exe_drizzle= dtr_exe_exists("$path_client_bindir/drizzle");

1260

1261

if (!$opt_extern)

1262

{

1263

# Look for SQL scripts directory

1264

if ( $drizzle_version_id >= 50100 )

1265

{

1266

$exe_drizzleslap= mtr_exe_exists("$path_client_bindir/drizzleslap");

1266

$exe_drizzleslap= dtr_exe_exists("$path_client_bindir/drizzleslap");

1267

}

1268

}

1269

1270

# Look for schema_writer

1271

{

1272

$exe_schemawriter= mtr_exe_exists("$glob_basedir/drizzled/message/schema_writer",

1272

$exe_schemawriter= dtr_exe_exists("$glob_basedir/drizzled/message/schema_writer",

1273

"$glob_builddir/drizzled/message/schema_writer");

1274

}

1275

1276

# Look for drizzletest executable

1277

{

1278

$exe_drizzletest= mtr_exe_exists("$path_client_bindir/drizzletest");

1278

$exe_drizzletest= dtr_exe_exists("$path_client_bindir/drizzletest");

1279

}

1280

1281

# Look for drizzle_client_test executable which may _not_ exist in

1282

# some versions, test using it should be skipped

1283

{

1284

$exe_drizzle_client_test=

1285

mtr_exe_maybe_exists(

1285

dtr_exe_maybe_exists(

1286

"$glob_basedir/tests/drizzle_client_test",

1287

"$glob_basedir/bin/drizzle_client_test");

1288

}

1290

# Look for bug25714 executable which may _not_ exist in

1291

# some versions, test using it should be skipped

1292

$exe_bug25714=

1293

mtr_exe_maybe_exists(

1293

dtr_exe_maybe_exists(

1294

"$glob_basedir/tests/bug25714");

1295

}

1296

1297

1298

1299

sub generate_cmdline_mysqldump ($) {

1300

my($mysqld) = @_;

1299

sub generate_cmdline_drizzledump ($) {

1300

my($drizzled) = @_;

1301

return

1302

mtr_native_path($exe_drizzledump) .

1302

dtr_native_path($exe_drizzledump) .

1303

" --no-defaults -uroot " .

1304

"--port=$mysqld->{'port'} ";

1304

"--port=$drizzled->{'port'} ";

1305

}

1306

1307

sub generate_cmdline_drizzle ($) {

1308

my($mysqld) = @_;

1308

my($drizzled) = @_;

1309

return

1310

mtr_native_path($exe_drizzle) .

1311

" -uroot --port=$mysqld->{'port'} ";

1310

dtr_native_path($exe_drizzle) .

1311

" -uroot --port=$drizzled->{'port'} ";

1312

}

1313

1314

1324

my $exe= $exe_drizzle_client_test;

1325

1326

my $args;

1327

mtr_init_args(\$args);

1327

dtr_init_args(\$args);

1328

if ( $opt_valgrind_drizzletest )

1329

{

1330

valgrind_arguments($args, \$exe);

1331

}

1332

1333

mtr_add_arg($args, "--no-defaults");

1334

mtr_add_arg($args, "--testcase");

1335

mtr_add_arg($args, "--user=root");

1336

mtr_add_arg($args, "--port=$master->[0]->{'port'}");

1333

dtr_add_arg($args, "--no-defaults");

1334

dtr_add_arg($args, "--testcase");

1335

dtr_add_arg($args, "--user=root");

1336

dtr_add_arg($args, "--port=$master->[0]->{'port'}");

1337

1338

if ( $opt_extern || $drizzle_version_id >= 50000 )

1339

{

1340

mtr_add_arg($args, "--vardir=$opt_vardir")

1340

dtr_add_arg($args, "--vardir=$opt_vardir")

1341

}

1342

1343

if ( $opt_debug )

1344

{

1345

mtr_add_arg($args,

1345

dtr_add_arg($args,

1346

"--debug=d:t:A,$path_vardir_trace/log/drizzle_client_test.trace");

1347

}

1348

1350

}

1351

1352

1353

# Note that some env is setup in spawn/run, in "mtr_process.pl"

1353

# Note that some env is setup in spawn/run, in "dtr_process.pl"

1354

1355

sub environment_setup () {

1356

1389

my $deb_version;

1390

if ( $opt_valgrind and -d $debug_libraries_path and

1391

(! -e '/etc/debian_version' or

1392

($deb_version= mtr_grab_file('/etc/debian_version')) !~ /^[0-9]+\.[0-9]$/ or

1392

($deb_version= dtr_grab_file('/etc/debian_version')) !~ /^[0-9]+\.[0-9]$/ or

1393

$deb_version > 3.1 ) )

1394

{

1395

push(@ld_library_paths, $debug_libraries_path);

1399

$ENV{'LD_LIBRARY_PATH'} ?

1400

split(':', $ENV{'LD_LIBRARY_PATH'}) : (),

1401

@ld_library_paths);

1402

mtr_debug("LD_LIBRARY_PATH: $ENV{'LD_LIBRARY_PATH'}");

1402

dtr_debug("LD_LIBRARY_PATH: $ENV{'LD_LIBRARY_PATH'}");

1403

1404

$ENV{'DYLD_LIBRARY_PATH'}= join(":", @ld_library_paths,

1405

$ENV{'DYLD_LIBRARY_PATH'} ?

1406

split(':', $ENV{'DYLD_LIBRARY_PATH'}) : ());

1407

mtr_debug("DYLD_LIBRARY_PATH: $ENV{'DYLD_LIBRARY_PATH'}");

1407

dtr_debug("DYLD_LIBRARY_PATH: $ENV{'DYLD_LIBRARY_PATH'}");

1408

1409

# The environment variable used for shared libs on AIX

1410

$ENV{'SHLIB_PATH'}= join(":", @ld_library_paths,

1411

$ENV{'SHLIB_PATH'} ?

1412

split(':', $ENV{'SHLIB_PATH'}) : ());

1413

mtr_debug("SHLIB_PATH: $ENV{'SHLIB_PATH'}");

1413

dtr_debug("SHLIB_PATH: $ENV{'SHLIB_PATH'}");

1414

1415

# The environment variable used for shared libs on hp-ux

1416

$ENV{'LIBPATH'}= join(":", @ld_library_paths,

1417

$ENV{'LIBPATH'} ?

1418

split(':', $ENV{'LIBPATH'}) : ());

1419

mtr_debug("LIBPATH: $ENV{'LIBPATH'}");

1419

dtr_debug("LIBPATH: $ENV{'LIBPATH'}");

1420

1421

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

1422

# Also command lines in .opt files may contain env vars

1427

$ENV{'UMASK_DIR'}= "0770"; # The octal *string*

1428

1429

#

1430

# MySQL tests can produce output in various character sets

1430

# drizzle tests can produce output in various character sets

1431

# (especially, ctype_xxx.test). To avoid confusing Perl

1432

# with output which is incompatible with the current locale

1433

# settings, we reset the current values of LC_ALL and LC_CTYPE to "C".

1439

1440

$ENV{'LC_COLLATE'}= "C";

1441

$ENV{'USE_RUNNING_SERVER'}= $opt_extern;

1442

$ENV{'DRIZZLE_TEST_DIR'}= collapse_path($glob_mysql_test_dir);

1443

$ENV{'MYSQLTEST_VARDIR'}= $opt_vardir;

1442

$ENV{'DRIZZLE_TEST_DIR'}= collapse_path($glob_drizzle_test_dir);

1443

$ENV{'DRIZZLETEST_VARDIR'}= $opt_vardir;

1444

$ENV{'TOP_SRCDIR'}= $opt_top_srcdir;

1445

$ENV{'TOP_BUILDDIR'}= $opt_top_builddir;

1446

$ENV{'DRIZZLE_TMP_DIR'}= $opt_tmpdir;

1453

$ENV{'SLAVE_MYPORT1'}= $slave->[1]->{'port'};

1454

$ENV{'SLAVE_MYPORT2'}= $slave->[2]->{'port'};

1455

$ENV{'MC_PORT'}= $opt_memc_myport;

1456

$ENV{'DRIZZLE_TCP_PORT'}= $mysqld_variables{'drizzle-protocol.port'};

1457

1458

$ENV{'MTR_BUILD_THREAD'}= $opt_mtr_build_thread;

1459

1460

$ENV{'EXE_MYSQL'}= $exe_drizzle;

1456

$ENV{'DRIZZLE_TCP_PORT'}= $drizzled_variables{'drizzle-protocol.port'};

1457

1458

$ENV{'DTR_BUILD_THREAD'}= $opt_dtr_build_thread;

1459

1460

$ENV{'EXE_DRIZZLE'}= $exe_drizzle;

1461

1462

1463

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

1464

# Setup env to childs can execute myqldump

1465

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

1466

my $cmdline_mysqldump= generate_cmdline_mysqldump($master->[0]);

1467

my $cmdline_mysqldumpslave= generate_cmdline_mysqldump($slave->[0]);

1468

my $cmdline_mysqldump_secondary= mtr_native_path($exe_drizzledump) .

1466

my $cmdline_drizzledump= generate_cmdline_drizzledump($master->[0]);

1467

my $cmdline_drizzledumpslave= generate_cmdline_drizzledump($slave->[0]);

1468

my $cmdline_drizzledump_secondary= dtr_native_path($exe_drizzledump) .

1469

" --no-defaults -uroot " .

1470

" --port=$master->[0]->{'secondary_port'} ";

1471

1472

if ( $opt_debug )

1473

{

1474

$cmdline_mysqldump .=

1475

" --debug=d:t:A,$path_vardir_trace/log/mysqldump-master.trace";

1476

$cmdline_mysqldumpslave .=

1477

" --debug=d:t:A,$path_vardir_trace/log/mysqldump-slave.trace";

1478

$cmdline_mysqldump_secondary .=

1479

" --debug=d:t:A,$path_vardir_trace/log/mysqldump-mysql.trace";

1474

$cmdline_drizzledump .=

1475

" --debug=d:t:A,$path_vardir_trace/log/drizzledump-master.trace";

1476

$cmdline_drizzledumpslave .=

1477

" --debug=d:t:A,$path_vardir_trace/log/drizzledump-slave.trace";

1478

$cmdline_drizzledump_secondary .=

1479

" --debug=d:t:A,$path_vardir_trace/log/drizzledump-drizzle.trace";

1480

}

1481

$ENV{'DRIZZLE_DUMP'}= $cmdline_mysqldump;

1482

$ENV{'DRIZZLE_DUMP_SLAVE'}= $cmdline_mysqldumpslave;

1483

$ENV{'DRIZZLE_DUMP_SECONDARY'}= $cmdline_mysqldump_secondary;

1481

$ENV{'DRIZZLE_DUMP'}= $cmdline_drizzledump;

1482

$ENV{'DRIZZLE_DUMP_SLAVE'}= $cmdline_drizzledumpslave;

1483

$ENV{'DRIZZLE_DUMP_SECONDARY'}= $cmdline_drizzledump_secondary;

1484

1485

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

1486

# Setup env so we can execute drizzle client

1487

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

1488

my $cmdline_drizzle = generate_cmdline_drizzle($master->[0]);

1489

$ENV{'DRIZZLE'}= $cmdline_drizzle;

1488

#my $cmdline_drizzle = generate_cmdline_drizzle($master->[0]);

1489

#$ENV{'DRIZZLE'}= $cmdline_drizzle;

1490

1491

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

1492

# Setup env so childs can execute mysqlslap

1492

# Setup env so childs can execute drizzleslap

1493

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

1494

if ( $exe_drizzleslap )

1495

{

1500

$cmdline_drizzleslap= "$glob_basedir/libtool --mode=execute valgrind --log-file=$opt_vardir/log/drizzleslap-valgrind.log ";

1501

}

1502

$cmdline_drizzleslap .=

1503

mtr_native_path($exe_drizzleslap) .

1503

dtr_native_path($exe_drizzleslap) .

1504

" -uroot " .

1505

"--port=$master->[0]->{'port'} ";

1506

my $cmdline_drizzleslap_secondary=

1507

mtr_native_path($exe_drizzleslap) .

1507

dtr_native_path($exe_drizzleslap) .

1508

" -uroot " .

1509

" --port=$master->[0]->{'secondary_port'} ";

1510

1522

1523

1524

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

1525

# Setup env so childs can execute mysqlimport

1525

# Setup env so childs can execute drizzleimport

1526

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

1527

my $cmdline_mysqlimport=

1528

mtr_native_path($exe_drizzleimport) .

1527

my $cmdline_drizzleimport=

1528

dtr_native_path($exe_drizzleimport) .

1529

" -uroot " .

1530

"--port=$master->[0]->{'port'} ";

1531

1532

if ( $opt_debug )

1533

{

1534

$cmdline_mysqlimport .=

1535

" --debug=d:t:A,$path_vardir_trace/log/mysqlimport.trace";

1534

$cmdline_drizzleimport .=

1535

" --debug=d:t:A,$path_vardir_trace/log/drizzleimport.trace";

1536

}

1537

$ENV{'DRIZZLE_IMPORT'}= $cmdline_mysqlimport;

1538

1539

1540

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

1541

# Setup env so childs can execute mysql

1542

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

1543

my $cmdline_mysql=

1544

mtr_native_path($exe_drizzle) .

1537

$ENV{'DRIZZLE_IMPORT'}= $cmdline_drizzleimport;

1538

1539

1540

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

1541

# Setup env so childs can execute drizzle

1542

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

1543

my $cmdline_drizzle=

1544

dtr_native_path($exe_drizzle) .

1545

" --no-defaults --host=localhost --user=root --password= " .

1546

"--port=$master->[0]->{'port'} ";

1547

my $cmdline_drizzle_secondary=

1548

mtr_native_path($exe_drizzle) .

1548

dtr_native_path($exe_drizzle) .

1549

" --no-defaults --host=localhost --user=root --password= " .

1550

" --port=$master->[0]->{'secondary_port'} ";

1551

1552

$ENV{'MYSQL'}= $cmdline_mysql;

1552

$ENV{'DRIZZLE'}= $cmdline_drizzle;

1553

$ENV{'DRIZZLE_SECONDARY'}= $cmdline_drizzle_secondary;

1554

1555

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

1564

1565

1566

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

1567

# Setup env so childs can execute mysql_fix_system_tables

1567

# Setup env so childs can execute drizzle_fix_system_tables

1568

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

1569

#if ( !$opt_extern)

1570

if ( 0 )

1571

{

1572

my $cmdline_mysql_fix_system_tables=

1572

my $cmdline_drizzle_fix_system_tables=

1573

"$exe_drizzle_fix_system_tables --no-defaults --host=localhost " .

1574

"--user=root --password= " .

1575

"--basedir=$glob_basedir --bindir=$path_client_bindir --verbose " .

1576

"--port=$master->[0]->{'port'} ";

1577

$ENV{'DRIZZLE_FIX_SYSTEM_TABLES'}= $cmdline_mysql_fix_system_tables;

1577

$ENV{'DRIZZLE_FIX_SYSTEM_TABLES'}= $cmdline_drizzle_fix_system_tables;

1578

1579

}

1580

1581

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

1582

# Setup env so childs can shutdown the server

1583

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

1584

$ENV{'DRIZZLED_SHUTDOWN'}= mtr_native_path($exe_drizzle);

1584

$ENV{'DRIZZLED_SHUTDOWN'}= dtr_native_path($exe_drizzle);

1585

1586

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

1587

# Setup env so childs can execute perror

1588

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

1589

$ENV{'MY_PERROR'}= mtr_native_path($exe_perror);

1589

$ENV{'MY_PERROR'}= dtr_native_path($exe_perror);

1590

1591

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

1592

# Add the path where mysqld will find ha_example.so

1592

# Add the path where drizzled will find ha_example.so

1593

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

1594

$ENV{'EXAMPLE_PLUGIN'}=

1595

($lib_example_plugin ? basename($lib_example_plugin) : "");

1601

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

1602

if (!$opt_extern)

1603

{

1604

print "Using MTR_BUILD_THREAD = $ENV{MTR_BUILD_THREAD}\n";

1604

print "Using DTR_BUILD_THREAD = $ENV{DTR_BUILD_THREAD}\n";

1605

print "Using MASTER_MYPORT = $ENV{MASTER_MYPORT}\n";

1606

print "Using MASTER_MYPORT1 = $ENV{MASTER_MYPORT1}\n";

1607

print "Using SLAVE_MYPORT = $ENV{SLAVE_MYPORT}\n";

1631

1632

sub handle_int_signal () {

1633

$SIG{INT}= 'DEFAULT'; # If we get a ^C again, we die...

1634

mtr_warning("got INT signal, cleaning up.....");

1634

dtr_warning("got INT signal, cleaning up.....");

1635

stop_all_servers();

1636

mtr_error("We die from ^C signal from user");

1636

dtr_error("We die from ^C signal from user");

1637

}

1638

1639

1645

1646

sub kill_running_servers () {

1647

{

1648

# Ensure that no old mysqld test servers are running

1648

# Ensure that no old drizzled test servers are running

1649

# This is different from terminating processes we have

1650

# started from this run of the script, this is terminating

1651

# leftovers from previous runs.

1652

mtr_kill_leftovers();

1652

dtr_kill_leftovers();

1653

}

1654

}

1655

1659

#

1660

sub remove_stale_vardir () {

1661

1662

mtr_report("Removing Stale Files");

1662

dtr_report("Removing Stale Files");

1663

1664

# Safety!

1665

mtr_error("No, don't remove the vardir when running with --extern")

1665

dtr_error("No, don't remove the vardir when running with --extern")

1666

if $opt_extern;

1667

1668

mtr_verbose("opt_vardir: $opt_vardir");

1668

dtr_verbose("opt_vardir: $opt_vardir");

1669

if ( $opt_vardir eq $default_vardir )

1670

{

1671

#

1672

# Running with "var" in mysql-test dir

1672

# Running with "var" in drizzle-test dir

1673

#

1674

if ( -l $opt_vardir)

1675

{

1678

if ( $opt_mem and readlink($opt_vardir) eq $opt_mem )

1679

{

1680

# Remove the directory which the link points at

1681

mtr_verbose("Removing " . readlink($opt_vardir));

1682

mtr_rmtree(readlink($opt_vardir));

1681

dtr_verbose("Removing " . readlink($opt_vardir));

1682

dtr_rmtree(readlink($opt_vardir));

1683

1684

# Remove the "var" symlink

1685

mtr_verbose("unlink($opt_vardir)");

1685

dtr_verbose("unlink($opt_vardir)");

1686

unlink($opt_vardir);

1687

}

1688

elsif ( $opt_mem )

1689

{

1690

# Just remove the "var" symlink

1691

mtr_report("WARNING: Removing '$opt_vardir' symlink it's wrong");

1691

dtr_report("WARNING: Removing '$opt_vardir' symlink it's wrong");

1692

1693

mtr_verbose("unlink($opt_vardir)");

1693

dtr_verbose("unlink($opt_vardir)");

1694

unlink($opt_vardir);

1695

}

1696

else

1697

{

1698

# Some users creates a soft link in mysql-test/var to another area

1698

# Some users creates a soft link in drizzle-test/var to another area

1699

# - allow it, but remove all files in it

1700

1701

mtr_report("WARNING: Using the 'mysql-test/var' symlink");

1701

dtr_report("WARNING: Using the 'drizzle-test/var' symlink");

1702

1703

# Make sure the directory where it points exist

1704

mtr_error("The destination for symlink $opt_vardir does not exist")

1704

dtr_error("The destination for symlink $opt_vardir does not exist")

1705

if ! -d readlink($opt_vardir);

1706

1707

foreach my $bin ( glob("$opt_vardir/*") )

1708

{

1709

mtr_verbose("Removing bin $bin");

1710

mtr_rmtree($bin);

1709

dtr_verbose("Removing bin $bin");

1710

dtr_rmtree($bin);

1711

}

1712

}

1713

}

1714

else

1715

{

1716

# Remove the entire "var" dir

1717

mtr_verbose("Removing $opt_vardir/");

1718

mtr_rmtree("$opt_vardir/");

1717

dtr_verbose("Removing $opt_vardir/");

1718

dtr_rmtree("$opt_vardir/");

1719

}

1720

1721

if ( $opt_mem )

1723

# A symlink from var/ to $opt_mem will be set up

1724

# remove the $opt_mem dir to assure the symlink

1725

# won't point at an old directory

1726

mtr_verbose("Removing $opt_mem");

1727

mtr_rmtree($opt_mem);

1726

dtr_verbose("Removing $opt_mem");

1727

dtr_rmtree($opt_mem);

1728

}

1729

1730

}

1734

# Running with "var" in some other place

1735

#

1736

1737

# Remove the var/ dir in mysql-test dir if any

1737

# Remove the var/ dir in drizzle-test dir if any

1738

# this could be an old symlink that shouldn't be there

1739

mtr_verbose("Removing $default_vardir");

1740

mtr_rmtree($default_vardir);

1739

dtr_verbose("Removing $default_vardir");

1740

dtr_rmtree($default_vardir);

1741

1742

# Remove the "var" dir

1743

mtr_verbose("Removing $opt_vardir/");

1744

mtr_rmtree("$opt_vardir/");

1743

dtr_verbose("Removing $opt_vardir/");

1744

dtr_rmtree("$opt_vardir/");

1745

}

1746

}

1747

1749

# Create var and the directories needed in var

1750

#

1751

sub setup_vardir() {

1752

mtr_report("Creating Directories");

1752

dtr_report("Creating Directories");

1753

1754

if ( $opt_vardir eq $default_vardir )

1755

{

1756

#

1757

# Running with "var" in mysql-test dir

1757

# Running with "var" in drizzle-test dir

1758

#

1759

if ( -l $opt_vardir )

1760

{

1761

# it's a symlink

1762

1763

# Make sure the directory where it points exist

1764

mtr_error("The destination for symlink $opt_vardir does not exist")

1764

dtr_error("The destination for symlink $opt_vardir does not exist")

1765

if ! -d readlink($opt_vardir);

1766

}

1767

elsif ( $opt_mem )

1768

{

1769

# Runinng with "var" as a link to some "memory" location, normally tmpfs

1770

mtr_verbose("Creating $opt_mem");

1770

dtr_verbose("Creating $opt_mem");

1771

mkpath($opt_mem);

1772

1773

mtr_report("Symlinking 'var' to '$opt_mem'");

1773

dtr_report("Symlinking 'var' to '$opt_mem'");

1774

symlink($opt_mem, $opt_vardir);

1775

}

1776

}

1777

1778

if ( ! -d $opt_vardir )

1779

{

1780

mtr_verbose("Creating $opt_vardir");

1780

dtr_verbose("Creating $opt_vardir");

1781

mkpath($opt_vardir);

1782

}

1783

1784

# Ensure a proper error message if vardir couldn't be created

1785

unless ( -d $opt_vardir and -w $opt_vardir )

1786

{

1787

mtr_error("Writable 'var' directory is needed, use the " .

1787

dtr_error("Writable 'var' directory is needed, use the " .

1788

"'--vardir=<path>' option");

1789

}

1790

1796

# Create new data dirs

1797

foreach my $data_dir (@data_dir_lst)

1798

{

1799

mkpath("$data_dir/local/mysql");

1799

mkpath("$data_dir/local/drizzle");

1800

system("$exe_schemawriter mysql $data_dir/local/mysql/db.opt");

1801

1802

mkpath("$data_dir/local/test");

1804

}

1805

1806

# Make a link std_data_ln in var/ that points to std_data

1807

symlink(collapse_path("$glob_mysql_test_dir/std_data"),

1807

symlink(collapse_path("$glob_drizzle_test_dir/std_data"),

1808

"$opt_vardir/std_data_ln");

1809

1810

symlink(collapse_path("$glob_suite_path/filesystem_engine/tests/t"),

1826

# Check if running as root

1827

# i.e a file can be read regardless what mode we set it to

1828

my $test_file= "$opt_vardir/test_running_as_root.txt";

1829

mtr_tofile($test_file, "MySQL");

1829

dtr_tofile($test_file, "Drizzle");

1830

chmod(oct("0000"), $test_file);

1831

1832

my $result="";

1842

my $file_mode= (stat($test_file))[2] & 07777;

1843

1844

$ENV{'DRIZZLE_TEST_ROOT'}= "NO";

1845

mtr_verbose("result: $result, file_mode: $file_mode");

1846

if ($result eq "MySQL" && $file_mode == 0)

1845

dtr_verbose("result: $result, file_mode: $file_mode");

1846

if ($result eq "Drizzle" && $file_mode == 0)

1847

{

1848

mtr_warning("running this script as _root_ will cause some " .

1848

dtr_warning("running this script as _root_ will cause some " .

1849

"tests to be skipped");

1850

$ENV{'DRIZZLE_TEST_ROOT'}= "YES";

1851

}

1857

1858

1859

sub check_debug_support ($) {

1860

my $mysqld_variables= shift;

1860

my $drizzled_variables= shift;

1861

1862

if ( ! $mysqld_variables->{'debug'} )

1862

if ( ! $drizzled_variables->{'debug'} )

1863

{

1864

#mtr_report("Binaries are not debug compiled");

1864

#dtr_report("Binaries are not debug compiled");

1865

$debug_compiled_binaries= 0;

1866

1867

if ( $opt_debug )

1868

{

1869

mtr_error("Can't use --debug, binaries does not support it");

1869

dtr_error("Can't use --debug, binaries does not support it");

1870

}

1871

return;

1872

}

1873

mtr_report("Binaries are debug compiled");

1873

dtr_report("Binaries are debug compiled");

1874

$debug_compiled_binaries= 1;

1875

}

1876

1887

my $args;

1888

1889

{

1890

mysqld_start($master->[0],[],[]);

1890

drizzled_start($master->[0],[],[]);

1891

if ( ! $master->[0]->{'pid'} )

1892

{

1893

mtr_error("Can't start the mysqld server");

1893

dtr_error("Can't start the drizzled server");

1894

}

1895

}

1896

1897

mtr_init_args(\$args);

1897

dtr_init_args(\$args);

1898

1899

mtr_add_arg($args, "--user=%s", $opt_user);

1899

dtr_add_arg($args, "--user=%s", $opt_user);

1900

1901

if ( $opt_small_bench )

1902

{

1903

mtr_add_arg($args, "--small-test");

1904

mtr_add_arg($args, "--small-tables");

1903

dtr_add_arg($args, "--small-test");

1904

dtr_add_arg($args, "--small-tables");

1905

}

1906

1907

chdir($glob_mysql_bench_dir)

1908

or mtr_error("Couldn't chdir to '$glob_mysql_bench_dir': $!");

1907

chdir($glob_drizzle_bench_dir)

1908

or dtr_error("Couldn't chdir to '$glob_drizzle_bench_dir': $!");

1909

1910

if ( ! $benchmark )

1911

{

1912

mtr_run("$glob_mysql_bench_dir/run-all-tests", $args, "", "", "", "");

1912

dtr_run("$glob_drizzle_bench_dir/run-all-tests", $args, "", "", "", "");

1913

# FIXME check result code?!

1914

}

1915

elsif ( -x $benchmark )

1916

{

1917

mtr_run("$glob_mysql_bench_dir/$benchmark", $args, "", "", "", "");

1917

dtr_run("$glob_drizzle_bench_dir/$benchmark", $args, "", "", "", "");

1918

# FIXME check result code?!

1919

}

1920

else

1921

{

1922

mtr_error("Benchmark $benchmark not found");

1922

dtr_error("Benchmark $benchmark not found");

1923

}

1924

1925

chdir($glob_mysql_test_dir); # Go back

1925

chdir($glob_drizzle_test_dir); # Go back

1926

1927

{

1928

stop_masters();

1939

sub run_tests () {

1940

my ($tests)= @_;

1941

1942

mtr_print_thick_line();

1943

1944

mtr_timer_start($glob_timers,"suite", 60 * $opt_suite_timeout);

1945

1946

mtr_report_tests_not_skipped_though_disabled($tests);

1947

1948

mtr_print_header();

1942

dtr_print_thick_line();

1943

1944

dtr_timer_start($glob_timers,"suite", 60 * $opt_suite_timeout);

1945

1946

dtr_report_tests_not_skipped_though_disabled($tests);

1947

1948

dtr_print_header();

1949

1950

foreach my $tinfo ( @$tests )

1951

{

1956

next;

1957

}

1958

1959

mtr_timer_start($glob_timers,"testcase", 60 * $opt_testcase_timeout);

1959

dtr_timer_start($glob_timers,"testcase", 60 * $opt_testcase_timeout);

1960

run_testcase($tinfo);

1961

mtr_timer_stop($glob_timers,"testcase");

1961

dtr_timer_stop($glob_timers,"testcase");

1962

}

1963

}

1964

1965

mtr_print_line();

1965

dtr_print_line();

1966

1967

if ( ! $glob_debugger and

1968

! $opt_extern )

1979

gprof_collect(); # collect coverage information

1980

}

1981

1982

mtr_report_stats($tests);

1982

dtr_report_stats($tests);

1983

1984

mtr_timer_stop($glob_timers,"suite");

1984

dtr_timer_stop($glob_timers,"suite");

1985

}

1986

1987

2001

# vardir does not already exist it should be created

2002

if ( ! -d $opt_vardir )

2003

{

2004

mtr_report("Creating '$opt_vardir'");

2004

dtr_report("Creating '$opt_vardir'");

2005

setup_vardir();

2006

}

2007

else

2008

{

2009

mtr_verbose("No need to create '$opt_vardir' it already exists");

2009

dtr_verbose("No need to create '$opt_vardir' it already exists");

2010

}

2011

}

2012

else

2018

remove_stale_vardir();

2019

setup_vardir();

2020

2021

mysql_install_db();

2021

drizzle_install_db();

2022

if ( $opt_force )

2023

{

2024

# Save a snapshot of the freshly installed db

2029

}

2030

check_running_as_root();

2031

2032

mtr_log_init("$opt_vardir/log/drizzle-test-run.log");

2032

dtr_log_init("$opt_vardir/log/drizzle-test-run.log");

2033

2034

}

2035

2036

sub mysql_install_db () {

2036

sub drizzle_install_db () {

2037

2038

if ($max_master_num > 1)

2039

{

2054

my $type= shift;

2055

my $data_dir= shift;

2056

2057

mtr_report("Installing \u$type Database");

2057

dtr_report("Installing \u$type Database");

2058

2059

# Just copy the installed db from first master

2060

mtr_copy_dir($master->[0]->{'path_myddir'}, $data_dir);

2060

dtr_copy_dir($master->[0]->{'path_myddir'}, $data_dir);

2061

2062

}

2063

2075

{

2076

my $data_dir= $slave->[$idx]->{'path_myddir'};

2077

my $name= basename($data_dir);

2078

mtr_rmtree($data_dir);

2079

mtr_copy_dir("$path_snapshot/$name", $data_dir);

2078

dtr_rmtree($data_dir);

2079

dtr_copy_dir("$path_snapshot/$name", $data_dir);

2080

}

2081

}

2082

}

2095

2096

if ( $tinfo->{'skip'} )

2097

{

2098

mtr_report_test_name($tinfo);

2099

mtr_report_test_skipped($tinfo);

2098

dtr_report_test_name($tinfo);

2099

dtr_report_test_skipped($tinfo);

2100

return 1;

2101

}

2102

2110

my $args;

2111

2112

# Remove old files produced by drizzletest

2113

my $base_file= mtr_match_extension($tinfo->{'result_file'},

2113

my $base_file= dtr_match_extension($tinfo->{'result_file'},

2114

"result"); # Trim extension

2115

unlink("$base_file.reject");

2116

unlink("$base_file.progress");

2124

my $tinfo= shift;

2125

2126

# Save info from this testcase run to drizzletest.log

2127

mtr_appendfile_to_file($path_current_test_log, $path_drizzletest_log)

2127

dtr_appendfile_to_file($path_current_test_log, $path_drizzletest_log)

2128

if -f $path_current_test_log;

2129

mtr_appendfile_to_file($path_timefile, $path_drizzletest_log)

2129

dtr_appendfile_to_file($path_timefile, $path_drizzletest_log)

2130

if -f $path_timefile;

2131

}

2132

2138

# Write a marker to all log files

2139

2140

# The file indicating current test name

2141

mtr_tonewfile($path_current_test_log, $log_msg);

2141

dtr_tonewfile($path_current_test_log, $log_msg);

2142

2143

# each mysqld's .err file

2144

foreach my $mysqld (@{$master}, @{$slave})

2143

# each drizzled's .err file

2144

foreach my $drizzled (@{$master}, @{$slave})

2145

{

2146

mtr_tofile($mysqld->{path_myerr}, $log_msg);

2146

dtr_tofile($drizzled->{path_myerr}, $log_msg);

2147

}

2148

2149

}

2171

2172

if ( ! $reason )

2173

{

2174

mtr_warning("Could not find reason for skipping test in $path_timefile");

2174

dtr_warning("Could not find reason for skipping test in $path_timefile");

2175

$reason= "Detected by testcase(reason unknown) ";

2176

}

2177

$tinfo->{'comment'}= $reason;

2191

2192

# We don't start and kill the servers for each testcase. But some

2193

# testcases needs a restart, because they specify options to start

2194

# mysqld with. After that testcase, we need to restart again, to set

2194

# drizzled with. After that testcase, we need to restart again, to set

2195

# back the normal options.

2196

2197

sub run_testcase ($) {

2202

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

2203

2204

$ENV{'TZ'}= $tinfo->{'timezone'};

2205

mtr_verbose("Setting timezone: $tinfo->{'timezone'}");

2205

dtr_verbose("Setting timezone: $tinfo->{'timezone'}");

2206

2207

my $master_restart= run_testcase_need_master_restart($tinfo);

2208

my $slave_restart= run_testcase_need_slave_restart($tinfo);

2212

# Can't restart a running server that may be in use

2213

if ( $opt_extern )

2214

{

2215

mtr_report_test_name($tinfo);

2215

dtr_report_test_name($tinfo);

2216

$tinfo->{comment}= "Can't restart a running server";

2217

mtr_report_test_skipped($tinfo);

2217

dtr_report_test_skipped($tinfo);

2218

return;

2219

}

2220

2224

# Write to all log files to indicate start of testcase

2225

run_testcase_mark_logs($tinfo, "CURRENT_TEST: $tinfo->{name}\n");

2226

2227

my $died= mtr_record_dead_children();

2227

my $died= dtr_record_dead_children();

2228

if ($died or $master_restart or $slave_restart)

2229

{

2230

if (run_testcase_start_servers($tinfo))

2231

{

2232

mtr_report_test_name($tinfo);

2232

dtr_report_test_name($tinfo);

2233

report_failure_and_restart($tinfo);

2234

return 1;

2235

}

2240

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

2241

if ( $opt_start_and_exit or $opt_start_dirty )

2242

{

2243

mtr_timer_stop_all($glob_timers);

2244

mtr_report("\nServers started, exiting");

2243

dtr_timer_stop_all($glob_timers);

2244

dtr_report("\nServers started, exiting");

2245

exit(0);

2246

}

2247

2249

do_before_run_drizzletest($tinfo);

2250

2251

my $res= run_drizzletest($tinfo);

2252

mtr_report_test_name($tinfo);

2252

dtr_report_test_name($tinfo);

2253

2254

do_after_run_drizzletest($tinfo);

2255

2256

if ( $res == 0 )

2257

{

2258

mtr_report_test_passed($tinfo);

2258

dtr_report_test_passed($tinfo);

2259

}

2260

elsif ( $res == 62 )

2261

{

2263

2264

# Try to get reason from drizzletest.log

2265

find_testcase_skipped_reason($tinfo);

2266

mtr_report_test_skipped($tinfo);

2266

dtr_report_test_skipped($tinfo);

2267

}

2268

elsif ( $res == 63 )

2269

{

2299

#

2300

sub save_installed_db () {

2301

2302

mtr_report("Saving snapshot of installed databases");

2303

mtr_rmtree($path_snapshot);

2302

dtr_report("Saving snapshot of installed databases");

2303

dtr_rmtree($path_snapshot);

2304

2305

foreach my $data_dir (@data_dir_lst)

2306

{

2307

my $name= basename($data_dir);

2308

mtr_copy_dir("$data_dir", "$path_snapshot/$name");

2308

dtr_copy_dir("$data_dir", "$path_snapshot/$name");

2309

}

2310

}

2311

2324

{

2325

last if $opt_max_save_core > 0 && $num_saved_cores >= $opt_max_save_core;

2326

my $core_name= basename($core_file);

2327

mtr_report("Saving $core_name");

2327

dtr_report("Saving $core_name");

2328

mkdir($save_name) if ! -d $save_name;

2329

rename("$core_file", "$save_name/$core_name");

2330

++$num_saved_cores;

2341

2342

if ( -d $path_snapshot)

2343

{

2344

mtr_report("Restoring snapshot of databases");

2344

dtr_report("Restoring snapshot of databases");

2345

2346

foreach my $data_dir (@data_dir_lst)

2347

{

2348

my $name= basename($data_dir);

2349

save_files_before_restore($test_name, $data_dir);

2350

mtr_rmtree("$data_dir");

2351

mtr_copy_dir("$path_snapshot/$name", "$data_dir");

2350

dtr_rmtree("$data_dir");

2351

dtr_copy_dir("$path_snapshot/$name", "$data_dir");

2352

}

2353

}

2354

else

2355

{

2356

# No snapshot existed

2357

mtr_error("No snapshot existed");

2357

dtr_error("No snapshot existed");

2358

}

2359

}

2360

2361

sub report_failure_and_restart ($) {

2362

my $tinfo= shift;

2363

2364

mtr_report_test_failed($tinfo);

2364

dtr_report_test_failed($tinfo);

2365

print "\n";

2366

if ( $opt_force )

2367

{

2370

2371

# Restore the snapshot of the installed test db

2372

restore_installed_db($tinfo->{'name'});

2373

mtr_report("Resuming Tests\n");

2373

dtr_report("Resuming Tests\n");

2374

return;

2375

}

2376

2377

my $test_mode= join(" ", @::glob_test_mode) || "default";

2378

mtr_report("Aborting: $tinfo->{'name'} failed in $test_mode mode. ");

2379

mtr_report("To continue, re-run with '--force'.");

2378

dtr_report("Aborting: $tinfo->{'name'} failed in $test_mode mode. ");

2379

dtr_report("To continue, re-run with '--force'.");

2380

if ( ! $glob_debugger and

2381

! $opt_extern )

2382

{

2383

stop_all_servers();

2384

}

2385

mtr_exit(1);

2385

dtr_exit(1);

2386

2387

}

2388

2394

# Run master initialization shell script if one exists

2395

if ( $init_script )

2396

{

2397

my $ret= mtr_run("/bin/sh", [$init_script], "", "", "", "");

2397

my $ret= dtr_run("/bin/sh", [$init_script], "", "", "", "");

2398

if ( $ret != 0 )

2399

{

2400

# FIXME rewrite those scripts to return 0 if successful

2401

# mtr_warning("$init_script exited with code $ret");

2401

# dtr_warning("$init_script exited with code $ret");

2402

}

2403

}

2404

}

2457

# Run slave initialization shell script if one exists

2458

if ( $init_script )

2459

{

2460

my $ret= mtr_run("/bin/sh", [$init_script], "", "", "", "");

2460

my $ret= dtr_run("/bin/sh", [$init_script], "", "", "", "");

2461

if ( $ret != 0 )

2462

{

2463

# FIXME rewrite those scripts to return 0 if successful

2464

# mtr_warning("$init_script exited with code $ret");

2464

# dtr_warning("$init_script exited with code $ret");

2465

}

2466

}

2467

2472

}

2473

2474

2475

sub mysqld_arguments ($$$$) {

2475

sub drizzled_arguments ($$$$) {

2476

my $args= shift;

2477

my $mysqld= shift;

2477

my $drizzled= shift;

2478

my $extra_opt= shift;

2479

my $slave_master_info= shift;

2480

2481

my $idx= $mysqld->{'idx'};

2481

my $idx= $drizzled->{'idx'};

2482

my $sidx= ""; # Index as string, 0 is empty string

2483

if ( $idx> 0 )

2484

{

2487

2488

my $prefix= ""; # If drizzletest server arg

2489

2490

mtr_add_arg($args, "%s--no-defaults", $prefix);

2490

dtr_add_arg($args, "%s--no-defaults", $prefix);

2491

2492

if ($opt_engine)

2493

{

2494

mtr_add_arg($args, "%s--default-storage-engine=%s", $prefix, $opt_engine);

2494

dtr_add_arg($args, "%s--default-storage-engine=%s", $prefix, $opt_engine);

2495

}

2496

2497

if ( $drizzle_version_id >= 50036)

2498

{

2499

# By default, prevent the started mysqld to access files outside of vardir

2500

mtr_add_arg($args, "%s--secure-file-priv=%s", $prefix, $opt_vardir);

2499

# By default, prevent the started drizzled to access files outside of vardir

2500

dtr_add_arg($args, "%s--secure-file-priv=%s", $prefix, $opt_vardir);

2501

}

2502

2503

mtr_add_arg($args, "%s--tmpdir=$opt_tmpdir", $prefix);

2503

dtr_add_arg($args, "%s--tmpdir=$opt_tmpdir", $prefix);

2504

2505

# Increase default connect_timeout to avoid intermittent

2506

# disconnects when test servers are put under load

2507

# see BUG#28359

2508

mtr_add_arg($args, "%s--mysql-protocol.connect-timeout=60", $prefix);

2509

2510

2511

# When mysqld is run by a root user(euid is 0), it will fail

2508

dtr_add_arg($args, "%s--mysql-protocol.connect-timeout=60", $prefix);

2509

2510

2511

# When drizzled is run by a root user(euid is 0), it will fail

2512

# to start unless we specify what user to run as, see BUG#30630

2513

my $euid= $>;

2514

if (grep(/^--user/, @$extra_opt, @opt_extra_mysqld_opt) == 0) {

2515

mtr_add_arg($args, "%s--user=root", $prefix);

2514

if (grep(/^--user/, @$extra_opt, @opt_extra_drizzled_opt) == 0) {

2515

dtr_add_arg($args, "%s--user=root", $prefix);

2516

}

2517

2518

mtr_add_arg($args, "%s--pid-file=%s", $prefix,

2519

$mysqld->{'path_pid'});

2520

2521

mtr_add_arg($args, "%s--mysql-protocol.port=%d", $prefix,

2522

$mysqld->{'port'});

2523

2524

mtr_add_arg($args, "%s--drizzle-protocol.port=%d", $prefix,

2525

$mysqld->{'secondary_port'});

2526

2527

mtr_add_arg($args, "%s--datadir=%s", $prefix,

2528

$mysqld->{'path_myddir'});

2518

dtr_add_arg($args, "%s--pid-file=%s", $prefix,

2519

$drizzled->{'path_pid'});

2520

2521

dtr_add_arg($args, "%s--mysql-protocol.port=%d", $prefix,

2522

$drizzled->{'port'});

2523

2524

dtr_add_arg($args, "%s--mysql-protocol.port=%d", $prefix,

2525

$drizzled->{'secondary_port'});

2526

2527

dtr_add_arg($args, "%s--datadir=%s", $prefix,

2528

$drizzled->{'path_myddir'});

2529

2530

# Check if "extra_opt" contains --skip-log-bin

2531

if ( $mysqld->{'type'} eq 'master' )

2531

if ( $drizzled->{'type'} eq 'master' )

2532

{

2533

mtr_add_arg($args, "%s--server-id=%d", $prefix,

2533

dtr_add_arg($args, "%s--server-id=%d", $prefix,

2534

$idx > 0 ? $idx + 101 : 1);

2535

2536

mtr_add_arg($args,

2536

dtr_add_arg($args,

2537

"%s--innodb.data-file-path=ibdata1:20M:autoextend", $prefix);

2538

2539

}

2540

else

2541

{

2542

mtr_error("unknown mysqld type")

2543

unless $mysqld->{'type'} eq 'slave';

2542

dtr_error("unknown drizzled type")

2543

unless $drizzled->{'type'} eq 'slave';

2544

2545

# Directory where slaves find the dumps generated by "load data"

2546

# on the server. The path need to have constant length otherwise

2551

{

2552

foreach my $arg ( @$slave_master_info )

2553

{

2554

mtr_add_arg($args, "%s%s", $prefix, $arg);

2554

dtr_add_arg($args, "%s%s", $prefix, $arg);

2555

}

2556

}

2557

else

2558

{

2559

my $slave_server_id= 2 + $idx;

2560

my $slave_rpl_rank= $slave_server_id;

2561

mtr_add_arg($args, "%s--server-id=%d", $prefix, $slave_server_id);

2561

dtr_add_arg($args, "%s--server-id=%d", $prefix, $slave_server_id);

2562

}

2563

} # end slave

2564

2565

if ( $opt_debug )

2566

{

2567

mtr_add_arg($args, "%s--debug=d:t:i:A,%s/log/%s%s.trace",

2568

$prefix, $path_vardir_trace, $mysqld->{'type'}, $sidx);

2567

dtr_add_arg($args, "%s--debug=d:t:i:A,%s/log/%s%s.trace",

2568

$prefix, $path_vardir_trace, $drizzled->{'type'}, $sidx);

2569

}

2570

2571

mtr_add_arg($args, "%s--sort-buffer-size=256K", $prefix);

2572

mtr_add_arg($args, "%s--max-heap-table-size=1M", $prefix);

2571

dtr_add_arg($args, "%s--sort-buffer-size=256K", $prefix);

2572

dtr_add_arg($args, "%s--max-heap-table-size=1M", $prefix);

2573

2574

if ( $opt_warnings )

2575

{

2576

mtr_add_arg($args, "%s--log-warnings", $prefix);

2576

dtr_add_arg($args, "%s--log-warnings", $prefix);

2577

}

2578

2579

# Indicate to "mysqld" it will be debugged in debugger

2579

# Indicate to "drizzled" it will be debugged in debugger

2580

if ( $glob_debugger )

2581

{

2582

mtr_add_arg($args, "%s--gdb", $prefix);

2582

dtr_add_arg($args, "%s--gdb", $prefix);

2583

}

2584

2585

my $found_skip_core= 0;

2586

foreach my $arg ( @opt_extra_mysqld_opt, @$extra_opt )

2586

foreach my $arg ( @opt_extra_drizzled_opt, @$extra_opt )

2587

{

2588

# Allow --skip-core-file to be set in <testname>-[master|slave].opt file

2589

if ($arg eq "--skip-core-file")

2592

}

2593

else

2594

{

2595

mtr_add_arg($args, "%s%s", $prefix, $arg);

2595

dtr_add_arg($args, "%s%s", $prefix, $arg);

2596

}

2597

}

2598

if ( !$found_skip_core )

2599

{

2600

mtr_add_arg($args, "%s%s", $prefix, "--core-file");

2600

dtr_add_arg($args, "%s%s", $prefix, "--core-file");

2601

}

2602

2603

return $args;

2606

2607

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

2608

#

2609

# Start mysqld and return the PID

2609

# Start drizzled and return the PID

2610

#

2611

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

2612

2613

sub mysqld_start ($$$) {

2614

my $mysqld= shift;

2613

sub drizzled_start ($$$) {

2614

my $drizzled= shift;

2615

my $extra_opt= shift;

2616

my $slave_master_info= shift;

2617

2620

my $pid= -1;

2621

my $wait_for_pid_file= 1;

2622

2623

my $type= $mysqld->{'type'};

2624

my $idx= $mysqld->{'idx'};

2623

my $type= $drizzled->{'type'};

2624

my $idx= $drizzled->{'idx'};

2625

2626

if ( $type eq 'master' )

2627

{

2628

$exe= $exe_master_mysqld;

2628

$exe= $exe_master_drizzled;

2629

}

2630

elsif ( $type eq 'slave' )

2631

{

2632

$exe= $exe_slave_mysqld;

2632

$exe= $exe_slave_drizzled;

2633

}

2634

else

2635

{

2636

mtr_error("Unknown 'type' \"$type\" passed to mysqld_start");

2636

dtr_error("Unknown 'type' \"$type\" passed to drizzled_start");

2637

}

2638

2639

mtr_init_args(\$args);

2639

dtr_init_args(\$args);

2640

2641

if ( $opt_valgrind_mysqld )

2641

if ( $opt_valgrind_drizzled )

2642

{

2643

valgrind_arguments($args, \$exe);

2644

}

2645

2646

mysqld_arguments($args,$mysqld,$extra_opt,$slave_master_info);

2646

drizzled_arguments($args,$drizzled,$extra_opt,$slave_master_info);

2647

2648

if ( $opt_gdb || $opt_manual_gdb)

2649

{

2664

elsif ( $opt_manual_debug )

2665

{

2666

print "\nStart $type in your debugger\n" .

2667

"dir: $glob_mysql_test_dir\n" .

2667

"dir: $glob_drizzle_test_dir\n" .

2668

"exe: $exe\n" .

2669

"args: " . join(" ", @$args) . "\n\n" .

2670

"Waiting ....\n";

2679

}

2680

2681

# Remove the pidfile

2682

unlink($mysqld->{'path_pid'});

2682

unlink($drizzled->{'path_pid'});

2683

2684

if ( defined $exe )

2685

{

2686

mtr_verbose("running Drizzle with: $exe @$args");

2687

$pid= mtr_spawn($exe, $args, "",

2688

$mysqld->{'path_myerr'},

2689

$mysqld->{'path_myerr'},

2686

dtr_verbose("running Drizzle with: $exe @$args");

2687

$pid= dtr_spawn($exe, $args, "",

2688

$drizzled->{'path_myerr'},

2689

$drizzled->{'path_myerr'},

2690

"",

2691

{ append_log_file => 1 });

2692

}

2693

2694

2695

if ( $wait_for_pid_file && !sleep_until_file_created($mysqld->{'path_pid'},

2696

$mysqld->{'start_timeout'},

2695

if ( $wait_for_pid_file && !sleep_until_file_created($drizzled->{'path_pid'},

2696

$drizzled->{'start_timeout'},

2697

$pid))

2698

{

2699

2700

mtr_error("Failed to start mysqld $mysqld->{'type'}");

2700

dtr_error("Failed to start drizzled $drizzled->{'type'}");

2701

}

2702

2703

2704

# Remember pid of the started process

2705

$mysqld->{'pid'}= $pid;

2705

$drizzled->{'pid'}= $pid;

2706

2707

# Remember options used when starting

2708

$mysqld->{'start_opts'}= $extra_opt;

2709

$mysqld->{'start_slave_master_info'}= $slave_master_info;

2708

$drizzled->{'start_opts'}= $extra_opt;

2709

$drizzled->{'start_slave_master_info'}= $slave_master_info;

2710

2711

mtr_verbose("mysqld pid: $pid");

2711

dtr_verbose("drizzled pid: $pid");

2712

return $pid;

2713

}

2714

2715

2716

sub stop_all_servers () {

2717

2718

mtr_report("Stopping All Servers");

2718

dtr_report("Stopping All Servers");

2719

2720

my %admin_pids; # hash of admin processes that requests shutdown

2721

my @kill_pids; # list of processes to shutdown/kill

2722

my $pid;

2723

2724

# Start shutdown of all started masters

2725

foreach my $mysqld (@{$slave}, @{$master})

2725

foreach my $drizzled (@{$slave}, @{$master})

2726

{

2727

if ( $mysqld->{'pid'} )

2727

if ( $drizzled->{'pid'} )

2728

{

2729

$pid= mtr_server_shutdown($mysqld);

2729

$pid= dtr_server_shutdown($drizzled);

2730

$admin_pids{$pid}= 1;

2731

2732

push(@kill_pids,{

2733

pid => $mysqld->{'pid'},

2734

real_pid => $mysqld->{'real_pid'},

2735

pidfile => $mysqld->{'path_pid'},

2736

sockfile => $mysqld->{'path_sock'},

2737

port => $mysqld->{'port'},

2738

errfile => $mysqld->{'path_myerr'},

2733

pid => $drizzled->{'pid'},

2734

real_pid => $drizzled->{'real_pid'},

2735

pidfile => $drizzled->{'path_pid'},

2736

sockfile => $drizzled->{'path_sock'},

2737

port => $drizzled->{'port'},

2738

errfile => $drizzled->{'path_myerr'},

2739

});

2740

2741

$mysqld->{'pid'}= 0; # Assume we are done with it

2741

$drizzled->{'pid'}= 0; # Assume we are done with it

2742

}

2743

}

2744

2745

# Wait blocking until all shutdown processes has completed

2746

mtr_wait_blocking(\%admin_pids);

2746

dtr_wait_blocking(\%admin_pids);

2747

2748

# Make sure that process has shutdown else try to kill them

2749

mtr_check_stop_servers(\@kill_pids);

2749

dtr_check_stop_servers(\@kill_pids);

2750

}

2751

2752

2760

if ( $tinfo->{'master_sh'} )

2761

{

2762

$do_restart= 1; # Always restart if script to run

2763

mtr_verbose("Restart master: Always restart if script to run");

2763

dtr_verbose("Restart master: Always restart if script to run");

2764

}

2765

if ( $tinfo->{'force_restart'} )

2766

{

2767

$do_restart= 1; # Always restart if --force-restart in -opt file

2768

mtr_verbose("Restart master: Restart forced with --force-restart");

2768

dtr_verbose("Restart master: Restart forced with --force-restart");

2769

}

2770

elsif( $tinfo->{'component_id'} eq 'im' )

2771

{

2772

$do_restart= 1;

2773

mtr_verbose("Restart master: Always restart for im tests");

2773

dtr_verbose("Restart master: Always restart for im tests");

2774

}

2775

elsif ( $master->[0]->{'running_master_options'} and

2776

$master->[0]->{'running_master_options'}->{'timezone'} ne

2777

$tinfo->{'timezone'})

2778

{

2779

$do_restart= 1;

2780

mtr_verbose("Restart master: Different timezone");

2780

dtr_verbose("Restart master: Different timezone");

2781

}

2782

# Check that running master was started with same options

2783

# as the current test requires

2784

elsif (! mtr_same_opts($master->[0]->{'start_opts'},

2784

elsif (! dtr_same_opts($master->[0]->{'start_opts'},

2785

$tinfo->{'master_opt'}) )

2786

{

2787

# Chech that diff is binlog format only

2788

my $diff_opts= mtr_diff_opts($master->[0]->{'start_opts'},$tinfo->{'master_opt'});

2788

my $diff_opts= dtr_diff_opts($master->[0]->{'start_opts'},$tinfo->{'master_opt'});

2789

if (scalar(@$diff_opts) eq 2)

2790

{

2791

$do_restart= 1;

2793

else

2794

{

2795

$do_restart= 1;

2796

mtr_verbose("Restart master: running with different options '" .

2796

dtr_verbose("Restart master: running with different options '" .

2797

join(" ", @{$tinfo->{'master_opt'}}) . "' != '" .

2798

join(" ", @{$master->[0]->{'start_opts'}}) . "'" );

2799

}

2803

if ( $opt_extern )

2804

{

2805

$do_restart= 0;

2806

mtr_verbose("No restart: using extern master");

2806

dtr_verbose("No restart: using extern master");

2807

}

2808

else

2809

{

2810

$do_restart= 1;

2811

mtr_verbose("Restart master: master is not started");

2811

dtr_verbose("Restart master: master is not started");

2812

}

2813

}

2814

return $do_restart;

2823

2824

if ( $max_slave_num == 0)

2825

{

2826

mtr_verbose("Skip slave restart: No testcase use slaves");

2826

dtr_verbose("Skip slave restart: No testcase use slaves");

2827

}

2828

else

2829

{

2830

2831

# Check if any slave is currently started

2832

my $any_slave_started= 0;

2833

foreach my $mysqld (@{$slave})

2833

foreach my $drizzled (@{$slave})

2834

{

2835

if ( $mysqld->{'pid'} )

2835

if ( $drizzled->{'pid'} )

2836

{

2837

$any_slave_started= 1;

2838

last;

2841

2842

if ($any_slave_started)

2843

{

2844

mtr_verbose("Restart slave: Slave is started, always restart");

2844

dtr_verbose("Restart slave: Slave is started, always restart");

2845

$do_slave_restart= 1;

2846

}

2847

elsif ( $tinfo->{'slave_num'} )

2848

{

2849

mtr_verbose("Restart slave: Test need slave");

2849

dtr_verbose("Restart slave: Test need slave");

2850

$do_slave_restart= 1;

2851

}

2852

}

2880

delete $master->[0]->{'running_master_options'}; # Forget history

2881

2882

# Start shutdown of all started masters

2883

foreach my $mysqld (@{$master})

2883

foreach my $drizzled (@{$master})

2884

{

2885

if ( $mysqld->{'pid'} )

2885

if ( $drizzled->{'pid'} )

2886

{

2887

$pid= mtr_server_shutdown($mysqld);

2887

$pid= dtr_server_shutdown($drizzled);

2888

2889

$admin_pids{$pid}= 1;

2890

2891

push(@kill_pids,{

2892

pid => $mysqld->{'pid'},

2893

real_pid => $mysqld->{'real_pid'},

2894

pidfile => $mysqld->{'path_pid'},

2895

sockfile => $mysqld->{'path_sock'},

2896

port => $mysqld->{'port'},

2897

errfile => $mysqld->{'path_myerr'},

2892

pid => $drizzled->{'pid'},

2893

real_pid => $drizzled->{'real_pid'},

2894

pidfile => $drizzled->{'path_pid'},

2895

sockfile => $drizzled->{'path_sock'},

2896

port => $drizzled->{'port'},

2897

errfile => $drizzled->{'path_myerr'},

2898

});

2899

2900

$mysqld->{'pid'}= 0; # Assume we are done with it

2900

$drizzled->{'pid'}= 0; # Assume we are done with it

2901

}

2902

}

2903

}

2908

delete $slave->[0]->{'running_slave_options'}; # Forget history

2909

2910

# Start shutdown of all started slaves

2911

foreach my $mysqld (@{$slave})

2911

foreach my $drizzled (@{$slave})

2912

{

2913

if ( $mysqld->{'pid'} )

2913

if ( $drizzled->{'pid'} )

2914

{

2915

$pid= mtr_server_shutdown($mysqld);

2915

$pid= dtr_server_shutdown($drizzled);

2916

2917

$admin_pids{$pid}= 1;

2918

2919

push(@kill_pids,{

2920

pid => $mysqld->{'pid'},

2921

real_pid => $mysqld->{'real_pid'},

2922

pidfile => $mysqld->{'path_pid'},

2923

sockfile => $mysqld->{'path_sock'},

2924

port => $mysqld->{'port'},

2925

errfile => $mysqld->{'path_myerr'},

2920

pid => $drizzled->{'pid'},

2921

real_pid => $drizzled->{'real_pid'},

2922

pidfile => $drizzled->{'path_pid'},

2923

sockfile => $drizzled->{'path_sock'},

2924

port => $drizzled->{'port'},

2925

errfile => $drizzled->{'path_myerr'},

2926

});

2927

2928

$mysqld->{'pid'}= 0; # Assume we are done with it

2928

$drizzled->{'pid'}= 0; # Assume we are done with it

2929

}

2930

}

2931

}

2936

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

2937

2938

# Wait blocking until all shutdown processes has completed

2939

mtr_wait_blocking(\%admin_pids);

2939

dtr_wait_blocking(\%admin_pids);

2940

2941

2942

# Make sure that process has shutdown else try to kill them

2943

mtr_check_stop_servers(\@kill_pids);

2943

dtr_check_stop_servers(\@kill_pids);

2944

}

2945

2946

2958

my $tinfo= shift;

2959

my $tname= $tinfo->{'name'};

2960

2961

if ( $tinfo->{'component_id'} eq 'mysqld' )

2961

if ( $tinfo->{'component_id'} eq 'drizzled' )

2962

{

2963

if ( !$master->[0]->{'pid'} )

2964

{

2965

# Master mysqld is not started

2965

# Master drizzled is not started

2966

do_before_start_master($tinfo);

2967

2968

mysqld_start($master->[0],$tinfo->{'master_opt'},[]);

2968

drizzled_start($master->[0],$tinfo->{'master_opt'},[]);

2969

2970

}

2971

2986

{

2987

if ( ! $slave->[$idx]->{'pid'} )

2988

{

2989

mysqld_start($slave->[$idx],$tinfo->{'slave_opt'},

2989

drizzled_start($slave->[$idx],$tinfo->{'slave_opt'},

2990

$tinfo->{'slave_mi'});

2991

2992

}

2996

$slave->[0]->{'running_slave_options'}= $tinfo;

2997

}

2998

2999

# Wait for mysqld's to start

3000

foreach my $mysqld (@{$master},@{$slave})

2999

# Wait for drizzled's to start

3000

foreach my $drizzled (@{$master},@{$slave})

3001

{

3002

3003

next if !$mysqld->{'pid'};

3003

next if !$drizzled->{'pid'};

3004

3005

if (mysqld_wait_started($mysqld))

3005

if (drizzled_wait_started($drizzled))

3006

{

3007

# failed to start

3008

$tinfo->{'comment'}=

3009

"Failed to start $mysqld->{'type'} mysqld $mysqld->{'idx'}";

3009

"Failed to start $drizzled->{'type'} drizzled $drizzled->{'idx'}";

3010

return 1;

3011

}

3012

}

3025

sub run_check_testcase ($$) {

3026

3027

my $mode= shift;

3028

my $mysqld= shift;

3028

my $drizzled= shift;

3029

3030

my $name= "check-" . $mysqld->{'type'} . $mysqld->{'idx'};

3030

my $name= "check-" . $drizzled->{'type'} . $drizzled->{'idx'};

3031

3032

my $args;

3033

mtr_init_args(\$args);

3034

3035

mtr_add_arg($args, "--no-defaults");

3036

mtr_add_arg($args, "--silent");

3037

mtr_add_arg($args, "--tmpdir=%s", $opt_tmpdir);

3038

3039

mtr_add_arg($args, "--port=%d", $mysqld->{'port'});

3040

mtr_add_arg($args, "--database=test");

3041

mtr_add_arg($args, "--user=%s", $opt_user);

3042

mtr_add_arg($args, "--password=");

3043

3044

mtr_add_arg($args, "-R");

3045

mtr_add_arg($args, "$opt_vardir/tmp/$name.result");

3033

dtr_init_args(\$args);

3034

3035

dtr_add_arg($args, "--no-defaults");

3036

dtr_add_arg($args, "--silent");

3037

dtr_add_arg($args, "--tmpdir=%s", $opt_tmpdir);

3038

3039

dtr_add_arg($args, "--port=%d", $drizzled->{'port'});

3040

dtr_add_arg($args, "--database=test");

3041

dtr_add_arg($args, "--user=%s", $opt_user);

3042

dtr_add_arg($args, "--password=");

3043

3044

dtr_add_arg($args, "-R");

3045

dtr_add_arg($args, "$opt_vardir/tmp/$name.result");

3046

3047

if ( $mode eq "before" )

3048

{

3049

mtr_add_arg($args, "--record");

3049

dtr_add_arg($args, "--record");

3050

}

3051

3052

if ( $opt_testdir )

3053

{

3054

mtr_add_arg($args, "--testdir=%s", $opt_testdir);

3054

dtr_add_arg($args, "--testdir=%s", $opt_testdir);

3055

}

3056

3057

my $res = mtr_run_test($exe_drizzletest,$args,

3057

my $res = dtr_run_test($exe_drizzletest,$args,

3058

"include/check-testcase.test", "", "", "");

3059

3060

if ( $res == 1 and $mode eq "after")

3061

{

3062

mtr_run("diff",["-u",

3062

dtr_run("diff",["-u",

3063

"$opt_vardir/tmp/$name.result",

3064

"$opt_vardir/tmp/$name.reject"],

3065

"", "", "", "");

3066

}

3067

elsif ( $res )

3068

{

3069

mtr_error("Could not execute 'check-testcase' $mode testcase");

3069

dtr_error("Could not execute 'check-testcase' $mode testcase");

3070

}

3071

return $res;

3072

}

3081

my $args;

3082

3083

{

3084

mysqld_start($master->[0],[],[]);

3084

drizzled_start($master->[0],[],[]);

3085

if ( ! $master->[0]->{'pid'} )

3086

{

3087

mtr_error("Can't start the mysqld server");

3087

dtr_error("Can't start the drizzled server");

3088

}

3089

mysqld_wait_started($master->[0]);

3089

drizzled_wait_started($master->[0]);

3090

}

3091

3092

my $tinfo = {};

3093

$tinfo->{'name'} = 'report features';

3094

$tinfo->{'result_file'} = undef;

3095

$tinfo->{'component_id'} = 'mysqld';

3095

$tinfo->{'component_id'} = 'drizzled';

3096

$tinfo->{'path'} = 'include/report-features.test';

3097

$tinfo->{'timezone'}= "GMT-3";

3098

$tinfo->{'slave_num'} = 0;

3113

my $exe= $exe_drizzletest;

3114

my $args;

3115

3116

mtr_init_args(\$args);

3116

dtr_init_args(\$args);

3117

3118

mtr_add_arg($args, "--no-defaults");

3119

mtr_add_arg($args, "--silent");

3120

mtr_add_arg($args, "--tmpdir=%s", $opt_tmpdir);

3121

mtr_add_arg($args, "--logdir=%s/log", $opt_vardir);

3118

dtr_add_arg($args, "--no-defaults");

3119

dtr_add_arg($args, "--silent");

3120

dtr_add_arg($args, "--tmpdir=%s", $opt_tmpdir);

3121

dtr_add_arg($args, "--logdir=%s/log", $opt_vardir);

3122

3123

# Log line number and time for each line in .test file

3124

mtr_add_arg($args, "--mark-progress")

3124

dtr_add_arg($args, "--mark-progress")

3125

if $opt_mark_progress;

3126

3127

{

3128

mtr_add_arg($args, "--port=%d", $master->[0]->{'port'});

3129

mtr_add_arg($args, "--database=test");

3130

mtr_add_arg($args, "--user=%s", $opt_user);

3131

mtr_add_arg($args, "--password=");

3128

dtr_add_arg($args, "--port=%d", $master->[0]->{'port'});

3129

dtr_add_arg($args, "--database=test");

3130

dtr_add_arg($args, "--user=%s", $opt_user);

3131

dtr_add_arg($args, "--password=");

3132

}

3133

3134

if ( $opt_strace_client )

3135

{

3136

$exe= "strace"; # FIXME there are ktrace, ....

3137

mtr_add_arg($args, "-o");

3138

mtr_add_arg($args, "%s/log/drizzletest.strace", $opt_vardir);

3139

mtr_add_arg($args, "$exe_drizzletest");

3137

dtr_add_arg($args, "-o");

3138

dtr_add_arg($args, "%s/log/drizzletest.strace", $opt_vardir);

3139

dtr_add_arg($args, "$exe_drizzletest");

3140

}

3141

3142

if ( $opt_timer )

3143

{

3144

mtr_add_arg($args, "--timer-file=%s/log/timer", $opt_vardir);

3144

dtr_add_arg($args, "--timer-file=%s/log/timer", $opt_vardir);

3145

}

3146

3147

if ( $opt_compress )

3148

{

3149

mtr_add_arg($args, "--compress");

3149

dtr_add_arg($args, "--compress");

3150

}

3151

3152

if ( $opt_sleep )

3153

{

3154

mtr_add_arg($args, "--sleep=%d", $opt_sleep);

3154

dtr_add_arg($args, "--sleep=%d", $opt_sleep);

3155

}

3156

3157

if ( $opt_debug )

3158

{

3159

mtr_add_arg($args, "--debug=d:t:A,%s/log/drizzletest.trace",

3159

dtr_add_arg($args, "--debug=d:t:A,%s/log/drizzletest.trace",

3160

$path_vardir_trace);

3161

}

3162

3163

if ( $opt_testdir )

3164

{

3165

mtr_add_arg($args, "--testdir=%s", $opt_testdir);

3165

dtr_add_arg($args, "--testdir=%s", $opt_testdir);

3166

}

3167

3168

3170

# export DRIZZLE_TEST variable containing <path>/drizzletest <args>

3171

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

3172

$ENV{'DRIZZLE_TEST'}=

3173

mtr_native_path($exe_drizzletest) . " " . join(" ", @$args);

3173

dtr_native_path($exe_drizzletest) . " " . join(" ", @$args);

3174

3175

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

3176

# Add arguments that should not go into the DRIZZLE_TEST env var

3182

# We do this here, since we do not want to Valgrind the nested invocations

3183

# of drizzletest; that would mess up the stderr output causing test failure.

3184

my @args_saved = @$args;

3185

mtr_init_args(\$args);

3185

dtr_init_args(\$args);

3186

valgrind_arguments($args, \$exe);

3187

mtr_add_arg($args, "%s", $_) for @args_saved;

3187

dtr_add_arg($args, "%s", $_) for @args_saved;

3188

}

3189

3190

mtr_add_arg($args, "--test-file=%s", $tinfo->{'path'});

3190

dtr_add_arg($args, "--test-file=%s", $tinfo->{'path'});

3191

3192

# Number of lines of resut to include in failure report

3193

mtr_add_arg($args, "--tail-lines=20");

3193

dtr_add_arg($args, "--tail-lines=20");

3194

3195

if ( defined $tinfo->{'result_file'} ) {

3196

mtr_add_arg($args, "--result-file=%s", $tinfo->{'result_file'});

3196

dtr_add_arg($args, "--result-file=%s", $tinfo->{'result_file'});

3197

}

3198

3199

if ( $opt_record )

3200

{

3201

mtr_add_arg($args, "--record");

3201

dtr_add_arg($args, "--record");

3202

}

3203

3204

if ( $opt_client_gdb )

3216

3217

if ( $opt_check_testcases )

3218

{

3219

foreach my $mysqld (@{$master}, @{$slave})

3219

foreach my $drizzled (@{$master}, @{$slave})

3220

{

3221

if ($mysqld->{'pid'})

3221

if ($drizzled->{'pid'})

3222

{

3223

run_check_testcase("before", $mysqld);

3223

run_check_testcase("before", $drizzled);

3224

}

3225

}

3226

}

3227

3228

my $res = mtr_run_test($exe,$args,"","",$path_timefile,"");

3228

my $res = dtr_run_test($exe,$args,"","",$path_timefile,"");

3229

3230

if ( $opt_check_testcases )

3231

{

3232

foreach my $mysqld (@{$master}, @{$slave})

3232

foreach my $drizzled (@{$master}, @{$slave})

3233

{

3234

if ($mysqld->{'pid'})

3234

if ($drizzled->{'pid'})

3235

{

3236

if (run_check_testcase("after", $mysqld))

3236

if (run_check_testcase("after", $drizzled))

3237

{

3238

# Check failed, mark the test case with that info

3239

$tinfo->{'check_testcase_failed'}= 1;

3263

if ( $type eq "client" )

3264

{

3265

# write init file for client

3266

mtr_tofile($dbx_init_file,

3266

dtr_tofile($dbx_init_file,

3267

"runargs $str\n" .

3268

"run\n");

3269

}

3270

else

3271

{

3272

# write init file for drizzled

3273

mtr_tofile($dbx_init_file,

3273

dtr_tofile($dbx_init_file,

3274

"stop in __1cIdrizzledLmysql_parse6Fpn0AHSession_pkcI_v_\n" .

3275

"runargs $str\n" .

3276

"run\n" .

3288

}

3289

3290

$$args= [];

3291

mtr_add_arg($$args, "-title");

3292

mtr_add_arg($$args, "$type");

3293

mtr_add_arg($$args, "-e");

3291

dtr_add_arg($$args, "-title");

3292

dtr_add_arg($$args, "$type");

3293

dtr_add_arg($$args, "-e");

3294

3295

mtr_add_arg($$args, "dbx");

3296

mtr_add_arg($$args, "-c");

3297

mtr_add_arg($$args, "source $dbx_init_file");

3298

mtr_add_arg($$args, "$$exe");

3295

dtr_add_arg($$args, "dbx");

3296

dtr_add_arg($$args, "-c");

3297

dtr_add_arg($$args, "source $dbx_init_file");

3298

dtr_add_arg($$args, "$$exe");

3299

3300

$$exe= "xterm";

3301

}

3330

if ( $type eq "client" )

3331

{

3332

# write init file for client

3333

mtr_tofile($gdb_init_file,

3333

dtr_tofile($gdb_init_file,

3334

"set args $str\n" .

3335

"$extra_gdb_init" .

3336

"break main\n");

3337

}

3338

else

3339

{

3340

# write init file for mysqld

3341

mtr_tofile($gdb_init_file,

3340

# write init file for drizzled

3341

dtr_tofile($gdb_init_file,

3342

"set args $str\n" .

3343

"$extra_gdb_init" .

3344

"set breakpoint pending on\n" .

3353

if ( $opt_manual_gdb )

3354

{

3355

print "\nTo start gdb for $type, type in another window:\n";

3356

print "$glob_mysql_test_dir/../libtool --mode=execute gdb -cd $glob_mysql_test_dir -x $gdb_init_file $$exe\n";

3356

print "$glob_drizzle_test_dir/../libtool --mode=execute gdb -cd $glob_drizzle_test_dir -x $gdb_init_file $$exe\n";

3357

3358

# Indicate the exe should not be started

3359

$$exe= undef;

3361

}

3362

3363

$$args= [];

3364

mtr_add_arg($$args, "-title");

3365

mtr_add_arg($$args, "$type");

3366

mtr_add_arg($$args, "-e");

3364

dtr_add_arg($$args, "-title");

3365

dtr_add_arg($$args, "$type");

3366

dtr_add_arg($$args, "-e");

3367

3368

if ( $exe_libtool )

3369

{

3370

mtr_add_arg($$args, $exe_libtool);

3371

mtr_add_arg($$args, "--mode=execute");

3370

dtr_add_arg($$args, $exe_libtool);

3371

dtr_add_arg($$args, "--mode=execute");

3372

}

3373

3374

mtr_add_arg($$args, "gdb");

3375

mtr_add_arg($$args, "-x");

3376

mtr_add_arg($$args, "$gdb_init_file");

3377

mtr_add_arg($$args, "$$exe");

3374

dtr_add_arg($$args, "gdb");

3375

dtr_add_arg($$args, "-x");

3376

dtr_add_arg($$args, "$gdb_init_file");

3377

dtr_add_arg($$args, "$$exe");

3378

3379

$$exe= "xterm";

3380

}

3398

if ( $type eq "client" )

3399

{

3400

# write init file for client

3401

mtr_tofile($gdb_init_file,

3401

dtr_tofile($gdb_init_file,

3402

"set args $str\n" .

3403

"break main\n");

3404

}

3405

else

3406

{

3407

# write init file for mysqld

3408

mtr_tofile($gdb_init_file,

3407

# write init file for drizzled

3408

dtr_tofile($gdb_init_file,

3409

"file $$exe\n" .

3410

"set args $str\n" .

3411

"break drizzled::mysql_parse\n" .

3417

if ( $opt_manual_ddd )

3418

{

3419

print "\nTo start ddd for $type, type in another window:\n";

3420

print "ddd -cd $glob_mysql_test_dir -x $gdb_init_file $$exe\n";

3420

print "ddd -cd $glob_drizzle_test_dir -x $gdb_init_file $$exe\n";

3421

3422

# Indicate the exe should not be started

3423

$$exe= undef;

3429

if ( $exe_libtool )

3430

{

3431

$$exe= $exe_libtool;

3432

mtr_add_arg($$args, "--mode=execute");

3433

mtr_add_arg($$args, "ddd");

3432

dtr_add_arg($$args, "--mode=execute");

3433

dtr_add_arg($$args, "ddd");

3434

}

3435

else

3436

{

3437

$$exe= "ddd";

3438

}

3439

mtr_add_arg($$args, "--command=$gdb_init_file");

3440

mtr_add_arg($$args, "$save_exe");

3439

dtr_add_arg($$args, "--command=$gdb_init_file");

3440

dtr_add_arg($$args, "$save_exe");

3441

}

3442

3443

3475

# }

3476

else

3477

{

3478

mtr_error("Unknown argument \"$debugger\" passed to --debugger");

3478

dtr_error("Unknown argument \"$debugger\" passed to --debugger");

3479

}

3480

}

3481

3489

3490

if ( $opt_callgrind)

3491

{

3492

mtr_add_arg($args, "--tool=callgrind");

3492

dtr_add_arg($args, "--tool=callgrind");

3493

}

3494

elsif ($opt_massif)

3495

{

3496

mtr_add_arg($args, "--tool=massif");

3496

dtr_add_arg($args, "--tool=massif");

3497

}

3498

else

3499

{

3500

mtr_add_arg($args, "--tool=memcheck"); # From >= 2.1.2 needs this option

3501

mtr_add_arg($args, "--leak-check=yes");

3502

mtr_add_arg($args, "--num-callers=16");

3503

mtr_add_arg($args, "--suppressions=%s/valgrind.supp", $glob_mysql_test_dir)

3504

if -f "$glob_mysql_test_dir/valgrind.supp";

3500

dtr_add_arg($args, "--tool=memcheck"); # From >= 2.1.2 needs this option

3501

dtr_add_arg($args, "--leak-check=yes");

3502

dtr_add_arg($args, "--num-callers=16");

3503

dtr_add_arg($args, "--suppressions=%s/valgrind.supp", $glob_drizzle_test_dir)

3504

if -f "$glob_drizzle_test_dir/valgrind.supp";

3505

}

3506

3507

# Add valgrind options, can be overriden by user

3508

mtr_add_arg($args, '%s', $_) for (@valgrind_args);

3508

dtr_add_arg($args, '%s', $_) for (@valgrind_args);

3509

3510

mtr_add_arg($args, $$exe);

3510

dtr_add_arg($args, $$exe);

3511

3512

$$exe= $opt_valgrind_path || "valgrind";

3513

3521

}

3522

3523

3524

sub mysqld_wait_started($){

3525

my $mysqld= shift;

3524

sub drizzled_wait_started($){

3525

my $drizzled= shift;

3526

3527

if (sleep_until_file_created($mysqld->{'path_pid'},

3528

$mysqld->{'start_timeout'},

3529

$mysqld->{'pid'}) == 0)

3527

if (sleep_until_file_created($drizzled->{'path_pid'},

3528

$drizzled->{'start_timeout'},

3529

$drizzled->{'pid'}) == 0)

3530

{

3531

# Failed to wait for pid file

3532

return 1;

3534

3535

# Get the "real pid" of the process, it will be used for killing

3536

# the process in ActiveState's perl on windows

3537

$mysqld->{'real_pid'}= mtr_get_pid_from_file($mysqld->{'path_pid'});

3537

$drizzled->{'real_pid'}= dtr_get_pid_from_file($drizzled->{'path_pid'});

3538

3539

return 0;

3540

}

3604

using a builtin list of standard locations

3605

for tmpfs (/dev/shm)

3606

The option can also be set using environment

3607

variable MTR_MEM=[DIR]

3607

variable DTR_MEM=[DIR]

3608

3609

Options to control what test suites or cases to run

3610

3620

list of suite names.

3621

The default is: "$opt_suites_default"

3622

skip-rpl Skip the replication test cases.

3623

combination="ARG1 .. ARG2" Specify a set of "mysqld" arguments for one

3623

combination="ARG1 .. ARG2" Specify a set of "drizzled" arguments for one

3624

combination.

3625

skip-combination Skip any combination options and combinations files

3626

repeat-test=n How many times to repeat each test (default: 1)

3629

3630

master_port=PORT Specify the port number used by the first master

3631

slave_port=PORT Specify the port number used by the first slave

3632

mtr-build-thread=# Specify unique collection of ports. Can also be set by

3633

setting the environment variable MTR_BUILD_THREAD.

3632

dtr-build-thread=# Specify unique collection of ports. Can also be set by

3633

setting the environment variable DTR_BUILD_THREAD.

3634

3635

Options for test case authoring

3636

3640

3641

Options that pass on options

3642

3643

mysqld=ARGS Specify additional arguments to "mysqld"

3643

drizzled=ARGS Specify additional arguments to "drizzled"

3644

3645

Options to run test on running server

3646

3652

client-ddd Start drizzletest client in ddd

3653

client-debugger=NAME Start drizzletest in the selected debugger

3654

client-gdb Start drizzletest client in gdb

3655

ddd Start mysqld in ddd

3655

ddd Start drizzled in ddd

3656

debug Dump trace output for all servers and client programs

3657

debugger=NAME Start mysqld in the selected debugger

3658

gdb Start the mysqld(s) in gdb

3659

manual-debug Let user manually start mysqld in debugger, before

3657

debugger=NAME Start drizzled in the selected debugger

3658

gdb Start the drizzled(s) in gdb

3659

manual-debug Let user manually start drizzled in debugger, before

3660

running test(s)

3661

manual-gdb Let user manually start mysqld in gdb, before running

3662

test(s)

3663

manual-ddd Let user manually start mysqld in ddd, before running

3664

test(s)

3665

master-binary=PATH Specify the master "mysqld" to use

3666

slave-binary=PATH Specify the slave "mysqld" to use

3661

manual-gdb Let user manually start drizzled in gdb, before running

3662

test(s)

3663

manual-ddd Let user manually start drizzled in ddd, before running

3664

test(s)

3665

master-binary=PATH Specify the master "drizzled" to use

3666

slave-binary=PATH Specify the slave "drizzled" to use

3667

strace-client Create strace output for drizzletest client

3668

max-save-core Limit the number of core files saved (to avoid filling

3669

up disks for heavily crashing server). Defaults to

3673

3674

gcov FIXME

3675

gprof See online documentation on how to use it.

3676

valgrind Run the "drizzletest" and "mysqld" executables using

3676

valgrind Run the "drizzletest" and "drizzled" executables using

3677

valgrind with default options

3678

valgrind-all Synonym for --valgrind

3679

valgrind-drizzleslap Run "drizzleslap" with valgrind.

3680

valgrind-drizzletest Run the "drizzletest" and "drizzle_client_test" executable

3681

with valgrind

3682

valgrind-mysqld Run the "mysqld" executable with valgrind

3682

valgrind-drizzled Run the "drizzled" executable with valgrind

3683

valgrind-options=ARGS Deprecated, use --valgrind-option

3684

valgrind-option=ARGS Option to give valgrind, replaces default option(s),

3685

can be specified more then once

3703

3704

testcase-timeout=MINUTES Max test case run time (default $default_testcase_timeout)

3705

suite-timeout=MINUTES Max test suite run time (default $default_suite_timeout)

3706

warnings | log-warnings Pass --log-warnings to mysqld

3706

warnings | log-warnings Pass --log-warnings to drizzled

3707

3708

sleep=SECONDS Passed to drizzletest, will be used as fixed sleep time

3709

3710

HERE

3711

mtr_exit(1);

3711

dtr_exit(1);

3712

3713

}