← Back to branch summary

~ubuntu-branches/ubuntu/precise/mysql-5.1/precise

« back to all changes in this revision

Viewing changes to mysql-test/lib/My/ConfigFactory.pm

  • Committer: Bazaar Package Importer
  • Author(s): Norbert Tretkowski
  • Date: 2010-03-17 14:56:02 UTC
  • Revision ID: james.westby@ubuntu.com-20100317145602-x7e30l1b2sb5s6w6
Tags: upstream-5.1.45
Import upstream version 5.1.45

Show diffs side-by-side

added added

removed removed

Lines of Context:
mysql-test/lib/My/ConfigFactory.pm
 
1
# -*- cperl -*-
 
2
package My::ConfigFactory;
 
3
 
 
4
use strict;
 
5
use warnings;
 
6
use Carp;
 
7
 
 
8
use My::Config;
 
9
use My::Find;
 
10
use My::Platform;
 
11
 
 
12
use File::Basename;
 
13
 
 
14
 
 
15
#
 
16
# Rules to run first of all
 
17
#
 
18
my @pre_rules=
 
19
(
 
20
);
 
21
 
 
22
 
 
23
my @share_locations= ("share/mysql", "sql/share", "share");
 
24
 
 
25
 
 
26
sub get_basedir {
 
27
  my ($self, $group)= @_;
 
28
  my $basedir= $group->if_exist('basedir') ||
 
29
    $self->{ARGS}->{basedir};
 
30
  return $basedir;
 
31
}
 
32
 
 
33
 
 
34
sub fix_charset_dir {
 
35
  my ($self, $config, $group_name, $group)= @_;
 
36
  return my_find_dir($self->get_basedir($group),
 
37
                     \@share_locations, "charsets");
 
38
}
 
39
 
 
40
sub fix_language {
 
41
  my ($self, $config, $group_name, $group)= @_;
 
42
  return my_find_dir($self->get_basedir($group),
 
43
                     \@share_locations, "english");
 
44
}
 
45
 
 
46
sub fix_datadir {
 
47
  my ($self, $config, $group_name)= @_;
 
48
  my $vardir= $self->{ARGS}->{vardir};
 
49
  return "$vardir/$group_name/data";
 
50
}
 
51
 
 
52
sub fix_pidfile {
 
53
  my ($self, $config, $group_name, $group)= @_;
 
54
  my $vardir= $self->{ARGS}->{vardir};
 
55
  return "$vardir/run/$group_name.pid";
 
56
}
 
57
 
 
58
sub fix_port {
 
59
  my ($self, $config, $group_name, $group)= @_;
 
60
  my $hostname= $group->value('#host');
 
61
  return $self->{HOSTS}->{$hostname}++;
 
62
}
 
63
 
 
64
sub fix_host {
 
65
  my ($self)= @_;
 
66
  # Get next host from HOSTS array
 
67
  my @hosts= keys(%{$self->{HOSTS}});;
 
68
  my $host_no= $self->{NEXT_HOST}++ % @hosts;
 
69
  return $hosts[$host_no];
 
70
}
 
71
 
 
72
sub is_unique {
 
73
  my ($config, $name, $value)= @_;
 
74
 
 
75
  foreach my $group ( $config->groups() ) {
 
76
    if ($group->option($name)) {
 
77
      if ($group->value($name) eq $value){
 
78
        return 0;
 
79
      }
 
80
    }
 
81
  }
 
82
  return 1;
 
83
}
 
84
 
 
85
sub fix_server_id {
 
86
  my ($self, $config, $group_name, $group)= @_;
 
87
#define in the order that mysqlds are listed in my.cnf 
 
88
 
 
89
  my $server_id= $group->if_exist('server-id');
 
90
  if (defined $server_id){
 
91
    if (!is_unique($config, 'server-id', $server_id)) {
 
92
      croak "The server-id($server_id) for '$group_name' is not unique";
 
93
    }
 
94
    return $server_id;
 
95
  }
 
96
 
 
97
  do {
 
98
    $server_id= $self->{SERVER_ID}++;
 
99
  } while(!is_unique($config, 'server-id', $server_id));
 
100
 
 
101
  #print "$group_name: server_id: $server_id\n";
 
102
  return $server_id;
 
103
}
 
104
 
 
105
sub fix_socket {
 
106
  my ($self, $config, $group_name, $group)= @_;
 
107
  # Put socket file in tmpdir
 
108
  my $dir= $self->{ARGS}->{tmpdir};
 
109
  return "$dir/$group_name.sock";
 
110
}
 
111
 
 
112
sub fix_tmpdir {
 
113
  my ($self, $config, $group_name, $group)= @_;
 
114
  my $dir= $self->{ARGS}->{tmpdir};
 
115
  return "$dir/$group_name";
 
116
}
 
117
 
 
118
sub fix_log_error {
 
119
  my ($self, $config, $group_name, $group)= @_;
 
120
  my $dir= $self->{ARGS}->{vardir};
 
121
  return "$dir/log/$group_name.err";
 
122
}
 
123
 
 
124
sub fix_log {
 
125
  my ($self, $config, $group_name, $group)= @_;
 
126
  my $dir= dirname($group->value('datadir'));
 
127
  return "$dir/mysqld.log";
 
128
}
 
129
 
 
130
sub fix_log_slow_queries {
 
131
  my ($self, $config, $group_name, $group)= @_;
 
132
  my $dir= dirname($group->value('datadir'));
 
133
  return "$dir/mysqld-slow.log";
 
134
}
 
135
 
 
136
sub fix_secure_file_priv {
 
137
  my ($self)= @_;
 
138
  my $vardir= $self->{ARGS}->{vardir};
 
139
  # By default, prevent the started mysqld to access files outside of vardir
 
140
  return $vardir;
 
141
}
 
142
 
 
143
sub fix_std_data {
 
144
  my ($self, $config, $group_name, $group)= @_;
 
145
  my $basedir= $self->get_basedir($group);
 
146
  return "$basedir/mysql-test/std_data";
 
147
}
 
148
 
 
149
sub ssl_supported {
 
150
  my ($self)= @_;
 
151
  return $self->{ARGS}->{ssl};
 
152
}
 
153
 
 
154
sub fix_skip_ssl {
 
155
  return if !ssl_supported(@_);
 
156
  # Add skip-ssl if ssl is supported to avoid
 
157
  # that mysqltest connects with SSL by default
 
158
  return 1;
 
159
}
 
160
 
 
161
sub fix_ssl_ca {
 
162
  return if !ssl_supported(@_);
 
163
  my $std_data= fix_std_data(@_);
 
164
  return "$std_data/cacert.pem"
 
165
}
 
166
 
 
167
sub fix_ssl_server_cert {
 
168
  return if !ssl_supported(@_);
 
169
  my $std_data= fix_std_data(@_);
 
170
  return "$std_data/server-cert.pem"
 
171
}
 
172
 
 
173
sub fix_ssl_client_cert {
 
174
  return if !ssl_supported(@_);
 
175
  my $std_data= fix_std_data(@_);
 
176
  return "$std_data/client-cert.pem"
 
177
}
 
178
 
 
179
sub fix_ssl_server_key {
 
180
  return if !ssl_supported(@_);
 
181
  my $std_data= fix_std_data(@_);
 
182
  return "$std_data/server-key.pem"
 
183
}
 
184
 
 
185
sub fix_ssl_client_key {
 
186
  return if !ssl_supported(@_);
 
187
  my $std_data= fix_std_data(@_);
 
188
  return "$std_data/client-key.pem"
 
189
}
 
190
 
 
191
 
 
192
#
 
193
# Rules to run for each mysqld in the config
 
194
#  - will be run in order listed here
 
195
#
 
196
my @mysqld_rules=
 
197
  (
 
198
 { 'basedir' => sub { return shift->{ARGS}->{basedir}; } },
 
199
 { 'tmpdir' => \&fix_tmpdir },
 
200
 { 'character-sets-dir' => \&fix_charset_dir },
 
201
 { 'language' => \&fix_language },
 
202
 { 'datadir' => \&fix_datadir },
 
203
 { 'pid-file' => \&fix_pidfile },
 
204
 { '#host' => \&fix_host },
 
205
 { 'port' => \&fix_port },
 
206
 { 'socket' => \&fix_socket },
 
207
 { '#log-error' => \&fix_log_error },
 
208
 { 'general_log' => 1 },
 
209
 { 'general_log_file' => \&fix_log },
 
210
 { 'slow_query_log' => 1 },
 
211
 { 'slow_query_log_file' => \&fix_log_slow_queries },
 
212
 { '#user' => sub { return shift->{ARGS}->{user} || ""; } },
 
213
 { '#password' => sub { return shift->{ARGS}->{password} || ""; } },
 
214
 { 'server-id' => \&fix_server_id, },
 
215
 # By default, prevent the started mysqld to access files outside of vardir
 
216
 { 'secure-file-priv' => sub { return shift->{ARGS}->{vardir}; } },
 
217
 { 'ssl-ca' => \&fix_ssl_ca },
 
218
 { 'ssl-cert' => \&fix_ssl_server_cert },
 
219
 { 'ssl-key' => \&fix_ssl_server_key },
 
220
  );
 
221
 
 
222
if (IS_WINDOWS)
 
223
{
 
224
  # For simplicity, we use the same names for shared memory and 
 
225
  # named pipes.
 
226
  push(@mysqld_rules, {'shared-memory-base-name' => \&fix_socket});
 
227
}
 
228
 
 
229
sub fix_ndb_mgmd_port {
 
230
  my ($self, $config, $group_name, $group)= @_;
 
231
  my $hostname= $group->value('HostName');
 
232
  return $self->{HOSTS}->{$hostname}++;
 
233
}
 
234
 
 
235
 
 
236
sub fix_cluster_dir {
 
237
  my ($self, $config, $group_name, $group)= @_;
 
238
  my $vardir= $self->{ARGS}->{vardir};
 
239
  my (undef, $process_type, $idx, $suffix)= split(/\./, $group_name);
 
240
  return "$vardir/mysql_cluster.$suffix/$process_type.$idx";
 
241
}
 
242
 
 
243
 
 
244
sub fix_cluster_backup_dir {
 
245
  my ($self, $config, $group_name, $group)= @_;
 
246
  my $vardir= $self->{ARGS}->{vardir};
 
247
  my (undef, $process_type, $idx, $suffix)= split(/\./, $group_name);
 
248
  return "$vardir/mysql_cluster.$suffix/";
 
249
}
 
250
 
 
251
 
 
252
#
 
253
# Rules to run for each ndb_mgmd in the config
 
254
#  - will be run in order listed here
 
255
#
 
256
my @ndb_mgmd_rules=
 
257
(
 
258
 { 'PortNumber' => \&fix_ndb_mgmd_port },
 
259
 { 'DataDir' => \&fix_cluster_dir },
 
260
);
 
261
 
 
262
 
 
263
#
 
264
# Rules to run for each ndbd in the config
 
265
#  - will be run in order listed here
 
266
#
 
267
my @ndbd_rules=
 
268
(
 
269
 { 'HostName' => \&fix_host },
 
270
 { 'DataDir' => \&fix_cluster_dir },
 
271
 { 'BackupDataDir' => \&fix_cluster_backup_dir },
 
272
);
 
273
 
 
274
 
 
275
#
 
276
# Rules to run for each cluster_config section
 
277
#  - will be run in order listed here
 
278
#
 
279
my @cluster_config_rules=
 
280
(
 
281
 { 'ndb_mgmd' => \&fix_host },
 
282
 { 'ndbd' => \&fix_host },
 
283
 { 'mysqld' => \&fix_host },
 
284
 { 'ndbapi' => \&fix_host },
 
285
);
 
286
 
 
287
 
 
288
#
 
289
# Rules to run for [client] section
 
290
#  - will be run in order listed here
 
291
#
 
292
my @client_rules=
 
293
(
 
294
);
 
295
 
 
296
 
 
297
#
 
298
# Rules to run for [mysqltest] section
 
299
#  - will be run in order listed here
 
300
#
 
301
my @mysqltest_rules=
 
302
(
 
303
 { 'ssl-ca' => \&fix_ssl_ca },
 
304
 { 'ssl-cert' => \&fix_ssl_client_cert },
 
305
 { 'ssl-key' => \&fix_ssl_client_key },
 
306
 { 'skip-ssl' => \&fix_skip_ssl },
 
307
);
 
308
 
 
309
 
 
310
#
 
311
# Rules to run for [mysqlbinlog] section
 
312
#  - will be run in order listed here
 
313
#
 
314
my @mysqlbinlog_rules=
 
315
(
 
316
 { 'character-sets-dir' => \&fix_charset_dir },
 
317
);
 
318
 
 
319
 
 
320
#
 
321
# Rules to run for [mysql_upgrade] section
 
322
#  - will be run in order listed here
 
323
#
 
324
my @mysql_upgrade_rules=
 
325
(
 
326
 { 'tmpdir' => sub { return shift->{ARGS}->{tmpdir}; } },
 
327
);
 
328
 
 
329
 
 
330
#
 
331
# Generate a [client.<suffix>] group to be
 
332
# used for connecting to [mysqld.<suffix>]
 
333
#
 
334
sub post_check_client_group {
 
335
  my ($self, $config, $client_group_name, $mysqld_group_name)= @_;
 
336
 
 
337
  #  Settings needed for client, copied from its "mysqld"
 
338
  my %client_needs=
 
339
    (
 
340
     port       => 'port',
 
341
     socket     => 'socket',
 
342
     host       => '#host',
 
343
     user       => '#user',
 
344
     password   => '#password',
 
345
    );
 
346
 
 
347
  my $group_to_copy_from= $config->group($mysqld_group_name);
 
348
  while (my ($name_to, $name_from)= each( %client_needs )) {
 
349
    my $option= $group_to_copy_from->option($name_from);
 
350
 
 
351
    if (! defined $option){
 
352
      #print $config;
 
353
      croak "Could not get value for '$name_from'";
 
354
    }
 
355
    $config->insert($client_group_name, $name_to, $option->value())
 
356
  }
 
357
  
 
358
  if (IS_WINDOWS)
 
359
  {
 
360
    if (! $self->{ARGS}->{embedded})
 
361
    {
 
362
      # Shared memory base may or may not be defined (e.g not defined in embedded)
 
363
      my $shm = $group_to_copy_from->option("shared-memory-base-name");
 
364
      if (defined $shm)
 
365
      {
 
366
        $config->insert($client_group_name,"shared-memory-base-name", $shm->value());
 
367
      }
 
368
    }
 
369
  }
 
370
}
 
371
 
 
372
 
 
373
sub post_check_client_groups {
 
374
 my ($self, $config)= @_;
 
375
 
 
376
 my $first_mysqld= $config->first_like('mysqld.');
 
377
 
 
378
 return unless $first_mysqld;
 
379
 
 
380
 # Always generate [client] pointing to the first
 
381
 # [mysqld.<suffix>]
 
382
 $self->post_check_client_group($config,
 
383
                                'client',
 
384
                                $first_mysqld->name());
 
385
 
 
386
 # Then generate [client.<suffix>] for each [mysqld.<suffix>]
 
387
 foreach my $mysqld ( $config->like('mysqld.') ) {
 
388
   $self->post_check_client_group($config,
 
389
                                  'client'.$mysqld->after('mysqld'),
 
390
                                  $mysqld->name())
 
391
 }
 
392
 
 
393
}
 
394
 
 
395
 
 
396
#
 
397
# Generate [embedded] by copying the values
 
398
# needed from the default [mysqld] section
 
399
# and from first [mysqld.<suffix>]
 
400
#
 
401
sub post_check_embedded_group {
 
402
  my ($self, $config)= @_;
 
403
 
 
404
  return unless $self->{ARGS}->{embedded};
 
405
 
 
406
  my $mysqld= $config->group('mysqld') or
 
407
    croak "Can't run with embedded, config has no default mysqld section";
 
408
 
 
409
  my $first_mysqld= $config->first_like('mysqld.') or
 
410
    croak "Can't run with embedded, config has no mysqld";
 
411
 
 
412
  my @no_copy =
 
413
    (
 
414
     '#log-error', # Embedded server writes stderr to mysqltest's log file
 
415
     'slave-net-timeout', # Embedded server are not build with replication
 
416
     'shared-memory-base-name', # No shared memory for embedded
 
417
    );
 
418
 
 
419
  foreach my $option ( $mysqld->options(), $first_mysqld->options() ) {
 
420
    # Don't copy options whose name is in "no_copy" list
 
421
    next if grep ( $option->name() eq $_, @no_copy);
 
422
 
 
423
    $config->insert('embedded', $option->name(), $option->value())
 
424
  }
 
425
 
 
426
}
 
427
 
 
428
 
 
429
sub resolve_at_variable {
 
430
  my ($self, $config, $group, $option)= @_;
 
431
 
 
432
  # Split the options value on last .
 
433
  my @parts= split(/\./, $option->value());
 
434
  my $option_name= pop(@parts);
 
435
  my $group_name=  join('.', @parts);
 
436
 
 
437
  $group_name =~ s/^\@//; # Remove at
 
438
 
 
439
  my $from_group= $config->group($group_name)
 
440
    or croak "There is no group named '$group_name' that ",
 
441
      "can be used to resolve '$option_name'";
 
442
 
 
443
  my $from= $from_group->value($option_name);
 
444
  $config->insert($group->name(), $option->name(), $from)
 
445
}
 
446
 
 
447
 
 
448
sub post_fix_resolve_at_variables {
 
449
  my ($self, $config)= @_;
 
450
 
 
451
  foreach my $group ( $config->groups() ) {
 
452
    foreach my $option ( $group->options()) {
 
453
      next unless defined $option->value();
 
454
 
 
455
      $self->resolve_at_variable($config, $group, $option)
 
456
        if ($option->value() =~ /^\@/);
 
457
    }
 
458
  }
 
459
}
 
460
 
 
461
sub post_fix_mysql_cluster_section {
 
462
  my ($self, $config)= @_;
 
463
 
 
464
  # Add a [mysl_cluster.<suffix>] section for each
 
465
  # defined [cluster_config.<suffix>] section
 
466
  foreach my $group ( $config->like('cluster_config\.\w*$') )
 
467
  {
 
468
    my @urls;
 
469
    # Generate ndb_connectstring for this cluster
 
470
    foreach my $ndb_mgmd ( $config->like('cluster_config.ndb_mgmd.')) {
 
471
      if ($ndb_mgmd->suffix() eq $group->suffix()) {
 
472
        my $host= $ndb_mgmd->value('HostName');
 
473
        my $port= $ndb_mgmd->value('PortNumber');
 
474
        push(@urls, "$host:$port");
 
475
      }
 
476
    }
 
477
    croak "Could not generate valid ndb_connectstring for '$group'"
 
478
      unless @urls > 0;
 
479
    my $ndb_connectstring= join(";", @urls);
 
480
 
 
481
    # Add ndb_connectstring to [mysql_cluster.<suffix>]
 
482
    $config->insert('mysql_cluster'.$group->suffix(),
 
483
                    'ndb_connectstring', $ndb_connectstring);
 
484
 
 
485
    # Add ndb_connectstring to each mysqld connected to this
 
486
    # cluster
 
487
    foreach my $mysqld ( $config->like('cluster_config.mysqld.')) {
 
488
      if ($mysqld->suffix() eq $group->suffix()) {
 
489
        my $after= $mysqld->after('cluster_config.mysqld');
 
490
        $config->insert("mysqld$after",
 
491
                        'ndb_connectstring', $ndb_connectstring);
 
492
      }
 
493
    }
 
494
  }
 
495
}
 
496
 
 
497
#
 
498
# Rules to run last of all
 
499
#
 
500
my @post_rules=
 
501
(
 
502
 \&post_check_client_groups,
 
503
 \&post_fix_mysql_cluster_section,
 
504
 \&post_fix_resolve_at_variables,
 
505
 \&post_check_embedded_group,
 
506
);
 
507
 
 
508
 
 
509
sub run_rules_for_group {
 
510
  my ($self, $config, $group, @rules)= @_;
 
511
  foreach my $hash ( @rules ) {
 
512
    while (my ($option, $rule)= each( %{$hash} )) {
 
513
      # Only run this rule if the value is not already defined
 
514
      if (!$config->exists($group->name(), $option)) {
 
515
        my $value;
 
516
        if (ref $rule eq "CODE") {
 
517
          # Call the rule function
 
518
          $value= &$rule($self, $config, $group->name(),
 
519
                         $config->group($group->name()));
 
520
        } else {
 
521
          $value= $rule;
 
522
        }
 
523
        if (defined $value) {
 
524
          $config->insert($group->name(), $option, $value, 1);
 
525
        }
 
526
      }
 
527
    }
 
528
  }
 
529
}
 
530
 
 
531
 
 
532
sub run_section_rules {
 
533
  my ($self, $config, $name, @rules)= @_;
 
534
 
 
535
  foreach my $group ( $config->like($name) ) {
 
536
    $self->run_rules_for_group($config, $group, @rules);
 
537
  }
 
538
}
 
539
 
 
540
 
 
541
sub run_generate_sections_from_cluster_config {
 
542
  my ($self, $config)= @_;
 
543
 
 
544
  my @options= ('ndb_mgmd', 'ndbd',
 
545
                'mysqld', 'ndbapi');
 
546
 
 
547
  foreach my $group ( $config->like('cluster_config\.\w*$') ) {
 
548
 
 
549
    # Keep track of current index per process type
 
550
    my %idxes;
 
551
    map { $idxes{$_}= 1; } @options;
 
552
 
 
553
    foreach my $option_name ( @options ) {
 
554
      my $value= $group->value($option_name);
 
555
      my @hosts= split(/,/, $value, -1); # -1 => return also empty strings
 
556
 
 
557
      # Add at least one host
 
558
      push(@hosts, undef) unless scalar(@hosts);
 
559
 
 
560
      # Assign hosts unless already fixed
 
561
      @hosts= map { $self->fix_host() unless $_; } @hosts;
 
562
 
 
563
      # Write the hosts value back
 
564
      $group->insert($option_name, join(",", @hosts));
 
565
 
 
566
      # Generate sections for each host
 
567
      foreach my $host ( @hosts ){
 
568
        my $idx= $idxes{$option_name}++;
 
569
 
 
570
        my $suffix= $group->suffix();
 
571
        # Generate a section for ndb_mgmd to read
 
572
        $config->insert("cluster_config.$option_name.$idx$suffix",
 
573
                        "HostName", $host);
 
574
 
 
575
        if ($option_name eq 'mysqld'){
 
576
          my $datadir=
 
577
            $self->fix_cluster_dir($config,
 
578
                                   "cluster_config.mysqld.$idx$suffix",
 
579
                                   $group);
 
580
          $config->insert("mysqld.$idx$suffix",
 
581
                          'datadir', "$datadir/data");
 
582
        }
 
583
      }
 
584
    }
 
585
  }
 
586
}
 
587
 
 
588
 
 
589
sub new_config {
 
590
  my ($class, $args)= @_;
 
591
 
 
592
  my @required_args= ('basedir', 'baseport', 'vardir', 'template_path');
 
593
 
 
594
  foreach my $required ( @required_args ) {
 
595
    croak "you must pass '$required'" unless defined $args->{$required};
 
596
  }
 
597
 
 
598
  # Fill in hosts/port hash
 
599
  my $hosts= {};
 
600
  my $baseport= $args->{baseport};
 
601
  $args->{hosts}= [ 'localhost' ] unless exists($args->{hosts});
 
602
  foreach my $host ( @{$args->{hosts}} ) {
 
603
     $hosts->{$host}= $baseport;
 
604
  }
 
605
 
 
606
  # Open the config template
 
607
  my $config= My::Config->new($args->{'template_path'});
 
608
  my $extra_template_path= $args->{'extra_template_path'};
 
609
  if ($extra_template_path){
 
610
    $config->append(My::Config->new($extra_template_path));
 
611
  }
 
612
  my $self= bless {
 
613
                   CONFIG       => $config,
 
614
                   ARGS         => $args,
 
615
                   HOSTS        => $hosts,
 
616
                   NEXT_HOST    => 0,
 
617
                   SERVER_ID    => 1,
 
618
                  }, $class;
 
619
 
 
620
 
 
621
  {
 
622
    # Run pre rules
 
623
    foreach my $rule ( @pre_rules ) {
 
624
      &$rule($self, $config);
 
625
    }
 
626
  }
 
627
 
 
628
 
 
629
  $self->run_section_rules($config,
 
630
                           'cluster_config\.\w*$',
 
631
                           @cluster_config_rules);
 
632
  $self->run_generate_sections_from_cluster_config($config);
 
633
 
 
634
  $self->run_section_rules($config,
 
635
                           'cluster_config.ndb_mgmd.',
 
636
                           @ndb_mgmd_rules);
 
637
  $self->run_section_rules($config,
 
638
                           'cluster_config.ndbd',
 
639
                           @ndbd_rules);
 
640
 
 
641
  $self->run_section_rules($config,
 
642
                           'mysqld.',
 
643
                           @mysqld_rules);
 
644
 
 
645
  # [mysqlbinlog] need additional settings
 
646
  $self->run_rules_for_group($config,
 
647
                             $config->insert('mysqlbinlog'),
 
648
                             @mysqlbinlog_rules);
 
649
 
 
650
  # [mysql_upgrade] need additional settings
 
651
  $self->run_rules_for_group($config,
 
652
                             $config->insert('mysql_upgrade'),
 
653
                             @mysql_upgrade_rules);
 
654
 
 
655
  # Additional rules required for [client]
 
656
  $self->run_rules_for_group($config,
 
657
                             $config->insert('client'),
 
658
                             @client_rules);
 
659
 
 
660
 
 
661
  # Additional rules required for [mysqltest]
 
662
  $self->run_rules_for_group($config,
 
663
                             $config->insert('mysqltest'),
 
664
                             @mysqltest_rules);
 
665
 
 
666
  {
 
667
    # Run post rules
 
668
    foreach my $rule ( @post_rules ) {
 
669
      &$rule($self, $config);
 
670
    }
 
671
  }
 
672
 
 
673
  return $config;
 
674
}
 
675
 
 
676
 
 
677
1;
 
678