On Wed, Apr 6, 2016 at 5:04 PM, Michael Paquier <michael.paqu...@gmail.com> wrote: > On Wed, Apr 6, 2016 at 4:08 PM, Michael Paquier > <michael.paqu...@gmail.com> wrote: >> Here are few things I have noticed: >> + for (i = 0; i < max_wal_senders; i++) >> + { >> + walsnd = &WalSndCtl->walsnds[i]; >> No volatile pointer to prevent code reordering? >> >> */ >> typedef struct WalSnd >> { >> + int slotno; /* index of this slot in WalSnd array */ >> pid_t pid; /* this walsender's process id, or 0 */ >> slotno is used nowhere. >> >> I'll grab the tests and look at them. > > So I had a look at those tests and finished with the attached: > - patch 1 adds a reload routine to PostgresNode > - patch 2 the list of tests.
Thanks for updating the patches! Attached is the refactored version of the patch. Regards, -- Fujii Masao
*** a/src/test/perl/PostgresNode.pm --- b/src/test/perl/PostgresNode.pm *************** *** 668,673 **** sub stop --- 668,691 ---- =pod + =item $node->reload() + + Reload configuration parameters on the node. + + =cut + + sub reload + { + my ($self) = @_; + my $port = $self->port; + my $pgdata = $self->data_dir; + my $name = $self->name; + print "### Reloading node \"$name\"\n"; + TestLib::system_log('pg_ctl', '-D', $pgdata, 'reload'); + } + + =pod + =item $node->restart() Wrapper for pg_ctl -w restart *** /dev/null --- b/src/test/recovery/t/007_sync_rep.pl *************** *** 0 **** --- 1,149 ---- + # Minimal test testing synchronous replication sync_state transition + use strict; + use warnings; + use PostgresNode; + use TestLib; + use Test::More tests => 8; + + # Query checking sync_priority and sync_state of each standby + my $check_sql = "SELECT application_name, sync_priority, sync_state FROM pg_stat_replication ORDER BY application_name;"; + + # Check that sync_state of each standby is expected. + # If $setting is given, synchronous_standby_names is set to it and + # the configuration file is reloaded before the test. + sub test_sync_state + { + my ($self, $expected, $msg, $setting) = @_; + + if (defined($setting)) + { + $self->psql('postgres', + "ALTER SYSTEM SET synchronous_standby_names = '$setting';"); + $self->reload; + } + + my $result = $self->safe_psql('postgres', $check_sql); + is($result, $expected, $msg); + } + + # Initialize master node + my $node_master = get_new_node('master'); + $node_master->init(allows_streaming => 1); + $node_master->start; + my $backup_name = 'master_backup'; + + # Take backup + $node_master->backup($backup_name); + + # Create standby1 linking to master + my $node_standby_1 = get_new_node('standby1'); + $node_standby_1->init_from_backup($node_master, $backup_name, + has_streaming => 1); + $node_standby_1->start; + + # Create standby2 linking to master + my $node_standby_2 = get_new_node('standby2'); + $node_standby_2->init_from_backup($node_master, $backup_name, + has_streaming => 1); + $node_standby_2->start; + + # Create standby3 linking to master + my $node_standby_3 = get_new_node('standby3'); + $node_standby_3->init_from_backup($node_master, $backup_name, + has_streaming => 1); + $node_standby_3->start; + + # Check that sync_state is determined correctly when + # synchronous_standby_names is specified in old syntax. + test_sync_state($node_master, qq(standby1|1|sync + standby2|2|potential + standby3|0|async), + 'old syntax of synchronous_standby_names', + 'standby1,standby2'); + + # Check that all the standbys are considered as either sync or + # potential when * is specified in synchronous_standby_names. + # Note that standby1 is chosen as sync standby because + # it's stored in the head of WalSnd array which manages + # all the standbys though they have the same priority. + test_sync_state($node_master, qq(standby1|1|sync + standby2|1|potential + standby3|1|potential), + 'asterisk in synchronous_standby_names', + '*'); + + # Stop and start standbys to rearrange the order of standbys + # in WalSnd array. Now, if standbys have the same priority, + # standby2 is selected preferentially and standby3 is next. + $node_standby_1->stop; + $node_standby_2->stop; + $node_standby_3->stop; + + $node_standby_2->start; + $node_standby_3->start; + + # Specify 2 as the number of sync standbys. + # Check that two standbys are in 'sync' state. + test_sync_state($node_master, qq(standby2|2|sync + standby3|3|sync), + '2 synchronous standbys', + '2(standby1,standby2,standby3)'); + + # Start standby1 + $node_standby_1->start; + + # Create standby4 linking to master + my $node_standby_4 = get_new_node('standby4'); + $node_standby_4->init_from_backup($node_master, $backup_name, + has_streaming => 1); + $node_standby_4->start; + + # Check that standby1 and standby2 whose names appear earlier in + # synchronous_standby_names are considered as sync. Also check that + # standby3 appearing later represents potential, and standby4 is + # in 'async' state because it's not in the list. + test_sync_state($node_master, qq(standby1|1|sync + standby2|2|sync + standby3|3|potential + standby4|0|async), + '2 sync, 1 potential and 1 async'); + + # Check that sync_state of each standby is determined correctly + # when num_sync exceeds the number of names of potential sync standbys + # specified in synchronous_standby_names. + test_sync_state($node_master, qq(standby1|0|async + standby2|4|sync + standby3|3|sync + standby4|1|sync), + 'num_sync exceeds the num of potential sync standbys', + '6(standby4,standby0,standby3,standby2)'); + + # The setting that * comes before another standby name is acceptable + # but does not make sense in most cases. Check that sync_state is + # chosen properly even in case of that setting. + # The priority of standby2 should be 2 because it matches * first. + test_sync_state($node_master, qq(standby1|1|sync + standby2|2|sync + standby3|2|potential + standby4|2|potential), + 'asterisk comes before another standby name', + '2(standby1,*,standby2)'); + + # Check that the setting of '2(*)' chooses standby2 and standby3 that are stored + # earlier in WalSnd array as sync standbys. + test_sync_state($node_master, qq(standby1|1|potential + standby2|1|sync + standby3|1|sync + standby4|1|potential), + 'multiple standbys having the same priority are chosen as sync', + '2(*)'); + + # Stop Standby3 which is considered in 'sync' state. + $node_standby_3->stop; + + # Check that the state of standby1 stored earlier in WalSnd array than + # standby4 is transited from potential to sync. + test_sync_state($node_master, qq(standby1|1|sync + standby2|1|sync + standby4|1|potential), + 'potential standby found earlier in array is promoted to sync');
-- Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org) To make changes to your subscription: http://www.postgresql.org/mailpref/pgsql-hackers