#
$node = get_new_node('CIC_test');
$node->init;
-$node->append_conf('postgresql.conf', 'lock_timeout = 180000');
+$node->append_conf('postgresql.conf',
+ 'lock_timeout = ' . (1000 * $TestLib::timeout_default));
$node->start;
$node->safe_psql('postgres', q(CREATE EXTENSION amcheck));
$node->safe_psql('postgres', q(CREATE TABLE tbl(i int)));
$node = get_new_node('CIC_2PC_test');
$node->init;
$node->append_conf('postgresql.conf', 'max_prepared_transactions = 10');
-$node->append_conf('postgresql.conf', 'lock_timeout = 180000');
+$node->append_conf('postgresql.conf',
+ 'lock_timeout = ' . (1000 * $TestLib::timeout_default));
$node->start;
$node->safe_psql('postgres', q(CREATE EXTENSION amcheck));
$node->safe_psql('postgres', q(CREATE TABLE tbl(i int)));
my $main_in = '';
my $main_out = '';
-my $main_timer = IPC::Run::timeout(180);
+my $main_timer = IPC::Run::timeout($TestLib::timeout_default);
my $main_h =
$node->background_psql('postgres', \$main_in, \$main_out,
my $cic_in = '';
my $cic_out = '';
-my $cic_timer = IPC::Run::timeout(180);
+my $cic_timer = IPC::Run::timeout($TestLib::timeout_default);
my $cic_h =
$node->background_psql('postgres', \$cic_in, \$cic_out,
$cic_timer, on_error_stop => 1);
));
$node->restart;
-my $reindex_in = '';
-my $reindex_out = '';
-my $reindex_timer = IPC::Run::timeout(180);
+my $reindex_in = '';
+my $reindex_out = '';
+my $reindex_timer =
+ IPC::Run::timeout($TestLib::timeout_default);
my $reindex_h =
$node->background_psql('postgres', \$reindex_in, \$reindex_out,
$reindex_timer, on_error_stop => 1);
$node->psql('postgres', 'SELECT 1/0');
# might need to retry if logging collector process is slow...
-my $max_attempts = 180 * 10;
+my $max_attempts = 10 * $TestLib::timeout_default;
my $current_logfiles;
for (my $attempts = 0; $attempts < $max_attempts; $attempts++)
'--no-sync',
"--file=$tempdir/only_dump_test_table.sql",
'--table=dump_test.test_table',
- '--lock-wait-timeout=1000000',
+ '--lock-wait-timeout='
+ . (1000 * $TestLib::timeout_default),
'postgres',
],
},
my $in = '';
my $out = '';
-my $timer = timer(5);
+my $timer = timer($TestLib::timeout_default);
my $h = $node->interactive_psql('postgres', \$in, \$out, $timer);
# reset output collector
$out = "";
# restart per-command timer
- $timer->start(5);
+ $timer->start($TestLib::timeout_default);
# send the data to be sent
$in .= $send;
# wait ...
clear_line();
# send psql an explicit \q to shut it down, else pty won't close properly
-$timer->start(5);
+$timer->start($TestLib::timeout_default);
$in .= "\\q\n";
finish $h or die "psql returned $?";
$timer->reset;
$node->init;
$node->start;
-# use a long timeout for the benefit of very slow buildfarm machines
-$node->command_ok([qw(pg_isready --timeout=60)],
+$node->command_ok(
+ [ 'pg_isready', "--timeout=$TestLib::timeout_default" ],
'succeeds with server running');
my ($stdout, $stderr, $timed_out);
my $cmdret = $node->psql('postgres', 'SELECT pg_sleep(600)',
stdout => \$stdout, stderr => \$stderr,
- timeout => 180, timed_out => \$timed_out,
+ timeout => $TestLib::timeout_default,
+ timed_out => \$timed_out,
extra_params => ['--single-transaction'],
on_error_die => 1)
print "Sleep timed out" if $timed_out;
my ($stdout, $stderr, $timed_out);
my $cmdret = $node->psql('postgres', 'SELECT pg_sleep(600)',
stdout => \$stdout, stderr => \$stderr,
- timeout => 180, timed_out => \$timed_out,
+ timeout => $TestLib::timeout_default,
+ timed_out => \$timed_out,
extra_params => ['--single-transaction'])
will set $cmdret to undef and $timed_out to a true value.
while idling this backend.
The specified timer object is attached to the harness, as well. It's caller's
-responsibility to select the timeout length, and to restart the timer after
+responsibility to set the timeout length (usually
+$TestLib::timeout_default), and to restart the timer after
each command if the timeout is per-command.
psql is invoked in tuples-only unaligned mode with reading of B<.psqlrc>
and its stdout and stderr go to the $stdout scalar reference.
ptys are used so that psql thinks it's being called interactively.
-The specified timer object is attached to the harness, as well.
-It's caller's responsibility to select the timeout length, and to
-restart the timer after each command if the timeout is per-command.
+The specified timer object is attached to the harness, as well. It's caller's
+responsibility to set the timeout length (usually
+$TestLib::timeout_default), and to restart the timer after
+each command if the timeout is per-command.
psql is invoked in tuples-only unaligned mode with reading of B<.psqlrc>
disabled. That may be overridden by passing extra psql parameters.
Run B<$query> repeatedly, until it returns the B<$expected> result
('t', or SQL boolean true, by default).
Continues polling if B
returns an error result.-Times out after 180 seconds.
+Times out after $TestLib::timeout_default seconds.
Returns 1 if successful, 0 if timed out.
=cut
'-d', $self->connstr($dbname)
];
my ($stdout, $stderr);
- my $max_attempts = 180 * 10;
+ my $max_attempts = 10 * $TestLib::timeout_default;
my $attempts = 0;
while ($attempts < $max_attempts)
$attempts++;
}
- # The query result didn't change in 180 seconds. Give up. Print the
- # output from the last attempt, hopefully that's useful for debugging.
+ # Give up. Print the output from the last attempt, hopefully that's useful
+ # for debugging.
diag qq(poll_query_until timed out executing this query:
$query
expecting this output:
$use_unix_sockets
);
-our ($windows_os, $is_msys2, $use_unix_sockets, $tmp_check, $log_path,
- $test_logfile);
+our ($windows_os, $is_msys2, $use_unix_sockets, $timeout_default,
+ $tmp_check, $log_path, $test_logfile);
BEGIN
{
# supported, but it can be overridden if desired.
$use_unix_sockets =
(!$windows_os || defined $ENV{PG_TEST_USE_UNIX_SOCKETS});
+
+ $timeout_default = $ENV{PG_TEST_TIMEOUT_DEFAULT};
+ $timeout_default = 180
+ if not defined $timeout_default or $timeout_default eq '';
}
=pod
$node_standby->logfile, 'start'
]);
-# wait up to 180s for postgres to terminate
-foreach my $i (0 .. 1800)
+# wait for postgres to terminate
+foreach my $i (0 .. 10 * $TestLib::timeout_default)
{
last if !-f $node_standby->data_dir . '/postmaster.pid';
usleep(100_000);
);
my $stdout_recv = $node_primary->pg_recvlogical_upto(
- 'postgres', 'test_slot', $endpos, 180,
+ 'postgres', 'test_slot', $endpos,
+ $TestLib::timeout_default,
'include-xids' => '0',
'skip-empty-xacts' => '1');
chomp($stdout_recv);
) or die "slot never became inactive";
$stdout_recv = $node_primary->pg_recvlogical_upto(
- 'postgres', 'test_slot', $endpos, 180,
+ 'postgres', 'test_slot', $endpos,
+ $TestLib::timeout_default,
'include-xids' => '0',
'skip-empty-xacts' => '1');
chomp($stdout_recv);
($ret, $stdout, $stderr) = $node_replica->psql(
'postgres',
"SELECT data FROM pg_logical_slot_peek_changes('before_basebackup', NULL, NULL, 'include-xids', '0', 'skip-empty-xacts', '1');",
- timeout => 180);
+ timeout => $TestLib::timeout_default);
is($ret, 0, 'replay from slot before_basebackup succeeds');
my $final_expected_output_bb = q(BEGIN
$stdout = $node_replica->pg_recvlogical_upto(
'postgres', 'before_basebackup',
- $endpos, 180,
+ $endpos, $TestLib::timeout_default,
'include-xids' => '0',
'skip-empty-xacts' => '1');
# instance being driven by us, add a timeout high enough that it
# should never trigger even on very slow machines, unless something
# is really wrong.
-my $psql_timeout = IPC::Run::timer(60);
+my $psql_timeout = IPC::Run::timer($TestLib::timeout_default);
my $node = get_new_node('primary');
$node->init(allows_streaming => 1);
\$stdout,
'2>',
\$stderr,
- IPC::Run::timeout(900)); # five times the poll_query_until timeout
+ IPC::Run::timeout(5 * $TestLib::timeout_default));
ok( $gnat->poll_query_until(
'postgres',
"SELECT 1 FROM pg_stat_activity WHERE query = '$slow_query'", '1'),
unlink($gnat->data_dir . '/postmaster.pid');
$gnat->rotate_logfile; # on Windows, can't open old log for writing
log_ipcs();
-# Reject ordinary startup. Retry for the same reasons poll_start() does.
+# Reject ordinary startup. Retry for the same reasons poll_start() does,
+# every 0.1s for at least $TestLib::timeout_default seconds.
my $pre_existing_msg = qr/pre-existing shared memory block/;
{
- my $max_attempts = 180 * 10; # Retry every 0.1s for at least 180s.
+ my $max_attempts = 10 * $TestLib::timeout_default;
my $attempts = 0;
while ($attempts < $max_attempts)
{
{
my ($node) = @_;
- my $max_attempts = 180 * 10;
+ my $max_attempts = 10 * $TestLib::timeout_default;
my $attempts = 0;
while ($attempts < $max_attempts)
$attempts++;
}
- # No success within 180 seconds. Try one last time without fail_ok, which
- # will BAIL_OUT unless it succeeds.
+ # Try one last time without fail_ok, which will BAIL_OUT unless it
+ # succeeds.
$node->start && return 1;
return 0;
}
SELECT pg_switch_wal();
CHECKPOINT;
SELECT 'finished';",
- timeout => '60'));
+ timeout => $TestLib::timeout_default));
is($result[1], 'finished', 'check if checkpoint command is not blocked');
$node_primary2->stop;
kill 'STOP', $senderpid, $receiverpid;
advance_wal($node_primary3, 2);
-my $max_attempts = 180;
+my $max_attempts = $TestLib::timeout_default;
while ($max_attempts-- >= 0)
{
if (find_in_log(
"lost")
or die "timed out waiting for slot to be lost";
-$max_attempts = 180;
+$max_attempts = $TestLib::timeout_default;
while ($max_attempts-- >= 0)
{
if (find_in_log(
$node_standby->append_conf('postgresql.conf', 'max_prepared_transactions=10');
$node_standby->start;
-# To avoid hanging while expecting some specific input from a psql
-# instance being driven by us, add a timeout high enough that it
-# should never trigger even on very slow machines, unless something
-# is really wrong.
-my $psql_timeout = IPC::Run::timer(300);
+my $psql_timeout =
+ IPC::Run::timer(2 * $TestLib::timeout_default);
# One psql to primary and standby each, for all queries. That allows
# to check uncommitted changes being replicated and such.
}
-# To avoid hanging while expecting some specific input from a psql
-# instance being driven by us, add a timeout high enough that it
-# should never trigger even on very slow machines, unless something
-# is really wrong.
-my $psql_timeout = IPC::Run::timer(60);
+my $psql_timeout = IPC::Run::timer($TestLib::timeout_default);
my $node = get_new_node('node_crash');
$node->init();
$recovery_node->logfile, 'start'
]);
- # Wait up to 180s for postgres to terminate
- foreach my $i (0 .. 1800)
+ # wait for postgres to terminate
+ foreach my $i (0 .. 10 * $TestLib::timeout_default)
{
last if !-f $recovery_node->data_dir . '/postmaster.pid';
usleep(100_000);
my $in = '';
my $out = '';
-my $timer = IPC::Run::timeout(180);
+my $timer = IPC::Run::timeout($TestLib::timeout_default);
my $h = $node_publisher->background_psql('postgres', \$in, \$out, $timer,
on_error_stop => 0);
projects / postgresql.git / commitdiff