← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to tests/test-run.pl

  • Committer: Monty Taylor
  • Date: 2008-09-16 00:00:48 UTC
  • mto: This revision was merged to the branch mainline in revision 391.
  • Revision ID: monty@inaugust.com-20080916000048-3rvrv3gv9l0ad3gs
Fixed copyright headers in drizzled/

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/test-run.pl
1
1
#!/usr/bin/perl
2
2
# -*- cperl -*-
3
3
 
4
 
use utf8;
5
 
 
6
 
#
7
 
# Copyright (C) 2008
8
 
# 
9
 
# This program is free software; you can redistribute it and/or modify
10
 
# it under the terms of the GNU General Public License as published by
11
 
# the Free Software Foundation; version 2 of the License.
12
 
# 
13
 
# This program is distributed in the hope that it will be useful,
14
 
# but WITHOUT ANY WARRANTY; without even the implied warranty of
15
 
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16
 
# GNU General Public License for more details.
17
 
# 
18
 
# You should have received a copy of the GNU General Public License
19
 
# along with this program; if not, write to the Free Software
20
 
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA */
21
 
#
22
4
#
23
5
##############################################################################
24
6
#
38
20
#
39
21
#   - To make this Perl script easy to alter even for those that not
40
22
#     code Perl that often, keeep the coding style as close as possible to
41
 
#     the C/C++ drizzle coding standard.
 
23
#     the C/C++ MySQL coding standard.
42
24
#
43
25
#   - All lists of arguments to send to commands are Perl lists/arrays,
44
26
#     not strings we append args to. Within reason, most string
45
27
#     concatenation for arguments should be avoided.
46
28
#
47
29
#   - Functions defined in the main program are not to be prefixed,
48
 
#     functions in "library files" are to be prefixed with "dtr_" (for
49
 
#     Drizzle-Test-Run). There are some exceptions, code that fits best in
 
30
#     functions in "library files" are to be prefixed with "mtr_" (for
 
31
#     Mysql-Test-Run). There are some exceptions, code that fits best in
50
32
#     the main program, but are put into separate files to avoid
51
33
#     clutter, may be without prefix.
52
34
#
68
50
# A nice way to trace the execution of this script while debugging
69
51
# is to use the Devel::Trace package found at
70
52
# "http://www.plover.com/~mjd/perl/Trace/" and run this script like
71
 
# "perl -d:Trace test-run.pl"
 
53
# "perl -d:Trace drizzle-test-run.pl"
72
54
#
73
55
 
74
56
 
81
63
use File::Basename;
82
64
use File::Copy;
83
65
use File::Temp qw /tempdir/;
84
 
use File::Spec::Functions qw /splitdir catpath catdir
85
 
                              updir curdir splitpath rel2abs/;
 
66
use File::Spec::Functions qw /splitdir/;
86
67
use Cwd;
87
68
use Getopt::Long;
88
69
use IO::Socket;
93
74
select(STDOUT);
94
75
$| = 1; # Automatically flush STDOUT
95
76
 
96
 
require "dtr_cases.pl";
97
 
require "dtr_process.pl";
98
 
require "dtr_timer.pl";
99
 
require "dtr_io.pl";
100
 
require "dtr_gcov.pl";
101
 
require "dtr_gprof.pl";
102
 
require "dtr_report.pl";
103
 
require "dtr_match.pl";
104
 
require "dtr_misc.pl";
105
 
require "dtr_stress.pl";
106
 
require "dtr_unique.pl";
 
77
require "mtr_cases.pl";
 
78
require "mtr_process.pl";
 
79
require "mtr_timer.pl";
 
80
require "mtr_io.pl";
 
81
require "mtr_gcov.pl";
 
82
require "mtr_gprof.pl";
 
83
require "mtr_report.pl";
 
84
require "mtr_match.pl";
 
85
require "mtr_misc.pl";
 
86
require "mtr_stress.pl";
 
87
require "mtr_unique.pl";
107
88
 
108
89
$Devel::Trace::TRACE= 1;
109
90
 
114
95
##############################################################################
115
96
 
116
97
# Misc global variables
117
 
our $drizzle_version_id;
118
 
our $glob_suite_path=             undef;
119
 
our $glob_drizzle_test_dir=         undef;
120
 
our $glob_drizzle_bench_dir=        undef;
 
98
our $mysql_version_id;
 
99
our $glob_mysql_test_dir=         undef;
 
100
our $glob_mysql_bench_dir=        undef;
121
101
our $glob_scriptname=             undef;
122
102
our $glob_timers=                 undef;
123
103
our @glob_test_mode;
124
104
 
125
 
our $glob_builddir;
126
 
 
127
105
our $glob_basedir;
128
106
 
129
107
our $path_client_bindir;
131
109
our $path_snapshot;
132
110
our $path_drizzletest_log;
133
111
our $path_current_test_log;
 
112
our $path_my_basedir;
134
113
 
135
114
our $opt_vardir;                 # A path but set directly on cmd line
136
 
our $opt_top_srcdir;
137
 
our $opt_top_builddir;
138
115
our $path_vardir_trace;          # unix formatted opt_vardir for trace files
139
116
our $opt_tmpdir;                 # A path but set directly on cmd line
140
 
our $opt_suitepath;
141
 
our $opt_testdir;
142
117
 
143
 
our $opt_subunit;
144
118
 
145
119
our $default_vardir;
146
 
our $default_top_srcdir;
147
 
our $default_top_builddir;
148
120
 
149
121
our $opt_usage;
150
122
our $opt_suites;
151
 
our $opt_suites_default= "main"; # Default suites to run
 
123
our $opt_suites_default= "main,binlog,rpl"; # Default suites to run
152
124
our $opt_script_debug= 0;  # Script debugging, enable with --script-debug
153
125
our $opt_verbose= 0;  # Verbose output, enable with --verbose
154
126
 
155
 
our $opt_repeat_test= 1;
156
 
 
157
 
our $exe_master_drizzled;
 
127
our $exe_master_mysqld;
158
128
our $exe_drizzle;
159
129
our $exe_drizzleadmin;
 
130
our $exe_drizzlebinlog;
160
131
our $exe_drizzle_client_test;
161
132
our $exe_bug25714;
162
133
our $exe_drizzled;
 
134
our $exe_drizzlecheck;
163
135
our $exe_drizzledump;
164
136
our $exe_drizzleslap;
165
137
our $exe_drizzleimport;
166
138
our $exe_drizzle_fix_system_tables;
167
139
our $exe_drizzletest;
168
 
our $exe_slave_drizzled;
 
140
our $exe_slave_mysqld;
 
141
our $exe_my_print_defaults;
169
142
our $exe_perror;
170
143
our $lib_udf_example;
171
144
our $lib_example_plugin;
172
145
our $exe_libtool;
173
 
our $exe_schemawriter;
174
146
 
175
147
our $opt_bench= 0;
176
148
our $opt_small_bench= 0;
 
149
our $opt_big_test= 0;
177
150
 
178
151
our @opt_combinations;
179
152
our $opt_skip_combination;
180
153
 
181
 
our @opt_extra_drizzled_opt;
 
154
our @opt_extra_mysqld_opt;
182
155
 
183
156
our $opt_compress;
184
157
 
185
158
our $opt_debug;
186
159
our $opt_do_test;
187
160
our @opt_cases;                  # The test cases names in argv
188
 
our $opt_engine;
189
161
 
190
162
our $opt_extern= 0;
191
163
our $opt_socket;
194
166
our $opt_force;
195
167
our $opt_reorder= 0;
196
168
our $opt_enable_disabled;
197
 
our $opt_mem= $ENV{'DTR_MEM'};
 
169
our $opt_mem= $ENV{'MTR_MEM'};
198
170
 
199
171
our $opt_gcov;
200
172
our $opt_gcov_err;
202
174
 
203
175
our $glob_debugger= 0;
204
176
our $opt_gdb;
205
 
our $opt_dbx;
206
177
our $opt_client_gdb;
207
 
our $opt_client_dbx;
208
 
our $opt_dbx_gdb;
209
178
our $opt_ddd;
210
179
our $opt_client_ddd;
211
180
our $opt_manual_gdb;
212
 
our $opt_manual_dbx;
213
181
our $opt_manual_ddd;
214
182
our $opt_manual_debug;
215
 
# Magic number -69.4 results in traditional test ports starting from 9306.
216
 
our $opt_dtr_build_thread=-69.4;
 
183
our $opt_mtr_build_thread=0;
217
184
our $opt_debugger;
218
185
our $opt_client_debugger;
219
186
 
228
195
 
229
196
our $opt_master_myport;
230
197
our $opt_slave_myport;
231
 
our $opt_memc_myport;
232
 
our $opt_pbms_myport;
233
 
our $opt_rabbitmq_myport;
234
198
our $opt_record;
235
199
my $opt_report_features;
236
200
our $opt_check_testcases;
237
201
our $opt_mark_progress;
238
202
 
239
 
our $opt_skip_rpl= 1;
 
203
our $opt_skip_rpl;
240
204
our $max_slave_num= 0;
241
205
our $max_master_num= 1;
242
206
our $use_innodb;
260
224
our $opt_user;
261
225
 
262
226
my $opt_valgrind= 0;
263
 
my $opt_valgrind_drizzled= 0;
 
227
my $opt_valgrind_mysqld= 0;
264
228
my $opt_valgrind_drizzletest= 0;
265
 
my $opt_valgrind_drizzleslap= 0;
266
 
my @default_valgrind_args= ("--show-reachable=yes --malloc-fill=0xDEADBEEF --free-fill=0xDEADBEEF");
 
229
my @default_valgrind_args= ("--show-reachable=yes");
267
230
my @valgrind_args;
268
231
my $opt_valgrind_path;
269
232
my $opt_callgrind;
270
 
my $opt_massif;
271
233
 
272
234
our $opt_stress=               "";
273
235
our $opt_stress_suite=     "main";
281
243
 
282
244
our $opt_warnings;
283
245
 
 
246
our $opt_skip_master_binlog= 0;
 
247
our $opt_skip_slave_binlog= 0;
 
248
 
284
249
our $path_sql_dir;
285
250
 
286
251
our @data_dir_lst;
287
252
 
 
253
our $used_binlog_format;
288
254
our $used_default_engine;
289
255
our $debug_compiled_binaries;
290
256
 
291
 
our %drizzled_variables;
 
257
our %mysqld_variables;
292
258
 
293
259
my $source_dist= 0;
294
260
 
295
261
our $opt_max_save_core= 5;
296
262
my $num_saved_cores= 0;  # Number of core files saved in vardir/log/ so far.
297
 
our $secondary_port_offset= 50;
298
263
 
299
264
######################################################################
300
265
#
305
270
sub main ();
306
271
sub initial_setup ();
307
272
sub command_line_setup ();
308
 
sub set_dtr_build_thread_ports($);
 
273
sub set_mtr_build_thread_ports($);
309
274
sub datadir_list_setup ();
310
275
sub executable_setup ();
311
276
sub environment_setup ();
313
278
sub remove_stale_vardir ();
314
279
sub setup_vardir ();
315
280
sub check_running_as_root();
316
 
sub drizzled_wait_started($);
 
281
sub mysqld_wait_started($);
317
282
sub run_benchmarks ($);
318
283
sub initialize_servers ();
319
 
sub drizzle_install_db ();
 
284
sub mysql_install_db ();
320
285
sub copy_install_db ($$);
321
286
sub run_testcase ($);
322
287
sub run_testcase_stop_servers ($$$);
325
290
sub report_failure_and_restart ($);
326
291
sub do_before_start_master ($);
327
292
sub do_before_start_slave ($);
328
 
sub drizzled_start ($$$);
329
 
sub drizzled_arguments ($$$$);
 
293
sub mysqld_start ($$$);
 
294
sub mysqld_arguments ($$$$);
330
295
sub stop_all_servers ();
331
296
sub run_drizzletest ($);
332
 
sub collapse_path ($);
333
297
sub usage ($);
334
298
 
335
299
 
345
309
 
346
310
  command_line_setup();
347
311
 
348
 
  check_debug_support(\%drizzled_variables);
 
312
  check_debug_support(\%mysqld_variables);
349
313
 
350
314
  executable_setup();
351
315
 
374
338
  }
375
339
  else
376
340
  {
377
 
 
 
341
    # Figure out which tests we are going to run
378
342
    if (!$opt_suites)
379
343
    {
380
 
 
381
 
        $opt_suites= $opt_suites_default;
382
 
 
383
 
        my %extra_suites= ();
384
 
 
385
 
        foreach my $dir ( reverse splitdir($glob_basedir) )
386
 
        {
387
 
            my $extra_suite= $extra_suites{$dir};
388
 
            if (defined $extra_suite){
389
 
                dtr_report("Found extra suite: $extra_suite");
390
 
                $opt_suites= "$extra_suite,$opt_suites";
391
 
                last;
392
 
            }
393
 
        }
 
344
      $opt_suites= $opt_suites_default;
 
345
 
 
346
      # Check for any extra suites to enable based on the path name
 
347
      my %extra_suites= ();
 
348
 
 
349
      foreach my $dir ( reverse splitdir($glob_basedir) )
 
350
      {
 
351
        my $extra_suite= $extra_suites{$dir};
 
352
        if (defined $extra_suite){
 
353
          mtr_report("Found extra suite: $extra_suite");
 
354
          $opt_suites= "$extra_suite,$opt_suites";
 
355
          last;
 
356
        }
 
357
      }
394
358
    }
395
359
 
396
360
    my $tests= collect_test_cases($opt_suites);
405
369
        # Count max number of slaves used by a test case
406
370
        if ( $test->{slave_num} > $max_slave_num) {
407
371
          $max_slave_num= $test->{slave_num};
408
 
          dtr_error("Too many slaves") if $max_slave_num > 3;
 
372
          mtr_error("Too many slaves") if $max_slave_num > 3;
409
373
        }
410
374
 
411
375
        # Count max number of masters used by a test case
412
376
        if ( $test->{master_num} > $max_master_num) {
413
377
          $max_master_num= $test->{master_num};
414
 
          dtr_error("Too many masters") if $max_master_num > 2;
415
 
          dtr_error("Too few masters") if $max_master_num < 1;
 
378
          mtr_error("Too many masters") if $max_master_num > 2;
 
379
          mtr_error("Too few masters") if $max_master_num < 1;
416
380
        }
417
381
      }
418
382
      $use_innodb||= $test->{'innodb_test'};
427
391
    run_tests($tests);
428
392
  }
429
393
 
430
 
  dtr_exit(0);
 
394
  mtr_exit(0);
431
395
}
432
396
 
433
397
##############################################################################
438
402
 
439
403
#
440
404
# When an option is no longer used by this program, it must be explicitly
441
 
# ignored or else it will be passed through to drizzled.  GetOptions will call
 
405
# ignored or else it will be passed through to mysqld.  GetOptions will call
442
406
# this subroutine once for each such option on the command line.  See
443
407
# Getopt::Long documentation.
444
408
#
455
419
 
456
420
  my $opt_comment;
457
421
 
 
422
  # Magic number -69.4 results in traditional test ports starting from 9306.
 
423
  set_mtr_build_thread_ports(-69.4);
 
424
 
458
425
  # If so requested, we try to avail ourselves of a unique build thread number.
459
 
  if ( $ENV{'DTR_BUILD_THREAD'} ) {
460
 
    if ( lc($ENV{'DTR_BUILD_THREAD'}) eq 'auto' ) {
 
426
  if ( $ENV{'MTR_BUILD_THREAD'} ) {
 
427
    if ( lc($ENV{'MTR_BUILD_THREAD'}) eq 'auto' ) {
461
428
      print "Requesting build thread... ";
462
 
      $ENV{'DTR_BUILD_THREAD'} = dtr_require_unique_id_and_wait("/tmp/drizzle-test-ports", 200, 299);
463
 
      print "got ".$ENV{'DTR_BUILD_THREAD'}."\n";
 
429
      $ENV{'MTR_BUILD_THREAD'} = mtr_require_unique_id_and_wait("/tmp/mysql-test-ports", 200, 299);
 
430
      print "got ".$ENV{'MTR_BUILD_THREAD'}."\n";
464
431
    }
465
432
  }
466
433
 
467
 
  if ( $ENV{'DTR_BUILD_THREAD'} )
 
434
  if ( $ENV{'MTR_BUILD_THREAD'} )
468
435
  {
469
 
    set_dtr_build_thread_ports($ENV{'DTR_BUILD_THREAD'});
 
436
    set_mtr_build_thread_ports($ENV{'MTR_BUILD_THREAD'});
470
437
  }
471
438
 
472
439
  # This is needed for test log evaluation in "gen-build-status-page"
478
445
  # Note: Keep list, and the order, in sync with usage at end of this file
479
446
 
480
447
  # Options that are no longer used must still be processed, because all
481
 
  # unprocessed options are passed directly to drizzled.  The user will be
 
448
  # unprocessed options are passed directly to mysqld.  The user will be
482
449
  # warned that the option is being ignored.
483
450
  #
484
451
  # Put the complete option string here.  For example, to remove the --suite
496
463
 
497
464
             # Control what test suites or cases to run
498
465
             'force'                    => \$opt_force,
 
466
             'skip-master-binlog'       => \$opt_skip_master_binlog,
 
467
             'skip-slave-binlog'        => \$opt_skip_slave_binlog,
499
468
             'do-test=s'                => \$opt_do_test,
500
469
             'start-from=s'             => \$opt_start_from,
501
470
             'suite|suites=s'           => \$opt_suites,
502
471
             'skip-rpl'                 => \$opt_skip_rpl,
503
472
             'skip-test=s'              => \$opt_skip_test,
 
473
             'big-test'                 => \$opt_big_test,
504
474
             'combination=s'            => \@opt_combinations,
505
475
             'skip-combination'         => \$opt_skip_combination,
506
476
 
507
477
             # Specify ports
508
478
             'master_port=i'            => \$opt_master_myport,
509
479
             'slave_port=i'             => \$opt_slave_myport,
510
 
             'memc_port=i'              => \$opt_memc_myport,
511
 
             'pbms_port=i'              => \$opt_pbms_myport,
512
 
             'rabbitmq_port=i'              => \$opt_rabbitmq_myport,
513
 
             'dtr-build-thread=i'       => \$opt_dtr_build_thread,
 
480
             'mtr-build-thread=i'       => \$opt_mtr_build_thread,
514
481
 
515
482
             # Test case authoring
516
483
             'record'                   => \$opt_record,
517
484
             'check-testcases'          => \$opt_check_testcases,
518
485
             'mark-progress'            => \$opt_mark_progress,
519
486
 
520
 
             # Extra options used when starting drizzled
521
 
             'drizzled=s'                 => \@opt_extra_drizzled_opt,
522
 
             'engine=s'                 => \$opt_engine,
 
487
             # Extra options used when starting mysqld
 
488
             'mysqld=s'                 => \@opt_extra_mysqld_opt,
523
489
 
524
490
             # Run test on running server
525
491
             'extern'                   => \$opt_extern,
526
492
 
527
 
             # Output format
528
 
             'subunit'                  => \$opt_subunit,
529
 
 
530
493
             # Debugging
531
494
             'gdb'                      => \$opt_gdb,
532
 
             'dbx'                      => \$opt_dbx,
533
495
             'client-gdb'               => \$opt_client_gdb,
534
 
             'client-dbx'               => \$opt_client_dbx,
535
496
             'manual-gdb'               => \$opt_manual_gdb,
536
 
             'manual-dbx'               => \$opt_manual_dbx,
537
497
             'manual-debug'             => \$opt_manual_debug,
538
498
             'ddd'                      => \$opt_ddd,
539
499
             'client-ddd'               => \$opt_client_ddd,
541
501
             'debugger=s'               => \$opt_debugger,
542
502
             'client-debugger=s'        => \$opt_client_debugger,
543
503
             'strace-client'            => \$opt_strace_client,
544
 
             'master-binary=s'          => \$exe_master_drizzled,
545
 
             'slave-binary=s'           => \$exe_slave_drizzled,
 
504
             'master-binary=s'          => \$exe_master_mysqld,
 
505
             'slave-binary=s'           => \$exe_slave_mysqld,
546
506
             'max-save-core=i'          => \$opt_max_save_core,
547
507
 
548
508
             # Coverage, profiling etc
550
510
             'gprof'                    => \$opt_gprof,
551
511
             'valgrind|valgrind-all'    => \$opt_valgrind,
552
512
             'valgrind-drizzletest'       => \$opt_valgrind_drizzletest,
553
 
             'valgrind-drizzleslap'       => \$opt_valgrind_drizzleslap,
554
 
             'valgrind-drizzled'          => \$opt_valgrind_drizzled,
 
513
             'valgrind-mysqld'          => \$opt_valgrind_mysqld,
555
514
             'valgrind-options=s'       => sub {
556
515
               my ($opt, $value)= @_;
557
516
               # Deprecated option unless it's what we know pushbuild uses
566
525
             'valgrind-option=s'        => \@valgrind_args,
567
526
             'valgrind-path=s'          => \$opt_valgrind_path,
568
527
             'callgrind'                => \$opt_callgrind,
569
 
             'massif'                   => \$opt_massif,
570
528
 
571
529
             # Stress testing 
572
530
             'stress'                   => \$opt_stress,
582
540
             # Directories
583
541
             'tmpdir=s'                 => \$opt_tmpdir,
584
542
             'vardir=s'                 => \$opt_vardir,
585
 
             'top-builddir=s'           => \$opt_top_builddir,
586
 
             'top-srcdir=s'             => \$opt_top_srcdir,
587
 
             'suitepath=s'              => \$opt_suitepath,
588
 
             'testdir=s'                => \$opt_testdir,
589
 
             'benchdir=s'               => \$glob_drizzle_bench_dir,
 
543
             'benchdir=s'               => \$glob_mysql_bench_dir,
590
544
             'mem'                      => \$opt_mem,
591
545
 
592
546
             # Misc
607
561
             'testcase-timeout=i'       => \$opt_testcase_timeout,
608
562
             'suite-timeout=i'          => \$opt_suite_timeout,
609
563
             'warnings|log-warnings'    => \$opt_warnings,
610
 
             'repeat-test=i'            => \$opt_repeat_test,
611
564
 
612
565
             # Options which are no longer used
613
566
             (map { $_ => \&warn_about_removed_option } @removed_options),
615
568
             'help|h'                   => \$opt_usage,
616
569
            ) or usage("Can't read options");
617
570
 
618
 
  usage("you cannot specify --gdb and --dbx both!") if 
619
 
        ($opt_gdb && $opt_dbx) ||
620
 
        ($opt_manual_gdb && $opt_manual_dbx);
 
571
  usage("") if $opt_usage;
621
572
 
622
573
  $glob_scriptname=  basename($0);
623
574
 
624
 
  if ($opt_dtr_build_thread != 0)
625
 
  {
626
 
    set_dtr_build_thread_ports($opt_dtr_build_thread)
627
 
  }
628
 
  elsif ($ENV{'DTR_BUILD_THREAD'})
629
 
  {
630
 
    $opt_dtr_build_thread= $ENV{'DTR_BUILD_THREAD'};
 
575
  if ($opt_mtr_build_thread != 0)
 
576
  {
 
577
    set_mtr_build_thread_ports($opt_mtr_build_thread)
 
578
  }
 
579
  elsif ($ENV{'MTR_BUILD_THREAD'})
 
580
  {
 
581
    $opt_mtr_build_thread= $ENV{'MTR_BUILD_THREAD'};
 
582
  }
 
583
 
 
584
  # We require that we are in the "mysql-test" directory
 
585
  # to run drizzle-test-run
 
586
  if (! -f $glob_scriptname)
 
587
  {
 
588
    mtr_error("Can't find the location for the drizzle-test-run script\n" .
 
589
              "Go to to the mysql-test directory and execute the script " .
 
590
              "as follows:\n./$glob_scriptname");
631
591
  }
632
592
 
633
593
  if ( -d "../drizzled" )
636
596
  }
637
597
 
638
598
  # Find the absolute path to the test directory
639
 
  if ( ! $opt_testdir )
640
 
  {
641
 
    $glob_drizzle_test_dir=  cwd();
642
 
  } 
643
 
  else
644
 
  {
645
 
    $glob_drizzle_test_dir= $opt_testdir;
646
 
  }
647
 
  $default_vardir= "$glob_drizzle_test_dir/var";
648
 
  $default_top_srcdir= "$glob_drizzle_test_dir/..";
649
 
  $default_top_builddir= "$glob_drizzle_test_dir/..";
 
599
  $glob_mysql_test_dir=  cwd();
 
600
  $default_vardir= "$glob_mysql_test_dir/var";
650
601
 
651
 
  if ( ! $opt_suitepath )
652
 
  {
653
 
    $glob_suite_path= "$glob_drizzle_test_dir/../plugin";
654
 
  }
655
 
  else
656
 
  {
657
 
    $glob_suite_path= $opt_suitepath;
658
 
  }
659
602
  # In most cases, the base directory we find everything relative to,
660
 
  # is the parent directory of the "drizzle-test" directory. For source
 
603
  # is the parent directory of the "mysql-test" directory. For source
661
604
  # distributions, TAR binary distributions and some other packages.
662
 
  $glob_basedir= dirname($glob_drizzle_test_dir);
663
 
 
664
 
  # Figure out which tests we are going to run
665
 
  my $suitedir= "$glob_drizzle_test_dir/suite";
666
 
  if ( -d $suitedir )
667
 
  {
668
 
      opendir(SUITE_DIR, $suitedir)
669
 
          or dtr_error("can't open directory \"$suitedir\": $!");
670
 
 
671
 
      while ( my $elem= readdir(SUITE_DIR) )
672
 
      {
673
 
          next if $elem eq ".";
674
 
          next if $elem eq "..";
675
 
          next if $elem eq "big"; # Eats up too much disk
676
 
          next if $elem eq "large_tests"; # Eats up too much disk
677
 
          next if $elem eq "stress"; # Currently fails
678
 
          next if $elem eq "broken"; # Old broken test, mainly unsupported featurs
679
 
 
680
 
          my $local_dir= "$suitedir/$elem";
681
 
 
682
 
          next unless -d $local_dir;
683
 
          next unless -d "$local_dir/t"; # We want to make sure it has tests
684
 
          next unless -d "$local_dir/r"; # Ditto, results
685
 
 
686
 
          $opt_suites_default.= ",$elem";
687
 
      }
688
 
      closedir(SUITE_DIR);
689
 
  }
690
 
 
691
 
  usage("") if $opt_usage;
 
605
  $glob_basedir= dirname($glob_mysql_test_dir);
692
606
 
693
607
  # In the RPM case, binaries and libraries are installed in the
694
608
  # default system locations, instead of having our own private base
695
 
  # directory. And we install "/usr/share/drizzle-test". Moving up one
696
 
  # more directory relative to "drizzle-test" gives us a usable base
 
609
  # directory. And we install "/usr/share/mysql-test". Moving up one
 
610
  # more directory relative to "mysql-test" gives us a usable base
697
611
  # directory for RPM installs.
698
612
  if ( ! $source_dist and ! -d "$glob_basedir/bin" )
699
613
  {
700
614
    $glob_basedir= dirname($glob_basedir);
701
615
  }
702
616
 
703
 
  if ( $opt_testdir and -d $opt_testdir and $opt_vardir and -d $opt_vardir
704
 
         and -f "$opt_vardir/../../drizzled/drizzled")
705
 
  {
706
 
    # probably in a VPATH build
707
 
    $glob_builddir= "$opt_vardir/../..";
708
 
  }
709
 
  else
710
 
  {
711
 
    $glob_builddir="..";
712
 
  }
713
 
 
714
 
  # Expect drizzle-bench to be located adjacent to the source tree, by default
715
 
  $glob_drizzle_bench_dir= "$glob_basedir/../drizzle-bench"
716
 
    unless defined $glob_drizzle_bench_dir;
717
 
  $glob_drizzle_bench_dir= undef
718
 
    unless -d $glob_drizzle_bench_dir;
719
 
 
720
 
  $glob_timers= dtr_init_timers();
 
617
  # Expect mysql-bench to be located adjacent to the source tree, by default
 
618
  $glob_mysql_bench_dir= "$glob_basedir/../mysql-bench"
 
619
    unless defined $glob_mysql_bench_dir;
 
620
  $glob_mysql_bench_dir= undef
 
621
    unless -d $glob_mysql_bench_dir;
 
622
 
 
623
  $path_my_basedir=
 
624
    $source_dist ? $glob_mysql_test_dir : $glob_basedir;
 
625
 
 
626
  $glob_timers= mtr_init_timers();
721
627
 
722
628
  #
723
 
  # Find the drizzled executable to be able to find the drizzled version
 
629
  # Find the mysqld executable to be able to find the mysqld version
724
630
  # number as early as possible
725
631
  #
726
632
 
727
633
  # Look for the client binaries directory
728
 
  $path_client_bindir= dtr_path_exists("$glob_builddir/client",
729
 
                                       "$glob_basedir/client",
 
634
  $path_client_bindir= mtr_path_exists("$glob_basedir/client",
730
635
                                       "$glob_basedir/bin");
731
636
 
732
637
  if (!$opt_extern)
733
638
  {
734
 
    $exe_drizzled=       dtr_exe_exists ("$glob_basedir/drizzled/drizzled",
 
639
    $exe_drizzled=       mtr_exe_exists ("$glob_basedir/drizzled/drizzled",
735
640
                                       "$path_client_bindir/drizzled",
736
641
                                       "$glob_basedir/libexec/drizzled",
737
642
                                       "$glob_basedir/bin/drizzled",
738
 
                                       "$glob_basedir/sbin/drizzled",
739
 
                                       "$glob_builddir/drizzled/drizzled");
 
643
                                       "$glob_basedir/sbin/drizzled");
740
644
 
741
 
    # Use the drizzled found above to find out what features are available
742
 
    collect_drizzled_features();
 
645
    # Use the mysqld found above to find out what features are available
 
646
    collect_mysqld_features();
743
647
  }
744
648
  else
745
649
  {
746
 
    $drizzled_variables{'port'}= 4427;
747
 
  }
748
 
 
749
 
  if (!$opt_engine)
750
 
  {
751
 
    $opt_engine= "innodb";
 
650
    $mysqld_variables{'port'}= 4427;
752
651
  }
753
652
 
754
653
  if ( $opt_comment )
763
662
  {
764
663
    if ( $arg =~ /^--skip-/ )
765
664
    {
766
 
      push(@opt_extra_drizzled_opt, $arg);
 
665
      push(@opt_extra_mysqld_opt, $arg);
767
666
    }
768
667
    elsif ( $arg =~ /^--$/ )
769
668
    {
782
681
  }
783
682
 
784
683
  # --------------------------------------------------------------------------
 
684
  # Find out type of logging that are being used
 
685
  # --------------------------------------------------------------------------
 
686
  if (!$opt_extern && $mysql_version_id >= 50100 )
 
687
  {
 
688
    foreach my $arg ( @opt_extra_mysqld_opt )
 
689
    {
 
690
      if ( $arg =~ /binlog[-_]format=(\S+)/ )
 
691
      {
 
692
        $used_binlog_format= $1;
 
693
      }
 
694
    }
 
695
    if (defined $used_binlog_format) 
 
696
    {
 
697
      mtr_report("Using binlog format '$used_binlog_format'");
 
698
    }
 
699
    else
 
700
    {
 
701
      mtr_report("Using dynamic switching of binlog format");
 
702
    }
 
703
  }
 
704
 
 
705
 
 
706
  # --------------------------------------------------------------------------
785
707
  # Find out default storage engine being used(if any)
786
708
  # --------------------------------------------------------------------------
787
 
  foreach my $arg ( @opt_extra_drizzled_opt )
 
709
  foreach my $arg ( @opt_extra_mysqld_opt )
788
710
  {
789
711
    if ( $arg =~ /default-storage-engine=(\S+)/ )
790
712
    {
791
713
      $used_default_engine= $1;
792
714
    }
793
715
  }
794
 
  dtr_report("Using default engine '$used_default_engine'")
 
716
  mtr_report("Using default engine '$used_default_engine'")
795
717
    if defined $used_default_engine;
796
718
 
797
719
  # --------------------------------------------------------------------------
799
721
  # --------------------------------------------------------------------------
800
722
  if ( defined $opt_mem )
801
723
  {
802
 
    dtr_error("Can't use --mem and --vardir at the same time ")
 
724
    mtr_error("Can't use --mem and --vardir at the same time ")
803
725
      if $opt_vardir;
804
 
    dtr_error("Can't use --mem and --tmpdir at the same time ")
 
726
    mtr_error("Can't use --mem and --tmpdir at the same time ")
805
727
      if $opt_tmpdir;
806
728
 
807
729
    # Search through list of locations that are known
813
735
    {
814
736
      if ( -d $fs )
815
737
      {
816
 
        dtr_report("Using tmpfs in $fs");
 
738
        mtr_report("Using tmpfs in $fs");
817
739
        $opt_mem= "$fs/var";
818
 
        $opt_mem .= $opt_dtr_build_thread if $opt_dtr_build_thread;
 
740
        $opt_mem .= $opt_mtr_build_thread if $opt_mtr_build_thread;
819
741
        last;
820
742
      }
821
743
    }
828
750
  {
829
751
    $opt_vardir= $default_vardir;
830
752
  }
831
 
 
832
 
  if ( ! $opt_top_srcdir )
833
 
  {
834
 
    $opt_top_srcdir= $default_top_srcdir;
835
 
  }
836
 
  else
837
 
  {
838
 
    $opt_top_srcdir= rel2abs($opt_top_srcdir);
839
 
  }
840
 
 
841
 
  if ( ! $opt_top_builddir )
842
 
  {
843
 
    $opt_top_builddir= $default_top_builddir;
844
 
  }
845
 
  else
846
 
  {
847
 
    $opt_top_builddir= rel2abs($opt_top_builddir);
 
753
  elsif ( $mysql_version_id < 50000 and
 
754
          $opt_vardir ne $default_vardir)
 
755
  {
 
756
    # Version 4.1 and --vardir was specified
 
757
    # Only supported as a symlink from var/
 
758
    # by setting up $opt_mem that symlink will be created
 
759
    {
 
760
      # Only platforms that have native symlinks can use the vardir trick
 
761
      $opt_mem= $opt_vardir;
 
762
      mtr_report("Using 4.1 vardir trick");
 
763
    }
 
764
 
 
765
    $opt_vardir= $default_vardir;
848
766
  }
849
767
 
850
768
  $path_vardir_trace= $opt_vardir;
851
769
  # Chop off any "c:", DBUG likes a unix path ex: c:/src/... => /src/...
852
770
  $path_vardir_trace=~ s/^\w://;
853
771
 
854
 
  $opt_vardir= collapse_path($opt_vardir);
 
772
  # We make the path absolute, as the server will do a chdir() before usage
 
773
  unless ( $opt_vardir =~ m,^/,)
 
774
  {
 
775
    # Make absolute path, relative test dir
 
776
    $opt_vardir= "$glob_mysql_test_dir/$opt_vardir";
 
777
  }
855
778
 
856
779
  # --------------------------------------------------------------------------
857
780
  # Set tmpdir
864
787
# --------------------------------------------------------------------------
865
788
  if ( $opt_record and ! @opt_cases )
866
789
  {
867
 
    dtr_error("Will not run in record mode without a specific test case");
 
790
    mtr_error("Will not run in record mode without a specific test case");
868
791
  }
869
792
 
870
793
  if ( $opt_record )
881
804
  }
882
805
 
883
806
  # --------------------------------------------------------------------------
 
807
  # Big test flags
 
808
  # --------------------------------------------------------------------------
 
809
   if ( $opt_big_test )
 
810
   {
 
811
     $ENV{'BIG_TEST'}= 1;
 
812
   }
 
813
 
 
814
  # --------------------------------------------------------------------------
884
815
  # Gcov flag
885
816
  # --------------------------------------------------------------------------
886
817
  if ( $opt_gcov and ! $source_dist )
887
818
  {
888
 
    dtr_error("Coverage test needs the source - please use source dist");
 
819
    mtr_error("Coverage test needs the source - please use source dist");
889
820
  }
890
821
 
891
822
  # --------------------------------------------------------------------------
893
824
  # --------------------------------------------------------------------------
894
825
  if ( $opt_gdb || $opt_client_gdb || $opt_ddd || $opt_client_ddd ||
895
826
       $opt_manual_gdb || $opt_manual_ddd || $opt_manual_debug ||
896
 
       $opt_debugger || $opt_client_debugger || $opt_gdb || $opt_manual_gdb)
 
827
       $opt_debugger || $opt_client_debugger )
897
828
  {
898
829
    # Indicate that we are using debugger
899
830
    $glob_debugger= 1;
900
831
    if ( $opt_extern )
901
832
    {
902
 
      dtr_error("Can't use --extern when using debugger");
 
833
      mtr_error("Can't use --extern when using debugger");
903
834
    }
904
835
  }
905
836
 
906
837
  # --------------------------------------------------------------------------
907
838
  # Check if special exe was selected for master or slave
908
839
  # --------------------------------------------------------------------------
909
 
  $exe_master_drizzled= $exe_master_drizzled || $exe_drizzled;
910
 
  $exe_slave_drizzled=  $exe_slave_drizzled  || $exe_drizzled;
 
840
  $exe_master_mysqld= $exe_master_mysqld || $exe_drizzled;
 
841
  $exe_slave_mysqld=  $exe_slave_mysqld  || $exe_drizzled;
911
842
 
912
843
  # --------------------------------------------------------------------------
913
844
  # Check valgrind arguments
914
845
  # --------------------------------------------------------------------------
915
846
  if ( $opt_valgrind or $opt_valgrind_path or @valgrind_args)
916
847
  {
917
 
    dtr_report("Turning on valgrind for all executables");
 
848
    mtr_report("Turning on valgrind for all executables");
918
849
    $opt_valgrind= 1;
919
 
    $opt_valgrind_drizzled= 1;
 
850
    $opt_valgrind_mysqld= 1;
920
851
    $opt_valgrind_drizzletest= 1;
921
 
    $ENV{'VALGRIND_RUN'} = '1';
922
852
  }
923
 
  elsif ( $opt_valgrind_drizzled )
 
853
  elsif ( $opt_valgrind_mysqld )
924
854
  {
925
 
    dtr_report("Turning on valgrind for drizzled(s) only");
 
855
    mtr_report("Turning on valgrind for mysqld(s) only");
926
856
    $opt_valgrind= 1;
927
857
  }
928
858
  elsif ( $opt_valgrind_drizzletest )
929
859
  {
930
 
    dtr_report("Turning on valgrind for drizzletest and drizzle_client_test only");
931
 
    $opt_valgrind= 1;
932
 
  }
933
 
  elsif ( $opt_valgrind_drizzleslap )
934
 
  {
935
 
    dtr_report("Turning on valgrind for drizzleslap only");
 
860
    mtr_report("Turning on valgrind for drizzletest and drizzle_client_test only");
936
861
    $opt_valgrind= 1;
937
862
  }
938
863
 
939
864
  if ( $opt_callgrind )
940
865
  {
941
 
    dtr_report("Turning on valgrind with callgrind for drizzled(s)");
 
866
    mtr_report("Turning on valgrind with callgrind for mysqld(s)");
942
867
    $opt_valgrind= 1;
943
 
    $opt_valgrind_drizzled= 1;
 
868
    $opt_valgrind_mysqld= 1;
944
869
 
945
870
    # Set special valgrind options unless options passed on command line
946
871
    push(@valgrind_args, "--trace-children=yes")
947
872
      unless @valgrind_args;
948
873
  }
949
874
 
950
 
  if ( $opt_massif )
951
 
  {
952
 
    dtr_report("Valgrind with Massif tool for drizzled(s)");
953
 
    $opt_valgrind= 1;
954
 
    $opt_valgrind_drizzled= 1;
955
 
  }
956
 
 
957
875
  if ( $opt_valgrind )
958
876
  {
959
877
    # Set valgrind_options to default unless already defined
960
878
    push(@valgrind_args, @default_valgrind_args)
961
879
      unless @valgrind_args;
962
880
 
963
 
    dtr_report("Running valgrind with options \"",
 
881
    mtr_report("Running valgrind with options \"",
964
882
               join(" ", @valgrind_args), "\"");
965
883
  }
966
884
 
988
906
    }
989
907
  }
990
908
 
 
909
  # On QNX, /tmp/dir/master.sock and /tmp/dir//master.sock seem to be
 
910
  # considered different, so avoid the extra slash (/) in the socket
 
911
  # paths.
 
912
  my $sockdir = $opt_tmpdir;
 
913
  $sockdir =~ s|/+$||;
 
914
 
 
915
  # On some operating systems, there is a limit to the length of a
 
916
  # UNIX domain socket's path far below PATH_MAX, so try to avoid long
 
917
  # socket path names.
 
918
  $sockdir = tempdir(CLEANUP => 0) if ( length($sockdir) >= 70 );
 
919
 
991
920
  $master->[0]=
992
921
  {
993
 
   pid            => 0,
994
 
   type           => "master",
995
 
   idx            => 0,
996
 
   path_myddir    => "$opt_vardir/master-data",
997
 
   path_myerr     => "$opt_vardir/log/master.err",
998
 
   path_pid       => "$opt_vardir/run/master.pid",
999
 
   path_sock      => "$opt_vardir/master.sock",
1000
 
   port           =>  $opt_master_myport,
1001
 
   secondary_port =>  $opt_master_myport + $secondary_port_offset,
1002
 
   start_timeout  =>  400, # enough time create innodb tables
1003
 
   cluster        =>  0, # index in clusters list
1004
 
   start_opts     => [],
 
922
   pid           => 0,
 
923
   type          => "master",
 
924
   idx           => 0,
 
925
   path_myddir   => "$opt_vardir/master-data",
 
926
   path_myerr    => "$opt_vardir/log/master.err",
 
927
   path_pid      => "$opt_vardir/run/master.pid",
 
928
   path_sock     => "$sockdir/master.sock",
 
929
   port          =>  $opt_master_myport,
 
930
   start_timeout =>  400, # enough time create innodb tables
 
931
   cluster       =>  0, # index in clusters list
 
932
   start_opts    => [],
1005
933
  };
1006
934
 
1007
935
  $master->[1]=
1008
936
  {
1009
 
   pid            => 0,
1010
 
   type           => "master",
1011
 
   idx            => 1,
1012
 
   path_myddir    => "$opt_vardir/master1-data",
1013
 
   path_myerr     => "$opt_vardir/log/master1.err",
1014
 
   path_pid       => "$opt_vardir/run/master1.pid",
1015
 
   path_sock      => "$opt_vardir/master1.sock",
1016
 
   port           => $opt_master_myport + 1,
1017
 
   secondary_port => $opt_master_myport + 1 + $secondary_port_offset,
1018
 
   start_timeout  => 400, # enough time create innodb tables
1019
 
   cluster        =>  0, # index in clusters list
1020
 
   start_opts     => [],
 
937
   pid           => 0,
 
938
   type          => "master",
 
939
   idx           => 1,
 
940
   path_myddir   => "$opt_vardir/master1-data",
 
941
   path_myerr    => "$opt_vardir/log/master1.err",
 
942
   path_pid      => "$opt_vardir/run/master1.pid",
 
943
   path_sock     => "$sockdir/master1.sock",
 
944
   port          => $opt_master_myport + 1,
 
945
   start_timeout => 400, # enough time create innodb tables
 
946
   cluster       =>  0, # index in clusters list
 
947
   start_opts    => [],
1021
948
  };
1022
949
 
1023
950
  $slave->[0]=
1024
951
  {
1025
 
   pid            => 0,
1026
 
   type           => "slave",
1027
 
   idx            => 0,
1028
 
   path_myddir    => "$opt_vardir/slave-data",
1029
 
   path_myerr     => "$opt_vardir/log/slave.err",
1030
 
   path_pid       => "$opt_vardir/run/slave.pid",
1031
 
   path_sock      => "$opt_vardir/slave.sock",
1032
 
   port           => $opt_slave_myport,
1033
 
   secondary_port => $opt_slave_myport + $secondary_port_offset,
1034
 
   start_timeout  => 400,
1035
 
   cluster        =>  1, # index in clusters list
1036
 
   start_opts     => [],
 
952
   pid           => 0,
 
953
   type          => "slave",
 
954
   idx           => 0,
 
955
   path_myddir   => "$opt_vardir/slave-data",
 
956
   path_myerr    => "$opt_vardir/log/slave.err",
 
957
   path_pid    => "$opt_vardir/run/slave.pid",
 
958
   path_sock   => "$sockdir/slave.sock",
 
959
   port   => $opt_slave_myport,
 
960
   start_timeout => 400,
 
961
 
 
962
   cluster       =>  1, # index in clusters list
 
963
   start_opts    => [],
1037
964
  };
1038
965
 
1039
966
  $slave->[1]=
1040
967
  {
1041
 
   pid            => 0,
1042
 
   type           => "slave",
1043
 
   idx            => 1,
1044
 
   path_myddir    => "$opt_vardir/slave1-data",
1045
 
   path_myerr     => "$opt_vardir/log/slave1.err",
1046
 
   path_pid       => "$opt_vardir/run/slave1.pid",
1047
 
   path_sock      => "$opt_vardir/slave1.sock",
1048
 
   port           => $opt_slave_myport + 1,
1049
 
   secondary_port => $opt_slave_myport + 1 + $secondary_port_offset,
1050
 
   start_timeout  => 300,
1051
 
   cluster        =>  -1, # index in clusters list
1052
 
   start_opts     => [],
 
968
   pid           => 0,
 
969
   type          => "slave",
 
970
   idx           => 1,
 
971
   path_myddir   => "$opt_vardir/slave1-data",
 
972
   path_myerr    => "$opt_vardir/log/slave1.err",
 
973
   path_pid    => "$opt_vardir/run/slave1.pid",
 
974
   path_sock   => "$sockdir/slave1.sock",
 
975
   port   => $opt_slave_myport + 1,
 
976
   start_timeout => 300,
 
977
   cluster       =>  -1, # index in clusters list
 
978
   start_opts    => [],
1053
979
  };
1054
980
 
1055
981
  $slave->[2]=
1056
982
  {
1057
 
   pid            => 0,
1058
 
   type           => "slave",
1059
 
   idx            => 2,
1060
 
   path_myddir    => "$opt_vardir/slave2-data",
1061
 
   path_myerr     => "$opt_vardir/log/slave2.err",
1062
 
   path_pid       => "$opt_vardir/run/slave2.pid",
1063
 
   path_sock      => "$opt_vardir/slave2.sock",
1064
 
   port           => $opt_slave_myport + 2,
1065
 
   secondary_port => $opt_slave_myport + 2 + $secondary_port_offset,
1066
 
   start_timeout  => 300,
1067
 
   cluster        =>  -1, # index in clusters list
1068
 
   start_opts     => [],
 
983
   pid           => 0,
 
984
   type          => "slave",
 
985
   idx           => 2,
 
986
   path_myddir   => "$opt_vardir/slave2-data",
 
987
   path_myerr    => "$opt_vardir/log/slave2.err",
 
988
   path_pid    => "$opt_vardir/run/slave2.pid",
 
989
   path_sock   => "$sockdir/slave2.sock",
 
990
   port   => $opt_slave_myport + 2,
 
991
   start_timeout => 300,
 
992
   cluster       =>  -1, # index in clusters list
 
993
   start_opts    => [],
1069
994
  };
1070
995
 
1071
996
 
1079
1004
    warn("Currenty broken --extern");
1080
1005
 
1081
1006
    # Setup master->[0] with the settings for the extern server
1082
 
    $master->[0]->{'path_sock'}=  $opt_socket ? $opt_socket : "/tmp/drizzle.sock";
1083
 
    dtr_report("Using extern server at '$master->[0]->{path_sock}'");
 
1007
    $master->[0]->{'path_sock'}=  $opt_socket ? $opt_socket : "/tmp/mysql.sock";
 
1008
    mtr_report("Using extern server at '$master->[0]->{path_sock}'");
1084
1009
  }
1085
1010
  else
1086
1011
  {
1087
 
    dtr_error("--socket can only be used in combination with --extern")
 
1012
    mtr_error("--socket can only be used in combination with --extern")
1088
1013
      if $opt_socket;
1089
1014
  }
1090
1015
 
1100
1025
    # When both --valgrind and --debug is selected, send
1101
1026
    # all output to the trace file, making it possible to
1102
1027
    # see the exact location where valgrind complains
1103
 
    foreach my $drizzled (@{$master}, @{$slave})
 
1028
    foreach my $mysqld (@{$master}, @{$slave})
1104
1029
    {
1105
 
      my $sidx= $drizzled->{idx} ? "$drizzled->{idx}" : "";
1106
 
      $drizzled->{path_myerr}=
1107
 
        "$opt_vardir/log/" . $drizzled->{type} . "$sidx.trace";
1108
 
    }
1109
 
  }
1110
 
}
1111
 
 
1112
 
sub gimme_a_good_port($)
1113
 
{
1114
 
  my $port_to_test= shift;
1115
 
  if ($port_to_test == 8000)
1116
 
  {
1117
 
    $port_to_test = 8001;
1118
 
  }
1119
 
  my $is_port_bad= 1;
1120
 
  while ($is_port_bad) {
1121
 
    my $sock = new IO::Socket::INET( PeerAddr => 'localhost',
1122
 
                                     PeerPort => $port_to_test,
1123
 
                                     Proto => 'tcp' );
1124
 
    if ($sock) {
1125
 
      close($sock);
1126
 
      $port_to_test += 1;
1127
 
      if ($port_to_test >= 32767) {
1128
 
        $port_to_test = 5001;
1129
 
      }
1130
 
 
1131
 
    } else {
1132
 
      $is_port_bad= 0;
1133
 
    }
1134
 
  }
1135
 
  return $port_to_test;
1136
 
 
1137
 
}
 
1030
      my $sidx= $mysqld->{idx} ? "$mysqld->{idx}" : "";
 
1031
      $mysqld->{path_myerr}=
 
1032
        "$opt_vardir/log/" . $mysqld->{type} . "$sidx.trace";
 
1033
    }
 
1034
  }
 
1035
}
 
1036
 
1138
1037
#
1139
1038
# To make it easier for different devs to work on the same host,
1140
1039
# an environment variable can be used to control all ports. A small
1142
1041
#
1143
1042
# Note the MASTER_MYPORT has to be set the same in all 4.x and 5.x
1144
1043
# versions of this script, else a 4.0 test run might conflict with a
1145
 
# 5.1 test run, even if different DTR_BUILD_THREAD is used. This means
 
1044
# 5.1 test run, even if different MTR_BUILD_THREAD is used. This means
1146
1045
# all port numbers might not be used in this version of the script.
1147
1046
#
1148
1047
# Also note the limitation of ports we are allowed to hand out. This
1151
1050
# But a fairly safe range seems to be 5001 - 32767
1152
1051
#
1153
1052
 
1154
 
sub set_dtr_build_thread_ports($) {
1155
 
  my $dtr_build_thread= shift;
 
1053
sub set_mtr_build_thread_ports($) {
 
1054
  my $mtr_build_thread= shift;
1156
1055
 
1157
 
  if ( lc($dtr_build_thread) eq 'auto' ) {
 
1056
  if ( lc($mtr_build_thread) eq 'auto' ) {
1158
1057
    print "Requesting build thread... ";
1159
 
    $ENV{'DTR_BUILD_THREAD'} = $dtr_build_thread = dtr_require_unique_id_and_wait("/tmp/drizzle-test-ports", 200, 299);
1160
 
    print "got ".$dtr_build_thread."\n";
 
1058
    $ENV{'MTR_BUILD_THREAD'} = $mtr_build_thread = mtr_require_unique_id_and_wait("/tmp/mysql-test-ports", 200, 299);
 
1059
    print "got ".$mtr_build_thread."\n";
1161
1060
  }
1162
1061
 
1163
 
  $dtr_build_thread= (($dtr_build_thread * 10) % 2000) - 1000;
1164
 
 
1165
1062
  # Up to two masters, up to three slaves
1166
1063
  # A magic value in command_line_setup depends on these equations.
1167
 
  $opt_master_myport=         gimme_a_good_port($dtr_build_thread + 9000); # and 1
1168
 
 
1169
 
 
1170
 
  $opt_slave_myport=          gimme_a_good_port($opt_master_myport + 2);  # and 3 4
1171
 
  $opt_memc_myport= gimme_a_good_port($opt_master_myport + 10);
1172
 
  $opt_pbms_myport= gimme_a_good_port($opt_master_myport + 11);
1173
 
  $opt_rabbitmq_myport= gimme_a_good_port($opt_master_myport + 12);
 
1064
  $opt_master_myport=         $mtr_build_thread * 10 + 10000; # and 1
 
1065
  $opt_slave_myport=          $opt_master_myport + 2;  # and 3 4
1174
1066
 
1175
1067
  if ( $opt_master_myport < 5001 or $opt_master_myport + 10 >= 32767 )
1176
1068
  {
1177
 
    dtr_error("DTR_BUILD_THREAD number results in a port",
 
1069
    mtr_error("MTR_BUILD_THREAD number results in a port",
1178
1070
              "outside 5001 - 32767",
1179
1071
              "($opt_master_myport - $opt_master_myport + 10)");
1180
1072
  }
1203
1095
##############################################################################
1204
1096
 
1205
1097
 
1206
 
sub collect_drizzled_features () {
 
1098
sub collect_mysqld_features () {
1207
1099
  my $found_variable_list_start= 0;
1208
1100
  my $tmpdir= tempdir(CLEANUP => 0); # Directory removed by this function
1209
1101
 
1210
1102
  #
1211
 
  # Execute "drizzled --help" to get a list
 
1103
  # Execute "mysqld --help --verbose" to get a list
1212
1104
  # list of all features and settings
1213
1105
  #
1214
 
  # --no-defaults are to avoid loading
 
1106
  # --no-defaults and --skip-grant-tables are to avoid loading
1215
1107
  # system-wide configs and plugins
1216
1108
  #
1217
 
  my $list= `$exe_drizzled --no-defaults --help`;
 
1109
  # --datadir must exist, mysqld will chdir into it
 
1110
  #
 
1111
  my $list= `$exe_drizzled --no-defaults --datadir=$tmpdir --skip-grant-tables --verbose --help`;
1218
1112
 
1219
1113
  foreach my $line (split('\n', $list))
1220
1114
  {
1221
1115
    # First look for version
1222
 
    if ( !$drizzle_version_id )
 
1116
    if ( !$mysql_version_id )
1223
1117
    {
1224
1118
      # Look for version
1225
1119
      my $exe_name= basename($exe_drizzled);
1226
 
      dtr_verbose("exe_name: $exe_name");
 
1120
      mtr_verbose("exe_name: $exe_name");
1227
1121
      if ( $line =~ /^\S*$exe_name\s\sVer\s([0-9]*)\.([0-9]*)\.([0-9]*)/ )
1228
1122
      {
1229
1123
        #print "Major: $1 Minor: $2 Build: $3\n";
1230
 
        $drizzle_version_id= $1*10000 + $2*100 + $3;
1231
 
        #print "drizzle_version_id: $drizzle_version_id\n";
1232
 
        dtr_report("Drizzle Version $1.$2.$3");
 
1124
        $mysql_version_id= $1*10000 + $2*100 + $3;
 
1125
        #print "mysql_version_id: $mysql_version_id\n";
 
1126
        mtr_report("MySQL Version $1.$2.$3");
 
1127
      }
 
1128
    }
 
1129
    else
 
1130
    {
 
1131
      if (!$found_variable_list_start)
 
1132
      {
 
1133
        # Look for start of variables list
 
1134
        if ( $line =~ /[\-]+\s[\-]+/ )
 
1135
        {
 
1136
          $found_variable_list_start= 1;
 
1137
        }
 
1138
      }
 
1139
      else
 
1140
      {
 
1141
        # Put variables into hash
 
1142
        if ( $line =~ /^([\S]+)[ \t]+(.*?)\r?$/ )
 
1143
        {
 
1144
          # print "$1=\"$2\"\n";
 
1145
          $mysqld_variables{$1}= $2;
 
1146
        }
 
1147
        else
 
1148
        {
 
1149
          # The variable list is ended with a blank line
 
1150
          if ( $line =~ /^[\s]*$/ )
 
1151
          {
 
1152
            last;
 
1153
          }
 
1154
          else
 
1155
          {
 
1156
            # Send out a warning, we should fix the variables that has no
 
1157
            # space between variable name and it's value
 
1158
            # or should it be fixed width column parsing? It does not
 
1159
            # look like that in function my_print_variables in my_getopt.c
 
1160
            mtr_warning("Could not parse variable list line : $line");
 
1161
          }
 
1162
        }
1233
1163
      }
1234
1164
    }
1235
1165
  }
1236
1166
  rmtree($tmpdir);
1237
 
  dtr_error("Could not find version of Drizzle") unless $drizzle_version_id;
 
1167
  mtr_error("Could not find version of MySQL") unless $mysql_version_id;
 
1168
  mtr_error("Could not find variabes list") unless $found_variable_list_start;
1238
1169
 
1239
1170
}
1240
1171
 
1241
1172
 
1242
1173
sub run_query($$) {
1243
 
  my ($drizzled, $query)= @_;
 
1174
  my ($mysqld, $query)= @_;
1244
1175
 
1245
1176
  my $args;
1246
 
  dtr_init_args(\$args);
 
1177
  mtr_init_args(\$args);
1247
1178
 
1248
 
  dtr_add_arg($args, "--no-defaults");
1249
 
  dtr_add_arg($args, "--skip-stack-trace");
1250
 
  dtr_add_arg($args, "--user=%s", $opt_user);
1251
 
  dtr_add_arg($args, "--port=%d", $drizzled->{'port'});
1252
 
  dtr_add_arg($args, "--silent"); # Tab separated output
1253
 
  dtr_add_arg($args, "-e '%s'", $query);
 
1179
  mtr_add_arg($args, "--no-defaults");
 
1180
  mtr_add_arg($args, "--user=%s", $opt_user);
 
1181
  mtr_add_arg($args, "--port=%d", $mysqld->{'port'});
 
1182
  mtr_add_arg($args, "--silent"); # Tab separated output
 
1183
  mtr_add_arg($args, "-e '%s'", $query);
1254
1184
 
1255
1185
  my $cmd= "$exe_drizzle " . join(' ', @$args);
1256
 
  dtr_verbose("cmd: $cmd");
 
1186
  mtr_verbose("cmd: $cmd");
1257
1187
  return `$cmd`;
1258
1188
}
1259
1189
 
1260
1190
 
1261
 
sub collect_drizzled_features_from_running_server ()
 
1191
sub collect_mysqld_features_from_running_server ()
1262
1192
{
1263
 
  my $list= run_query($master->[0], "use drizzle; SHOW VARIABLES");
 
1193
  my $list= run_query($master->[0], "use mysql; SHOW VARIABLES");
1264
1194
 
1265
1195
  foreach my $line (split('\n', $list))
1266
1196
  {
1268
1198
    if ( $line =~ /^([\S]+)[ \t]+(.*?)\r?$/ )
1269
1199
    {
1270
1200
      print "$1=\"$2\"\n";
1271
 
      $drizzled_variables{$1}= $2;
 
1201
      $mysqld_variables{$1}= $2;
1272
1202
    }
1273
1203
  }
1274
1204
}
1286
1216
    $exe_libtool= "../libtool";
1287
1217
    if ($opt_valgrind or $glob_debugger)
1288
1218
    {
1289
 
      dtr_report("Using \"$exe_libtool\" when running valgrind or debugger");
 
1219
      mtr_report("Using \"$exe_libtool\" when running valgrind or debugger");
1290
1220
    }
1291
1221
  }
1292
1222
 
 
1223
# Look for my_print_defaults
 
1224
  $exe_my_print_defaults=
 
1225
    mtr_exe_exists(
 
1226
        "$path_client_bindir/my_print_defaults",
 
1227
        "$glob_basedir/extra/my_print_defaults");
 
1228
 
1293
1229
# Look for perror
1294
1230
  $exe_perror= "perror";
1295
1231
 
1296
1232
# Look for the client binaries
1297
 
  $exe_drizzledump= dtr_exe_exists("$path_client_bindir/drizzledump");
1298
 
  $exe_drizzleimport= dtr_exe_exists("$path_client_bindir/drizzleimport");
1299
 
  $exe_drizzle=          dtr_exe_exists("$path_client_bindir/drizzle");
1300
 
  $exe_drizzleadmin= dtr_exe_exists("$path_client_bindir/drizzleadmin");
 
1233
  $exe_drizzlecheck= mtr_exe_exists("$path_client_bindir/drizzlecheck");
 
1234
  $exe_drizzledump= mtr_exe_exists("$path_client_bindir/drizzledump");
 
1235
  $exe_drizzleimport= mtr_exe_exists("$path_client_bindir/drizzleimport");
 
1236
  $exe_drizzlebinlog= mtr_exe_exists("$path_client_bindir/drizzlebinlog");
 
1237
  $exe_drizzleadmin= mtr_exe_exists("$path_client_bindir/drizzleadmin");
 
1238
  $exe_drizzle=          mtr_exe_exists("$path_client_bindir/drizzle");
1301
1239
 
1302
1240
  if (!$opt_extern)
1303
1241
  {
1304
1242
# Look for SQL scripts directory
1305
 
     if ( $drizzle_version_id >= 50100 )
 
1243
     if ( $mysql_version_id >= 50100 )
1306
1244
     {
1307
 
         $exe_drizzleslap= dtr_exe_exists("$path_client_bindir/drizzleslap");
 
1245
         $exe_drizzleslap= mtr_exe_exists("$path_client_bindir/drizzleslap");
1308
1246
     }
1309
1247
  }
1310
1248
 
1311
 
# Look for schema_writer
1312
 
  {
1313
 
    $exe_schemawriter= dtr_exe_exists("$glob_basedir/drizzled/message/schema_writer",
1314
 
                                      "$glob_builddir/drizzled/message/schema_writer");
1315
 
  }
1316
 
 
1317
1249
# Look for drizzletest executable
1318
1250
  {
1319
 
    $exe_drizzletest= dtr_exe_exists("$path_client_bindir/drizzletest");
 
1251
    $exe_drizzletest= mtr_exe_exists("$path_client_bindir/drizzletest");
1320
1252
  }
1321
1253
 
1322
1254
# Look for drizzle_client_test executable which may _not_ exist in
1323
1255
# some versions, test using it should be skipped
1324
1256
  {
1325
1257
    $exe_drizzle_client_test=
1326
 
      dtr_exe_maybe_exists(
 
1258
      mtr_exe_maybe_exists(
1327
1259
          "$glob_basedir/tests/drizzle_client_test",
1328
1260
          "$glob_basedir/bin/drizzle_client_test");
1329
1261
  }
1331
1263
# Look for bug25714 executable which may _not_ exist in
1332
1264
# some versions, test using it should be skipped
1333
1265
  $exe_bug25714=
1334
 
    dtr_exe_maybe_exists(
 
1266
    mtr_exe_maybe_exists(
1335
1267
        "$glob_basedir/tests/bug25714");
1336
1268
}
1337
1269
 
1338
1270
 
1339
1271
 
1340
 
sub generate_cmdline_drizzledump ($) {
1341
 
  my($drizzled) = @_;
1342
 
  return
1343
 
    dtr_native_path($exe_drizzledump) .
1344
 
      " --no-defaults -uroot " .
1345
 
      "--port=$drizzled->{'port'} ";
1346
 
}
1347
 
 
1348
 
sub generate_cmdline_drizzle ($) {
1349
 
  my($drizzled) = @_;
1350
 
  return
1351
 
    dtr_native_path($exe_drizzle) .
1352
 
    " -uroot --port=$drizzled->{'port'} ";
1353
 
}
1354
 
 
1355
 
sub generate_cmdline_drizzleadmin ($) {
1356
 
  my($drizzled) = @_;
1357
 
  return
1358
 
    dtr_native_path($exe_drizzleadmin) .
1359
 
    " -uroot --port=$drizzled->{'port'} ";
1360
 
}
 
1272
sub generate_cmdline_mysqldump ($) {
 
1273
  my($mysqld) = @_;
 
1274
  return
 
1275
    mtr_native_path($exe_drizzledump) .
 
1276
      " --no-defaults -uroot --debug-check " .
 
1277
      "--port=$mysqld->{'port'} ";
 
1278
}
 
1279
 
1361
1280
 
1362
1281
##############################################################################
1363
1282
#
1371
1290
  my $exe= $exe_drizzle_client_test;
1372
1291
 
1373
1292
  my $args;
1374
 
  dtr_init_args(\$args);
 
1293
  mtr_init_args(\$args);
1375
1294
  if ( $opt_valgrind_drizzletest )
1376
1295
  {
1377
1296
    valgrind_arguments($args, \$exe);
1378
1297
  }
1379
1298
 
1380
 
  dtr_add_arg($args, "--no-defaults");
1381
 
  dtr_add_arg($args, "--testcase");
1382
 
  dtr_add_arg($args, "--user=root");
1383
 
  dtr_add_arg($args, "--port=$master->[0]->{'port'}");
 
1299
  mtr_add_arg($args, "--no-defaults");
 
1300
  mtr_add_arg($args, "--testcase");
 
1301
  mtr_add_arg($args, "--user=root");
 
1302
  mtr_add_arg($args, "--port=$master->[0]->{'port'}");
1384
1303
 
1385
 
  if ( $opt_extern || $drizzle_version_id >= 50000 )
 
1304
  if ( $opt_extern || $mysql_version_id >= 50000 )
1386
1305
  {
1387
 
    dtr_add_arg($args, "--vardir=$opt_vardir")
 
1306
    mtr_add_arg($args, "--vardir=$opt_vardir")
1388
1307
  }
1389
1308
 
1390
1309
  if ( $opt_debug )
1391
1310
  {
1392
 
    dtr_add_arg($args,
 
1311
    mtr_add_arg($args,
1393
1312
      "--debug=d:t:A,$path_vardir_trace/log/drizzle_client_test.trace");
1394
1313
  }
1395
1314
 
1397
1316
}
1398
1317
 
1399
1318
 
1400
 
# Note that some env is setup in spawn/run, in "dtr_process.pl"
 
1319
# Note that some env is setup in spawn/run, in "mtr_process.pl"
1401
1320
 
1402
1321
sub environment_setup () {
1403
1322
 
1411
1330
  # --------------------------------------------------------------------------
1412
1331
  if ( $source_dist )
1413
1332
  {
1414
 
    push(@ld_library_paths, "$glob_basedir/libdrizzleclient/.libs/",
1415
 
                            "$glob_basedir/mysys/.libs/",
1416
 
                            "$glob_basedir/mystrings/.libs/",
1417
 
                            "$glob_basedir/drizzled/.libs/",
1418
 
                            "/usr/local/lib");
 
1333
    push(@ld_library_paths, "$glob_basedir/libmysql/.libs/",
 
1334
                            "$glob_basedir/libmysql_r/.libs/",
 
1335
                            "$glob_basedir/zlib.libs/");
1419
1336
  }
1420
1337
  else
1421
1338
  {
1436
1353
  my $deb_version;
1437
1354
  if (  $opt_valgrind and -d $debug_libraries_path and
1438
1355
        (! -e '/etc/debian_version' or
1439
 
         ($deb_version= dtr_grab_file('/etc/debian_version')) !~ /^[0-9]+\.[0-9]$/ or
 
1356
         ($deb_version= mtr_grab_file('/etc/debian_version')) !~ /^[0-9]+\.[0-9]$/ or
1440
1357
         $deb_version > 3.1 ) )
1441
1358
  {
1442
1359
    push(@ld_library_paths, $debug_libraries_path);
1443
1360
  }
1444
1361
 
1445
 
  $ENV{'LD_LIBRARY_PATH'}= join(":", 
 
1362
  $ENV{'LD_LIBRARY_PATH'}= join(":", @ld_library_paths,
1446
1363
                                $ENV{'LD_LIBRARY_PATH'} ?
1447
 
                                split(':', $ENV{'LD_LIBRARY_PATH'}) : (),
1448
 
                                @ld_library_paths);
1449
 
  dtr_debug("LD_LIBRARY_PATH: $ENV{'LD_LIBRARY_PATH'}");
 
1364
                                split(':', $ENV{'LD_LIBRARY_PATH'}) : ());
 
1365
  mtr_debug("LD_LIBRARY_PATH: $ENV{'LD_LIBRARY_PATH'}");
1450
1366
 
1451
1367
  $ENV{'DYLD_LIBRARY_PATH'}= join(":", @ld_library_paths,
1452
1368
                                  $ENV{'DYLD_LIBRARY_PATH'} ?
1453
1369
                                  split(':', $ENV{'DYLD_LIBRARY_PATH'}) : ());
1454
 
  dtr_debug("DYLD_LIBRARY_PATH: $ENV{'DYLD_LIBRARY_PATH'}");
 
1370
  mtr_debug("DYLD_LIBRARY_PATH: $ENV{'DYLD_LIBRARY_PATH'}");
1455
1371
 
1456
1372
  # The environment variable used for shared libs on AIX
1457
1373
  $ENV{'SHLIB_PATH'}= join(":", @ld_library_paths,
1458
1374
                           $ENV{'SHLIB_PATH'} ?
1459
1375
                           split(':', $ENV{'SHLIB_PATH'}) : ());
1460
 
  dtr_debug("SHLIB_PATH: $ENV{'SHLIB_PATH'}");
 
1376
  mtr_debug("SHLIB_PATH: $ENV{'SHLIB_PATH'}");
1461
1377
 
1462
1378
  # The environment variable used for shared libs on hp-ux
1463
1379
  $ENV{'LIBPATH'}= join(":", @ld_library_paths,
1464
1380
                        $ENV{'LIBPATH'} ?
1465
1381
                        split(':', $ENV{'LIBPATH'}) : ());
1466
 
  dtr_debug("LIBPATH: $ENV{'LIBPATH'}");
 
1382
  mtr_debug("LIBPATH: $ENV{'LIBPATH'}");
1467
1383
 
1468
1384
  # --------------------------------------------------------------------------
1469
1385
  # Also command lines in .opt files may contain env vars
1474
1390
  $ENV{'UMASK_DIR'}=          "0770"; # The octal *string*
1475
1391
  
1476
1392
  #
1477
 
  # drizzle tests can produce output in various character sets
 
1393
  # MySQL tests can produce output in various character sets
1478
1394
  # (especially, ctype_xxx.test). To avoid confusing Perl
1479
1395
  # with output which is incompatible with the current locale
1480
1396
  # settings, we reset the current values of LC_ALL and LC_CTYPE to "C".
1486
1402
  
1487
1403
  $ENV{'LC_COLLATE'}=         "C";
1488
1404
  $ENV{'USE_RUNNING_SERVER'}= $opt_extern;
1489
 
  $ENV{'DRIZZLE_TEST_DIR'}=     collapse_path($glob_drizzle_test_dir);
1490
 
  $ENV{'DRIZZLETEST_VARDIR'}=   $opt_vardir;
1491
 
  $ENV{'TOP_SRCDIR'}= $opt_top_srcdir;
1492
 
  $ENV{'TOP_BUILDDIR'}= $opt_top_builddir;
 
1405
  $ENV{'DRIZZLE_TEST_DIR'}=     $glob_mysql_test_dir;
 
1406
  $ENV{'MYSQLTEST_VARDIR'}=   $opt_vardir;
1493
1407
  $ENV{'DRIZZLE_TMP_DIR'}=      $opt_tmpdir;
1494
1408
  $ENV{'MASTER_MYSOCK'}=      $master->[0]->{'path_sock'};
1495
1409
  $ENV{'MASTER_MYSOCK1'}=     $master->[1]->{'path_sock'};
1499
1413
  $ENV{'SLAVE_MYPORT'}=       $slave->[0]->{'port'};
1500
1414
  $ENV{'SLAVE_MYPORT1'}=      $slave->[1]->{'port'};
1501
1415
  $ENV{'SLAVE_MYPORT2'}=      $slave->[2]->{'port'};
1502
 
  $ENV{'MC_PORT'}=            $opt_memc_myport;
1503
 
  $ENV{'PBMS_PORT'}=          $opt_pbms_myport;
1504
 
  $ENV{'RABBITMQ_NODE_PORT'}= $opt_rabbitmq_myport;
1505
 
  $ENV{'DRIZZLE_TCP_PORT'}=   $drizzled_variables{'drizzle-protocol.port'};
1506
 
 
1507
 
  $ENV{'DTR_BUILD_THREAD'}=      $opt_dtr_build_thread;
1508
 
 
1509
 
  $ENV{'EXE_DRIZZLE'}=          $exe_drizzle;
1510
 
 
 
1416
  $ENV{'DRIZZLE_TCP_PORT'}=     $mysqld_variables{'port'};
 
1417
 
 
1418
  $ENV{MTR_BUILD_THREAD}=      $opt_mtr_build_thread;
 
1419
 
 
1420
  $ENV{'EXE_MYSQL'}=          $exe_drizzle;
 
1421
 
 
1422
  # ----------------------------------------------------
 
1423
  # Setup env so childs can execute mysqlcheck
 
1424
  # ----------------------------------------------------
 
1425
  my $cmdline_mysqlcheck=
 
1426
    mtr_native_path($exe_drizzlecheck) .
 
1427
    " --no-defaults --debug-check -uroot " .
 
1428
    "--port=$master->[0]->{'port'} ";
 
1429
 
 
1430
  if ( $opt_debug )
 
1431
  {
 
1432
    $cmdline_mysqlcheck .=
 
1433
      " --debug=d:t:A,$path_vardir_trace/log/mysqlcheck.trace";
 
1434
  }
 
1435
  $ENV{'DRIZZLE_CHECK'}=              $cmdline_mysqlcheck;
1511
1436
 
1512
1437
  # ----------------------------------------------------
1513
1438
  # Setup env to childs can execute myqldump
1514
1439
  # ----------------------------------------------------
1515
 
  my $cmdline_drizzleadmin= generate_cmdline_drizzleadmin($master->[0]);
1516
 
  my $cmdline_drizzledump= generate_cmdline_drizzledump($master->[0]);
1517
 
  my $cmdline_drizzledumpslave= generate_cmdline_drizzledump($slave->[0]);
1518
 
  my $cmdline_drizzledump_secondary= dtr_native_path($exe_drizzledump) .
1519
 
       " --no-defaults -uroot " .
1520
 
       " --port=$master->[0]->{'secondary_port'} ";
 
1440
  my $cmdline_mysqldump= generate_cmdline_mysqldump($master->[0]);
 
1441
  my $cmdline_mysqldumpslave= generate_cmdline_mysqldump($slave->[0]);
1521
1442
 
1522
1443
  if ( $opt_debug )
1523
1444
  {
1524
 
    $cmdline_drizzledump .=
1525
 
      " --debug=d:t:A,$path_vardir_trace/log/drizzledump-master.trace";
1526
 
    $cmdline_drizzledumpslave .=
1527
 
      " --debug=d:t:A,$path_vardir_trace/log/drizzledump-slave.trace";
1528
 
    $cmdline_drizzledump_secondary .=
1529
 
      " --debug=d:t:A,$path_vardir_trace/log/drizzledump-drizzle.trace";
 
1445
    $cmdline_mysqldump .=
 
1446
      " --debug=d:t:A,$path_vardir_trace/log/mysqldump-master.trace";
 
1447
    $cmdline_mysqldumpslave .=
 
1448
      " --debug=d:t:A,$path_vardir_trace/log/mysqldump-slave.trace";
1530
1449
  }
1531
 
  $ENV{'DRIZZLE_ADMIN'}= $cmdline_drizzleadmin;
1532
 
  $ENV{'DRIZZLE_DUMP'}= $cmdline_drizzledump;
1533
 
  $ENV{'DRIZZLE_DUMP_SLAVE'}= $cmdline_drizzledumpslave;
1534
 
  $ENV{'DRIZZLE_DUMP_SECONDARY'}= $cmdline_drizzledump_secondary;
1535
 
 
1536
 
  # ----------------------------------------------------
1537
 
  # Setup env so we can execute drizzle client
1538
 
  # ----------------------------------------------------
1539
 
  #my $cmdline_drizzle = generate_cmdline_drizzle($master->[0]);
1540
 
  #$ENV{'DRIZZLE'}= $cmdline_drizzle;
1541
 
 
1542
 
  # ----------------------------------------------------
1543
 
  # Setup env so childs can execute drizzleslap
 
1450
  $ENV{'DRIZZLE_DUMP'}= $cmdline_mysqldump;
 
1451
  $ENV{'DRIZZLE_DUMP_SLAVE'}= $cmdline_mysqldumpslave;
 
1452
 
 
1453
  # ----------------------------------------------------
 
1454
  # Setup env so childs can execute mysqlslap
1544
1455
  # ----------------------------------------------------
1545
1456
  if ( $exe_drizzleslap )
1546
1457
  {
1547
 
    my $cmdline_drizzleslap;
1548
 
 
1549
 
    if ( $opt_valgrind_drizzleslap )
1550
 
    {
1551
 
      $cmdline_drizzleslap= "$glob_basedir/libtool --mode=execute valgrind --log-file=$opt_vardir/log/drizzleslap-valgrind.log ";
1552
 
    }
1553
 
    $cmdline_drizzleslap .=
1554
 
      dtr_native_path($exe_drizzleslap) .
 
1458
    my $cmdline_drizzleslap=
 
1459
      mtr_native_path($exe_drizzleslap) .
1555
1460
      " -uroot " .
1556
1461
      "--port=$master->[0]->{'port'} ";
1557
 
    my $cmdline_drizzleslap_secondary=
1558
 
      dtr_native_path($exe_drizzleslap) .
1559
 
      " -uroot " .
1560
 
      " --port=$master->[0]->{'secondary_port'} ";
1561
1462
 
1562
1463
    if ( $opt_debug )
1563
1464
   {
1564
1465
      $cmdline_drizzleslap .=
1565
1466
        " --debug=d:t:A,$path_vardir_trace/log/drizzleslap.trace";
1566
 
      $cmdline_drizzleslap_secondary .=
1567
 
        " --debug=d:t:A,$path_vardir_trace/log/drizzleslap.trace";
1568
1467
    }
1569
1468
    $ENV{'DRIZZLE_SLAP'}= $cmdline_drizzleslap;
1570
 
    $ENV{'DRIZZLE_SLAP_SECONDARY'}= $cmdline_drizzleslap_secondary;
1571
 
  }
1572
 
 
1573
 
 
1574
 
 
1575
 
  # ----------------------------------------------------
1576
 
  # Setup env so childs can execute drizzleimport
1577
 
  # ----------------------------------------------------
1578
 
  my $cmdline_drizzleimport=
1579
 
    dtr_native_path($exe_drizzleimport) .
1580
 
    " -uroot " .
1581
 
    "--port=$master->[0]->{'port'} ";
1582
 
 
1583
 
  if ( $opt_debug )
1584
 
  {
1585
 
    $cmdline_drizzleimport .=
1586
 
      " --debug=d:t:A,$path_vardir_trace/log/drizzleimport.trace";
1587
 
  }
1588
 
  $ENV{'DRIZZLE_IMPORT'}= $cmdline_drizzleimport;
1589
 
 
1590
 
 
1591
 
  # ----------------------------------------------------
1592
 
  # Setup env so childs can execute drizzle
1593
 
  # ----------------------------------------------------
1594
 
  my $cmdline_drizzle=
1595
 
    dtr_native_path($exe_drizzle) .
1596
 
    " --no-defaults --host=localhost  --user=root --password= " .
1597
 
    "--port=$master->[0]->{'port'} ";
1598
 
  my $cmdline_drizzle_secondary=
1599
 
    dtr_native_path($exe_drizzle) .
1600
 
    " --no-defaults --host=localhost  --user=root --password= " .
1601
 
    " --port=$master->[0]->{'secondary_port'} ";
1602
 
 
1603
 
  $ENV{'DRIZZLE'}= $cmdline_drizzle;
1604
 
  $ENV{'DRIZZLE_SECONDARY'}= $cmdline_drizzle_secondary;
 
1469
  }
 
1470
 
 
1471
 
 
1472
 
 
1473
  # ----------------------------------------------------
 
1474
  # Setup env so childs can execute mysqlimport
 
1475
  # ----------------------------------------------------
 
1476
  my $cmdline_mysqlimport=
 
1477
    mtr_native_path($exe_drizzleimport) .
 
1478
    " -uroot --debug-check " .
 
1479
    "--port=$master->[0]->{'port'} ";
 
1480
 
 
1481
  if ( $opt_debug )
 
1482
  {
 
1483
    $cmdline_mysqlimport .=
 
1484
      " --debug=d:t:A,$path_vardir_trace/log/mysqlimport.trace";
 
1485
  }
 
1486
  $ENV{'DRIZZLE_IMPORT'}= $cmdline_mysqlimport;
 
1487
 
 
1488
 
 
1489
  # ----------------------------------------------------
 
1490
  # Setup env so childs can execute mysqlbinlog
 
1491
  # ----------------------------------------------------
 
1492
  my $cmdline_mysqlbinlog=
 
1493
    mtr_native_path($exe_drizzlebinlog) .
 
1494
      " --no-defaults --disable-force-if-open --debug-check";
 
1495
 
 
1496
  if ( $opt_debug )
 
1497
  {
 
1498
    $cmdline_mysqlbinlog .=
 
1499
      " --debug=d:t:A,$path_vardir_trace/log/mysqlbinlog.trace";
 
1500
  }
 
1501
  $ENV{'DRIZZLE_BINLOG'}= $cmdline_mysqlbinlog;
 
1502
 
 
1503
  # ----------------------------------------------------
 
1504
  # Setup env so childs can execute mysql
 
1505
  # ----------------------------------------------------
 
1506
  my $cmdline_mysql=
 
1507
    mtr_native_path($exe_drizzle) .
 
1508
    " --no-defaults --debug-check --host=localhost  --user=root --password= " .
 
1509
    "--port=$master->[0]->{'port'} ";
 
1510
 
 
1511
  $ENV{'MYSQL'}= $cmdline_mysql;
1605
1512
 
1606
1513
  # ----------------------------------------------------
1607
1514
  # Setup env so childs can execute bug25714
1615
1522
 
1616
1523
 
1617
1524
  # ----------------------------------------------------
1618
 
  # Setup env so childs can execute drizzle_fix_system_tables
 
1525
  # Setup env so childs can execute mysql_fix_system_tables
1619
1526
  # ----------------------------------------------------
1620
1527
  #if ( !$opt_extern)
1621
1528
  if ( 0 )
1622
1529
  {
1623
 
    my $cmdline_drizzle_fix_system_tables=
 
1530
    my $cmdline_mysql_fix_system_tables=
1624
1531
      "$exe_drizzle_fix_system_tables --no-defaults --host=localhost " .
1625
1532
      "--user=root --password= " .
1626
1533
      "--basedir=$glob_basedir --bindir=$path_client_bindir --verbose " .
1627
1534
      "--port=$master->[0]->{'port'} ";
1628
 
    $ENV{'DRIZZLE_FIX_SYSTEM_TABLES'}=  $cmdline_drizzle_fix_system_tables;
 
1535
    $ENV{'DRIZZLE_FIX_SYSTEM_TABLES'}=  $cmdline_mysql_fix_system_tables;
1629
1536
 
1630
1537
  }
1631
1538
 
1632
1539
  # ----------------------------------------------------
1633
 
  # Setup env so childs can shutdown the server
1634
 
  # ----------------------------------------------------
1635
 
  $ENV{'DRIZZLED_SHUTDOWN'}= dtr_native_path($exe_drizzle);
 
1540
  # Setup env so childs can execute my_print_defaults
 
1541
  # ----------------------------------------------------
 
1542
  $ENV{'DRIZZLE_MY_PRINT_DEFAULTS'}= mtr_native_path($exe_my_print_defaults);
 
1543
 
 
1544
  # ----------------------------------------------------
 
1545
  # Setup env so childs can execute mysqladmin
 
1546
  # ----------------------------------------------------
 
1547
  $ENV{'MYSQLADMIN'}= mtr_native_path($exe_drizzleadmin);
1636
1548
 
1637
1549
  # ----------------------------------------------------
1638
1550
  # Setup env so childs can execute perror  
1639
1551
  # ----------------------------------------------------
1640
 
  $ENV{'MY_PERROR'}= dtr_native_path($exe_perror);
 
1552
  $ENV{'MY_PERROR'}= mtr_native_path($exe_perror);
1641
1553
 
1642
1554
  # ----------------------------------------------------
1643
 
  # Add the path where drizzled will find ha_example.so
 
1555
  # Add the path where mysqld will find ha_example.so
1644
1556
  # ----------------------------------------------------
1645
1557
  $ENV{'EXAMPLE_PLUGIN'}=
1646
1558
    ($lib_example_plugin ? basename($lib_example_plugin) : "");
1648
1560
    ($lib_example_plugin ? "--plugin_dir=" . dirname($lib_example_plugin) : "");
1649
1561
 
1650
1562
  # ----------------------------------------------------
 
1563
  # Setup env so childs can execute myisampack and myisamchk
 
1564
  # ----------------------------------------------------
 
1565
#  $ENV{'MYISAMCHK'}= mtr_native_path(mtr_exe_exists(
 
1566
#                       "$path_client_bindir/myisamchk",
 
1567
#                       "$glob_basedir/storage/myisam/myisamchk",
 
1568
#                       "$glob_basedir/myisam/myisamchk"));
 
1569
#  $ENV{'MYISAMPACK'}= mtr_native_path(mtr_exe_exists(
 
1570
#                        "$path_client_bindir/myisampack",
 
1571
#                        "$glob_basedir/storage/myisam/myisampack",
 
1572
#                        "$glob_basedir/myisam/myisampack"));
 
1573
 
 
1574
  # ----------------------------------------------------
1651
1575
  # We are nice and report a bit about our settings
1652
1576
  # ----------------------------------------------------
1653
1577
  if (!$opt_extern)
1654
1578
  {
1655
 
    print "Using DTR_BUILD_THREAD      = $ENV{DTR_BUILD_THREAD}\n";
 
1579
    print "Using MTR_BUILD_THREAD      = $ENV{MTR_BUILD_THREAD}\n";
1656
1580
    print "Using MASTER_MYPORT         = $ENV{MASTER_MYPORT}\n";
1657
1581
    print "Using MASTER_MYPORT1        = $ENV{MASTER_MYPORT1}\n";
1658
1582
    print "Using SLAVE_MYPORT          = $ENV{SLAVE_MYPORT}\n";
1659
1583
    print "Using SLAVE_MYPORT1         = $ENV{SLAVE_MYPORT1}\n";
1660
1584
    print "Using SLAVE_MYPORT2         = $ENV{SLAVE_MYPORT2}\n";
1661
 
    print "Using MC_PORT               = $ENV{MC_PORT}\n";
1662
 
    print "Using PBMS_PORT             = $ENV{PBMS_PORT}\n";
1663
 
    print "Using RABBITMQ_NODE_PORT    = $ENV{RABBITMQ_NODE_PORT}\n";
1664
1585
  }
1665
1586
 
1666
1587
  # Create an environment variable to make it possible
1684
1605
 
1685
1606
sub handle_int_signal () {
1686
1607
  $SIG{INT}= 'DEFAULT';         # If we get a ^C again, we die...
1687
 
  dtr_warning("got INT signal, cleaning up.....");
 
1608
  mtr_warning("got INT signal, cleaning up.....");
1688
1609
  stop_all_servers();
1689
 
  dtr_error("We die from ^C signal from user");
 
1610
  mtr_error("We die from ^C signal from user");
1690
1611
}
1691
1612
 
1692
1613
 
1698
1619
 
1699
1620
sub kill_running_servers () {
1700
1621
  {
1701
 
    # Ensure that no old drizzled test servers are running
 
1622
    # Ensure that no old mysqld test servers are running
1702
1623
    # This is different from terminating processes we have
1703
1624
    # started from this run of the script, this is terminating
1704
1625
    # leftovers from previous runs.
1705
 
    dtr_kill_leftovers();
 
1626
    mtr_kill_leftovers();
1706
1627
   }
1707
1628
}
1708
1629
 
1712
1633
#
1713
1634
sub remove_stale_vardir () {
1714
1635
 
1715
 
  dtr_report("Removing Stale Files");
 
1636
  mtr_report("Removing Stale Files");
1716
1637
 
1717
1638
  # Safety!
1718
 
  dtr_error("No, don't remove the vardir when running with --extern")
 
1639
  mtr_error("No, don't remove the vardir when running with --extern")
1719
1640
    if $opt_extern;
1720
1641
 
1721
 
  dtr_verbose("opt_vardir: $opt_vardir");
 
1642
  mtr_verbose("opt_vardir: $opt_vardir");
1722
1643
  if ( $opt_vardir eq $default_vardir )
1723
1644
  {
1724
1645
    #
1725
 
    # Running with "var" in drizzle-test dir
 
1646
    # Running with "var" in mysql-test dir
1726
1647
    #
1727
1648
    if ( -l $opt_vardir)
1728
1649
    {
1731
1652
      if ( $opt_mem and readlink($opt_vardir) eq $opt_mem )
1732
1653
      {
1733
1654
        # Remove the directory which the link points at
1734
 
        dtr_verbose("Removing " . readlink($opt_vardir));
1735
 
        dtr_rmtree(readlink($opt_vardir));
 
1655
        mtr_verbose("Removing " . readlink($opt_vardir));
 
1656
        mtr_rmtree(readlink($opt_vardir));
1736
1657
 
1737
1658
        # Remove the "var" symlink
1738
 
        dtr_verbose("unlink($opt_vardir)");
 
1659
        mtr_verbose("unlink($opt_vardir)");
1739
1660
        unlink($opt_vardir);
1740
1661
      }
1741
1662
      elsif ( $opt_mem )
1742
1663
      {
1743
1664
        # Just remove the "var" symlink
1744
 
        dtr_report("WARNING: Removing '$opt_vardir' symlink it's wrong");
 
1665
        mtr_report("WARNING: Removing '$opt_vardir' symlink it's wrong");
1745
1666
 
1746
 
        dtr_verbose("unlink($opt_vardir)");
 
1667
        mtr_verbose("unlink($opt_vardir)");
1747
1668
        unlink($opt_vardir);
1748
1669
      }
1749
1670
      else
1750
1671
      {
1751
 
        # Some users creates a soft link in drizzle-test/var to another area
 
1672
        # Some users creates a soft link in mysql-test/var to another area
1752
1673
        # - allow it, but remove all files in it
1753
1674
 
1754
 
        dtr_report("WARNING: Using the 'drizzle-test/var' symlink");
 
1675
        mtr_report("WARNING: Using the 'mysql-test/var' symlink");
1755
1676
 
1756
1677
        # Make sure the directory where it points exist
1757
 
        dtr_error("The destination for symlink $opt_vardir does not exist")
 
1678
        mtr_error("The destination for symlink $opt_vardir does not exist")
1758
1679
          if ! -d readlink($opt_vardir);
1759
1680
 
1760
1681
        foreach my $bin ( glob("$opt_vardir/*") )
1761
1682
        {
1762
 
          dtr_verbose("Removing bin $bin");
1763
 
          dtr_rmtree($bin);
 
1683
          mtr_verbose("Removing bin $bin");
 
1684
          mtr_rmtree($bin);
1764
1685
        }
1765
1686
      }
1766
1687
    }
1767
1688
    else
1768
1689
    {
1769
1690
      # Remove the entire "var" dir
1770
 
      dtr_verbose("Removing $opt_vardir/");
1771
 
      dtr_rmtree("$opt_vardir/");
 
1691
      mtr_verbose("Removing $opt_vardir/");
 
1692
      mtr_rmtree("$opt_vardir/");
1772
1693
    }
1773
1694
 
1774
1695
    if ( $opt_mem )
1776
1697
      # A symlink from var/ to $opt_mem will be set up
1777
1698
      # remove the $opt_mem dir to assure the symlink
1778
1699
      # won't point at an old directory
1779
 
      dtr_verbose("Removing $opt_mem");
1780
 
      dtr_rmtree($opt_mem);
 
1700
      mtr_verbose("Removing $opt_mem");
 
1701
      mtr_rmtree($opt_mem);
1781
1702
    }
1782
1703
 
1783
1704
  }
1787
1708
    # Running with "var" in some other place
1788
1709
    #
1789
1710
 
1790
 
    # Remove the var/ dir in drizzle-test dir if any
 
1711
    # Remove the var/ dir in mysql-test dir if any
1791
1712
    # this could be an old symlink that shouldn't be there
1792
 
    dtr_verbose("Removing $default_vardir");
1793
 
    dtr_rmtree($default_vardir);
 
1713
    mtr_verbose("Removing $default_vardir");
 
1714
    mtr_rmtree($default_vardir);
1794
1715
 
1795
1716
    # Remove the "var" dir
1796
 
    dtr_verbose("Removing $opt_vardir/");
1797
 
    dtr_rmtree("$opt_vardir/");
 
1717
    mtr_verbose("Removing $opt_vardir/");
 
1718
    mtr_rmtree("$opt_vardir/");
1798
1719
  }
1799
1720
}
1800
1721
 
1802
1723
# Create var and the directories needed in var
1803
1724
#
1804
1725
sub setup_vardir() {
1805
 
  dtr_report("Creating Directories");
 
1726
  mtr_report("Creating Directories");
1806
1727
 
1807
1728
  if ( $opt_vardir eq $default_vardir )
1808
1729
  {
1809
1730
    #
1810
 
    # Running with "var" in drizzle-test dir
 
1731
    # Running with "var" in mysql-test dir
1811
1732
    #
1812
1733
    if ( -l $opt_vardir )
1813
1734
    {
1814
1735
      #  it's a symlink
1815
1736
 
1816
1737
      # Make sure the directory where it points exist
1817
 
      dtr_error("The destination for symlink $opt_vardir does not exist")
 
1738
      mtr_error("The destination for symlink $opt_vardir does not exist")
1818
1739
        if ! -d readlink($opt_vardir);
1819
1740
    }
1820
1741
    elsif ( $opt_mem )
1821
1742
    {
1822
1743
      # Runinng with "var" as a link to some "memory" location, normally tmpfs
1823
 
      dtr_verbose("Creating $opt_mem");
 
1744
      mtr_verbose("Creating $opt_mem");
1824
1745
      mkpath($opt_mem);
1825
1746
 
1826
 
      dtr_report("Symlinking 'var' to '$opt_mem'");
 
1747
      mtr_report("Symlinking 'var' to '$opt_mem'");
1827
1748
      symlink($opt_mem, $opt_vardir);
1828
1749
    }
1829
1750
  }
1830
1751
 
1831
1752
  if ( ! -d $opt_vardir )
1832
1753
  {
1833
 
    dtr_verbose("Creating $opt_vardir");
 
1754
    mtr_verbose("Creating $opt_vardir");
1834
1755
    mkpath($opt_vardir);
1835
1756
  }
1836
1757
 
1837
1758
  # Ensure a proper error message if vardir couldn't be created
1838
1759
  unless ( -d $opt_vardir and -w $opt_vardir )
1839
1760
  {
1840
 
    dtr_error("Writable 'var' directory is needed, use the " .
 
1761
    mtr_error("Writable 'var' directory is needed, use the " .
1841
1762
              "'--vardir=<path>' option");
1842
1763
  }
1843
1764
 
1849
1770
  # Create new data dirs
1850
1771
  foreach my $data_dir (@data_dir_lst)
1851
1772
  {
1852
 
    mkpath("$data_dir/local/mysql");
1853
 
    system("$exe_schemawriter mysql $data_dir/local/mysql/db.opt");
1854
 
 
1855
 
    mkpath("$data_dir/local/test");
1856
 
    system("$exe_schemawriter test $data_dir/local/test/db.opt");
 
1773
    mkpath("$data_dir/mysql");
 
1774
    mkpath("$data_dir/test");
1857
1775
  }
1858
1776
 
1859
1777
  # Make a link std_data_ln in var/ that points to std_data
1860
 
  symlink(collapse_path("$glob_drizzle_test_dir/std_data"),
1861
 
          "$opt_vardir/std_data_ln");
1862
 
 
1863
 
  symlink(collapse_path("$glob_suite_path/filesystem_engine/tests/t"),
1864
 
          "$opt_vardir/filesystem_ln");
 
1778
  symlink("$glob_mysql_test_dir/std_data", "$opt_vardir/std_data_ln");
1865
1779
 
1866
1780
  # Remove old log files
1867
1781
  foreach my $name (glob("r/*.progress r/*.log r/*.warnings"))
1868
1782
  {
1869
1783
    unlink($name);
1870
1784
  }
1871
 
  system("chmod -R ugo+r $opt_vardir");
1872
 
  system("chmod -R ugo+r $opt_vardir/std_data_ln/*");
1873
 
  system("chmod -R ugo+rw $opt_vardir/filesystem_ln/*");
1874
 
  system("chmod -R ugo+w $glob_suite_path/filesystem_engine/tests/t");
1875
1785
}
1876
1786
 
1877
1787
 
1879
1789
  # Check if running as root
1880
1790
  # i.e a file can be read regardless what mode we set it to
1881
1791
  my $test_file= "$opt_vardir/test_running_as_root.txt";
1882
 
  dtr_tofile($test_file, "Drizzle");
 
1792
  mtr_tofile($test_file, "MySQL");
1883
1793
  chmod(oct("0000"), $test_file);
1884
1794
 
1885
1795
  my $result="";
1895
1805
  my $file_mode= (stat($test_file))[2] & 07777;
1896
1806
 
1897
1807
  $ENV{'DRIZZLE_TEST_ROOT'}= "NO";
1898
 
  dtr_verbose("result: $result, file_mode: $file_mode");
1899
 
  if ($result eq "Drizzle" && $file_mode == 0)
 
1808
  mtr_verbose("result: $result, file_mode: $file_mode");
 
1809
  if ($result eq "MySQL" && $file_mode == 0)
1900
1810
  {
1901
 
    dtr_warning("running this script as _root_ will cause some " .
 
1811
    mtr_warning("running this script as _root_ will cause some " .
1902
1812
                "tests to be skipped");
1903
1813
    $ENV{'DRIZZLE_TEST_ROOT'}= "YES";
1904
1814
  }
1910
1820
 
1911
1821
 
1912
1822
sub check_debug_support ($) {
1913
 
  my $drizzled_variables= shift;
 
1823
  my $mysqld_variables= shift;
1914
1824
 
1915
 
  if ( ! $drizzled_variables->{'debug'} )
 
1825
  if ( ! $mysqld_variables->{'debug'} )
1916
1826
  {
1917
 
    #dtr_report("Binaries are not debug compiled");
 
1827
    #mtr_report("Binaries are not debug compiled");
1918
1828
    $debug_compiled_binaries= 0;
1919
1829
 
1920
1830
    if ( $opt_debug )
1921
1831
    {
1922
 
      dtr_error("Can't use --debug, binaries does not support it");
 
1832
      mtr_error("Can't use --debug, binaries does not support it");
1923
1833
    }
1924
1834
    return;
1925
1835
  }
1926
 
  dtr_report("Binaries are debug compiled");
 
1836
  mtr_report("Binaries are debug compiled");
1927
1837
  $debug_compiled_binaries= 1;
1928
1838
}
1929
1839
 
1940
1850
  my $args;
1941
1851
 
1942
1852
  {
1943
 
    drizzled_start($master->[0],[],[]);
 
1853
    mysqld_start($master->[0],[],[]);
1944
1854
    if ( ! $master->[0]->{'pid'} )
1945
1855
    {
1946
 
      dtr_error("Can't start the drizzled server");
 
1856
      mtr_error("Can't start the mysqld server");
1947
1857
    }
1948
1858
  }
1949
1859
 
1950
 
  dtr_init_args(\$args);
 
1860
  mtr_init_args(\$args);
1951
1861
 
1952
 
  dtr_add_arg($args, "--user=%s", $opt_user);
 
1862
  mtr_add_arg($args, "--user=%s", $opt_user);
1953
1863
 
1954
1864
  if ( $opt_small_bench )
1955
1865
  {
1956
 
    dtr_add_arg($args, "--small-test");
1957
 
    dtr_add_arg($args, "--small-tables");
 
1866
    mtr_add_arg($args, "--small-test");
 
1867
    mtr_add_arg($args, "--small-tables");
1958
1868
  }
1959
1869
 
1960
 
  chdir($glob_drizzle_bench_dir)
1961
 
    or dtr_error("Couldn't chdir to '$glob_drizzle_bench_dir': $!");
 
1870
  chdir($glob_mysql_bench_dir)
 
1871
    or mtr_error("Couldn't chdir to '$glob_mysql_bench_dir': $!");
1962
1872
 
1963
1873
  if ( ! $benchmark )
1964
1874
  {
1965
 
    dtr_run("$glob_drizzle_bench_dir/run-all-tests", $args, "", "", "", "");
 
1875
    mtr_add_arg($args, "--log");
 
1876
    mtr_run("$glob_mysql_bench_dir/run-all-tests", $args, "", "", "", "");
1966
1877
    # FIXME check result code?!
1967
1878
  }
1968
1879
  elsif ( -x $benchmark )
1969
1880
  {
1970
 
    dtr_run("$glob_drizzle_bench_dir/$benchmark", $args, "", "", "", "");
 
1881
    mtr_run("$glob_mysql_bench_dir/$benchmark", $args, "", "", "", "");
1971
1882
    # FIXME check result code?!
1972
1883
  }
1973
1884
  else
1974
1885
  {
1975
 
    dtr_error("Benchmark $benchmark not found");
 
1886
    mtr_error("Benchmark $benchmark not found");
1976
1887
  }
1977
1888
 
1978
 
  chdir($glob_drizzle_test_dir);          # Go back
 
1889
  chdir($glob_mysql_test_dir);          # Go back
1979
1890
 
1980
1891
  {
1981
1892
    stop_masters();
1992
1903
sub run_tests () {
1993
1904
  my ($tests)= @_;
1994
1905
 
1995
 
  dtr_print_thick_line();
1996
 
 
1997
 
  dtr_timer_start($glob_timers,"suite", 60 * $opt_suite_timeout);
1998
 
 
1999
 
  dtr_report_tests_not_skipped_though_disabled($tests);
2000
 
 
2001
 
  dtr_print_header();
 
1906
  mtr_print_thick_line();
 
1907
 
 
1908
  mtr_timer_start($glob_timers,"suite", 60 * $opt_suite_timeout);
 
1909
 
 
1910
  mtr_report_tests_not_skipped_though_disabled($tests);
 
1911
 
 
1912
  mtr_print_header();
2002
1913
 
2003
1914
  foreach my $tinfo ( @$tests )
2004
1915
  {
2005
 
    foreach(1..$opt_repeat_test)
 
1916
    if (run_testcase_check_skip_test($tinfo))
2006
1917
    {
2007
 
      if (run_testcase_check_skip_test($tinfo))
2008
 
        {
2009
 
          next;
2010
 
        }
2011
 
 
2012
 
      dtr_timer_start($glob_timers,"testcase", 60 * $opt_testcase_timeout);
2013
 
      run_testcase($tinfo);
2014
 
      dtr_timer_stop($glob_timers,"testcase");
 
1918
      next;
2015
1919
    }
 
1920
 
 
1921
    mtr_timer_start($glob_timers,"testcase", 60 * $opt_testcase_timeout);
 
1922
    run_testcase($tinfo);
 
1923
    mtr_timer_stop($glob_timers,"testcase");
2016
1924
  }
2017
1925
 
2018
 
  dtr_print_line();
 
1926
  mtr_print_line();
2019
1927
 
2020
1928
  if ( ! $glob_debugger and
2021
1929
       ! $opt_extern )
2032
1940
    gprof_collect(); # collect coverage information
2033
1941
  }
2034
1942
 
2035
 
  dtr_report_stats($tests);
 
1943
  mtr_report_stats($tests);
2036
1944
 
2037
 
  dtr_timer_stop($glob_timers,"suite");
 
1945
  mtr_timer_stop($glob_timers,"suite");
2038
1946
}
2039
1947
 
2040
1948
 
2054
1962
    # vardir does not already exist it should be created
2055
1963
    if ( ! -d $opt_vardir )
2056
1964
    {
2057
 
      dtr_report("Creating '$opt_vardir'");
 
1965
      mtr_report("Creating '$opt_vardir'");
2058
1966
      setup_vardir();
2059
1967
    }
2060
1968
    else
2061
1969
    {
2062
 
      dtr_verbose("No need to create '$opt_vardir' it already exists");
 
1970
      mtr_verbose("No need to create '$opt_vardir' it already exists");
2063
1971
    }
2064
1972
  }
2065
1973
  else
2071
1979
      remove_stale_vardir();
2072
1980
      setup_vardir();
2073
1981
 
2074
 
      drizzle_install_db();
 
1982
      mysql_install_db();
2075
1983
      if ( $opt_force )
2076
1984
      {
2077
1985
        # Save a snapshot of the freshly installed db
2082
1990
  }
2083
1991
  check_running_as_root();
2084
1992
 
2085
 
  dtr_log_init("$opt_vardir/log/drizzle-test-run.log");
 
1993
  mtr_log_init("$opt_vardir/log/drizzle-test-run.log");
2086
1994
 
2087
1995
}
2088
1996
 
2089
 
sub drizzle_install_db () {
 
1997
sub mysql_install_db () {
2090
1998
 
2091
1999
  if ($max_master_num > 1)
2092
2000
  {
2093
 
    copy_install_db('master', $master->[1]->{'path_myddir'} . "/local");
 
2001
    copy_install_db('master', $master->[1]->{'path_myddir'});
2094
2002
  }
2095
2003
 
2096
2004
  # Install the number of slave databses needed
2107
2015
  my $type=      shift;
2108
2016
  my $data_dir=  shift;
2109
2017
 
2110
 
  dtr_report("Installing \u$type Database");
 
2018
  mtr_report("Installing \u$type Database");
2111
2019
 
2112
2020
  # Just copy the installed db from first master
2113
 
  dtr_copy_dir($master->[0]->{'path_myddir'}, $data_dir);
 
2021
  mtr_copy_dir($master->[0]->{'path_myddir'}, $data_dir);
2114
2022
 
2115
2023
}
2116
2024
 
2128
2036
    {
2129
2037
      my $data_dir= $slave->[$idx]->{'path_myddir'};
2130
2038
      my $name= basename($data_dir);
2131
 
      dtr_rmtree($data_dir);
2132
 
      dtr_copy_dir("$path_snapshot/$name", $data_dir);
 
2039
      mtr_rmtree($data_dir);
 
2040
      mtr_copy_dir("$path_snapshot/$name", $data_dir);
2133
2041
    }
2134
2042
  }
2135
2043
}
2148
2056
 
2149
2057
  if ( $tinfo->{'skip'} )
2150
2058
  {
2151
 
    dtr_report_test_name($tinfo);
2152
 
    dtr_report_test_skipped($tinfo);
 
2059
    mtr_report_test_name($tinfo);
 
2060
    mtr_report_test_skipped($tinfo);
2153
2061
    return 1;
2154
2062
  }
2155
2063
 
2163
2071
  my $args;
2164
2072
 
2165
2073
  # Remove old files produced by drizzletest
2166
 
  my $base_file= dtr_match_extension($tinfo->{'result_file'},
 
2074
  my $base_file= mtr_match_extension($tinfo->{'result_file'},
2167
2075
                                    "result"); # Trim extension
2168
2076
  unlink("$base_file.reject");
2169
2077
  unlink("$base_file.progress");
2170
2078
  unlink("$base_file.log");
2171
2079
  unlink("$base_file.warnings");
2172
2080
 
 
2081
  if (!$opt_extern)
 
2082
  {
 
2083
    if (defined $tinfo->{binlog_format} and  $mysql_version_id > 50100 )
 
2084
    {
 
2085
      # Dynamically switch binlog format of
 
2086
      # master, slave is always restarted
 
2087
      foreach my $server ( @$master )
 
2088
      {
 
2089
        next unless ($server->{'pid'});
 
2090
 
 
2091
        mtr_init_args(\$args);
 
2092
        mtr_add_arg($args, "--no-defaults");
 
2093
        mtr_add_arg($args, "--user=root");
 
2094
        mtr_add_arg($args, "--port=$server->{'port'}");
 
2095
 
 
2096
        my $sql= "include/set_binlog_format_".$tinfo->{binlog_format}.".sql";
 
2097
        mtr_verbose("Setting binlog format:", $tinfo->{binlog_format});
 
2098
        if (mtr_run($exe_drizzle, $args, $sql, "", "", "") != 0)
 
2099
        {
 
2100
          mtr_error("Failed to switch binlog format");
 
2101
        }
 
2102
      }
 
2103
    }
 
2104
  }
2173
2105
}
2174
2106
 
2175
2107
sub do_after_run_drizzletest($)
2177
2109
  my $tinfo= shift;
2178
2110
 
2179
2111
  # Save info from this testcase run to drizzletest.log
2180
 
  dtr_appendfile_to_file($path_current_test_log, $path_drizzletest_log)
 
2112
  mtr_appendfile_to_file($path_current_test_log, $path_drizzletest_log)
2181
2113
    if -f $path_current_test_log;
2182
 
  dtr_appendfile_to_file($path_timefile, $path_drizzletest_log)
 
2114
  mtr_appendfile_to_file($path_timefile, $path_drizzletest_log)
2183
2115
    if -f $path_timefile;
2184
2116
}
2185
2117
 
2191
2123
  # Write a marker to all log files
2192
2124
 
2193
2125
  # The file indicating current test name
2194
 
  dtr_tonewfile($path_current_test_log, $log_msg);
 
2126
  mtr_tonewfile($path_current_test_log, $log_msg);
2195
2127
 
2196
 
  # each drizzled's .err file
2197
 
  foreach my $drizzled (@{$master}, @{$slave})
 
2128
  # each mysqld's .err file
 
2129
  foreach my $mysqld (@{$master}, @{$slave})
2198
2130
  {
2199
 
    dtr_tofile($drizzled->{path_myerr}, $log_msg);
 
2131
    mtr_tofile($mysqld->{path_myerr}, $log_msg);
2200
2132
  }
2201
2133
 
2202
2134
}
2224
2156
 
2225
2157
  if ( ! $reason )
2226
2158
  {
2227
 
    dtr_warning("Could not find reason for skipping test in $path_timefile");
 
2159
    mtr_warning("Could not find reason for skipping test in $path_timefile");
2228
2160
    $reason= "Detected by testcase(reason unknown) ";
2229
2161
  }
2230
2162
  $tinfo->{'comment'}= $reason;
2244
2176
 
2245
2177
# We don't start and kill the servers for each testcase. But some
2246
2178
# testcases needs a restart, because they specify options to start
2247
 
# drizzled with. After that testcase, we need to restart again, to set
 
2179
# mysqld with. After that testcase, we need to restart again, to set
2248
2180
# back the normal options.
2249
2181
 
2250
2182
sub run_testcase ($) {
2255
2187
  # -------------------------------------------------------
2256
2188
 
2257
2189
  $ENV{'TZ'}= $tinfo->{'timezone'};
2258
 
  dtr_verbose("Setting timezone: $tinfo->{'timezone'}");
 
2190
  mtr_verbose("Setting timezone: $tinfo->{'timezone'}");
2259
2191
 
2260
2192
  my $master_restart= run_testcase_need_master_restart($tinfo);
2261
2193
  my $slave_restart= run_testcase_need_slave_restart($tinfo);
2265
2197
    # Can't restart a running server that may be in use
2266
2198
    if ( $opt_extern )
2267
2199
    {
2268
 
      dtr_report_test_name($tinfo);
 
2200
      mtr_report_test_name($tinfo);
2269
2201
      $tinfo->{comment}= "Can't restart a running server";
2270
 
      dtr_report_test_skipped($tinfo);
 
2202
      mtr_report_test_skipped($tinfo);
2271
2203
      return;
2272
2204
    }
2273
2205
 
2277
2209
  # Write to all log files to indicate start of testcase
2278
2210
  run_testcase_mark_logs($tinfo, "CURRENT_TEST: $tinfo->{name}\n");
2279
2211
 
2280
 
  my $died= dtr_record_dead_children();
 
2212
  my $died= mtr_record_dead_children();
2281
2213
  if ($died or $master_restart or $slave_restart)
2282
2214
  {
2283
2215
    if (run_testcase_start_servers($tinfo))
2284
2216
    {
2285
 
      dtr_report_test_name($tinfo);
 
2217
      mtr_report_test_name($tinfo);
2286
2218
      report_failure_and_restart($tinfo);
2287
2219
      return 1;
2288
2220
    }
2293
2225
  # ----------------------------------------------------------------------
2294
2226
  if ( $opt_start_and_exit or $opt_start_dirty )
2295
2227
  {
2296
 
    dtr_timer_stop_all($glob_timers);
2297
 
    dtr_report("\nServers started, exiting");
 
2228
    mtr_timer_stop_all($glob_timers);
 
2229
    mtr_report("\nServers started, exiting");
2298
2230
    exit(0);
2299
2231
  }
2300
2232
 
2302
2234
    do_before_run_drizzletest($tinfo);
2303
2235
 
2304
2236
    my $res= run_drizzletest($tinfo);
2305
 
    dtr_report_test_name($tinfo);
 
2237
    mtr_report_test_name($tinfo);
2306
2238
 
2307
2239
    do_after_run_drizzletest($tinfo);
2308
2240
 
2309
2241
    if ( $res == 0 )
2310
2242
    {
2311
 
      dtr_report_test_passed($tinfo);
 
2243
      mtr_report_test_passed($tinfo);
2312
2244
    }
2313
2245
    elsif ( $res == 62 )
2314
2246
    {
2316
2248
 
2317
2249
      # Try to get reason from drizzletest.log
2318
2250
      find_testcase_skipped_reason($tinfo);
2319
 
      dtr_report_test_skipped($tinfo);
 
2251
      mtr_report_test_skipped($tinfo);
2320
2252
    }
2321
2253
    elsif ( $res == 63 )
2322
2254
    {
2352
2284
#
2353
2285
sub save_installed_db () {
2354
2286
 
2355
 
  dtr_report("Saving snapshot of installed databases");
2356
 
  dtr_rmtree($path_snapshot);
 
2287
  mtr_report("Saving snapshot of installed databases");
 
2288
  mtr_rmtree($path_snapshot);
2357
2289
 
2358
2290
  foreach my $data_dir (@data_dir_lst)
2359
2291
  {
2360
2292
    my $name= basename($data_dir);
2361
 
    dtr_copy_dir("$data_dir", "$path_snapshot/$name");
 
2293
    mtr_copy_dir("$data_dir", "$path_snapshot/$name");
2362
2294
  }
2363
2295
}
2364
2296
 
2377
2309
  {
2378
2310
    last if $opt_max_save_core > 0 && $num_saved_cores >= $opt_max_save_core;
2379
2311
    my $core_name= basename($core_file);
2380
 
    dtr_report("Saving $core_name");
 
2312
    mtr_report("Saving $core_name");
2381
2313
    mkdir($save_name) if ! -d $save_name;
2382
2314
    rename("$core_file", "$save_name/$core_name");
2383
2315
    ++$num_saved_cores;
2394
2326
 
2395
2327
  if ( -d $path_snapshot)
2396
2328
  {
2397
 
    dtr_report("Restoring snapshot of databases");
 
2329
    mtr_report("Restoring snapshot of databases");
2398
2330
 
2399
2331
    foreach my $data_dir (@data_dir_lst)
2400
2332
    {
2401
2333
      my $name= basename($data_dir);
2402
2334
      save_files_before_restore($test_name, $data_dir);
2403
 
      dtr_rmtree("$data_dir");
2404
 
      dtr_copy_dir("$path_snapshot/$name", "$data_dir");
 
2335
      mtr_rmtree("$data_dir");
 
2336
      mtr_copy_dir("$path_snapshot/$name", "$data_dir");
2405
2337
    }
2406
2338
  }
2407
2339
  else
2408
2340
  {
2409
2341
    # No snapshot existed
2410
 
    dtr_error("No snapshot existed");
 
2342
    mtr_error("No snapshot existed");
2411
2343
  }
2412
2344
}
2413
2345
 
2414
2346
sub report_failure_and_restart ($) {
2415
2347
  my $tinfo= shift;
2416
2348
 
2417
 
  dtr_report_test_failed($tinfo);
 
2349
  mtr_report_test_failed($tinfo);
2418
2350
  print "\n";
2419
2351
  if ( $opt_force )
2420
2352
  {
2423
2355
 
2424
2356
    # Restore the snapshot of the installed test db
2425
2357
    restore_installed_db($tinfo->{'name'});
2426
 
    dtr_report("Resuming Tests\n");
 
2358
    mtr_report("Resuming Tests\n");
2427
2359
    return;
2428
2360
  }
2429
2361
 
2430
2362
  my $test_mode= join(" ", @::glob_test_mode) || "default";
2431
 
  dtr_report("Aborting: $tinfo->{'name'} failed in $test_mode mode. ");
2432
 
  dtr_report("To continue, re-run with '--force'.");
 
2363
  mtr_report("Aborting: $tinfo->{'name'} failed in $test_mode mode. ");
 
2364
  mtr_report("To continue, re-run with '--force'.");
2433
2365
  if ( ! $glob_debugger and
2434
2366
       ! $opt_extern )
2435
2367
  {
2436
2368
    stop_all_servers();
2437
2369
  }
2438
 
  dtr_exit(1);
 
2370
  mtr_exit(1);
2439
2371
 
2440
2372
}
2441
2373
 
2447
2379
  # Run master initialization shell script if one exists
2448
2380
  if ( $init_script )
2449
2381
  {
2450
 
    my $ret= dtr_run("/bin/sh", [$init_script], "", "", "", "");
 
2382
    my $ret= mtr_run("/bin/sh", [$init_script], "", "", "", "");
2451
2383
    if ( $ret != 0 )
2452
2384
    {
2453
2385
      # FIXME rewrite those scripts to return 0 if successful
2454
 
      # dtr_warning("$init_script exited with code $ret");
 
2386
      # mtr_warning("$init_script exited with code $ret");
2455
2387
    }
2456
2388
  }
2457
2389
}
2510
2442
  # Run slave initialization shell script if one exists
2511
2443
  if ( $init_script )
2512
2444
  {
2513
 
    my $ret= dtr_run("/bin/sh", [$init_script], "", "", "", "");
 
2445
    my $ret= mtr_run("/bin/sh", [$init_script], "", "", "", "");
2514
2446
    if ( $ret != 0 )
2515
2447
    {
2516
2448
      # FIXME rewrite those scripts to return 0 if successful
2517
 
      # dtr_warning("$init_script exited with code $ret");
 
2449
      # mtr_warning("$init_script exited with code $ret");
2518
2450
    }
2519
2451
  }
2520
2452
 
2525
2457
}
2526
2458
 
2527
2459
 
2528
 
sub drizzled_arguments ($$$$) {
 
2460
sub mysqld_arguments ($$$$) {
2529
2461
  my $args=              shift;
2530
 
  my $drizzled=            shift;
 
2462
  my $mysqld=            shift;
2531
2463
  my $extra_opt=         shift;
2532
2464
  my $slave_master_info= shift;
2533
2465
 
2534
 
  my $idx= $drizzled->{'idx'};
 
2466
  my $idx= $mysqld->{'idx'};
2535
2467
  my $sidx= "";                 # Index as string, 0 is empty string
2536
2468
  if ( $idx> 0 )
2537
2469
  {
2540
2472
 
2541
2473
  my $prefix= "";               # If drizzletest server arg
2542
2474
 
2543
 
  dtr_add_arg($args, "%s--no-defaults", $prefix);
2544
 
 
2545
 
  if ($opt_engine)
2546
 
  {
2547
 
    dtr_add_arg($args, "%s--default-storage-engine=%s", $prefix, $opt_engine);
2548
 
  }
2549
 
 
2550
 
  if ( $drizzle_version_id >= 50036)
2551
 
  {
2552
 
    # By default, prevent the started drizzled to access files outside of vardir
2553
 
    dtr_add_arg($args, "%s--secure-file-priv=%s", $prefix, $opt_vardir);
2554
 
  }
2555
 
 
2556
 
  dtr_add_arg($args, "%s--tmpdir=$opt_tmpdir", $prefix);
 
2475
  mtr_add_arg($args, "%s--no-defaults", $prefix);
 
2476
 
 
2477
  mtr_add_arg($args, "%s--basedir=%s", $prefix, $path_my_basedir);
 
2478
 
 
2479
  if ( $mysql_version_id >= 50036)
 
2480
  {
 
2481
    # By default, prevent the started mysqld to access files outside of vardir
 
2482
    mtr_add_arg($args, "%s--secure-file-priv=%s", $prefix, $opt_vardir);
 
2483
  }
 
2484
 
 
2485
  if ( $mysql_version_id >= 50000 )
 
2486
  {
 
2487
    mtr_add_arg($args, "%s--log-bin-trust-function-creators", $prefix);
 
2488
  }
 
2489
 
 
2490
  mtr_add_arg($args, "%s--default-character-set=utf8", $prefix);
 
2491
  mtr_add_arg($args, "%s--tmpdir=$opt_tmpdir", $prefix);
2557
2492
 
2558
2493
  # Increase default connect_timeout to avoid intermittent
2559
2494
  # disconnects when test servers are put under load
2560
2495
  # see BUG#28359
2561
 
  dtr_add_arg($args, "%s--mysql-protocol.connect-timeout=60", $prefix);
2562
 
 
2563
 
 
2564
 
  # When drizzled is run by a root user(euid is 0), it will fail
 
2496
  mtr_add_arg($args, "%s--connect-timeout=60", $prefix);
 
2497
 
 
2498
 
 
2499
  # When mysqld is run by a root user(euid is 0), it will fail
2565
2500
  # to start unless we specify what user to run as, see BUG#30630
2566
2501
  my $euid= $>;
2567
 
  if (grep(/^--user/, @$extra_opt, @opt_extra_drizzled_opt) == 0) {
2568
 
    dtr_add_arg($args, "%s--user=root", $prefix);
 
2502
  if (grep(/^--user/, @$extra_opt, @opt_extra_mysqld_opt) == 0) {
 
2503
    mtr_add_arg($args, "%s--user=root", $prefix);
2569
2504
  }
2570
2505
 
2571
 
  dtr_add_arg($args, "%s--pid-file=%s", $prefix,
2572
 
              $drizzled->{'path_pid'});
2573
 
 
2574
 
  dtr_add_arg($args, "%s--mysql-protocol.port=%d", $prefix,
2575
 
              $drizzled->{'port'});
2576
 
 
2577
 
  dtr_add_arg($args, "%s--drizzle-protocol.port=%d", $prefix,
2578
 
              $drizzled->{'secondary_port'});
2579
 
 
2580
 
  dtr_add_arg($args, "%s--datadir=%s", $prefix,
2581
 
              $drizzled->{'path_myddir'});
2582
 
 
2583
 
  dtr_add_arg($args, "%s--mysql-unix-socket-protocol.path=%s", $prefix,
2584
 
              $drizzled->{'path_sock'});
 
2506
  mtr_add_arg($args, "%s--pid-file=%s", $prefix,
 
2507
              $mysqld->{'path_pid'});
 
2508
 
 
2509
  mtr_add_arg($args, "%s--port=%d", $prefix,
 
2510
                $mysqld->{'port'});
 
2511
 
 
2512
  mtr_add_arg($args, "%s--datadir=%s", $prefix,
 
2513
              $mysqld->{'path_myddir'});
 
2514
 
 
2515
  my $log_base_path= "$opt_vardir/log/$mysqld->{'type'}$sidx";
 
2516
  mtr_add_arg($args, "%s--log=%s.log", $prefix, $log_base_path);
 
2517
  mtr_add_arg($args,
 
2518
              "%s--log-slow-queries=%s-slow.log", $prefix, $log_base_path);
2585
2519
 
2586
2520
  # Check if "extra_opt" contains --skip-log-bin
2587
 
  if ( $drizzled->{'type'} eq 'master' )
 
2521
  my $skip_binlog= grep(/^--skip-log-bin/, @$extra_opt, @opt_extra_mysqld_opt);
 
2522
  if ( $mysqld->{'type'} eq 'master' )
2588
2523
  {
2589
 
    dtr_add_arg($args, "%s--server-id=%d", $prefix,
 
2524
    if (! ($opt_skip_master_binlog || $skip_binlog) )
 
2525
    {
 
2526
      mtr_add_arg($args, "%s--log-bin=%s/log/master-bin%s", $prefix,
 
2527
                  $opt_vardir, $sidx);
 
2528
    }
 
2529
 
 
2530
    mtr_add_arg($args, "%s--server-id=%d", $prefix,
2590
2531
               $idx > 0 ? $idx + 101 : 1);
2591
2532
 
2592
 
    dtr_add_arg($args,
2593
 
      "%s--innodb.data-file-path=ibdata1:20M:autoextend", $prefix);
2594
 
 
 
2533
    mtr_add_arg($args, "%s--loose-innodb_data_file_path=ibdata1:10M:autoextend",
 
2534
                $prefix);
 
2535
 
 
2536
    mtr_add_arg($args, "%s--local-infile", $prefix);
 
2537
 
 
2538
    if ( $idx > 0 or !$use_innodb)
 
2539
    {
 
2540
      mtr_add_arg($args, "%s--loose-skip-innodb", $prefix);
 
2541
    }
2595
2542
  }
2596
2543
  else
2597
2544
  {
2598
 
    dtr_error("unknown drizzled type")
2599
 
      unless $drizzled->{'type'} eq 'slave';
 
2545
    mtr_error("unknown mysqld type")
 
2546
      unless $mysqld->{'type'} eq 'slave';
 
2547
 
 
2548
    #mtr_add_arg($args, "%s--init-rpl-role=slave", $prefix);
 
2549
    if (! ( $opt_skip_slave_binlog || $skip_binlog ))
 
2550
    {
 
2551
      mtr_add_arg($args, "%s--log-bin=%s/log/slave%s-bin", $prefix,
 
2552
                  $opt_vardir, $sidx); # FIXME use own dir for binlogs
 
2553
      mtr_add_arg($args, "%s--log-slave-updates", $prefix);
 
2554
    }
 
2555
 
 
2556
    mtr_add_arg($args, "%s--master-retry-count=10", $prefix);
 
2557
 
 
2558
    mtr_add_arg($args, "%s--relay-log=%s/log/slave%s-relay-bin", $prefix,
 
2559
                $opt_vardir, $sidx);
 
2560
    mtr_add_arg($args, "%s--report-host=127.0.0.1", $prefix);
 
2561
    mtr_add_arg($args, "%s--report-port=%d", $prefix,
 
2562
                $mysqld->{'port'});
 
2563
#    mtr_add_arg($args, "%s--report-user=root", $prefix);
 
2564
    mtr_add_arg($args, "%s--loose-skip-innodb", $prefix);
 
2565
    mtr_add_arg($args, "%s--skip-slave-start", $prefix);
2600
2566
 
2601
2567
    # Directory where slaves find the dumps generated by "load data"
2602
2568
    # on the server. The path need to have constant length otherwise
2603
2569
    # test results will vary, thus a relative path is used.
2604
2570
    my $slave_load_path= "../tmp";
 
2571
    mtr_add_arg($args, "%s--slave-load-tmpdir=%s", $prefix,
 
2572
                $slave_load_path);
 
2573
    mtr_add_arg($args, "%s--set-variable=slave_net_timeout=120", $prefix);
2605
2574
 
2606
2575
    if ( @$slave_master_info )
2607
2576
    {
2608
2577
      foreach my $arg ( @$slave_master_info )
2609
2578
      {
2610
 
        dtr_add_arg($args, "%s%s", $prefix, $arg);
 
2579
        mtr_add_arg($args, "%s%s", $prefix, $arg);
2611
2580
      }
2612
2581
    }
2613
2582
    else
2614
2583
    {
2615
2584
      my $slave_server_id=  2 + $idx;
2616
2585
      my $slave_rpl_rank= $slave_server_id;
2617
 
      dtr_add_arg($args, "%s--server-id=%d", $prefix, $slave_server_id);
 
2586
      mtr_add_arg($args, "%s--server-id=%d", $prefix, $slave_server_id);
 
2587
#      mtr_add_arg($args, "%s--rpl-recovery-rank=%d", $prefix, $slave_rpl_rank);
2618
2588
    }
2619
2589
  } # end slave
2620
2590
 
2621
2591
  if ( $opt_debug )
2622
2592
  {
2623
 
    dtr_add_arg($args, "%s--debug=d:t:i:A,%s/log/%s%s.trace",
2624
 
                $prefix, $path_vardir_trace, $drizzled->{'type'}, $sidx);
 
2593
    mtr_add_arg($args, "%s--debug=d:t:i:A,%s/log/%s%s.trace",
 
2594
                $prefix, $path_vardir_trace, $mysqld->{'type'}, $sidx);
2625
2595
  }
2626
2596
 
2627
 
  dtr_add_arg($args, "%s--sort-buffer-size=256K", $prefix);
2628
 
  dtr_add_arg($args, "%s--max-heap-table-size=1M", $prefix);
 
2597
  mtr_add_arg($args, "%s--key_buffer_size=1M", $prefix);
 
2598
  mtr_add_arg($args, "%s--sort_buffer=256K", $prefix);
 
2599
  mtr_add_arg($args, "%s--max_heap_table_size=1M", $prefix);
2629
2600
 
2630
2601
  if ( $opt_warnings )
2631
2602
  {
2632
 
    dtr_add_arg($args, "%s--log-warnings", $prefix);
 
2603
    mtr_add_arg($args, "%s--log-warnings", $prefix);
2633
2604
  }
2634
2605
 
2635
 
  # Indicate to "drizzled" it will be debugged in debugger
 
2606
  # Indicate to "mysqld" it will be debugged in debugger
2636
2607
  if ( $glob_debugger )
2637
2608
  {
2638
 
    dtr_add_arg($args, "%s--gdb", $prefix);
 
2609
    mtr_add_arg($args, "%s--gdb", $prefix);
2639
2610
  }
2640
2611
 
2641
2612
  my $found_skip_core= 0;
2642
 
  foreach my $arg ( @opt_extra_drizzled_opt, @$extra_opt )
 
2613
  foreach my $arg ( @opt_extra_mysqld_opt, @$extra_opt )
2643
2614
  {
2644
2615
    # Allow --skip-core-file to be set in <testname>-[master|slave].opt file
2645
2616
    if ($arg eq "--skip-core-file")
2646
2617
    {
2647
2618
      $found_skip_core= 1;
2648
2619
    }
 
2620
    elsif ($skip_binlog and mtr_match_prefix($arg, "--binlog-format"))
 
2621
    {
 
2622
      ; # Dont add --binlog-format when running without binlog
 
2623
    }
2649
2624
    else
2650
2625
    {
2651
 
      dtr_add_arg($args, "%s%s", $prefix, $arg);
 
2626
      mtr_add_arg($args, "%s%s", $prefix, $arg);
2652
2627
    }
2653
2628
  }
2654
2629
  if ( !$found_skip_core )
2655
2630
  {
2656
 
    dtr_add_arg($args, "%s%s", $prefix, "--core-file");
 
2631
    mtr_add_arg($args, "%s%s", $prefix, "--core-file");
 
2632
  }
 
2633
 
 
2634
  if ( $opt_bench )
 
2635
  {
 
2636
    #mtr_add_arg($args, "%s--rpl-recovery-rank=1", $prefix);
 
2637
    #mtr_add_arg($args, "%s--init-rpl-role=master", $prefix);
 
2638
  }
 
2639
  elsif ( $mysqld->{'type'} eq 'master' )
 
2640
  {
 
2641
    mtr_add_arg($args, "%s--open-files-limit=1024", $prefix);
2657
2642
  }
2658
2643
 
2659
2644
  return $args;
2662
2647
 
2663
2648
##############################################################################
2664
2649
#
2665
 
#  Start drizzled and return the PID
 
2650
#  Start mysqld and return the PID
2666
2651
#
2667
2652
##############################################################################
2668
2653
 
2669
 
sub drizzled_start ($$$) {
2670
 
  my $drizzled=            shift;
 
2654
sub mysqld_start ($$$) {
 
2655
  my $mysqld=            shift;
2671
2656
  my $extra_opt=         shift;
2672
2657
  my $slave_master_info= shift;
2673
2658
 
2676
2661
  my $pid= -1;
2677
2662
  my $wait_for_pid_file= 1;
2678
2663
 
2679
 
  my $type= $drizzled->{'type'};
2680
 
  my $idx= $drizzled->{'idx'};
 
2664
  my $type= $mysqld->{'type'};
 
2665
  my $idx= $mysqld->{'idx'};
2681
2666
 
2682
2667
  if ( $type eq 'master' )
2683
2668
  {
2684
 
    $exe= $exe_master_drizzled;
 
2669
    $exe= $exe_master_mysqld;
2685
2670
  }
2686
2671
  elsif ( $type eq 'slave' )
2687
2672
  {
2688
 
    $exe= $exe_slave_drizzled;
 
2673
    $exe= $exe_slave_mysqld;
2689
2674
  }
2690
2675
  else
2691
2676
  {
2692
 
    dtr_error("Unknown 'type' \"$type\" passed to drizzled_start");
 
2677
    mtr_error("Unknown 'type' \"$type\" passed to mysqld_start");
2693
2678
  }
2694
2679
 
2695
 
  dtr_init_args(\$args);
 
2680
  mtr_init_args(\$args);
2696
2681
 
2697
 
  if ( $opt_valgrind_drizzled )
 
2682
  if ( $opt_valgrind_mysqld )
2698
2683
  {
2699
2684
    valgrind_arguments($args, \$exe);
2700
2685
  }
2701
2686
 
2702
 
  drizzled_arguments($args,$drizzled,$extra_opt,$slave_master_info);
 
2687
  mysqld_arguments($args,$mysqld,$extra_opt,$slave_master_info);
2703
2688
 
2704
2689
  if ( $opt_gdb || $opt_manual_gdb)
2705
2690
  {
2709
2694
  {
2710
2695
    ddd_arguments(\$args, \$exe, "$type"."_$idx");
2711
2696
  }
2712
 
  if ( $opt_dbx || $opt_manual_dbx)
2713
 
  {
2714
 
    dbx_arguments(\$args, \$exe, "$type"."_$idx");
2715
 
  }
2716
2697
  elsif ( $opt_debugger )
2717
2698
  {
2718
2699
    debugger_arguments(\$args, \$exe, "$type"."_$idx");
2720
2701
  elsif ( $opt_manual_debug )
2721
2702
  {
2722
2703
     print "\nStart $type in your debugger\n" .
2723
 
           "dir: $glob_drizzle_test_dir\n" .
 
2704
           "dir: $glob_mysql_test_dir\n" .
2724
2705
           "exe: $exe\n" .
2725
2706
           "args:  " . join(" ", @$args)  . "\n\n" .
2726
2707
           "Waiting ....\n";
2735
2716
  }
2736
2717
 
2737
2718
  # Remove the pidfile
2738
 
  unlink($drizzled->{'path_pid'});
 
2719
  unlink($mysqld->{'path_pid'});
2739
2720
 
2740
2721
  if ( defined $exe )
2741
2722
  {
2742
 
    dtr_verbose("running Drizzle with: $exe @$args");
2743
 
    $pid= dtr_spawn($exe, $args, "",
2744
 
                    $drizzled->{'path_myerr'},
2745
 
                    $drizzled->{'path_myerr'},
 
2723
    $pid= mtr_spawn($exe, $args, "",
 
2724
                    $mysqld->{'path_myerr'},
 
2725
                    $mysqld->{'path_myerr'},
2746
2726
                    "",
2747
2727
                    { append_log_file => 1 });
2748
2728
  }
2749
2729
 
2750
2730
 
2751
 
  if ( $wait_for_pid_file && !sleep_until_file_created($drizzled->{'path_pid'},
2752
 
                                                       $drizzled->{'start_timeout'},
 
2731
  if ( $wait_for_pid_file && !sleep_until_file_created($mysqld->{'path_pid'},
 
2732
                                                       $mysqld->{'start_timeout'},
2753
2733
                                                       $pid))
2754
2734
  {
2755
2735
 
2756
 
    dtr_error("Failed to start drizzled $drizzled->{'type'}");
 
2736
    mtr_error("Failed to start mysqld $mysqld->{'type'}");
2757
2737
  }
2758
2738
 
2759
2739
 
2760
2740
  # Remember pid of the started process
2761
 
  $drizzled->{'pid'}= $pid;
 
2741
  $mysqld->{'pid'}= $pid;
2762
2742
 
2763
2743
  # Remember options used when starting
2764
 
  $drizzled->{'start_opts'}= $extra_opt;
2765
 
  $drizzled->{'start_slave_master_info'}= $slave_master_info;
 
2744
  $mysqld->{'start_opts'}= $extra_opt;
 
2745
  $mysqld->{'start_slave_master_info'}= $slave_master_info;
2766
2746
 
2767
 
  dtr_verbose("drizzled pid: $pid");
 
2747
  mtr_verbose("mysqld pid: $pid");
2768
2748
  return $pid;
2769
2749
}
2770
2750
 
2771
2751
 
2772
2752
sub stop_all_servers () {
2773
2753
 
2774
 
  dtr_report("Stopping All Servers");
 
2754
  mtr_report("Stopping All Servers");
2775
2755
 
2776
2756
  my %admin_pids; # hash of admin processes that requests shutdown
2777
2757
  my @kill_pids;  # list of processes to shutdown/kill
2778
2758
  my $pid;
2779
2759
 
2780
2760
  # Start shutdown of all started masters
2781
 
  foreach my $drizzled (@{$slave}, @{$master})
 
2761
  foreach my $mysqld (@{$slave}, @{$master})
2782
2762
  {
2783
 
    if ( $drizzled->{'pid'} )
 
2763
    if ( $mysqld->{'pid'} )
2784
2764
    {
2785
 
      $pid= dtr_server_shutdown($drizzled);
 
2765
      $pid= mtr_mysqladmin_start($mysqld, "shutdown", 70);
2786
2766
      $admin_pids{$pid}= 1;
2787
2767
 
2788
2768
      push(@kill_pids,{
2789
 
                       pid      => $drizzled->{'pid'},
2790
 
                       real_pid => $drizzled->{'real_pid'},
2791
 
                       pidfile  => $drizzled->{'path_pid'},
2792
 
                       sockfile => $drizzled->{'path_sock'},
2793
 
                       port     => $drizzled->{'port'},
2794
 
                       errfile  => $drizzled->{'path_myerr'},
 
2769
                       pid      => $mysqld->{'pid'},
 
2770
                       real_pid => $mysqld->{'real_pid'},
 
2771
                       pidfile  => $mysqld->{'path_pid'},
 
2772
                       sockfile => $mysqld->{'path_sock'},
 
2773
                       port     => $mysqld->{'port'},
 
2774
                       errfile  => $mysqld->{'path_myerr'},
2795
2775
                      });
2796
2776
 
2797
 
      $drizzled->{'pid'}= 0; # Assume we are done with it
 
2777
      $mysqld->{'pid'}= 0; # Assume we are done with it
2798
2778
    }
2799
2779
  }
2800
2780
 
2801
2781
  # Wait blocking until all shutdown processes has completed
2802
 
  dtr_wait_blocking(\%admin_pids);
 
2782
  mtr_wait_blocking(\%admin_pids);
2803
2783
 
2804
2784
  # Make sure that process has shutdown else try to kill them
2805
 
  dtr_check_stop_servers(\@kill_pids);
 
2785
  mtr_check_stop_servers(\@kill_pids);
2806
2786
}
2807
2787
 
2808
2788
 
2816
2796
  if ( $tinfo->{'master_sh'} )
2817
2797
  {
2818
2798
    $do_restart= 1;           # Always restart if script to run
2819
 
    dtr_verbose("Restart master: Always restart if script to run");
 
2799
    mtr_verbose("Restart master: Always restart if script to run");
2820
2800
  }
2821
2801
  if ( $tinfo->{'force_restart'} )
2822
2802
  {
2823
2803
    $do_restart= 1; # Always restart if --force-restart in -opt file
2824
 
    dtr_verbose("Restart master: Restart forced with --force-restart");
 
2804
    mtr_verbose("Restart master: Restart forced with --force-restart");
2825
2805
  }
2826
2806
  elsif( $tinfo->{'component_id'} eq 'im' )
2827
2807
  {
2828
2808
    $do_restart= 1;
2829
 
    dtr_verbose("Restart master: Always restart for im tests");
 
2809
    mtr_verbose("Restart master: Always restart for im tests");
2830
2810
  }
2831
2811
  elsif ( $master->[0]->{'running_master_options'} and
2832
2812
          $master->[0]->{'running_master_options'}->{'timezone'} ne
2833
2813
          $tinfo->{'timezone'})
2834
2814
  {
2835
2815
    $do_restart= 1;
2836
 
    dtr_verbose("Restart master: Different timezone");
 
2816
    mtr_verbose("Restart master: Different timezone");
2837
2817
  }
2838
2818
  # Check that running master was started with same options
2839
2819
  # as the current test requires
2840
 
  elsif (! dtr_same_opts($master->[0]->{'start_opts'},
 
2820
  elsif (! mtr_same_opts($master->[0]->{'start_opts'},
2841
2821
                         $tinfo->{'master_opt'}) )
2842
2822
  {
2843
2823
    # Chech that diff is binlog format only
2844
 
    my $diff_opts= dtr_diff_opts($master->[0]->{'start_opts'},$tinfo->{'master_opt'});
 
2824
    my $diff_opts= mtr_diff_opts($master->[0]->{'start_opts'},$tinfo->{'master_opt'});
2845
2825
    if (scalar(@$diff_opts) eq 2) 
2846
2826
    {
2847
 
      $do_restart= 1;
 
2827
      $do_restart= 1 unless ($diff_opts->[0] =~/^--binlog-format=/ and $diff_opts->[1] =~/^--binlog-format=/);
2848
2828
    }
2849
2829
    else
2850
2830
    {
2851
2831
      $do_restart= 1;
2852
 
      dtr_verbose("Restart master: running with different options '" .
 
2832
      mtr_verbose("Restart master: running with different options '" .
2853
2833
                 join(" ", @{$tinfo->{'master_opt'}}) . "' != '" .
2854
2834
                join(" ", @{$master->[0]->{'start_opts'}}) . "'" );
2855
2835
    }
2859
2839
    if ( $opt_extern )
2860
2840
    {
2861
2841
      $do_restart= 0;
2862
 
      dtr_verbose("No restart: using extern master");
 
2842
      mtr_verbose("No restart: using extern master");
2863
2843
    }
2864
2844
    else
2865
2845
    {
2866
2846
      $do_restart= 1;
2867
 
      dtr_verbose("Restart master: master is not started");
 
2847
      mtr_verbose("Restart master: master is not started");
2868
2848
    }
2869
2849
  }
2870
2850
  return $do_restart;
2879
2859
 
2880
2860
  if ( $max_slave_num == 0)
2881
2861
  {
2882
 
    dtr_verbose("Skip slave restart: No testcase use slaves");
 
2862
    mtr_verbose("Skip slave restart: No testcase use slaves");
2883
2863
  }
2884
2864
  else
2885
2865
  {
2886
2866
 
2887
2867
    # Check if any slave is currently started
2888
2868
    my $any_slave_started= 0;
2889
 
    foreach my $drizzled (@{$slave})
 
2869
    foreach my $mysqld (@{$slave})
2890
2870
    {
2891
 
      if ( $drizzled->{'pid'} )
 
2871
      if ( $mysqld->{'pid'} )
2892
2872
      {
2893
2873
        $any_slave_started= 1;
2894
2874
        last;
2897
2877
 
2898
2878
    if ($any_slave_started)
2899
2879
    {
2900
 
      dtr_verbose("Restart slave: Slave is started, always restart");
 
2880
      mtr_verbose("Restart slave: Slave is started, always restart");
2901
2881
      $do_slave_restart= 1;
2902
2882
    }
2903
2883
    elsif ( $tinfo->{'slave_num'} )
2904
2884
    {
2905
 
      dtr_verbose("Restart slave: Test need slave");
 
2885
      mtr_verbose("Restart slave: Test need slave");
2906
2886
      $do_slave_restart= 1;
2907
2887
    }
2908
2888
  }
2936
2916
    delete $master->[0]->{'running_master_options'}; # Forget history
2937
2917
 
2938
2918
    # Start shutdown of all started masters
2939
 
    foreach my $drizzled (@{$master})
 
2919
    foreach my $mysqld (@{$master})
2940
2920
    {
2941
 
      if ( $drizzled->{'pid'} )
 
2921
      if ( $mysqld->{'pid'} )
2942
2922
      {
2943
 
        $pid= dtr_server_shutdown($drizzled);
2944
 
 
2945
 
        $admin_pids{$pid}= 1;
2946
 
 
2947
 
        push(@kill_pids,{
2948
 
              pid      => $drizzled->{'pid'},
2949
 
              real_pid => $drizzled->{'real_pid'},
2950
 
              pidfile  => $drizzled->{'path_pid'},
2951
 
              sockfile => $drizzled->{'path_sock'},
2952
 
              port     => $drizzled->{'port'},
2953
 
              errfile   => $drizzled->{'path_myerr'},
2954
 
        });
2955
 
 
2956
 
        $drizzled->{'pid'}= 0; # Assume we are done with it
 
2923
        $pid= mtr_mysqladmin_start($mysqld, "shutdown", 20);
 
2924
 
 
2925
        $admin_pids{$pid}= 1;
 
2926
 
 
2927
        push(@kill_pids,{
 
2928
                         pid      => $mysqld->{'pid'},
 
2929
                         real_pid => $mysqld->{'real_pid'},
 
2930
                         pidfile  => $mysqld->{'path_pid'},
 
2931
                         sockfile => $mysqld->{'path_sock'},
 
2932
                         port     => $mysqld->{'port'},
 
2933
                         errfile   => $mysqld->{'path_myerr'},
 
2934
                        });
 
2935
 
 
2936
        $mysqld->{'pid'}= 0; # Assume we are done with it
2957
2937
      }
2958
2938
    }
2959
2939
  }
2964
2944
    delete $slave->[0]->{'running_slave_options'}; # Forget history
2965
2945
 
2966
2946
    # Start shutdown of all started slaves
2967
 
    foreach my $drizzled (@{$slave})
 
2947
    foreach my $mysqld (@{$slave})
2968
2948
    {
2969
 
      if ( $drizzled->{'pid'} )
 
2949
      if ( $mysqld->{'pid'} )
2970
2950
      {
2971
 
        $pid= dtr_server_shutdown($drizzled);
2972
 
 
2973
 
        $admin_pids{$pid}= 1;
2974
 
 
2975
 
        push(@kill_pids,{
2976
 
              pid      => $drizzled->{'pid'},
2977
 
              real_pid => $drizzled->{'real_pid'},
2978
 
              pidfile  => $drizzled->{'path_pid'},
2979
 
              sockfile => $drizzled->{'path_sock'},
2980
 
              port     => $drizzled->{'port'},
2981
 
              errfile  => $drizzled->{'path_myerr'},
2982
 
        });
2983
 
 
2984
 
        $drizzled->{'pid'}= 0; # Assume we are done with it
 
2951
        $pid= mtr_mysqladmin_start($mysqld, "shutdown", 20);
 
2952
 
 
2953
        $admin_pids{$pid}= 1;
 
2954
 
 
2955
        push(@kill_pids,{
 
2956
                         pid      => $mysqld->{'pid'},
 
2957
                         real_pid => $mysqld->{'real_pid'},
 
2958
                         pidfile  => $mysqld->{'path_pid'},
 
2959
                         sockfile => $mysqld->{'path_sock'},
 
2960
                         port     => $mysqld->{'port'},
 
2961
                         errfile   => $mysqld->{'path_myerr'},
 
2962
                        });
 
2963
 
 
2964
 
 
2965
        $mysqld->{'pid'}= 0; # Assume we are done with it
2985
2966
      }
2986
2967
    }
2987
2968
  }
2992
2973
  # ----------------------------------------------------------------------
2993
2974
 
2994
2975
  # Wait blocking until all shutdown processes has completed
2995
 
  dtr_wait_blocking(\%admin_pids);
 
2976
  mtr_wait_blocking(\%admin_pids);
2996
2977
 
2997
2978
 
2998
2979
  # Make sure that process has shutdown else try to kill them
2999
 
  dtr_check_stop_servers(\@kill_pids);
 
2980
  mtr_check_stop_servers(\@kill_pids);
3000
2981
}
3001
2982
 
3002
2983
 
3014
2995
  my $tinfo= shift;
3015
2996
  my $tname= $tinfo->{'name'};
3016
2997
 
3017
 
  if ( $tinfo->{'component_id'} eq 'drizzled' )
 
2998
  if ( $tinfo->{'component_id'} eq 'mysqld' )
3018
2999
  {
3019
3000
    if ( !$master->[0]->{'pid'} )
3020
3001
    {
3021
 
      # Master drizzled is not started
 
3002
      # Master mysqld is not started
3022
3003
      do_before_start_master($tinfo);
3023
3004
 
3024
 
      drizzled_start($master->[0],$tinfo->{'master_opt'},[]);
 
3005
      mysqld_start($master->[0],$tinfo->{'master_opt'},[]);
3025
3006
 
3026
3007
    }
3027
3008
 
3042
3023
    {
3043
3024
      if ( ! $slave->[$idx]->{'pid'} )
3044
3025
      {
3045
 
        drizzled_start($slave->[$idx],$tinfo->{'slave_opt'},
 
3026
        mysqld_start($slave->[$idx],$tinfo->{'slave_opt'},
3046
3027
                     $tinfo->{'slave_mi'});
3047
3028
 
3048
3029
      }
3052
3033
    $slave->[0]->{'running_slave_options'}= $tinfo;
3053
3034
  }
3054
3035
 
3055
 
  # Wait for drizzled's to start
3056
 
  foreach my $drizzled (@{$master},@{$slave})
 
3036
  # Wait for mysqld's to start
 
3037
  foreach my $mysqld (@{$master},@{$slave})
3057
3038
  {
3058
3039
 
3059
 
    next if !$drizzled->{'pid'};
 
3040
    next if !$mysqld->{'pid'};
3060
3041
 
3061
 
    if (drizzled_wait_started($drizzled))
 
3042
    if (mysqld_wait_started($mysqld))
3062
3043
    {
3063
3044
      # failed to start
3064
3045
      $tinfo->{'comment'}=
3065
 
        "Failed to start $drizzled->{'type'} drizzled $drizzled->{'idx'}";
 
3046
        "Failed to start $mysqld->{'type'} mysqld $mysqld->{'idx'}";
3066
3047
      return 1;
3067
3048
    }
3068
3049
  }
3081
3062
sub run_check_testcase ($$) {
3082
3063
 
3083
3064
  my $mode=     shift;
3084
 
  my $drizzled=   shift;
 
3065
  my $mysqld=   shift;
3085
3066
 
3086
 
  my $name= "check-" . $drizzled->{'type'} . $drizzled->{'idx'};
 
3067
  my $name= "check-" . $mysqld->{'type'} . $mysqld->{'idx'};
3087
3068
 
3088
3069
  my $args;
3089
 
  dtr_init_args(\$args);
3090
 
 
3091
 
  dtr_add_arg($args, "--no-defaults");
3092
 
  dtr_add_arg($args, "--silent");
3093
 
  dtr_add_arg($args, "--tmpdir=%s", $opt_tmpdir);
3094
 
 
3095
 
  dtr_add_arg($args, "--port=%d", $drizzled->{'port'});
3096
 
  dtr_add_arg($args, "--database=test");
3097
 
  dtr_add_arg($args, "--user=%s", $opt_user);
3098
 
  dtr_add_arg($args, "--password=");
3099
 
 
3100
 
  dtr_add_arg($args, "-R");
3101
 
  dtr_add_arg($args, "$opt_vardir/tmp/$name.result");
 
3070
  mtr_init_args(\$args);
 
3071
 
 
3072
  mtr_add_arg($args, "--no-defaults");
 
3073
  mtr_add_arg($args, "--silent");
 
3074
  mtr_add_arg($args, "--tmpdir=%s", $opt_tmpdir);
 
3075
 
 
3076
  mtr_add_arg($args, "--port=%d", $mysqld->{'port'});
 
3077
  mtr_add_arg($args, "--database=test");
 
3078
  mtr_add_arg($args, "--user=%s", $opt_user);
 
3079
  mtr_add_arg($args, "--password=");
 
3080
 
 
3081
  mtr_add_arg($args, "-R");
 
3082
  mtr_add_arg($args, "$opt_vardir/tmp/$name.result");
3102
3083
 
3103
3084
  if ( $mode eq "before" )
3104
3085
  {
3105
 
    dtr_add_arg($args, "--record");
3106
 
  }
3107
 
 
3108
 
  if ( $opt_testdir )
3109
 
  {
3110
 
    dtr_add_arg($args, "--testdir=%s", $opt_testdir);
3111
 
  }
3112
 
 
3113
 
  my $res = dtr_run_test($exe_drizzletest,$args,
 
3086
    mtr_add_arg($args, "--record");
 
3087
  }
 
3088
 
 
3089
  my $res = mtr_run_test($exe_drizzletest,$args,
3114
3090
                "include/check-testcase.test", "", "", "");
3115
3091
 
3116
3092
  if ( $res == 1  and $mode eq "after")
3117
3093
  {
3118
 
    dtr_run("diff",["-u",
 
3094
    mtr_run("diff",["-u",
3119
3095
                    "$opt_vardir/tmp/$name.result",
3120
3096
                    "$opt_vardir/tmp/$name.reject"],
3121
3097
            "", "", "", "");
3122
3098
  }
3123
3099
  elsif ( $res )
3124
3100
  {
3125
 
    dtr_error("Could not execute 'check-testcase' $mode testcase");
 
3101
    mtr_error("Could not execute 'check-testcase' $mode testcase");
3126
3102
  }
3127
3103
  return $res;
3128
3104
}
3137
3113
  my $args;
3138
3114
 
3139
3115
  {
3140
 
    drizzled_start($master->[0],[],[]);
 
3116
    mysqld_start($master->[0],[],[]);
3141
3117
    if ( ! $master->[0]->{'pid'} )
3142
3118
    {
3143
 
      dtr_error("Can't start the drizzled server");
 
3119
      mtr_error("Can't start the mysqld server");
3144
3120
    }
3145
 
    drizzled_wait_started($master->[0]);
 
3121
    mysqld_wait_started($master->[0]);
3146
3122
  }
3147
3123
 
3148
3124
  my $tinfo = {};
3149
3125
  $tinfo->{'name'} = 'report features';
3150
3126
  $tinfo->{'result_file'} = undef;
3151
 
  $tinfo->{'component_id'} = 'drizzled';
 
3127
  $tinfo->{'component_id'} = 'mysqld';
3152
3128
  $tinfo->{'path'} = 'include/report-features.test';
3153
3129
  $tinfo->{'timezone'}=  "GMT-3";
3154
3130
  $tinfo->{'slave_num'} = 0;
3169
3145
  my $exe= $exe_drizzletest;
3170
3146
  my $args;
3171
3147
 
3172
 
  dtr_init_args(\$args);
 
3148
  mtr_init_args(\$args);
3173
3149
 
3174
 
  dtr_add_arg($args, "--no-defaults");
3175
 
  dtr_add_arg($args, "--silent");
3176
 
  dtr_add_arg($args, "--tmpdir=%s", $opt_tmpdir);
3177
 
  dtr_add_arg($args, "--logdir=%s/log", $opt_vardir);
 
3150
  mtr_add_arg($args, "--no-defaults");
 
3151
  mtr_add_arg($args, "--silent");
 
3152
  mtr_add_arg($args, "--tmpdir=%s", $opt_tmpdir);
 
3153
  mtr_add_arg($args, "--logdir=%s/log", $opt_vardir);
3178
3154
 
3179
3155
  # Log line number and time  for each line in .test file
3180
 
  dtr_add_arg($args, "--mark-progress")
 
3156
  mtr_add_arg($args, "--mark-progress")
3181
3157
    if $opt_mark_progress;
3182
3158
 
3183
3159
  {
3184
 
    dtr_add_arg($args, "--port=%d", $master->[0]->{'port'});
3185
 
    dtr_add_arg($args, "--database=test");
3186
 
    dtr_add_arg($args, "--user=%s", $opt_user);
3187
 
    dtr_add_arg($args, "--password=");
 
3160
    mtr_add_arg($args, "--port=%d", $master->[0]->{'port'});
 
3161
    mtr_add_arg($args, "--database=test");
 
3162
    mtr_add_arg($args, "--user=%s", $opt_user);
 
3163
    mtr_add_arg($args, "--password=");
3188
3164
  }
3189
3165
 
3190
3166
  if ( $opt_strace_client )
3191
3167
  {
3192
3168
    $exe=  "strace";            # FIXME there are ktrace, ....
3193
 
    dtr_add_arg($args, "-o");
3194
 
    dtr_add_arg($args, "%s/log/drizzletest.strace", $opt_vardir);
3195
 
    dtr_add_arg($args, "$exe_drizzletest");
 
3169
    mtr_add_arg($args, "-o");
 
3170
    mtr_add_arg($args, "%s/log/drizzletest.strace", $opt_vardir);
 
3171
    mtr_add_arg($args, "$exe_drizzletest");
3196
3172
  }
3197
3173
 
3198
3174
  if ( $opt_timer )
3199
3175
  {
3200
 
    dtr_add_arg($args, "--timer-file=%s/log/timer", $opt_vardir);
 
3176
    mtr_add_arg($args, "--timer-file=%s/log/timer", $opt_vardir);
3201
3177
  }
3202
3178
 
3203
3179
  if ( $opt_compress )
3204
3180
  {
3205
 
    dtr_add_arg($args, "--compress");
 
3181
    mtr_add_arg($args, "--compress");
3206
3182
  }
3207
3183
 
3208
3184
  if ( $opt_sleep )
3209
3185
  {
3210
 
    dtr_add_arg($args, "--sleep=%d", $opt_sleep);
 
3186
    mtr_add_arg($args, "--sleep=%d", $opt_sleep);
3211
3187
  }
3212
3188
 
3213
3189
  if ( $opt_debug )
3214
3190
  {
3215
 
    dtr_add_arg($args, "--debug=d:t:A,%s/log/drizzletest.trace",
 
3191
    mtr_add_arg($args, "--debug=d:t:A,%s/log/drizzletest.trace",
3216
3192
                $path_vardir_trace);
3217
3193
  }
3218
3194
 
3219
 
  if ( $opt_testdir )
3220
 
  {
3221
 
    dtr_add_arg($args, "--testdir=%s", $opt_testdir);
3222
 
  }
3223
 
 
3224
 
 
3225
3195
  # ----------------------------------------------------------------------
3226
3196
  # export DRIZZLE_TEST variable containing <path>/drizzletest <args>
3227
3197
  # ----------------------------------------------------------------------
3228
3198
  $ENV{'DRIZZLE_TEST'}=
3229
 
    dtr_native_path($exe_drizzletest) . " " . join(" ", @$args);
 
3199
    mtr_native_path($exe_drizzletest) . " " . join(" ", @$args);
3230
3200
 
3231
3201
  # ----------------------------------------------------------------------
3232
3202
  # Add arguments that should not go into the DRIZZLE_TEST env var
3238
3208
    # We do this here, since we do not want to Valgrind the nested invocations
3239
3209
    # of drizzletest; that would mess up the stderr output causing test failure.
3240
3210
    my @args_saved = @$args;
3241
 
    dtr_init_args(\$args);
 
3211
    mtr_init_args(\$args);
3242
3212
    valgrind_arguments($args, \$exe);
3243
 
    dtr_add_arg($args, "%s", $_) for @args_saved;
 
3213
    mtr_add_arg($args, "%s", $_) for @args_saved;
3244
3214
  }
3245
3215
 
3246
 
  dtr_add_arg($args, "--test-file=%s", $tinfo->{'path'});
 
3216
  mtr_add_arg($args, "--test-file=%s", $tinfo->{'path'});
3247
3217
 
3248
3218
  # Number of lines of resut to include in failure report
3249
 
  dtr_add_arg($args, "--tail-lines=20");
 
3219
  mtr_add_arg($args, "--tail-lines=20");
3250
3220
 
3251
3221
  if ( defined $tinfo->{'result_file'} ) {
3252
 
    dtr_add_arg($args, "--result-file=%s", $tinfo->{'result_file'});
 
3222
    mtr_add_arg($args, "--result-file=%s", $tinfo->{'result_file'});
3253
3223
  }
3254
3224
 
3255
3225
  if ( $opt_record )
3256
3226
  {
3257
 
    dtr_add_arg($args, "--record");
 
3227
    mtr_add_arg($args, "--record");
3258
3228
  }
3259
3229
 
3260
3230
  if ( $opt_client_gdb )
3272
3242
 
3273
3243
  if ( $opt_check_testcases )
3274
3244
  {
3275
 
    foreach my $drizzled (@{$master}, @{$slave})
 
3245
    foreach my $mysqld (@{$master}, @{$slave})
3276
3246
    {
3277
 
      if ($drizzled->{'pid'})
 
3247
      if ($mysqld->{'pid'})
3278
3248
      {
3279
 
        run_check_testcase("before", $drizzled);
 
3249
        run_check_testcase("before", $mysqld);
3280
3250
      }
3281
3251
    }
3282
3252
  }
3283
3253
 
3284
 
  my $res = dtr_run_test($exe,$args,"","",$path_timefile,"");
 
3254
  my $res = mtr_run_test($exe,$args,"","",$path_timefile,"");
3285
3255
 
3286
3256
  if ( $opt_check_testcases )
3287
3257
  {
3288
 
    foreach my $drizzled (@{$master}, @{$slave})
 
3258
    foreach my $mysqld (@{$master}, @{$slave})
3289
3259
    {
3290
 
      if ($drizzled->{'pid'})
 
3260
      if ($mysqld->{'pid'})
3291
3261
      {
3292
 
        if (run_check_testcase("after", $drizzled))
 
3262
        if (run_check_testcase("after", $mysqld))
3293
3263
        {
3294
3264
          # Check failed, mark the test case with that info
3295
3265
          $tinfo->{'check_testcase_failed'}= 1;
3302
3272
 
3303
3273
}
3304
3274
 
3305
 
#
3306
 
# Modify the exe and args so that program is run in gdb in xterm
3307
 
#
3308
 
sub dbx_arguments {
3309
 
  my $args= shift;
3310
 
  my $exe=  shift;
3311
 
  my $type= shift;
3312
 
 
3313
 
  # Write $args to gdb init file
3314
 
  my $str= join(" ", @$$args);
3315
 
  my $dbx_init_file= "$opt_tmpdir/dbxinit.$type";
3316
 
 
3317
 
  # Remove the old gdbinit file
3318
 
  unlink($dbx_init_file);
3319
 
  if ( $type eq "client" )
3320
 
  {
3321
 
    # write init file for client
3322
 
    dtr_tofile($dbx_init_file,
3323
 
               "runargs $str\n" .
3324
 
               "run\n");
3325
 
  }
3326
 
  else
3327
 
  {
3328
 
    # write init file for drizzled
3329
 
    dtr_tofile($dbx_init_file,
3330
 
               "stop in __1cIdrizzledLparse6Fpn0AHSession_pkcI_v_\n" .
3331
 
               "runargs $str\n" .
3332
 
               "run\n" .
3333
 
               "\n");
3334
 
  }
3335
 
 
3336
 
  if ( $opt_manual_dbx )
3337
 
  {
3338
 
     print "\nTo start dbx for $type, type in another window:\n";
3339
 
     print "dbx -c 'source $dbx_init_file' $$exe\n";
3340
 
 
3341
 
     # Indicate the exe should not be started
3342
 
     $$exe= undef;
3343
 
     return;
3344
 
  }
3345
 
 
3346
 
  $$args= [];
3347
 
  dtr_add_arg($$args, "-title");
3348
 
  dtr_add_arg($$args, "$type");
3349
 
  dtr_add_arg($$args, "-e");
3350
 
 
3351
 
  dtr_add_arg($$args, "dbx");
3352
 
  dtr_add_arg($$args, "-c");
3353
 
  dtr_add_arg($$args, "source $dbx_init_file");
3354
 
  dtr_add_arg($$args, "$$exe");
3355
 
 
3356
 
  $$exe= "xterm";
3357
 
}
3358
3275
 
3359
3276
#
3360
3277
# Modify the exe and args so that program is run in gdb in xterm
3363
3280
  my $args= shift;
3364
3281
  my $exe=  shift;
3365
3282
  my $type= shift;
3366
 
  # We add needed, extra lines to gdbinit on OS X
3367
 
  my $extra_gdb_init = '' ;
3368
 
  if ($^O eq 'darwin')
3369
 
  {
3370
 
    $extra_gdb_init= "set env DYLD_INSERT_LIBRARIES /usr/lib/libgmalloc.dylib\n".
3371
 
                 "set env MallocStackLogging 1\n".
3372
 
                 "set env MallocScribble 1\n".
3373
 
                 "set env MallocPreScribble 1\n".
3374
 
                 "set env MallocStackLogging 1\n".
3375
 
                 "set env MallocStackLoggingNoCompact 1\n".
3376
 
                 "set env MallocGuardEdges 1\n" ;
3377
 
  }
3378
3283
 
3379
3284
  # Write $args to gdb init file
3380
3285
  my $str= join(" ", @$$args);
3386
3291
  if ( $type eq "client" )
3387
3292
  {
3388
3293
    # write init file for client
3389
 
    dtr_tofile($gdb_init_file,
 
3294
    mtr_tofile($gdb_init_file,
3390
3295
               "set args $str\n" .
3391
 
               "$extra_gdb_init" .
3392
3296
               "break main\n");
3393
3297
  }
3394
3298
  else
3395
3299
  {
3396
 
    # write init file for drizzled
3397
 
    dtr_tofile($gdb_init_file,
 
3300
    # write init file for mysqld
 
3301
    mtr_tofile($gdb_init_file,
3398
3302
               "set args $str\n" .
3399
 
               "$extra_gdb_init" .
3400
 
               "set breakpoint pending on\n" .
3401
 
               "break drizzled::parse\n" .
 
3303
               "break mysql_parse\n" .
3402
3304
               "commands 1\n" .
3403
3305
               "disable 1\n" .
3404
3306
               "end\n" .
3405
 
               "set breakpoint pending off\n" .
3406
3307
               "run");
3407
3308
  }
3408
3309
 
3409
3310
  if ( $opt_manual_gdb )
3410
3311
  {
3411
3312
     print "\nTo start gdb for $type, type in another window:\n";
3412
 
     print "$glob_drizzle_test_dir/../libtool --mode=execute gdb -cd $glob_drizzle_test_dir -x $gdb_init_file $$exe\n";
 
3313
     print "gdb -cd $glob_mysql_test_dir -x $gdb_init_file $$exe\n";
3413
3314
 
3414
3315
     # Indicate the exe should not be started
3415
3316
     $$exe= undef;
3417
3318
  }
3418
3319
 
3419
3320
  $$args= [];
3420
 
  dtr_add_arg($$args, "-title");
3421
 
  dtr_add_arg($$args, "$type");
3422
 
  dtr_add_arg($$args, "-e");
 
3321
  mtr_add_arg($$args, "-title");
 
3322
  mtr_add_arg($$args, "$type");
 
3323
  mtr_add_arg($$args, "-e");
3423
3324
 
3424
3325
  if ( $exe_libtool )
3425
3326
  {
3426
 
    dtr_add_arg($$args, $exe_libtool);
3427
 
    dtr_add_arg($$args, "--mode=execute");
 
3327
    mtr_add_arg($$args, $exe_libtool);
 
3328
    mtr_add_arg($$args, "--mode=execute");
3428
3329
  }
3429
3330
 
3430
 
  dtr_add_arg($$args, "gdb");
3431
 
  dtr_add_arg($$args, "-x");
3432
 
  dtr_add_arg($$args, "$gdb_init_file");
3433
 
  dtr_add_arg($$args, "$$exe");
 
3331
  mtr_add_arg($$args, "gdb");
 
3332
  mtr_add_arg($$args, "-x");
 
3333
  mtr_add_arg($$args, "$gdb_init_file");
 
3334
  mtr_add_arg($$args, "$$exe");
3434
3335
 
3435
3336
  $$exe= "xterm";
3436
3337
}
3454
3355
  if ( $type eq "client" )
3455
3356
  {
3456
3357
    # write init file for client
3457
 
    dtr_tofile($gdb_init_file,
 
3358
    mtr_tofile($gdb_init_file,
3458
3359
               "set args $str\n" .
3459
3360
               "break main\n");
3460
3361
  }
3461
3362
  else
3462
3363
  {
3463
 
    # write init file for drizzled
3464
 
    dtr_tofile($gdb_init_file,
 
3364
    # write init file for mysqld
 
3365
    mtr_tofile($gdb_init_file,
3465
3366
               "file $$exe\n" .
3466
3367
               "set args $str\n" .
3467
 
               "break drizzled::parse\n" .
 
3368
               "break mysql_parse\n" .
3468
3369
               "commands 1\n" .
3469
3370
               "disable 1\n" .
3470
3371
               "end");
3473
3374
  if ( $opt_manual_ddd )
3474
3375
  {
3475
3376
     print "\nTo start ddd for $type, type in another window:\n";
3476
 
     print "ddd -cd $glob_drizzle_test_dir -x $gdb_init_file $$exe\n";
 
3377
     print "ddd -cd $glob_mysql_test_dir -x $gdb_init_file $$exe\n";
3477
3378
 
3478
3379
     # Indicate the exe should not be started
3479
3380
     $$exe= undef;
3485
3386
  if ( $exe_libtool )
3486
3387
  {
3487
3388
    $$exe= $exe_libtool;
3488
 
    dtr_add_arg($$args, "--mode=execute");
3489
 
    dtr_add_arg($$args, "ddd");
 
3389
    mtr_add_arg($$args, "--mode=execute");
 
3390
    mtr_add_arg($$args, "ddd");
3490
3391
  }
3491
3392
  else
3492
3393
  {
3493
3394
    $$exe= "ddd";
3494
3395
  }
3495
 
  dtr_add_arg($$args, "--command=$gdb_init_file");
3496
 
  dtr_add_arg($$args, "$save_exe");
 
3396
  mtr_add_arg($$args, "--command=$gdb_init_file");
 
3397
  mtr_add_arg($$args, "$save_exe");
3497
3398
}
3498
3399
 
3499
3400
 
3517
3418
    $$exe= $debugger;
3518
3419
 
3519
3420
  }
3520
 
  #elsif ( $debugger eq "dbx" )
3521
 
  #{
3522
 
  #  # xterm -e dbx -r exe arg1 .. argn
3523
 
#
3524
 
#    unshift(@$$args, $$exe);
3525
 
#    unshift(@$$args, "-r");
3526
 
#    unshift(@$$args, $debugger);
3527
 
#    unshift(@$$args, "-e");
3528
 
#
3529
 
#    $$exe= "xterm";
3530
 
#
3531
 
#  }
 
3421
  elsif ( $debugger eq "dbx" )
 
3422
  {
 
3423
    # xterm -e dbx -r exe arg1 .. argn
 
3424
 
 
3425
    unshift(@$$args, $$exe);
 
3426
    unshift(@$$args, "-r");
 
3427
    unshift(@$$args, $debugger);
 
3428
    unshift(@$$args, "-e");
 
3429
 
 
3430
    $$exe= "xterm";
 
3431
 
 
3432
  }
3532
3433
  else
3533
3434
  {
3534
 
    dtr_error("Unknown argument \"$debugger\" passed to --debugger");
 
3435
    mtr_error("Unknown argument \"$debugger\" passed to --debugger");
3535
3436
  }
3536
3437
}
3537
3438
 
3545
3446
 
3546
3447
  if ( $opt_callgrind)
3547
3448
  {
3548
 
    dtr_add_arg($args, "--tool=callgrind");
3549
 
  }
3550
 
  elsif ($opt_massif)
3551
 
  {
3552
 
    dtr_add_arg($args, "--tool=massif");
 
3449
    mtr_add_arg($args, "--tool=callgrind");
 
3450
    mtr_add_arg($args, "--base=$opt_vardir/log");
3553
3451
  }
3554
3452
  else
3555
3453
  {
3556
 
    dtr_add_arg($args, "--tool=memcheck"); # From >= 2.1.2 needs this option
3557
 
    dtr_add_arg($args, "--leak-check=yes");
3558
 
    dtr_add_arg($args, "--num-callers=16");
3559
 
    dtr_add_arg($args, "--suppressions=%s/valgrind.supp", $glob_drizzle_test_dir)
3560
 
      if -f "$glob_drizzle_test_dir/valgrind.supp";
 
3454
    mtr_add_arg($args, "--tool=memcheck"); # From >= 2.1.2 needs this option
 
3455
    mtr_add_arg($args, "--alignment=8");
 
3456
    mtr_add_arg($args, "--leak-check=yes");
 
3457
    mtr_add_arg($args, "--num-callers=16");
 
3458
    mtr_add_arg($args, "--suppressions=%s/valgrind.supp", $glob_mysql_test_dir)
 
3459
      if -f "$glob_mysql_test_dir/valgrind.supp";
3561
3460
  }
3562
3461
 
3563
3462
  # Add valgrind options, can be overriden by user
3564
 
  dtr_add_arg($args, '%s', $_) for (@valgrind_args);
 
3463
  mtr_add_arg($args, '%s', $_) for (@valgrind_args);
3565
3464
 
3566
 
  dtr_add_arg($args, $$exe);
 
3465
  mtr_add_arg($args, $$exe);
3567
3466
 
3568
3467
  $$exe= $opt_valgrind_path || "valgrind";
3569
3468
 
3577
3476
}
3578
3477
 
3579
3478
 
3580
 
sub drizzled_wait_started($){
3581
 
  my $drizzled= shift;
 
3479
sub mysqld_wait_started($){
 
3480
  my $mysqld= shift;
3582
3481
 
3583
 
  if (sleep_until_file_created($drizzled->{'path_pid'},
3584
 
            $drizzled->{'start_timeout'},
3585
 
            $drizzled->{'pid'}) == 0)
 
3482
  if (sleep_until_file_created($mysqld->{'path_pid'},
 
3483
            $mysqld->{'start_timeout'},
 
3484
            $mysqld->{'pid'}) == 0)
3586
3485
  {
3587
3486
    # Failed to wait for pid file
3588
3487
    return 1;
3590
3489
 
3591
3490
  # Get the "real pid" of the process, it will be used for killing
3592
3491
  # the process in ActiveState's perl on windows
3593
 
  $drizzled->{'real_pid'}= dtr_get_pid_from_file($drizzled->{'path_pid'});
 
3492
  $mysqld->{'real_pid'}= mtr_get_pid_from_file($mysqld->{'path_pid'});
3594
3493
 
3595
3494
  return 0;
3596
3495
}
3597
3496
 
3598
 
sub collapse_path ($) {
3599
 
 
3600
 
    my $c_path= rel2abs(shift);
3601
 
    my $updir  = updir($c_path);
3602
 
    my $curdir = curdir($c_path);
3603
 
 
3604
 
    my($vol, $dirs, $file) = splitpath($c_path);
3605
 
    my @dirs = splitdir($dirs);
3606
 
 
3607
 
    my @collapsed;
3608
 
    foreach my $dir (@dirs) {
3609
 
        if( $dir eq $updir              and   # if we have an updir
3610
 
            @collapsed                  and   # and something to collapse
3611
 
            length $collapsed[-1]       and   # and its not the rootdir
3612
 
            $collapsed[-1] ne $updir    and   # nor another updir
3613
 
            $collapsed[-1] ne $curdir         # nor the curdir
3614
 
          )
3615
 
        {                                     # then
3616
 
            pop @collapsed;                   # collapse
3617
 
        }
3618
 
        else {                                # else
3619
 
            push @collapsed, $dir;            # just hang onto it
3620
 
        }
3621
 
    }
3622
 
 
3623
 
    return catpath($vol, catdir(@collapsed), $file);
3624
 
}
3625
3497
 
3626
3498
##############################################################################
3627
3499
#
3660
3532
                        using a builtin list of standard locations
3661
3533
                        for tmpfs (/dev/shm)
3662
3534
                        The option can also be set using environment
3663
 
                        variable DTR_MEM=[DIR]
 
3535
                        variable MTR_MEM=[DIR]
3664
3536
 
3665
3537
Options to control what test suites or cases to run
3666
3538
 
3676
3548
                        list of suite names.
3677
3549
                        The default is: "$opt_suites_default"
3678
3550
  skip-rpl              Skip the replication test cases.
3679
 
  combination="ARG1 .. ARG2" Specify a set of "drizzled" arguments for one
 
3551
  big-test              Set the environment variable BIG_TEST, which can be
 
3552
                        checked from test cases.
 
3553
  combination="ARG1 .. ARG2" Specify a set of "mysqld" arguments for one
3680
3554
                        combination.
3681
3555
  skip-combination      Skip any combination options and combinations files
3682
 
  repeat-test=n         How many times to repeat each test (default: 1)
3683
3556
 
3684
3557
Options that specify ports
3685
3558
 
3686
3559
  master_port=PORT      Specify the port number used by the first master
3687
3560
  slave_port=PORT       Specify the port number used by the first slave
3688
 
  dtr-build-thread=#    Specify unique collection of ports. Can also be set by
3689
 
                        setting the environment variable DTR_BUILD_THREAD.
 
3561
  mtr-build-thread=#    Specify unique collection of ports. Can also be set by
 
3562
                        setting the environment variable MTR_BUILD_THREAD.
3690
3563
 
3691
3564
Options for test case authoring
3692
3565
 
3696
3569
 
3697
3570
Options that pass on options
3698
3571
 
3699
 
  drizzled=ARGS           Specify additional arguments to "drizzled"
 
3572
  mysqld=ARGS           Specify additional arguments to "mysqld"
3700
3573
 
3701
3574
Options to run test on running server
3702
3575
 
3708
3581
  client-ddd            Start drizzletest client in ddd
3709
3582
  client-debugger=NAME  Start drizzletest in the selected debugger
3710
3583
  client-gdb            Start drizzletest client in gdb
3711
 
  ddd                   Start drizzled in ddd
 
3584
  ddd                   Start mysqld in ddd
3712
3585
  debug                 Dump trace output for all servers and client programs
3713
 
  debugger=NAME         Start drizzled in the selected debugger
3714
 
  gdb                   Start the drizzled(s) in gdb
3715
 
  manual-debug          Let user manually start drizzled in debugger, before
 
3586
  debugger=NAME         Start mysqld in the selected debugger
 
3587
  gdb                   Start the mysqld(s) in gdb
 
3588
  manual-debug          Let user manually start mysqld in debugger, before
3716
3589
                        running test(s)
3717
 
  manual-gdb            Let user manually start drizzled in gdb, before running
3718
 
                        test(s)
3719
 
  manual-ddd            Let user manually start drizzled in ddd, before running
3720
 
                        test(s)
3721
 
  master-binary=PATH    Specify the master "drizzled" to use
3722
 
  slave-binary=PATH     Specify the slave "drizzled" to use
 
3590
  manual-gdb            Let user manually start mysqld in gdb, before running
 
3591
                        test(s)
 
3592
  manual-ddd            Let user manually start mysqld in ddd, before running
 
3593
                        test(s)
 
3594
  master-binary=PATH    Specify the master "mysqld" to use
 
3595
  slave-binary=PATH     Specify the slave "mysqld" to use
3723
3596
  strace-client         Create strace output for drizzletest client
3724
3597
  max-save-core         Limit the number of core files saved (to avoid filling
3725
3598
                        up disks for heavily crashing server). Defaults to
3729
3602
 
3730
3603
  gcov                  FIXME
3731
3604
  gprof                 See online documentation on how to use it.
3732
 
  valgrind              Run the "drizzletest" and "drizzled" executables using
 
3605
  valgrind              Run the "drizzletest" and "mysqld" executables using
3733
3606
                        valgrind with default options
3734
3607
  valgrind-all          Synonym for --valgrind
3735
 
  valgrind-drizzleslap  Run "drizzleslap" with valgrind.
3736
 
  valgrind-drizzletest  Run the "drizzletest" and "drizzle_client_test" executable
 
3608
  valgrind-drizzletest    Run the "drizzletest" and "drizzle_client_test" executable
3737
3609
                        with valgrind
3738
 
  valgrind-drizzled       Run the "drizzled" executable with valgrind
 
3610
  valgrind-mysqld       Run the "mysqld" executable with valgrind
3739
3611
  valgrind-options=ARGS Deprecated, use --valgrind-option
3740
3612
  valgrind-option=ARGS  Option to give valgrind, replaces default option(s),
3741
3613
                        can be specified more then once
3742
3614
  valgrind-path=[EXE]   Path to the valgrind executable
3743
3615
  callgrind             Instruct valgrind to use callgrind
3744
 
  massif                Instruct valgrind to use massif
3745
3616
 
3746
3617
Misc options
3747
3618
 
3759
3630
 
3760
3631
  testcase-timeout=MINUTES Max test case run time (default $default_testcase_timeout)
3761
3632
  suite-timeout=MINUTES Max test suite run time (default $default_suite_timeout)
3762
 
  warnings | log-warnings Pass --log-warnings to drizzled
 
3633
  warnings | log-warnings Pass --log-warnings to mysqld
3763
3634
 
3764
3635
  sleep=SECONDS         Passed to drizzletest, will be used as fixed sleep time
3765
3636
 
3766
3637
HERE
3767
 
  dtr_exit(1);
 
3638
  mtr_exit(1);
3768
3639
 
3769
3640
}