Refactor Perl test code
The original code was a bit clunky; make it more amenable for further
reuse by creating a new Perl package PostgresNode, which is an
object-oriented representation of a single server, with some support
routines such as init, start, stop, psql. This serves as a better basis
on which to build further test code, and enables writing tests that use
more than one server without too much complication.
This commit modifies a lot of the existing test files, mostly to remove
explicit calls to system commands (pg_ctl) replacing them with method
calls of a PostgresNode object. The result is quite a bit more
straightforward.
Also move some initialization code to BEGIN and INIT blocks instead of
having it straight in as top-level code.
This commit also introduces package RecursiveCopy so that we can copy
whole directories without having to depend on packages that may not be
present on vanilla Perl 5.8 installations.
I also ran perltidy on the modified files, which changes some code sites
that are not otherwise touched by this patch. I tried to avoid this,
but it ended up being more trouble than it's worth.
Authors: Michael Paquier, Álvaro Herrera
Review: Noah Misch
2015-12-02 22:46:16 +01:00
|
|
|
# PostgresNode, class representing a data directory and postmaster.
|
|
|
|
#
|
|
|
|
# This contains a basic set of routines able to work on a PostgreSQL node,
|
|
|
|
# allowing to start, stop, backup and initialize it with various options.
|
|
|
|
# The set of nodes managed by a given test is also managed by this module.
|
|
|
|
|
|
|
|
package PostgresNode;
|
|
|
|
|
|
|
|
use strict;
|
|
|
|
use warnings;
|
|
|
|
|
|
|
|
use Config;
|
|
|
|
use Cwd;
|
|
|
|
use Exporter 'import';
|
|
|
|
use File::Basename;
|
|
|
|
use File::Spec;
|
|
|
|
use File::Temp ();
|
|
|
|
use IPC::Run;
|
|
|
|
use PostgresNode;
|
|
|
|
use RecursiveCopy;
|
|
|
|
use Test::More;
|
|
|
|
use TestLib ();
|
|
|
|
|
|
|
|
our @EXPORT = qw(
|
|
|
|
get_new_node
|
|
|
|
);
|
|
|
|
|
|
|
|
our ($test_pghost, $last_port_assigned, @all_nodes);
|
|
|
|
|
2015-12-07 23:25:31 +01:00
|
|
|
INIT
|
Refactor Perl test code
The original code was a bit clunky; make it more amenable for further
reuse by creating a new Perl package PostgresNode, which is an
object-oriented representation of a single server, with some support
routines such as init, start, stop, psql. This serves as a better basis
on which to build further test code, and enables writing tests that use
more than one server without too much complication.
This commit modifies a lot of the existing test files, mostly to remove
explicit calls to system commands (pg_ctl) replacing them with method
calls of a PostgresNode object. The result is quite a bit more
straightforward.
Also move some initialization code to BEGIN and INIT blocks instead of
having it straight in as top-level code.
This commit also introduces package RecursiveCopy so that we can copy
whole directories without having to depend on packages that may not be
present on vanilla Perl 5.8 installations.
I also ran perltidy on the modified files, which changes some code sites
that are not otherwise touched by this patch. I tried to avoid this,
but it ended up being more trouble than it's worth.
Authors: Michael Paquier, Álvaro Herrera
Review: Noah Misch
2015-12-02 22:46:16 +01:00
|
|
|
{
|
|
|
|
# PGHOST is set once and for all through a single series of tests when
|
|
|
|
# this module is loaded.
|
|
|
|
$test_pghost =
|
|
|
|
$TestLib::windows_os ? "127.0.0.1" : TestLib::tempdir_short;
|
|
|
|
$ENV{PGHOST} = $test_pghost;
|
|
|
|
$ENV{PGDATABASE} = 'postgres';
|
|
|
|
|
|
|
|
# Tracking of last port value assigned to accelerate free port lookup.
|
2015-12-07 23:25:31 +01:00
|
|
|
$last_port_assigned = int(rand() * 16384) + 49152;
|
Refactor Perl test code
The original code was a bit clunky; make it more amenable for further
reuse by creating a new Perl package PostgresNode, which is an
object-oriented representation of a single server, with some support
routines such as init, start, stop, psql. This serves as a better basis
on which to build further test code, and enables writing tests that use
more than one server without too much complication.
This commit modifies a lot of the existing test files, mostly to remove
explicit calls to system commands (pg_ctl) replacing them with method
calls of a PostgresNode object. The result is quite a bit more
straightforward.
Also move some initialization code to BEGIN and INIT blocks instead of
having it straight in as top-level code.
This commit also introduces package RecursiveCopy so that we can copy
whole directories without having to depend on packages that may not be
present on vanilla Perl 5.8 installations.
I also ran perltidy on the modified files, which changes some code sites
that are not otherwise touched by this patch. I tried to avoid this,
but it ended up being more trouble than it's worth.
Authors: Michael Paquier, Álvaro Herrera
Review: Noah Misch
2015-12-02 22:46:16 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
sub new
|
|
|
|
{
|
|
|
|
my $class = shift;
|
2016-01-20 18:13:11 +01:00
|
|
|
my $name = shift;
|
Refactor Perl test code
The original code was a bit clunky; make it more amenable for further
reuse by creating a new Perl package PostgresNode, which is an
object-oriented representation of a single server, with some support
routines such as init, start, stop, psql. This serves as a better basis
on which to build further test code, and enables writing tests that use
more than one server without too much complication.
This commit modifies a lot of the existing test files, mostly to remove
explicit calls to system commands (pg_ctl) replacing them with method
calls of a PostgresNode object. The result is quite a bit more
straightforward.
Also move some initialization code to BEGIN and INIT blocks instead of
having it straight in as top-level code.
This commit also introduces package RecursiveCopy so that we can copy
whole directories without having to depend on packages that may not be
present on vanilla Perl 5.8 installations.
I also ran perltidy on the modified files, which changes some code sites
that are not otherwise touched by this patch. I tried to avoid this,
but it ended up being more trouble than it's worth.
Authors: Michael Paquier, Álvaro Herrera
Review: Noah Misch
2015-12-02 22:46:16 +01:00
|
|
|
my $pghost = shift;
|
|
|
|
my $pgport = shift;
|
2015-12-07 23:25:31 +01:00
|
|
|
my $testname = basename($0);
|
|
|
|
$testname =~ s/\.[^.]+$//;
|
Refactor Perl test code
The original code was a bit clunky; make it more amenable for further
reuse by creating a new Perl package PostgresNode, which is an
object-oriented representation of a single server, with some support
routines such as init, start, stop, psql. This serves as a better basis
on which to build further test code, and enables writing tests that use
more than one server without too much complication.
This commit modifies a lot of the existing test files, mostly to remove
explicit calls to system commands (pg_ctl) replacing them with method
calls of a PostgresNode object. The result is quite a bit more
straightforward.
Also move some initialization code to BEGIN and INIT blocks instead of
having it straight in as top-level code.
This commit also introduces package RecursiveCopy so that we can copy
whole directories without having to depend on packages that may not be
present on vanilla Perl 5.8 installations.
I also ran perltidy on the modified files, which changes some code sites
that are not otherwise touched by this patch. I tried to avoid this,
but it ended up being more trouble than it's worth.
Authors: Michael Paquier, Álvaro Herrera
Review: Noah Misch
2015-12-02 22:46:16 +01:00
|
|
|
my $self = {
|
|
|
|
_port => $pgport,
|
|
|
|
_host => $pghost,
|
|
|
|
_basedir => TestLib::tempdir,
|
2016-01-20 18:13:11 +01:00
|
|
|
_name => $name,
|
|
|
|
_logfile => "$TestLib::log_path/${testname}_${name}.log" };
|
Refactor Perl test code
The original code was a bit clunky; make it more amenable for further
reuse by creating a new Perl package PostgresNode, which is an
object-oriented representation of a single server, with some support
routines such as init, start, stop, psql. This serves as a better basis
on which to build further test code, and enables writing tests that use
more than one server without too much complication.
This commit modifies a lot of the existing test files, mostly to remove
explicit calls to system commands (pg_ctl) replacing them with method
calls of a PostgresNode object. The result is quite a bit more
straightforward.
Also move some initialization code to BEGIN and INIT blocks instead of
having it straight in as top-level code.
This commit also introduces package RecursiveCopy so that we can copy
whole directories without having to depend on packages that may not be
present on vanilla Perl 5.8 installations.
I also ran perltidy on the modified files, which changes some code sites
that are not otherwise touched by this patch. I tried to avoid this,
but it ended up being more trouble than it's worth.
Authors: Michael Paquier, Álvaro Herrera
Review: Noah Misch
2015-12-02 22:46:16 +01:00
|
|
|
|
|
|
|
bless $self, $class;
|
|
|
|
$self->dump_info;
|
|
|
|
|
|
|
|
return $self;
|
|
|
|
}
|
|
|
|
|
|
|
|
sub port
|
|
|
|
{
|
|
|
|
my ($self) = @_;
|
|
|
|
return $self->{_port};
|
|
|
|
}
|
|
|
|
|
|
|
|
sub host
|
|
|
|
{
|
|
|
|
my ($self) = @_;
|
|
|
|
return $self->{_host};
|
|
|
|
}
|
|
|
|
|
|
|
|
sub basedir
|
|
|
|
{
|
|
|
|
my ($self) = @_;
|
|
|
|
return $self->{_basedir};
|
|
|
|
}
|
|
|
|
|
2016-01-20 18:13:11 +01:00
|
|
|
sub name
|
Refactor Perl test code
The original code was a bit clunky; make it more amenable for further
reuse by creating a new Perl package PostgresNode, which is an
object-oriented representation of a single server, with some support
routines such as init, start, stop, psql. This serves as a better basis
on which to build further test code, and enables writing tests that use
more than one server without too much complication.
This commit modifies a lot of the existing test files, mostly to remove
explicit calls to system commands (pg_ctl) replacing them with method
calls of a PostgresNode object. The result is quite a bit more
straightforward.
Also move some initialization code to BEGIN and INIT blocks instead of
having it straight in as top-level code.
This commit also introduces package RecursiveCopy so that we can copy
whole directories without having to depend on packages that may not be
present on vanilla Perl 5.8 installations.
I also ran perltidy on the modified files, which changes some code sites
that are not otherwise touched by this patch. I tried to avoid this,
but it ended up being more trouble than it's worth.
Authors: Michael Paquier, Álvaro Herrera
Review: Noah Misch
2015-12-02 22:46:16 +01:00
|
|
|
{
|
|
|
|
my ($self) = @_;
|
2016-01-20 18:13:11 +01:00
|
|
|
return $self->{_name};
|
Refactor Perl test code
The original code was a bit clunky; make it more amenable for further
reuse by creating a new Perl package PostgresNode, which is an
object-oriented representation of a single server, with some support
routines such as init, start, stop, psql. This serves as a better basis
on which to build further test code, and enables writing tests that use
more than one server without too much complication.
This commit modifies a lot of the existing test files, mostly to remove
explicit calls to system commands (pg_ctl) replacing them with method
calls of a PostgresNode object. The result is quite a bit more
straightforward.
Also move some initialization code to BEGIN and INIT blocks instead of
having it straight in as top-level code.
This commit also introduces package RecursiveCopy so that we can copy
whole directories without having to depend on packages that may not be
present on vanilla Perl 5.8 installations.
I also ran perltidy on the modified files, which changes some code sites
that are not otherwise touched by this patch. I tried to avoid this,
but it ended up being more trouble than it's worth.
Authors: Michael Paquier, Álvaro Herrera
Review: Noah Misch
2015-12-02 22:46:16 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
sub logfile
|
|
|
|
{
|
|
|
|
my ($self) = @_;
|
|
|
|
return $self->{_logfile};
|
|
|
|
}
|
|
|
|
|
|
|
|
sub connstr
|
|
|
|
{
|
|
|
|
my ($self, $dbname) = @_;
|
|
|
|
my $pgport = $self->port;
|
|
|
|
my $pghost = $self->host;
|
|
|
|
if (!defined($dbname))
|
|
|
|
{
|
|
|
|
return "port=$pgport host=$pghost";
|
|
|
|
}
|
|
|
|
return "port=$pgport host=$pghost dbname=$dbname";
|
|
|
|
}
|
|
|
|
|
|
|
|
sub data_dir
|
|
|
|
{
|
|
|
|
my ($self) = @_;
|
|
|
|
my $res = $self->basedir;
|
|
|
|
return "$res/pgdata";
|
|
|
|
}
|
|
|
|
|
|
|
|
sub archive_dir
|
|
|
|
{
|
|
|
|
my ($self) = @_;
|
|
|
|
my $basedir = $self->basedir;
|
|
|
|
return "$basedir/archives";
|
|
|
|
}
|
|
|
|
|
|
|
|
sub backup_dir
|
|
|
|
{
|
|
|
|
my ($self) = @_;
|
|
|
|
my $basedir = $self->basedir;
|
|
|
|
return "$basedir/backup";
|
|
|
|
}
|
|
|
|
|
|
|
|
# Dump node information
|
|
|
|
sub dump_info
|
|
|
|
{
|
|
|
|
my ($self) = @_;
|
2016-01-20 18:13:11 +01:00
|
|
|
print "Name: " . $self->name . "\n";
|
Refactor Perl test code
The original code was a bit clunky; make it more amenable for further
reuse by creating a new Perl package PostgresNode, which is an
object-oriented representation of a single server, with some support
routines such as init, start, stop, psql. This serves as a better basis
on which to build further test code, and enables writing tests that use
more than one server without too much complication.
This commit modifies a lot of the existing test files, mostly to remove
explicit calls to system commands (pg_ctl) replacing them with method
calls of a PostgresNode object. The result is quite a bit more
straightforward.
Also move some initialization code to BEGIN and INIT blocks instead of
having it straight in as top-level code.
This commit also introduces package RecursiveCopy so that we can copy
whole directories without having to depend on packages that may not be
present on vanilla Perl 5.8 installations.
I also ran perltidy on the modified files, which changes some code sites
that are not otherwise touched by this patch. I tried to avoid this,
but it ended up being more trouble than it's worth.
Authors: Michael Paquier, Álvaro Herrera
Review: Noah Misch
2015-12-02 22:46:16 +01:00
|
|
|
print "Data directory: " . $self->data_dir . "\n";
|
|
|
|
print "Backup directory: " . $self->backup_dir . "\n";
|
|
|
|
print "Archive directory: " . $self->archive_dir . "\n";
|
|
|
|
print "Connection string: " . $self->connstr . "\n";
|
|
|
|
print "Log file: " . $self->logfile . "\n";
|
|
|
|
}
|
|
|
|
|
|
|
|
sub set_replication_conf
|
|
|
|
{
|
|
|
|
my ($self) = @_;
|
|
|
|
my $pgdata = $self->data_dir;
|
|
|
|
|
|
|
|
open my $hba, ">>$pgdata/pg_hba.conf";
|
|
|
|
print $hba "\n# Allow replication (set up by PostgresNode.pm)\n";
|
|
|
|
if (!$TestLib::windows_os)
|
|
|
|
{
|
|
|
|
print $hba "local replication all trust\n";
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
print $hba
|
|
|
|
"host replication all 127.0.0.1/32 sspi include_realm=1 map=regress\n";
|
|
|
|
}
|
|
|
|
close $hba;
|
|
|
|
}
|
|
|
|
|
|
|
|
# Initialize a new cluster for testing.
|
|
|
|
#
|
|
|
|
# Authentication is set up so that only the current OS user can access the
|
|
|
|
# cluster. On Unix, we use Unix domain socket connections, with the socket in
|
|
|
|
# a directory that's only accessible to the current user to ensure that.
|
|
|
|
# On Windows, we use SSPI authentication to ensure the same (by pg_regress
|
|
|
|
# --config-auth).
|
|
|
|
sub init
|
|
|
|
{
|
|
|
|
my ($self, %params) = @_;
|
|
|
|
my $port = $self->port;
|
|
|
|
my $pgdata = $self->data_dir;
|
|
|
|
my $host = $self->host;
|
|
|
|
|
|
|
|
$params{hba_permit_replication} = 1
|
|
|
|
if (!defined($params{hba_permit_replication}));
|
|
|
|
|
|
|
|
mkdir $self->backup_dir;
|
|
|
|
mkdir $self->archive_dir;
|
|
|
|
|
|
|
|
TestLib::system_or_bail('initdb', '-D', $pgdata, '-A', 'trust', '-N');
|
|
|
|
TestLib::system_or_bail($ENV{PG_REGRESS}, '--config-auth', $pgdata);
|
|
|
|
|
|
|
|
open my $conf, ">>$pgdata/postgresql.conf";
|
2016-01-20 18:13:11 +01:00
|
|
|
print $conf "\n# Added by PostgresNode.pm\n";
|
Refactor Perl test code
The original code was a bit clunky; make it more amenable for further
reuse by creating a new Perl package PostgresNode, which is an
object-oriented representation of a single server, with some support
routines such as init, start, stop, psql. This serves as a better basis
on which to build further test code, and enables writing tests that use
more than one server without too much complication.
This commit modifies a lot of the existing test files, mostly to remove
explicit calls to system commands (pg_ctl) replacing them with method
calls of a PostgresNode object. The result is quite a bit more
straightforward.
Also move some initialization code to BEGIN and INIT blocks instead of
having it straight in as top-level code.
This commit also introduces package RecursiveCopy so that we can copy
whole directories without having to depend on packages that may not be
present on vanilla Perl 5.8 installations.
I also ran perltidy on the modified files, which changes some code sites
that are not otherwise touched by this patch. I tried to avoid this,
but it ended up being more trouble than it's worth.
Authors: Michael Paquier, Álvaro Herrera
Review: Noah Misch
2015-12-02 22:46:16 +01:00
|
|
|
print $conf "fsync = off\n";
|
|
|
|
print $conf "log_statement = all\n";
|
|
|
|
print $conf "port = $port\n";
|
|
|
|
if ($TestLib::windows_os)
|
|
|
|
{
|
|
|
|
print $conf "listen_addresses = '$host'\n";
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
print $conf "unix_socket_directories = '$host'\n";
|
|
|
|
print $conf "listen_addresses = ''\n";
|
|
|
|
}
|
|
|
|
close $conf;
|
|
|
|
|
|
|
|
$self->set_replication_conf if ($params{hba_permit_replication});
|
|
|
|
}
|
|
|
|
|
|
|
|
sub append_conf
|
|
|
|
{
|
|
|
|
my ($self, $filename, $str) = @_;
|
|
|
|
|
|
|
|
my $conffile = $self->data_dir . '/' . $filename;
|
|
|
|
|
|
|
|
TestLib::append_to_file($conffile, $str);
|
|
|
|
}
|
|
|
|
|
|
|
|
sub backup
|
|
|
|
{
|
|
|
|
my ($self, $backup_name) = @_;
|
|
|
|
my $backup_path = $self->backup_dir . '/' . $backup_name;
|
|
|
|
my $port = $self->port;
|
2016-01-20 18:13:11 +01:00
|
|
|
my $name = $self->name;
|
Refactor Perl test code
The original code was a bit clunky; make it more amenable for further
reuse by creating a new Perl package PostgresNode, which is an
object-oriented representation of a single server, with some support
routines such as init, start, stop, psql. This serves as a better basis
on which to build further test code, and enables writing tests that use
more than one server without too much complication.
This commit modifies a lot of the existing test files, mostly to remove
explicit calls to system commands (pg_ctl) replacing them with method
calls of a PostgresNode object. The result is quite a bit more
straightforward.
Also move some initialization code to BEGIN and INIT blocks instead of
having it straight in as top-level code.
This commit also introduces package RecursiveCopy so that we can copy
whole directories without having to depend on packages that may not be
present on vanilla Perl 5.8 installations.
I also ran perltidy on the modified files, which changes some code sites
that are not otherwise touched by this patch. I tried to avoid this,
but it ended up being more trouble than it's worth.
Authors: Michael Paquier, Álvaro Herrera
Review: Noah Misch
2015-12-02 22:46:16 +01:00
|
|
|
|
2016-01-20 18:13:11 +01:00
|
|
|
print "# Taking backup $backup_name from node \"$name\"\n";
|
Refactor Perl test code
The original code was a bit clunky; make it more amenable for further
reuse by creating a new Perl package PostgresNode, which is an
object-oriented representation of a single server, with some support
routines such as init, start, stop, psql. This serves as a better basis
on which to build further test code, and enables writing tests that use
more than one server without too much complication.
This commit modifies a lot of the existing test files, mostly to remove
explicit calls to system commands (pg_ctl) replacing them with method
calls of a PostgresNode object. The result is quite a bit more
straightforward.
Also move some initialization code to BEGIN and INIT blocks instead of
having it straight in as top-level code.
This commit also introduces package RecursiveCopy so that we can copy
whole directories without having to depend on packages that may not be
present on vanilla Perl 5.8 installations.
I also ran perltidy on the modified files, which changes some code sites
that are not otherwise touched by this patch. I tried to avoid this,
but it ended up being more trouble than it's worth.
Authors: Michael Paquier, Álvaro Herrera
Review: Noah Misch
2015-12-02 22:46:16 +01:00
|
|
|
TestLib::system_or_bail("pg_basebackup -D $backup_path -p $port -x");
|
|
|
|
print "# Backup finished\n";
|
|
|
|
}
|
|
|
|
|
|
|
|
sub init_from_backup
|
|
|
|
{
|
|
|
|
my ($self, $root_node, $backup_name) = @_;
|
|
|
|
my $backup_path = $root_node->backup_dir . '/' . $backup_name;
|
|
|
|
my $port = $self->port;
|
2016-01-20 18:13:11 +01:00
|
|
|
my $node_name = $self->name;
|
|
|
|
my $root_name = $root_node->name;
|
Refactor Perl test code
The original code was a bit clunky; make it more amenable for further
reuse by creating a new Perl package PostgresNode, which is an
object-oriented representation of a single server, with some support
routines such as init, start, stop, psql. This serves as a better basis
on which to build further test code, and enables writing tests that use
more than one server without too much complication.
This commit modifies a lot of the existing test files, mostly to remove
explicit calls to system commands (pg_ctl) replacing them with method
calls of a PostgresNode object. The result is quite a bit more
straightforward.
Also move some initialization code to BEGIN and INIT blocks instead of
having it straight in as top-level code.
This commit also introduces package RecursiveCopy so that we can copy
whole directories without having to depend on packages that may not be
present on vanilla Perl 5.8 installations.
I also ran perltidy on the modified files, which changes some code sites
that are not otherwise touched by this patch. I tried to avoid this,
but it ended up being more trouble than it's worth.
Authors: Michael Paquier, Álvaro Herrera
Review: Noah Misch
2015-12-02 22:46:16 +01:00
|
|
|
|
|
|
|
print
|
2016-01-20 18:13:11 +01:00
|
|
|
"# Initializing node \"$node_name\" from backup \"$backup_name\" of node \"$root_name\"\n";
|
|
|
|
die "Backup \"$backup_name\" does not exist at $backup_path"
|
|
|
|
unless -d $backup_path;
|
Refactor Perl test code
The original code was a bit clunky; make it more amenable for further
reuse by creating a new Perl package PostgresNode, which is an
object-oriented representation of a single server, with some support
routines such as init, start, stop, psql. This serves as a better basis
on which to build further test code, and enables writing tests that use
more than one server without too much complication.
This commit modifies a lot of the existing test files, mostly to remove
explicit calls to system commands (pg_ctl) replacing them with method
calls of a PostgresNode object. The result is quite a bit more
straightforward.
Also move some initialization code to BEGIN and INIT blocks instead of
having it straight in as top-level code.
This commit also introduces package RecursiveCopy so that we can copy
whole directories without having to depend on packages that may not be
present on vanilla Perl 5.8 installations.
I also ran perltidy on the modified files, which changes some code sites
that are not otherwise touched by this patch. I tried to avoid this,
but it ended up being more trouble than it's worth.
Authors: Michael Paquier, Álvaro Herrera
Review: Noah Misch
2015-12-02 22:46:16 +01:00
|
|
|
|
|
|
|
mkdir $self->backup_dir;
|
|
|
|
mkdir $self->archive_dir;
|
|
|
|
|
|
|
|
my $data_path = $self->data_dir;
|
|
|
|
rmdir($data_path);
|
|
|
|
RecursiveCopy::copypath($backup_path, $data_path);
|
|
|
|
chmod(0700, $data_path);
|
|
|
|
|
|
|
|
# Base configuration for this node
|
|
|
|
$self->append_conf(
|
|
|
|
'postgresql.conf',
|
|
|
|
qq(
|
|
|
|
port = $port
|
|
|
|
));
|
|
|
|
$self->set_replication_conf;
|
|
|
|
}
|
|
|
|
|
|
|
|
sub start
|
|
|
|
{
|
|
|
|
my ($self) = @_;
|
|
|
|
my $port = $self->port;
|
|
|
|
my $pgdata = $self->data_dir;
|
2016-01-20 18:13:11 +01:00
|
|
|
my $name = $self->name;
|
|
|
|
print("### Starting node \"$name\"\n");
|
Refactor Perl test code
The original code was a bit clunky; make it more amenable for further
reuse by creating a new Perl package PostgresNode, which is an
object-oriented representation of a single server, with some support
routines such as init, start, stop, psql. This serves as a better basis
on which to build further test code, and enables writing tests that use
more than one server without too much complication.
This commit modifies a lot of the existing test files, mostly to remove
explicit calls to system commands (pg_ctl) replacing them with method
calls of a PostgresNode object. The result is quite a bit more
straightforward.
Also move some initialization code to BEGIN and INIT blocks instead of
having it straight in as top-level code.
This commit also introduces package RecursiveCopy so that we can copy
whole directories without having to depend on packages that may not be
present on vanilla Perl 5.8 installations.
I also ran perltidy on the modified files, which changes some code sites
that are not otherwise touched by this patch. I tried to avoid this,
but it ended up being more trouble than it's worth.
Authors: Michael Paquier, Álvaro Herrera
Review: Noah Misch
2015-12-02 22:46:16 +01:00
|
|
|
my $ret = TestLib::system_log('pg_ctl', '-w', '-D', $self->data_dir, '-l',
|
|
|
|
$self->logfile, 'start');
|
|
|
|
|
|
|
|
if ($ret != 0)
|
|
|
|
{
|
|
|
|
print "# pg_ctl failed; logfile:\n";
|
|
|
|
print TestLib::slurp_file($self->logfile);
|
|
|
|
BAIL_OUT("pg_ctl failed");
|
|
|
|
}
|
|
|
|
|
|
|
|
$self->_update_pid;
|
|
|
|
}
|
|
|
|
|
|
|
|
sub stop
|
|
|
|
{
|
|
|
|
my ($self, $mode) = @_;
|
|
|
|
my $port = $self->port;
|
|
|
|
my $pgdata = $self->data_dir;
|
2016-01-20 18:13:11 +01:00
|
|
|
my $name = $self->name;
|
Refactor Perl test code
The original code was a bit clunky; make it more amenable for further
reuse by creating a new Perl package PostgresNode, which is an
object-oriented representation of a single server, with some support
routines such as init, start, stop, psql. This serves as a better basis
on which to build further test code, and enables writing tests that use
more than one server without too much complication.
This commit modifies a lot of the existing test files, mostly to remove
explicit calls to system commands (pg_ctl) replacing them with method
calls of a PostgresNode object. The result is quite a bit more
straightforward.
Also move some initialization code to BEGIN and INIT blocks instead of
having it straight in as top-level code.
This commit also introduces package RecursiveCopy so that we can copy
whole directories without having to depend on packages that may not be
present on vanilla Perl 5.8 installations.
I also ran perltidy on the modified files, which changes some code sites
that are not otherwise touched by this patch. I tried to avoid this,
but it ended up being more trouble than it's worth.
Authors: Michael Paquier, Álvaro Herrera
Review: Noah Misch
2015-12-02 22:46:16 +01:00
|
|
|
$mode = 'fast' if (!defined($mode));
|
2016-01-20 18:13:11 +01:00
|
|
|
print "### Stopping node \"$name\" using mode $mode\n";
|
Refactor Perl test code
The original code was a bit clunky; make it more amenable for further
reuse by creating a new Perl package PostgresNode, which is an
object-oriented representation of a single server, with some support
routines such as init, start, stop, psql. This serves as a better basis
on which to build further test code, and enables writing tests that use
more than one server without too much complication.
This commit modifies a lot of the existing test files, mostly to remove
explicit calls to system commands (pg_ctl) replacing them with method
calls of a PostgresNode object. The result is quite a bit more
straightforward.
Also move some initialization code to BEGIN and INIT blocks instead of
having it straight in as top-level code.
This commit also introduces package RecursiveCopy so that we can copy
whole directories without having to depend on packages that may not be
present on vanilla Perl 5.8 installations.
I also ran perltidy on the modified files, which changes some code sites
that are not otherwise touched by this patch. I tried to avoid this,
but it ended up being more trouble than it's worth.
Authors: Michael Paquier, Álvaro Herrera
Review: Noah Misch
2015-12-02 22:46:16 +01:00
|
|
|
TestLib::system_log('pg_ctl', '-D', $pgdata, '-m', $mode, 'stop');
|
|
|
|
$self->{_pid} = undef;
|
|
|
|
$self->_update_pid;
|
|
|
|
}
|
|
|
|
|
|
|
|
sub restart
|
|
|
|
{
|
|
|
|
my ($self) = @_;
|
|
|
|
my $port = $self->port;
|
|
|
|
my $pgdata = $self->data_dir;
|
|
|
|
my $logfile = $self->logfile;
|
2016-01-20 18:13:11 +01:00
|
|
|
my $name = $self->name;
|
|
|
|
print "### Restarting node \"$name\"\n";
|
Refactor Perl test code
The original code was a bit clunky; make it more amenable for further
reuse by creating a new Perl package PostgresNode, which is an
object-oriented representation of a single server, with some support
routines such as init, start, stop, psql. This serves as a better basis
on which to build further test code, and enables writing tests that use
more than one server without too much complication.
This commit modifies a lot of the existing test files, mostly to remove
explicit calls to system commands (pg_ctl) replacing them with method
calls of a PostgresNode object. The result is quite a bit more
straightforward.
Also move some initialization code to BEGIN and INIT blocks instead of
having it straight in as top-level code.
This commit also introduces package RecursiveCopy so that we can copy
whole directories without having to depend on packages that may not be
present on vanilla Perl 5.8 installations.
I also ran perltidy on the modified files, which changes some code sites
that are not otherwise touched by this patch. I tried to avoid this,
but it ended up being more trouble than it's worth.
Authors: Michael Paquier, Álvaro Herrera
Review: Noah Misch
2015-12-02 22:46:16 +01:00
|
|
|
TestLib::system_log('pg_ctl', '-D', $pgdata, '-w', '-l', $logfile,
|
|
|
|
'restart');
|
|
|
|
$self->_update_pid;
|
|
|
|
}
|
|
|
|
|
|
|
|
sub _update_pid
|
|
|
|
{
|
|
|
|
my $self = shift;
|
2016-01-20 18:13:11 +01:00
|
|
|
my $name = $self->name;
|
Refactor Perl test code
The original code was a bit clunky; make it more amenable for further
reuse by creating a new Perl package PostgresNode, which is an
object-oriented representation of a single server, with some support
routines such as init, start, stop, psql. This serves as a better basis
on which to build further test code, and enables writing tests that use
more than one server without too much complication.
This commit modifies a lot of the existing test files, mostly to remove
explicit calls to system commands (pg_ctl) replacing them with method
calls of a PostgresNode object. The result is quite a bit more
straightforward.
Also move some initialization code to BEGIN and INIT blocks instead of
having it straight in as top-level code.
This commit also introduces package RecursiveCopy so that we can copy
whole directories without having to depend on packages that may not be
present on vanilla Perl 5.8 installations.
I also ran perltidy on the modified files, which changes some code sites
that are not otherwise touched by this patch. I tried to avoid this,
but it ended up being more trouble than it's worth.
Authors: Michael Paquier, Álvaro Herrera
Review: Noah Misch
2015-12-02 22:46:16 +01:00
|
|
|
|
|
|
|
# If we can open the PID file, read its first line and that's the PID we
|
|
|
|
# want. If the file cannot be opened, presumably the server is not
|
|
|
|
# running; don't be noisy in that case.
|
2015-12-07 23:25:31 +01:00
|
|
|
if (open my $pidfile, $self->data_dir . "/postmaster.pid")
|
Refactor Perl test code
The original code was a bit clunky; make it more amenable for further
reuse by creating a new Perl package PostgresNode, which is an
object-oriented representation of a single server, with some support
routines such as init, start, stop, psql. This serves as a better basis
on which to build further test code, and enables writing tests that use
more than one server without too much complication.
This commit modifies a lot of the existing test files, mostly to remove
explicit calls to system commands (pg_ctl) replacing them with method
calls of a PostgresNode object. The result is quite a bit more
straightforward.
Also move some initialization code to BEGIN and INIT blocks instead of
having it straight in as top-level code.
This commit also introduces package RecursiveCopy so that we can copy
whole directories without having to depend on packages that may not be
present on vanilla Perl 5.8 installations.
I also ran perltidy on the modified files, which changes some code sites
that are not otherwise touched by this patch. I tried to avoid this,
but it ended up being more trouble than it's worth.
Authors: Michael Paquier, Álvaro Herrera
Review: Noah Misch
2015-12-02 22:46:16 +01:00
|
|
|
{
|
2015-12-07 23:25:31 +01:00
|
|
|
chomp($self->{_pid} = <$pidfile>);
|
2016-01-20 18:13:11 +01:00
|
|
|
print "# Postmaster PID for node \"$name\" is $self->{_pid}\n";
|
2015-12-07 23:25:31 +01:00
|
|
|
close $pidfile;
|
Refactor Perl test code
The original code was a bit clunky; make it more amenable for further
reuse by creating a new Perl package PostgresNode, which is an
object-oriented representation of a single server, with some support
routines such as init, start, stop, psql. This serves as a better basis
on which to build further test code, and enables writing tests that use
more than one server without too much complication.
This commit modifies a lot of the existing test files, mostly to remove
explicit calls to system commands (pg_ctl) replacing them with method
calls of a PostgresNode object. The result is quite a bit more
straightforward.
Also move some initialization code to BEGIN and INIT blocks instead of
having it straight in as top-level code.
This commit also introduces package RecursiveCopy so that we can copy
whole directories without having to depend on packages that may not be
present on vanilla Perl 5.8 installations.
I also ran perltidy on the modified files, which changes some code sites
that are not otherwise touched by this patch. I tried to avoid this,
but it ended up being more trouble than it's worth.
Authors: Michael Paquier, Álvaro Herrera
Review: Noah Misch
2015-12-02 22:46:16 +01:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2015-12-07 23:25:31 +01:00
|
|
|
$self->{_pid} = undef;
|
|
|
|
print "# No postmaster PID\n";
|
Refactor Perl test code
The original code was a bit clunky; make it more amenable for further
reuse by creating a new Perl package PostgresNode, which is an
object-oriented representation of a single server, with some support
routines such as init, start, stop, psql. This serves as a better basis
on which to build further test code, and enables writing tests that use
more than one server without too much complication.
This commit modifies a lot of the existing test files, mostly to remove
explicit calls to system commands (pg_ctl) replacing them with method
calls of a PostgresNode object. The result is quite a bit more
straightforward.
Also move some initialization code to BEGIN and INIT blocks instead of
having it straight in as top-level code.
This commit also introduces package RecursiveCopy so that we can copy
whole directories without having to depend on packages that may not be
present on vanilla Perl 5.8 installations.
I also ran perltidy on the modified files, which changes some code sites
that are not otherwise touched by this patch. I tried to avoid this,
but it ended up being more trouble than it's worth.
Authors: Michael Paquier, Álvaro Herrera
Review: Noah Misch
2015-12-02 22:46:16 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
#
|
|
|
|
# Cluster management functions
|
|
|
|
#
|
|
|
|
|
|
|
|
# Build a new PostgresNode object, assigning a free port number.
|
|
|
|
#
|
|
|
|
# We also register the node, to avoid the port number from being reused
|
|
|
|
# for another node even when this one is not active.
|
|
|
|
sub get_new_node
|
|
|
|
{
|
2016-01-20 18:13:11 +01:00
|
|
|
my $name = shift;
|
Refactor Perl test code
The original code was a bit clunky; make it more amenable for further
reuse by creating a new Perl package PostgresNode, which is an
object-oriented representation of a single server, with some support
routines such as init, start, stop, psql. This serves as a better basis
on which to build further test code, and enables writing tests that use
more than one server without too much complication.
This commit modifies a lot of the existing test files, mostly to remove
explicit calls to system commands (pg_ctl) replacing them with method
calls of a PostgresNode object. The result is quite a bit more
straightforward.
Also move some initialization code to BEGIN and INIT blocks instead of
having it straight in as top-level code.
This commit also introduces package RecursiveCopy so that we can copy
whole directories without having to depend on packages that may not be
present on vanilla Perl 5.8 installations.
I also ran perltidy on the modified files, which changes some code sites
that are not otherwise touched by this patch. I tried to avoid this,
but it ended up being more trouble than it's worth.
Authors: Michael Paquier, Álvaro Herrera
Review: Noah Misch
2015-12-02 22:46:16 +01:00
|
|
|
my $found = 0;
|
|
|
|
my $port = $last_port_assigned;
|
|
|
|
|
|
|
|
while ($found == 0)
|
|
|
|
{
|
2015-12-08 00:06:21 +01:00
|
|
|
# wrap correctly around range end
|
|
|
|
$port = 49152 if ++$port >= 65536;
|
Refactor Perl test code
The original code was a bit clunky; make it more amenable for further
reuse by creating a new Perl package PostgresNode, which is an
object-oriented representation of a single server, with some support
routines such as init, start, stop, psql. This serves as a better basis
on which to build further test code, and enables writing tests that use
more than one server without too much complication.
This commit modifies a lot of the existing test files, mostly to remove
explicit calls to system commands (pg_ctl) replacing them with method
calls of a PostgresNode object. The result is quite a bit more
straightforward.
Also move some initialization code to BEGIN and INIT blocks instead of
having it straight in as top-level code.
This commit also introduces package RecursiveCopy so that we can copy
whole directories without having to depend on packages that may not be
present on vanilla Perl 5.8 installations.
I also ran perltidy on the modified files, which changes some code sites
that are not otherwise touched by this patch. I tried to avoid this,
but it ended up being more trouble than it's worth.
Authors: Michael Paquier, Álvaro Herrera
Review: Noah Misch
2015-12-02 22:46:16 +01:00
|
|
|
print "# Checking for port $port\n";
|
|
|
|
if (!TestLib::run_log([ 'pg_isready', '-p', $port ]))
|
|
|
|
{
|
|
|
|
$found = 1;
|
|
|
|
|
|
|
|
# Found a potential candidate port number. Check first that it is
|
|
|
|
# not included in the list of registered nodes.
|
|
|
|
foreach my $node (@all_nodes)
|
|
|
|
{
|
|
|
|
$found = 0 if ($node->port == $port);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
print "# Found free port $port\n";
|
|
|
|
|
|
|
|
# Lock port number found by creating a new node
|
2016-01-20 18:13:11 +01:00
|
|
|
my $node = new PostgresNode($name, $test_pghost, $port);
|
Refactor Perl test code
The original code was a bit clunky; make it more amenable for further
reuse by creating a new Perl package PostgresNode, which is an
object-oriented representation of a single server, with some support
routines such as init, start, stop, psql. This serves as a better basis
on which to build further test code, and enables writing tests that use
more than one server without too much complication.
This commit modifies a lot of the existing test files, mostly to remove
explicit calls to system commands (pg_ctl) replacing them with method
calls of a PostgresNode object. The result is quite a bit more
straightforward.
Also move some initialization code to BEGIN and INIT blocks instead of
having it straight in as top-level code.
This commit also introduces package RecursiveCopy so that we can copy
whole directories without having to depend on packages that may not be
present on vanilla Perl 5.8 installations.
I also ran perltidy on the modified files, which changes some code sites
that are not otherwise touched by this patch. I tried to avoid this,
but it ended up being more trouble than it's worth.
Authors: Michael Paquier, Álvaro Herrera
Review: Noah Misch
2015-12-02 22:46:16 +01:00
|
|
|
|
|
|
|
# Add node to list of nodes
|
|
|
|
push(@all_nodes, $node);
|
|
|
|
|
|
|
|
# And update port for next time
|
|
|
|
$last_port_assigned = $port;
|
|
|
|
|
|
|
|
return $node;
|
|
|
|
}
|
|
|
|
|
|
|
|
sub DESTROY
|
|
|
|
{
|
|
|
|
my $self = shift;
|
2016-01-20 18:13:11 +01:00
|
|
|
my $name = $self->name;
|
Refactor Perl test code
The original code was a bit clunky; make it more amenable for further
reuse by creating a new Perl package PostgresNode, which is an
object-oriented representation of a single server, with some support
routines such as init, start, stop, psql. This serves as a better basis
on which to build further test code, and enables writing tests that use
more than one server without too much complication.
This commit modifies a lot of the existing test files, mostly to remove
explicit calls to system commands (pg_ctl) replacing them with method
calls of a PostgresNode object. The result is quite a bit more
straightforward.
Also move some initialization code to BEGIN and INIT blocks instead of
having it straight in as top-level code.
This commit also introduces package RecursiveCopy so that we can copy
whole directories without having to depend on packages that may not be
present on vanilla Perl 5.8 installations.
I also ran perltidy on the modified files, which changes some code sites
that are not otherwise touched by this patch. I tried to avoid this,
but it ended up being more trouble than it's worth.
Authors: Michael Paquier, Álvaro Herrera
Review: Noah Misch
2015-12-02 22:46:16 +01:00
|
|
|
return if not defined $self->{_pid};
|
2016-01-20 18:13:11 +01:00
|
|
|
print "### Signalling QUIT to $self->{_pid} for node \"$name\"\n";
|
2015-12-07 23:25:31 +01:00
|
|
|
TestLib::system_log('pg_ctl', 'kill', 'QUIT', $self->{_pid});
|
Refactor Perl test code
The original code was a bit clunky; make it more amenable for further
reuse by creating a new Perl package PostgresNode, which is an
object-oriented representation of a single server, with some support
routines such as init, start, stop, psql. This serves as a better basis
on which to build further test code, and enables writing tests that use
more than one server without too much complication.
This commit modifies a lot of the existing test files, mostly to remove
explicit calls to system commands (pg_ctl) replacing them with method
calls of a PostgresNode object. The result is quite a bit more
straightforward.
Also move some initialization code to BEGIN and INIT blocks instead of
having it straight in as top-level code.
This commit also introduces package RecursiveCopy so that we can copy
whole directories without having to depend on packages that may not be
present on vanilla Perl 5.8 installations.
I also ran perltidy on the modified files, which changes some code sites
that are not otherwise touched by this patch. I tried to avoid this,
but it ended up being more trouble than it's worth.
Authors: Michael Paquier, Álvaro Herrera
Review: Noah Misch
2015-12-02 22:46:16 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
sub teardown_node
|
|
|
|
{
|
|
|
|
my $self = shift;
|
|
|
|
|
|
|
|
$self->stop('immediate');
|
|
|
|
}
|
|
|
|
|
|
|
|
sub psql
|
|
|
|
{
|
|
|
|
my ($self, $dbname, $sql) = @_;
|
|
|
|
|
|
|
|
my ($stdout, $stderr);
|
2016-01-20 18:13:11 +01:00
|
|
|
my $name = $self->name;
|
|
|
|
print("### Running SQL command on node \"$name\": $sql\n");
|
Refactor Perl test code
The original code was a bit clunky; make it more amenable for further
reuse by creating a new Perl package PostgresNode, which is an
object-oriented representation of a single server, with some support
routines such as init, start, stop, psql. This serves as a better basis
on which to build further test code, and enables writing tests that use
more than one server without too much complication.
This commit modifies a lot of the existing test files, mostly to remove
explicit calls to system commands (pg_ctl) replacing them with method
calls of a PostgresNode object. The result is quite a bit more
straightforward.
Also move some initialization code to BEGIN and INIT blocks instead of
having it straight in as top-level code.
This commit also introduces package RecursiveCopy so that we can copy
whole directories without having to depend on packages that may not be
present on vanilla Perl 5.8 installations.
I also ran perltidy on the modified files, which changes some code sites
that are not otherwise touched by this patch. I tried to avoid this,
but it ended up being more trouble than it's worth.
Authors: Michael Paquier, Álvaro Herrera
Review: Noah Misch
2015-12-02 22:46:16 +01:00
|
|
|
|
|
|
|
IPC::Run::run [ 'psql', '-XAtq', '-d', $self->connstr($dbname), '-f',
|
|
|
|
'-' ], '<', \$sql, '>', \$stdout, '2>', \$stderr
|
|
|
|
or die;
|
|
|
|
|
|
|
|
if ($stderr ne "")
|
|
|
|
{
|
|
|
|
print "#### Begin standard error\n";
|
|
|
|
print $stderr;
|
|
|
|
print "#### End standard error\n";
|
|
|
|
}
|
|
|
|
chomp $stdout;
|
|
|
|
$stdout =~ s/\r//g if $Config{osname} eq 'msys';
|
|
|
|
return $stdout;
|
|
|
|
}
|
|
|
|
|
|
|
|
# Run a query once a second, until it returns 't' (i.e. SQL boolean true).
|
|
|
|
sub poll_query_until
|
|
|
|
{
|
|
|
|
my ($self, $dbname, $query) = @_;
|
|
|
|
|
2016-02-11 02:34:57 +01:00
|
|
|
my $max_attempts = 90;
|
Refactor Perl test code
The original code was a bit clunky; make it more amenable for further
reuse by creating a new Perl package PostgresNode, which is an
object-oriented representation of a single server, with some support
routines such as init, start, stop, psql. This serves as a better basis
on which to build further test code, and enables writing tests that use
more than one server without too much complication.
This commit modifies a lot of the existing test files, mostly to remove
explicit calls to system commands (pg_ctl) replacing them with method
calls of a PostgresNode object. The result is quite a bit more
straightforward.
Also move some initialization code to BEGIN and INIT blocks instead of
having it straight in as top-level code.
This commit also introduces package RecursiveCopy so that we can copy
whole directories without having to depend on packages that may not be
present on vanilla Perl 5.8 installations.
I also ran perltidy on the modified files, which changes some code sites
that are not otherwise touched by this patch. I tried to avoid this,
but it ended up being more trouble than it's worth.
Authors: Michael Paquier, Álvaro Herrera
Review: Noah Misch
2015-12-02 22:46:16 +01:00
|
|
|
my $attempts = 0;
|
|
|
|
my ($stdout, $stderr);
|
|
|
|
|
|
|
|
while ($attempts < $max_attempts)
|
|
|
|
{
|
|
|
|
my $cmd =
|
2015-12-08 20:04:08 +01:00
|
|
|
[ 'psql', '-XAt', '-c', $query, '-d', $self->connstr($dbname) ];
|
Refactor Perl test code
The original code was a bit clunky; make it more amenable for further
reuse by creating a new Perl package PostgresNode, which is an
object-oriented representation of a single server, with some support
routines such as init, start, stop, psql. This serves as a better basis
on which to build further test code, and enables writing tests that use
more than one server without too much complication.
This commit modifies a lot of the existing test files, mostly to remove
explicit calls to system commands (pg_ctl) replacing them with method
calls of a PostgresNode object. The result is quite a bit more
straightforward.
Also move some initialization code to BEGIN and INIT blocks instead of
having it straight in as top-level code.
This commit also introduces package RecursiveCopy so that we can copy
whole directories without having to depend on packages that may not be
present on vanilla Perl 5.8 installations.
I also ran perltidy on the modified files, which changes some code sites
that are not otherwise touched by this patch. I tried to avoid this,
but it ended up being more trouble than it's worth.
Authors: Michael Paquier, Álvaro Herrera
Review: Noah Misch
2015-12-02 22:46:16 +01:00
|
|
|
my $result = IPC::Run::run $cmd, '>', \$stdout, '2>', \$stderr;
|
|
|
|
|
|
|
|
chomp($stdout);
|
|
|
|
$stdout =~ s/\r//g if $Config{osname} eq 'msys';
|
|
|
|
if ($stdout eq "t")
|
|
|
|
{
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
# Wait a second before retrying.
|
|
|
|
sleep 1;
|
|
|
|
$attempts++;
|
|
|
|
}
|
|
|
|
|
2016-02-11 02:34:57 +01:00
|
|
|
# The query result didn't change in 90 seconds. Give up. Print the stderr
|
Refactor Perl test code
The original code was a bit clunky; make it more amenable for further
reuse by creating a new Perl package PostgresNode, which is an
object-oriented representation of a single server, with some support
routines such as init, start, stop, psql. This serves as a better basis
on which to build further test code, and enables writing tests that use
more than one server without too much complication.
This commit modifies a lot of the existing test files, mostly to remove
explicit calls to system commands (pg_ctl) replacing them with method
calls of a PostgresNode object. The result is quite a bit more
straightforward.
Also move some initialization code to BEGIN and INIT blocks instead of
having it straight in as top-level code.
This commit also introduces package RecursiveCopy so that we can copy
whole directories without having to depend on packages that may not be
present on vanilla Perl 5.8 installations.
I also ran perltidy on the modified files, which changes some code sites
that are not otherwise touched by this patch. I tried to avoid this,
but it ended up being more trouble than it's worth.
Authors: Michael Paquier, Álvaro Herrera
Review: Noah Misch
2015-12-02 22:46:16 +01:00
|
|
|
# from the last attempt, hopefully that's useful for debugging.
|
|
|
|
diag $stderr;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
sub command_ok
|
|
|
|
{
|
|
|
|
my $self = shift;
|
|
|
|
|
|
|
|
local $ENV{PGPORT} = $self->port;
|
|
|
|
|
|
|
|
TestLib::command_ok(@_);
|
|
|
|
}
|
|
|
|
|
|
|
|
sub command_fails
|
|
|
|
{
|
|
|
|
my $self = shift;
|
|
|
|
|
|
|
|
local $ENV{PGPORT} = $self->port;
|
|
|
|
|
|
|
|
TestLib::command_fails(@_);
|
|
|
|
}
|
|
|
|
|
|
|
|
sub command_like
|
|
|
|
{
|
|
|
|
my $self = shift;
|
|
|
|
|
|
|
|
local $ENV{PGPORT} = $self->port;
|
|
|
|
|
|
|
|
TestLib::command_like(@_);
|
|
|
|
}
|
|
|
|
|
|
|
|
# Run a command on the node, then verify that $expected_sql appears in the
|
|
|
|
# server log file.
|
|
|
|
sub issues_sql_like
|
|
|
|
{
|
|
|
|
my ($self, $cmd, $expected_sql, $test_name) = @_;
|
|
|
|
|
|
|
|
local $ENV{PGPORT} = $self->port;
|
|
|
|
|
|
|
|
truncate $self->logfile, 0;
|
|
|
|
my $result = TestLib::run_log($cmd);
|
|
|
|
ok($result, "@$cmd exit code 0");
|
|
|
|
my $log = TestLib::slurp_file($self->logfile);
|
|
|
|
like($log, $expected_sql, "$test_name: SQL found in server log");
|
|
|
|
}
|
|
|
|
|
|
|
|
1;
|