← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to tests/test-run.pl

  • Committer: Monty Taylor
  • Date: 2009-04-14 19:16:51 UTC
  • mto: (997.2.5 mordred)
  • mto: This revision was merged to the branch mainline in revision 994.
  • Revision ID: mordred@inaugust.com-20090414191651-ltbww6hpqks8k7qk
Clarified instructions in README.

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