← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to tests/test-run.pl

  • Committer: Lee
  • Date: 2009-01-01 17:36:53 UTC
  • mto: (758.1.3 devel)
  • mto: This revision was merged to the branch mainline in revision 759.
  • Revision ID: lbieber@lbieber-desktop-20090101173653-qo5945pnje5j3vuu
more header file cleanup

Show diffs side-by-side

added added

removed removed

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