On Tue, May 18, 2021 at 10:49:39AM +0900, Michael Paquier wrote: > Makes sense. For now, I'll update this patch set so as it is possible > to use custom dumps, as an option in parallel of pg_regress when > specifying a different source code path. I'll also decouple the > business with probin updates and stick with the approach used by the > buildfarm code.
This has proved to not be that difficult. With the updated version attached, pg_upgrade has two modes to set up the old instance used for the upgrade with older binaries: - With oldsrc and oldinstall set, pg_regress gets used, same way as HEAD. - With olddump and oldinstall set, an old dump is loaded instead in the old instance before launching the upgrade. oldsrc and olddump are exclusive options. Similarly to HEAD, the dumps taken from the old and new instances generate diffs that can be inspected manually. The updates of probin are done without any dependencies to the source path of the old instance, copying from the buildfarm. While on it, I have fixed a couple of things that exist in test.sh but were not reflected in this new script: - Handling of postfix operations with ~13 clusters. - Handling oldstyle_length for ~9.6 clusters. - Handling of EXTRA_REGRESS_OPT. This stuff still needs to be expanded depending on how PostgresNode is made backward-compatible, but I'll wait for that to happen before going further down here. I have also spent some time testing all that with MSVC, and the installation paths used for pg_regress&co make the script a tad more confusing, so I have dropped this part for now. Thanks, -- Michael
From bfb0086cfc35c063acc671896a7ffcb2c23dc2c2 Mon Sep 17 00:00:00 2001 From: Michael Paquier <mich...@paquier.xyz> Date: Thu, 20 May 2021 15:04:55 +0900 Subject: [PATCH v2] Switch tests of pg_upgrade to use TAP --- src/bin/pg_upgrade/Makefile | 17 +- src/bin/pg_upgrade/TESTING | 29 ++- src/bin/pg_upgrade/t/001_basic.pl | 9 + src/bin/pg_upgrade/t/002_pg_upgrade.pl | 266 ++++++++++++++++++++++++ src/bin/pg_upgrade/test.sh | 272 ------------------------- src/test/perl/PostgresNode.pm | 25 +++ 6 files changed, 323 insertions(+), 295 deletions(-) create mode 100644 src/bin/pg_upgrade/t/001_basic.pl create mode 100644 src/bin/pg_upgrade/t/002_pg_upgrade.pl delete mode 100644 src/bin/pg_upgrade/test.sh diff --git a/src/bin/pg_upgrade/Makefile b/src/bin/pg_upgrade/Makefile index 44d06be5a6..fa8dee0a9c 100644 --- a/src/bin/pg_upgrade/Makefile +++ b/src/bin/pg_upgrade/Makefile @@ -49,17 +49,8 @@ clean distclean maintainer-clean: pg_upgrade_dump_globals.sql \ pg_upgrade_dump_*.custom pg_upgrade_*.log -# When $(MAKE) is present, make automatically infers that this is a -# recursive make. which is not actually what we want here, as that -# e.g. prevents output synchronization from working (as make thinks -# that the subsidiary make knows how to deal with that itself, but -# we're invoking a shell script that doesn't know). Referencing -# $(MAKE) indirectly avoids that behaviour. -# See https://www.gnu.org/software/make/manual/html_node/MAKE-Variable.html#MAKE-Variable -NOTSUBMAKEMAKE=$(MAKE) +check: + $(prove_check) -check: test.sh all temp-install - MAKE=$(NOTSUBMAKEMAKE) $(with_temp_install) bindir=$(abs_top_builddir)/tmp_install/$(bindir) EXTRA_REGRESS_OPTS="$(EXTRA_REGRESS_OPTS)" $(SHELL) $< - -# installcheck is not supported because there's no meaningful way to test -# pg_upgrade against a single already-running server +installcheck: + $(prove_installcheck) diff --git a/src/bin/pg_upgrade/TESTING b/src/bin/pg_upgrade/TESTING index e69874b42d..185943dd4b 100644 --- a/src/bin/pg_upgrade/TESTING +++ b/src/bin/pg_upgrade/TESTING @@ -4,19 +4,26 @@ THE SHORT VERSION On non-Windows machines, you can execute the testing process described below by running make check -in this directory. This will run the shell script test.sh, performing -an upgrade from the version in this source tree to a new instance of -the same version. +in this directory. This will run the TAP tests to run pg_upgrade, +performing an upgrade from the version in this source tree to a +new instance of the same version. -To test an upgrade from a different version, you must have a built -source tree for the old version as well as this version, and you -must have done "make install" for both versions. Then do: +To test an upgrade from a different version, there are two options +available: + +1) You have a built source tree for the old version as well as this +version's binaries. Then set up the following variables: export oldsrc=...somewhere/postgresql (old version's source tree) -export oldbindir=...otherversion/bin (old version's installed bin dir) -export bindir=...thisversion/bin (this version's installed bin dir) -export libdir=...thisversion/lib (this version's installed lib dir) -sh test.sh +export oldinstall=...otherversion/bin (old version's install base path) + +2) You have a dump that can be used to set up the old version, as well +as this version's binaries. Then set up the following variables: +export olddump=...somewhere/dump.sql (old version's dump) +export oldinstall=...otherversion/bin (old version's install base path) + +Finally, the tests can be done by running + make check In this case, you will have to manually eyeball the resulting dump diff for version-specific differences, as explained below. @@ -87,3 +94,5 @@ steps: 7) Diff the regression database dump file with the regression dump file loaded into the old server. + +The generated dump may be reusable with "olddump", as defined above. diff --git a/src/bin/pg_upgrade/t/001_basic.pl b/src/bin/pg_upgrade/t/001_basic.pl new file mode 100644 index 0000000000..605a7f622f --- /dev/null +++ b/src/bin/pg_upgrade/t/001_basic.pl @@ -0,0 +1,9 @@ +use strict; +use warnings; + +use TestLib; +use Test::More tests => 8; + +program_help_ok('pg_upgrade'); +program_version_ok('pg_upgrade'); +program_options_handling_ok('pg_upgrade'); diff --git a/src/bin/pg_upgrade/t/002_pg_upgrade.pl b/src/bin/pg_upgrade/t/002_pg_upgrade.pl new file mode 100644 index 0000000000..4d813ad5c3 --- /dev/null +++ b/src/bin/pg_upgrade/t/002_pg_upgrade.pl @@ -0,0 +1,266 @@ +# Set of tests for pg_upgrade. +use strict; +use warnings; + +use Cwd qw(abs_path getcwd); +use File::Basename qw(dirname); + +use PostgresNode; +use TestLib; +use Test::More tests => 4; + +# Generate a database with a name made of a range of ASCII characters. +sub generate_db +{ + my ($node, $from_char, $to_char) = @_; + + my $dbname = ''; + for my $i ($from_char .. $to_char) + { + next if $i == 7 || $i == 10 || $i == 13; # skip BEL, LF, and CR + $dbname = $dbname . sprintf('%c', $i); + } + $node->run_log([ 'createdb', '--port', $node->port, $dbname ]); +} + +my $startdir = getcwd(); + +# From now on, the test of pg_upgrade consists in setting up an instance. +# This is the source instance used for the upgrade. Then a new and fresh +# instance is created, and is used as the target instance for the +# upgrade. Before running an upgrade a logical dump of the old instance +# is taken, and a second logical dump of the new instance is taken after +# the upgrade. The upgrade test passes if there are no differences after +# running pg_upgrade. + +# Testing upgrades with an older instance of PostgreSQL requires +# setting up two environment variables, among the following: +# - "oldsrc", to point to the code source of the older version. +# This is required to set up the old instance with pg_upgrade. +# - "olddump", to point to a dump file that will be used to set +# up the old instance to upgrade from. +# - "oldinstall", to point to the installation path of the older +# version. + +# "oldsrc" and "olddump" cannot be used together. Setting up +# "olddump" and "oldinstall" will use the dump pointed to to +# set up the old instance. If "oldsrc" is used instead of "olddump", +# the full set of regression tests of the old instance is run +# instead. + +if (defined($ENV{oldsrc}) && defined($ENV{olddump})) +{ + die "oldsrc and olddump are both defined"; +} +elsif (defined($ENV{oldsrc})) +{ + if ( (defined($ENV{oldsrc}) && !defined($ENV{oldinstall})) + || (!defined($ENV{oldsrc}) && defined($ENV{oldinstall}))) + { + # Not all variables are defined, so leave and die if test is + # done with an older installation. + die "oldsrc or oldinstall is undefined"; + } +} +elsif (defined($ENV{olddump})) +{ + if ( (defined($ENV{olddump}) && !defined($ENV{oldinstall})) + || (!defined($ENV{olddump}) && defined($ENV{oldinstall}))) + { + # Not all variables are defined, so leave and die if test is + # done with an older installation. + die "olddump or oldinstall is undefined"; + } +} + +if ((defined($ENV{oldsrc}) || defined($ENV{olddump})) && $windows_os) +{ + # This configuration is not supported on Windows, as regress.so + # location diverges across the compilation methods used on this + # platform. + die "No support for older version tests on Windows"; +} + +# Default is the location of this source code for both nodes used with +# the upgrade. +my $newsrc = abs_path("../../.."); +my $oldsrc = $ENV{oldsrc} || $newsrc; +$oldsrc = abs_path($oldsrc); + +# Temporary location for the dumps taken +my $tempdir = TestLib::tempdir; + +# Initialize node to upgrade +my $oldnode = get_new_node('old_node', install_path => $ENV{oldinstall}); + +$oldnode->init(extra => [ '--locale', 'C', '--encoding', 'LATIN1' ]); +$oldnode->start; + +# Set up the data of the old instance with pg_regress or an old dump. +if (defined($ENV{olddump})) +{ + # Use the dump specified. + my $olddumpfile = $ENV{olddump}; + die "no dump file found!" unless -e $olddumpfile; + + # Load the dump, and we are done here. + $oldnode->command_ok( + [ 'psql', '-f', $olddumpfile, '--port', $oldnode->port, 'postgres' ]); +} +else +{ + # Default is to just use pg_regress to setup the old instance + # Creating databases with names covering most ASCII bytes + generate_db($oldnode, 1, 45); + generate_db($oldnode, 46, 90); + generate_db($oldnode, 91, 127); + + # Run core regression tests on the old instance. + $oldnode->run_log([ "createdb", '--port', $oldnode->port, 'regression' ]); + + # This is more a trick than anything else, as pg_regress needs to be + # from the old instance. --dlpath is needed to be able to find the + # location of regress.so, and it is located in the same folder as + # pg_regress itself. + + # Grab any regression options that may be passed down by caller. + my $extra_opts_val = $ENV{EXTRA_REGRESS_OPT} || ""; + my @extra_opts = split(/\s+/, $extra_opts_val); + + chdir "$oldsrc/src/test/regress/"; + my @regress_command = [ + $ENV{PG_REGRESS}, '--schedule', + 'parallel_schedule', '--bindir', + $oldnode->config_data('--bindir'), '--make-testtablespace-dir', + '--dlpath', '.', + '--use-existing', '--port', + $oldnode->port + ]; + @regress_command = (@regress_command, @extra_opts); + + $oldnode->command_ok(@regress_command, + 'regression test run on old instance'); + + # Move back to the start path. + chdir $startdir; +} + +# Before dumping, get rid of objects not existing or not supported in later +# versions. This depends on the version of the old server used, and matters +# only if different versions are used for the dump. +my ($result, $oldpgversion, $stderr) = + $oldnode->psql('postgres', qq[SHOW server_version_num;]); +my $fix_sql; + +if (defined($ENV{oldinstall})) +{ + # Changes for PostgreSQL ~13 + if ($oldpgversion < 140000) + { + # Postfix operators are not supported anymore in 14. + $oldnode->psql( + 'regression', " + DROP OPERATOR IF EXISTS #@# (bigint,NONE); + DROP OPERATOR IF EXISTS #%# (bigint,NONE); + DROP OPERATOR IF EXISTS !=- (bigint,NONE); + DROP OPERATOR IF EXISTS #@%# (bigint,NONE);"); + # Last appeared in 13. + $oldnode->psql('regression', "DROP FUNCTION public.putenv(text);"); + } + + # Changes for PostgreSQL ~9.6 + if ($oldpgversion < 100000) + { + # Last appeared in 9.6. + $oldnode->psql('regression', + "DROP FUNCTION public.oldstyle_length(integer, text);"); + } + + # Add here tweaks to objects to adapt to newer versions. +} + +# Initialize a new node for the upgrade. This is done early so as it is +# possible to know with which node's PATH the initial dump needs to be +# taken. +my $newnode = get_new_node('new_node'); +$newnode->init(extra => [ '--locale=C', '--encoding=LATIN1' ]); +my $newbindir = $newnode->config_data('--bindir'); +my $oldbindir = $oldnode->config_data('--bindir'); + +# Take a dump before performing the upgrade as a base comparison. Note +# that we need to use pg_dumpall from the new node here. +$newnode->command_ok( + [ + 'pg_dumpall', '--no-sync', + '-d', $oldnode->connstr('postgres'), + '-f', "$tempdir/dump1.sql" + ], + 'dump before running pg_upgrade'); + +# After dumping, update references to the old source tree's regress.so +# to point to the new tree. +if (defined($ENV{oldinstall})) +{ + # First, fetch all the references to libraries that are not part + # of the default path $libdir. + my $output = $oldnode->safe_psql('regression', + "SELECT probin::text from pg_proc where probin not like '\$libdir%';" + ); + chomp($output); + my @libpaths = split("\n", $output); + + my $dump_data = slurp_file("$tempdir/dump1.sql"); + + my $newregresssrc = "$newsrc/src/test/regress"; + foreach (@libpaths) + { + my $libpath = $_; + $libpath = dirname($libpath); + $dump_data =~ s/$libpath/$newregresssrc/g; + } + + open my $fh, ">", "$tempdir/dump1.sql" or die "could not open dump file"; + print $fh $dump_data; + close $fh; + + # This replaces any references to the old tree's regress.so + # the new tree's regress.so. Any references that do *not* + # match $libdir are switched so as this request does not + # depend on the path of the old source tree. This is useful + # when using an old dump. + $oldnode->safe_psql( + 'regression', "UPDATE pg_proc SET probin = + regexp_replace(probin, '.*/', '$newregresssrc/') + WHERE probin NOT LIKE '\$libdir/%'"); +} + +# Move back to current directory, all logs generated need to be located +# at the origin. +chdir $startdir; + +# Update the instance. +$oldnode->stop; + +# Time for the real run. +chdir "$newsrc/src/test/regress"; +$newnode->command_ok( + [ + 'pg_upgrade', '-d', $oldnode->data_dir, '-D', + $newnode->data_dir, '-b', $oldbindir, '-B', + $newbindir, '-p', $oldnode->port, '-P', + $newnode->port + ], + 'run of pg_upgrade for new instance'); +$newnode->start; + +# Take a second dump on the upgraded instance. +$newnode->run_log( + [ + 'pg_dumpall', '--no-sync', + '-d', $newnode->connstr('postgres'), + '-f', "$tempdir/dump2.sql" + ]); + +# Compare the two dumps, there should be no differences. +command_ok([ 'diff', '-q', "$tempdir/dump1.sql", "$tempdir/dump2.sql" ], + 'Old and new dump match after pg_upgrade'); diff --git a/src/bin/pg_upgrade/test.sh b/src/bin/pg_upgrade/test.sh deleted file mode 100644 index 1ba326decd..0000000000 --- a/src/bin/pg_upgrade/test.sh +++ /dev/null @@ -1,272 +0,0 @@ -#!/bin/sh - -# src/bin/pg_upgrade/test.sh -# -# Test driver for pg_upgrade. Initializes a new database cluster, -# runs the regression tests (to put in some data), runs pg_dumpall, -# runs pg_upgrade, runs pg_dumpall again, compares the dumps. -# -# Portions Copyright (c) 1996-2021, PostgreSQL Global Development Group -# Portions Copyright (c) 1994, Regents of the University of California - -set -e - -: ${MAKE=make} - -# Guard against parallel make issues (see comments in pg_regress.c) -unset MAKEFLAGS -unset MAKELEVEL - -# Run a given "initdb" binary and overlay the regression testing -# authentication configuration. -standard_initdb() { - # To increase coverage of non-standard segment size and group access - # without increasing test runtime, run these tests with a custom setting. - # Also, specify "-A trust" explicitly to suppress initdb's warning. - "$1" -N --wal-segsize 1 -g -A trust - if [ -n "$TEMP_CONFIG" -a -r "$TEMP_CONFIG" ] - then - cat "$TEMP_CONFIG" >> "$PGDATA/postgresql.conf" - fi - ../../test/regress/pg_regress --config-auth "$PGDATA" -} - -# What flavor of host are we on? -# Treat MINGW* (msys1) and MSYS* (msys2) the same. -testhost=`uname -s | sed 's/^MSYS/MINGW/'` - -# Establish how the server will listen for connections -case $testhost in - MINGW*) - LISTEN_ADDRESSES="localhost" - PG_REGRESS_SOCKET_DIR="" - PGHOST=localhost - ;; - *) - LISTEN_ADDRESSES="" - # Select a socket directory. The algorithm is from the "configure" - # script; the outcome mimics pg_regress.c:make_temp_sockdir(). - if [ x"$PG_REGRESS_SOCKET_DIR" = x ]; then - set +e - dir=`(umask 077 && - mktemp -d /tmp/pg_upgrade_check-XXXXXX) 2>/dev/null` - if [ ! -d "$dir" ]; then - dir=/tmp/pg_upgrade_check-$$-$RANDOM - (umask 077 && mkdir "$dir") - if [ ! -d "$dir" ]; then - echo "could not create socket temporary directory in \"/tmp\"" - exit 1 - fi - fi - set -e - PG_REGRESS_SOCKET_DIR=$dir - trap 'rm -rf "$PG_REGRESS_SOCKET_DIR"' 0 - trap 'exit 3' 1 2 13 15 - fi - PGHOST=$PG_REGRESS_SOCKET_DIR - ;; -esac - -POSTMASTER_OPTS="-F -c listen_addresses=\"$LISTEN_ADDRESSES\" -k \"$PG_REGRESS_SOCKET_DIR\"" -export PGHOST - -# don't rely on $PWD here, as old shells don't set it -temp_root=`pwd`/tmp_check -rm -rf "$temp_root" -mkdir "$temp_root" - -: ${oldbindir=$bindir} - -: ${oldsrc=../../..} -oldsrc=`cd "$oldsrc" && pwd` -newsrc=`cd ../../.. && pwd` - -# We need to make pg_regress use psql from the desired installation -# (likely a temporary one), because otherwise the installcheck run -# below would try to use psql from the proper installation directory -# of the target version, which might be outdated or not exist. But -# don't override anything else that's already in EXTRA_REGRESS_OPTS. -EXTRA_REGRESS_OPTS="$EXTRA_REGRESS_OPTS --bindir='$oldbindir'" -export EXTRA_REGRESS_OPTS - -# While in normal cases this will already be set up, adding bindir to -# path allows test.sh to be invoked with different versions as -# described in ./TESTING -PATH=$bindir:$PATH -export PATH - -BASE_PGDATA="$temp_root/data" -PGDATA="${BASE_PGDATA}.old" -export PGDATA - -# Send installcheck outputs to a private directory. This avoids conflict when -# check-world runs pg_upgrade check concurrently with src/test/regress check. -# To retrieve interesting files after a run, use pattern tmp_check/*/*.diffs. -outputdir="$temp_root/regress" -EXTRA_REGRESS_OPTS="$EXTRA_REGRESS_OPTS --outputdir=$outputdir" -export EXTRA_REGRESS_OPTS -mkdir "$outputdir" - -logdir=`pwd`/log -rm -rf "$logdir" -mkdir "$logdir" - -# Clear out any environment vars that might cause libpq to connect to -# the wrong postmaster (cf pg_regress.c) -# -# Some shells, such as NetBSD's, return non-zero from unset if the variable -# is already unset. Since we are operating under 'set -e', this causes the -# script to fail. To guard against this, set them all to an empty string first. -PGDATABASE=""; unset PGDATABASE -PGUSER=""; unset PGUSER -PGSERVICE=""; unset PGSERVICE -PGSSLMODE=""; unset PGSSLMODE -PGREQUIRESSL=""; unset PGREQUIRESSL -PGCONNECT_TIMEOUT=""; unset PGCONNECT_TIMEOUT -PGHOSTADDR=""; unset PGHOSTADDR - -# Select a non-conflicting port number, similarly to pg_regress.c -PG_VERSION_NUM=`grep '#define PG_VERSION_NUM' "$newsrc"/src/include/pg_config.h | awk '{print $3}'` -PGPORT=`expr $PG_VERSION_NUM % 16384 + 49152` -export PGPORT - -i=0 -while psql -X postgres </dev/null 2>/dev/null -do - i=`expr $i + 1` - if [ $i -eq 16 ] - then - echo port $PGPORT apparently in use - exit 1 - fi - PGPORT=`expr $PGPORT + 1` - export PGPORT -done - -# buildfarm may try to override port via EXTRA_REGRESS_OPTS ... -EXTRA_REGRESS_OPTS="$EXTRA_REGRESS_OPTS --port=$PGPORT" -export EXTRA_REGRESS_OPTS - -standard_initdb "$oldbindir"/initdb -"$oldbindir"/pg_ctl start -l "$logdir/postmaster1.log" -o "$POSTMASTER_OPTS" -w - -# Create databases with names covering the ASCII bytes other than NUL, BEL, -# LF, or CR. BEL would ring the terminal bell in the course of this test, and -# it is not otherwise a special case. PostgreSQL doesn't support the rest. -dbname1=`awk 'BEGIN { for (i= 1; i < 46; i++) - if (i != 7 && i != 10 && i != 13) printf "%c", i }' </dev/null` -# Exercise backslashes adjacent to double quotes, a Windows special case. -dbname1='\"\'$dbname1'\\"\\\' -dbname2=`awk 'BEGIN { for (i = 46; i < 91; i++) printf "%c", i }' </dev/null` -dbname3=`awk 'BEGIN { for (i = 91; i < 128; i++) printf "%c", i }' </dev/null` -createdb "regression$dbname1" || createdb_status=$? -createdb "regression$dbname2" || createdb_status=$? -createdb "regression$dbname3" || createdb_status=$? - -if "$MAKE" -C "$oldsrc" installcheck-parallel; then - oldpgversion=`psql -X -A -t -d regression -c "SHOW server_version_num"` - - # before dumping, get rid of objects not feasible in later versions - if [ "$newsrc" != "$oldsrc" ]; then - fix_sql="" - case $oldpgversion in - 804??) - fix_sql="DROP FUNCTION public.myfunc(integer);" - ;; - esac - fix_sql="$fix_sql - DROP FUNCTION IF EXISTS - public.oldstyle_length(integer, text); -- last in 9.6 - DROP FUNCTION IF EXISTS - public.putenv(text); -- last in v13 - DROP OPERATOR IF EXISTS -- last in v13 - public.#@# (pg_catalog.int8, NONE), - public.#%# (pg_catalog.int8, NONE), - public.!=- (pg_catalog.int8, NONE), - public.#@%# (pg_catalog.int8, NONE);" - psql -X -d regression -c "$fix_sql;" || psql_fix_sql_status=$? - fi - - pg_dumpall --no-sync -f "$temp_root"/dump1.sql || pg_dumpall1_status=$? - - if [ "$newsrc" != "$oldsrc" ]; then - # update references to old source tree's regress.so etc - fix_sql="" - case $oldpgversion in - 804??) - fix_sql="UPDATE pg_proc SET probin = replace(probin::text, '$oldsrc', '$newsrc')::bytea WHERE probin LIKE '$oldsrc%';" - ;; - *) - fix_sql="UPDATE pg_proc SET probin = replace(probin, '$oldsrc', '$newsrc') WHERE probin LIKE '$oldsrc%';" - ;; - esac - psql -X -d regression -c "$fix_sql;" || psql_fix_sql_status=$? - - mv "$temp_root"/dump1.sql "$temp_root"/dump1.sql.orig - sed "s;$oldsrc;$newsrc;g" "$temp_root"/dump1.sql.orig >"$temp_root"/dump1.sql - fi -else - make_installcheck_status=$? -fi -"$oldbindir"/pg_ctl -m fast stop -if [ -n "$createdb_status" ]; then - exit 1 -fi -if [ -n "$make_installcheck_status" ]; then - exit 1 -fi -if [ -n "$psql_fix_sql_status" ]; then - exit 1 -fi -if [ -n "$pg_dumpall1_status" ]; then - echo "pg_dumpall of pre-upgrade database cluster failed" - exit 1 -fi - -PGDATA="$BASE_PGDATA" - -standard_initdb 'initdb' - -pg_upgrade $PG_UPGRADE_OPTS -d "${PGDATA}.old" -D "$PGDATA" -b "$oldbindir" -p "$PGPORT" -P "$PGPORT" - -# make sure all directories and files have group permissions, on Unix hosts -# Windows hosts don't support Unix-y permissions. -case $testhost in - MINGW*|CYGWIN*) ;; - *) if [ `find "$PGDATA" -type f ! -perm 640 | wc -l` -ne 0 ]; then - echo "files in PGDATA with permission != 640"; - exit 1; - fi ;; -esac - -case $testhost in - MINGW*|CYGWIN*) ;; - *) if [ `find "$PGDATA" -type d ! -perm 750 | wc -l` -ne 0 ]; then - echo "directories in PGDATA with permission != 750"; - exit 1; - fi ;; -esac - -pg_ctl start -l "$logdir/postmaster2.log" -o "$POSTMASTER_OPTS" -w - -pg_dumpall --no-sync -f "$temp_root"/dump2.sql || pg_dumpall2_status=$? -pg_ctl -m fast stop - -if [ -n "$pg_dumpall2_status" ]; then - echo "pg_dumpall of post-upgrade database cluster failed" - exit 1 -fi - -case $testhost in - MINGW*) MSYS2_ARG_CONV_EXCL=/c cmd /c delete_old_cluster.bat ;; - *) sh ./delete_old_cluster.sh ;; -esac - -if diff "$temp_root"/dump1.sql "$temp_root"/dump2.sql >/dev/null; then - echo PASSED - exit 0 -else - echo "Files $temp_root/dump1.sql and $temp_root/dump2.sql differ" - echo "dumps were not identical" - exit 1 -fi diff --git a/src/test/perl/PostgresNode.pm b/src/test/perl/PostgresNode.pm index f7088667a4..31ddbdfa4a 100644 --- a/src/test/perl/PostgresNode.pm +++ b/src/test/perl/PostgresNode.pm @@ -340,6 +340,31 @@ sub backup_dir =pod +=item $node->config_data($option) + +Grab some data from pg_config, with $option being the switched +used. + +=cut + +sub config_data +{ + my ($self, $option) = @_; + local %ENV = $self->_get_env(); + + my ($stdout, $stderr); + my $result = + IPC::Run::run [ $self->installed_command('pg_config'), $option ], + '>', \$stdout, '2>', \$stderr + or die "could not execute pg_config"; + chomp($stdout); + $stdout =~ s/\r$//; + + return $stdout; +} + +=pod + =item $node->info() Return a string containing human-readable diagnostic information (paths, etc) -- 2.31.1
signature.asc
Description: PGP signature
