From 11041cbd99e194028c756bd597764f1e21a26afe Mon Sep 17 00:00:00 2001 From: Craig Ringer Date: Tue, 1 Mar 2016 20:57:17 +0800 Subject: [PATCH 2/2] Tests for logical decoding timeline following Demonstrate that timeline following for logical decoding works independently of the proposed failover slot machinery by using the client to sync slot state from master to replica. See the README in src/test/modules/decoding_failover and comments in src/test/recovery/t/006_logical_decoding_timelines.pl --- src/test/modules/Makefile | 1 + src/test/modules/decoding_failover/.gitignore | 3 + src/test/modules/decoding_failover/Makefile | 22 ++ src/test/modules/decoding_failover/README | 19 ++ .../decoding_failover/decoding_failover--1.0.sql | 16 ++ .../modules/decoding_failover/decoding_failover.c | 124 ++++++++++ .../decoding_failover/decoding_failover.conf | 2 + .../decoding_failover/decoding_failover.control | 5 + .../decoding_failover/expected/load_extension.out | 19 ++ .../decoding_failover/sql/load_extension.sql | 7 + src/test/recovery/Makefile | 2 + .../recovery/t/006_logical_decoding_timelines.pl | 271 +++++++++++++++++++++ 12 files changed, 491 insertions(+) create mode 100644 src/test/modules/decoding_failover/.gitignore create mode 100644 src/test/modules/decoding_failover/Makefile create mode 100644 src/test/modules/decoding_failover/README create mode 100644 src/test/modules/decoding_failover/decoding_failover--1.0.sql create mode 100644 src/test/modules/decoding_failover/decoding_failover.c create mode 100644 src/test/modules/decoding_failover/decoding_failover.conf create mode 100644 src/test/modules/decoding_failover/decoding_failover.control create mode 100644 src/test/modules/decoding_failover/expected/load_extension.out create mode 100644 src/test/modules/decoding_failover/sql/load_extension.sql create mode 100644 src/test/recovery/t/006_logical_decoding_timelines.pl diff --git a/src/test/modules/Makefile b/src/test/modules/Makefile index 6167ec1..bbaf94f 100644 --- a/src/test/modules/Makefile +++ b/src/test/modules/Makefile @@ -7,6 +7,7 @@ include $(top_builddir)/src/Makefile.global SUBDIRS = \ brin \ commit_ts \ + decoding_failover \ dummy_seclabel \ test_ddl_deparse \ test_extensions \ diff --git a/src/test/modules/decoding_failover/.gitignore b/src/test/modules/decoding_failover/.gitignore new file mode 100644 index 0000000..543c50d --- /dev/null +++ b/src/test/modules/decoding_failover/.gitignore @@ -0,0 +1,3 @@ +results/ +tmp_check/ +log/ diff --git a/src/test/modules/decoding_failover/Makefile b/src/test/modules/decoding_failover/Makefile new file mode 100644 index 0000000..97c2c28 --- /dev/null +++ b/src/test/modules/decoding_failover/Makefile @@ -0,0 +1,22 @@ +# src/test/modules/worker_spi/Makefile + +MODULES = decoding_failover +PGFILEDESC = "decoding_failover - test utility for logical decoding" + +EXTENSION = decoding_failover +DATA = decoding_failover--1.0.sql + +EXTRA_INSTALL=contrib/test_decoding +REGRESS=load_extension +REGRESS_OPTS = --temp-config=$(top_srcdir)/src/test/modules/decoding_failover/decoding_failover.conf + +ifdef USE_PGXS +PG_CONFIG = pg_config +PGXS := $(shell $(PG_CONFIG) --pgxs) +include $(PGXS) +else +subdir = src/test/modules/decoding_failover +top_builddir = ../../../.. +include $(top_builddir)/src/Makefile.global +include $(top_srcdir)/contrib/contrib-global.mk +endif diff --git a/src/test/modules/decoding_failover/README b/src/test/modules/decoding_failover/README new file mode 100644 index 0000000..585f02f --- /dev/null +++ b/src/test/modules/decoding_failover/README @@ -0,0 +1,19 @@ +A test module for logical decoding failover and timeline following. + +This module provides a minimal way to maintain logical slots on replicas +that mirror the state on the master. It doesn't make decoding possible, +just tracking slot state so that a decoding client that's using the master +can follow a physical failover to the standby. The master doesn't know +about the slots on the standby, they're synced by a client that connects +to both. + +This is intentionally not part of the test_decoding module because that's meant +to serve as example code, where this module exercises internal server features +by unsafely exposing internal state to SQL. It's not the right way to do +failover, it's just a simple way to test it from the perl TAP framework to +prove the feature works. + +In a practical implementation of this approach a bgworker on the master would +monitor slot positions and relay them to a bgworker on the standby that applies +the position updates without exposing slot internals to SQL. That's too complex +for this test framework though. diff --git a/src/test/modules/decoding_failover/decoding_failover--1.0.sql b/src/test/modules/decoding_failover/decoding_failover--1.0.sql new file mode 100644 index 0000000..078b65e --- /dev/null +++ b/src/test/modules/decoding_failover/decoding_failover--1.0.sql @@ -0,0 +1,16 @@ +-- complain if script is sourced in psql, rather than via CREATE EXTENSION +\echo Use "CREATE EXTENSION decoding_failover" to load this file. \quit + +CREATE OR REPLACE FUNCTION decoding_failover_create_logical_slot(slot_name text, plugin text) +RETURNS void +LANGUAGE c AS 'MODULE_PATHNAME'; + +COMMENT ON FUNCTION decoding_failover_create_logical_slot(text, text) +IS 'Create a logical slot at a particular lsn and xid. Do not use in production servers, it is not safe. The slot is created with an invalid xmin and lsn.'; + +CREATE OR REPLACE FUNCTION decoding_failover_advance_logical_slot(slot_name text, new_xmin bigint, new_catalog_xmin bigint, new_restart_lsn pg_lsn, new_confirmed_lsn pg_lsn) +RETURNS void +LANGUAGE c AS 'MODULE_PATHNAME'; + +COMMENT ON FUNCTION decoding_failover_advance_logical_slot(text, bigint, bigint, pg_lsn, pg_lsn) +IS 'Advance a logical slot directly. Do not use this in production servers, it is not safe.'; diff --git a/src/test/modules/decoding_failover/decoding_failover.c b/src/test/modules/decoding_failover/decoding_failover.c new file mode 100644 index 0000000..bab0f3b --- /dev/null +++ b/src/test/modules/decoding_failover/decoding_failover.c @@ -0,0 +1,124 @@ +#include "postgres.h" + +#include "access/transam.h" + +#include "replication/slot.h" + +#include "utils/builtins.h" +#include "utils/pg_lsn.h" + +#include "fmgr.h" +#include "miscadmin.h" + +PG_MODULE_MAGIC; + +Datum decoding_failover_create_logical_slot(PG_FUNCTION_ARGS); +PG_FUNCTION_INFO_V1(decoding_failover_create_logical_slot); + +Datum decoding_failover_advance_logical_slot(PG_FUNCTION_ARGS); +PG_FUNCTION_INFO_V1(decoding_failover_advance_logical_slot); + +static void clear_slot_transient_state(void); + +/* + * Create a new logical slot, with invalid LSN and xid, directly. This does not + * use the snapshot builder or logical decoding machinery. It's only intended + * for creating a slot on a replica that mirrors the state of a slot on an + * upstream master. + * + * You should immediately decoding_failover_advance_logical_slot(...) it + * after creation. + */ +Datum +decoding_failover_create_logical_slot(PG_FUNCTION_ARGS) +{ + char* slotname = text_to_cstring(PG_GETARG_TEXT_P(0)); + char* plugin = text_to_cstring(PG_GETARG_TEXT_P(1)); + + CheckSlotRequirements(); + + ReplicationSlotCreate(slotname, true, RS_PERSISTENT); + + /* register the plugin name with the slot */ + StrNCpy(NameStr(MyReplicationSlot->data.plugin), plugin, NAMEDATALEN); + + /* + * Initialize persistent state to placeholders to be set + * by decoding_failover_advance_logical_slot . + */ + MyReplicationSlot->data.xmin = InvalidTransactionId; + MyReplicationSlot->data.catalog_xmin = InvalidTransactionId; + MyReplicationSlot->data.restart_lsn = InvalidXLogRecPtr; + MyReplicationSlot->data.confirmed_flush = InvalidXLogRecPtr; + + clear_slot_transient_state(); + + ReplicationSlotRelease(); + + PG_RETURN_VOID(); +} + +/* + * Set the state of a slot. + * + * This doesn't maintain the non-persistent state at all, + * but since the slot isn't in use that's OK. + * + * There's intentionally no check to prevent slots going backwards + * because they can actually go backwards if the master crashes when + * it hasn't yet flushed slot state to disk then we copy the older + * slot state after recovery. + * + * There's no checking done for xmin or catalog xmin either, since + * we can't really do anything useful that accounts for xid wrap-around. + */ +Datum +decoding_failover_advance_logical_slot(PG_FUNCTION_ARGS) +{ + char* slotname = text_to_cstring(PG_GETARG_TEXT_P(0)); + TransactionId new_xmin = (TransactionId)PG_GETARG_INT64(1); + TransactionId new_catalog_xmin = (TransactionId)PG_GETARG_INT64(2); + XLogRecPtr restart_lsn = PG_GETARG_LSN(3); + XLogRecPtr confirmed_lsn = PG_GETARG_LSN(4); + + CheckSlotRequirements(); + + ReplicationSlotAcquire(slotname); + + if (MyReplicationSlot->data.database != MyDatabaseId) + elog(ERROR, "Trying to update a slot on a different database"); + + MyReplicationSlot->data.xmin = new_xmin; + MyReplicationSlot->data.catalog_xmin = new_catalog_xmin; + MyReplicationSlot->data.restart_lsn = restart_lsn; + MyReplicationSlot->data.confirmed_flush = confirmed_lsn; + + clear_slot_transient_state(); + + ReplicationSlotMarkDirty(); + ReplicationSlotSave(); + ReplicationSlotRelease(); + + ReplicationSlotsComputeRequiredXmin(false); + ReplicationSlotsComputeRequiredLSN(); + + PG_RETURN_VOID(); +} + +static void +clear_slot_transient_state(void) +{ + Assert(MyReplicationSlot != NULL); + + /* + * Make sure the slot state is the same as if it were newly + * loaded from disk on recovery. + */ + MyReplicationSlot->effective_xmin = MyReplicationSlot->data.xmin; + MyReplicationSlot->effective_catalog_xmin = MyReplicationSlot->data.catalog_xmin; + + MyReplicationSlot->candidate_catalog_xmin = InvalidTransactionId; + MyReplicationSlot->candidate_xmin_lsn = InvalidXLogRecPtr; + MyReplicationSlot->candidate_restart_lsn = InvalidXLogRecPtr; + MyReplicationSlot->candidate_restart_valid = InvalidXLogRecPtr; +} diff --git a/src/test/modules/decoding_failover/decoding_failover.conf b/src/test/modules/decoding_failover/decoding_failover.conf new file mode 100644 index 0000000..56b46d7 --- /dev/null +++ b/src/test/modules/decoding_failover/decoding_failover.conf @@ -0,0 +1,2 @@ +max_replication_slots=2 +wal_level=logical diff --git a/src/test/modules/decoding_failover/decoding_failover.control b/src/test/modules/decoding_failover/decoding_failover.control new file mode 100644 index 0000000..92329b3 --- /dev/null +++ b/src/test/modules/decoding_failover/decoding_failover.control @@ -0,0 +1,5 @@ +# worker_spi extension +comment = 'Logical decoding failover tests' +default_version = '1.0' +module_pathname = '$libdir/decoding_failover' +relocatable = true diff --git a/src/test/modules/decoding_failover/expected/load_extension.out b/src/test/modules/decoding_failover/expected/load_extension.out new file mode 100644 index 0000000..fe3c54d --- /dev/null +++ b/src/test/modules/decoding_failover/expected/load_extension.out @@ -0,0 +1,19 @@ +CREATE EXTENSION decoding_failover; +SELECT decoding_failover_create_logical_slot('test_slot', 'test_decoding'); + decoding_failover_create_logical_slot +--------------------------------------- + +(1 row) + +SELECT decoding_failover_advance_logical_slot('test_slot', txid_current(), txid_current(), pg_current_xlog_location(), pg_current_xlog_location()); + decoding_failover_advance_logical_slot +---------------------------------------- + +(1 row) + +SELECT pg_drop_replication_slot('test_slot'); + pg_drop_replication_slot +-------------------------- + +(1 row) + diff --git a/src/test/modules/decoding_failover/sql/load_extension.sql b/src/test/modules/decoding_failover/sql/load_extension.sql new file mode 100644 index 0000000..4ea9f77 --- /dev/null +++ b/src/test/modules/decoding_failover/sql/load_extension.sql @@ -0,0 +1,7 @@ +CREATE EXTENSION decoding_failover; + +SELECT decoding_failover_create_logical_slot('test_slot', 'test_decoding'); + +SELECT decoding_failover_advance_logical_slot('test_slot', txid_current(), txid_current(), pg_current_xlog_location(), pg_current_xlog_location()); + +SELECT pg_drop_replication_slot('test_slot'); diff --git a/src/test/recovery/Makefile b/src/test/recovery/Makefile index 9290719..9710370 100644 --- a/src/test/recovery/Makefile +++ b/src/test/recovery/Makefile @@ -9,6 +9,8 @@ # #------------------------------------------------------------------------- +EXTRA_INSTALL=contrib/test_decoding src/test/modules/decoding_failover + subdir = src/test/recovery top_builddir = ../../.. include $(top_builddir)/src/Makefile.global diff --git a/src/test/recovery/t/006_logical_decoding_timelines.pl b/src/test/recovery/t/006_logical_decoding_timelines.pl new file mode 100644 index 0000000..7268a45 --- /dev/null +++ b/src/test/recovery/t/006_logical_decoding_timelines.pl @@ -0,0 +1,271 @@ +# Demonstrate that logical can follow timeline switches. +# +# Logical replication slots can follow timeline switches but it's +# normally not possible to have a logical slot on a replica where +# promotion and a timeline switch can occur. The only ways +# we can create that circumstance are: +# +# * By doing a filesystem-level copy of the DB, since pg_basebackup +# excludes pg_replslot but we can copy it directly; or +# +# * by creating a slot directly at the C level on the replica and +# advancing it as we go using the low level APIs. It can't be done +# from SQL since logical decoding isn't allowed on replicas. +# +# This module uses the first approach to show that timeline following +# on a logical slot works. +# +use strict; +use warnings; +use PostgresNode; +use TestLib; +use Test::More tests => 20; +use RecursiveCopy; +use File::Copy; + +my ($stdout, $stderr, $ret); + +# Initialize master node +my $node_master = get_new_node('master'); +$node_master->init(allows_streaming => 1, has_archiving => 1); +$node_master->append_conf('postgresql.conf', "wal_level = 'logical'\n"); +$node_master->append_conf('postgresql.conf', "max_replication_slots = 2\n"); +$node_master->append_conf('postgresql.conf', "max_wal_senders = 2\n"); +$node_master->append_conf('postgresql.conf', "log_min_messages = 'debug2'\n"); +$node_master->dump_info; +$node_master->start; + +diag "Testing logical timeline following with a filesystem-level copy"; + +$node_master->safe_psql('postgres', +"SELECT pg_create_logical_replication_slot('before_basebackup', 'test_decoding');" +); +$node_master->safe_psql('postgres', "CREATE TABLE decoding(blah text);"); +$node_master->safe_psql('postgres', + "INSERT INTO decoding(blah) VALUES ('beforebb');"); +$node_master->safe_psql('postgres', 'CHECKPOINT;'); + +my $backup_name = 'b1'; +$node_master->backup_fs_hot($backup_name); + +my $node_replica = get_new_node('replica'); +$node_replica->init_from_backup( + $node_master, $backup_name, + has_streaming => 1, + has_restoring => 1); +$node_replica->start; + +$node_master->safe_psql('postgres', +"SELECT pg_create_logical_replication_slot('after_basebackup', 'test_decoding');" +); +$node_master->safe_psql('postgres', + "INSERT INTO decoding(blah) VALUES ('afterbb');"); +$node_master->safe_psql('postgres', 'CHECKPOINT;'); + +# Verify that only the before base_backup slot is on the replica +$stdout = $node_replica->safe_psql('postgres', 'SELECT slot_name FROM pg_replication_slots ORDER BY slot_name'); +is($stdout, 'before_basebackup', 'Expected to find only slot before_basebackup on replica'); + +# Boom, crash +$node_master->stop('immediate'); + +$node_replica->promote; +$node_replica->poll_query_until('postgres', + "SELECT NOT pg_is_in_recovery();"); + +$node_replica->safe_psql('postgres', + "INSERT INTO decoding(blah) VALUES ('after failover');"); + +# Shouldn't be able to read from slot created after base backup +($ret, $stdout, $stderr) = $node_replica->psql('postgres', +"SELECT data FROM pg_logical_slot_peek_changes('after_basebackup', NULL, NULL, 'include-xids', '0', 'skip-empty-xacts', '1');" +); +is($ret, 3, 'replaying from after_basebackup slot fails'); +like( + $stderr, + qr/replication slot "after_basebackup" does not exist/, + 'after_basebackup slot missing'); + +# Should be able to read from slot created before base backup +($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 => 30); +is($ret, 0, 'replay from slot before_basebackup succeeds'); +is( $stdout, q(BEGIN +table public.decoding: INSERT: blah[text]:'beforebb' +COMMIT +BEGIN +table public.decoding: INSERT: blah[text]:'afterbb' +COMMIT +BEGIN +table public.decoding: INSERT: blah[text]:'after failover' +COMMIT), 'decoded expected data from slot before_basebackup'); +is($stderr, '', 'replay from slot before_basebackup produces no stderr'); + +# We don't need the standby anymore +$node_replica->teardown_node(); + + + +# OK, time to try the same thing again, but this time we'll +# be using slot mirroring on the standby and a pg_basebackup +# of the master. + +diag "Testing logical timeline following with decoding_failover module"; + +$node_master->start(); +# Clean up after the last test +$node_master->safe_psql('postgres', 'DELETE FROM decoding;'); +is($node_master->psql('postgres', 'SELECT pg_drop_replication_slot(slot_name) FROM pg_replication_slots;'), + 0, 'dropping slots succeeds via pg_drop_replication_slot'); + +# Same as before, we'll make one slot before basebackup, one after. This time +# the basebackup will be with pg_basebackup so it'll omit both slots, then +# we'll use SQL functions provided by the decoding_failover test module to +# sync them to the replica, do some work, sync them and fail over then test +# again. This time we should have both the before- and after-basebackup +# slots working. + +is($node_master->psql('postgres', +"SELECT pg_create_logical_replication_slot('before_basebackup', 'test_decoding');" +), 0, 'creating slot before_basebackup succeeds'); + +$node_master->safe_psql('postgres', + "INSERT INTO decoding(blah) VALUES ('beforebb');"); + +$backup_name = 'b2'; +$node_master->backup($backup_name); + +is($node_master->psql('postgres', +"SELECT pg_create_logical_replication_slot('after_basebackup', 'test_decoding');" +), 0, 'creating slot after_basebackup succeeds'); + +$node_master->safe_psql('postgres', + "INSERT INTO decoding(blah) VALUES ('afterbb');"); + +$node_replica = get_new_node('replica2'); +$node_replica->init_from_backup( + $node_master, $backup_name, + has_streaming => 1, + has_restoring => 1); + +$node_replica->start; + +# Verify the slots are both absent on the replica +$stdout = $node_replica->safe_psql('postgres', 'SELECT slot_name FROM pg_replication_slots ORDER BY slot_name'); +is($stdout, '', 'No slots exist on the replica'); + +# Now do our magic to sync the slot states across. Normally +# this would be being done continuously by a bgworker but +# we're just doing it by hand for this test. This is exposing +# postgres innards to SQL so it's unsafe except for testing. +$node_master->safe_psql('postgres', 'CREATE EXTENSION decoding_failover;'); +my $slotinfo = $node_master->safe_psql('postgres', + 'SELECT slot_name, plugin, xmin, catalog_xmin, restart_lsn, confirmed_flush_lsn FROM pg_replication_slots ORDER BY slot_name'); +diag "Copying slots to replica"; +open my $fh, '<', \$slotinfo or die $!; +while (<$fh>) { + print $_; + chomp $_; + my ($slot_name, $plugin, $xmin, $catalog_xmin, $restart_lsn, $confirmed_flush_lsn) + = map { if ($_ ne '') {"'$_'"} else {'NULL'}; } split qr/\|/, $_; + print "# Copying slot $slot_name,$plugin,$xmin,$catalog_xmin,$restart_lsn,$confirmed_flush_lsn\n"; + $node_replica->safe_psql('postgres', + "SELECT decoding_failover_create_logical_slot($slot_name, $plugin);"); + $node_replica->safe_psql('postgres', + "SELECT decoding_failover_advance_logical_slot($slot_name, $xmin, $catalog_xmin, $restart_lsn, $confirmed_flush_lsn);"); +} +close $fh or die $!; + +# Now both slots are present on the replica and exactly match the master +$stdout = $node_replica->safe_psql('postgres', 'SELECT slot_name FROM pg_replication_slots ORDER BY slot_name'); +is($stdout, "after_basebackup\nbefore_basebackup", 'both slots now exist on replica'); + +$stdout = $node_replica->safe_psql('postgres', + 'SELECT slot_name, plugin, xmin, catalog_xmin, restart_lsn, confirmed_flush_lsn FROM pg_replication_slots ORDER BY slot_name'); +is($stdout, $slotinfo, "slot data read back from replica matches slot data on master"); + +# We now have to copy some extra WAL to satisfy the requirements of the oldest +# replication slot. pg_basebackup doesn't know to copy the extra WAL for slots +# so we have to help out. We know the WAL is still retained on the master +# because we haven't advanced the slots there. +# +# Figure out what the oldest segment we need is by looking at the restart_lsn +# of the oldest slot. +# +# It only makes sense to do this once the slots are created on the replica, +# otherwise it might just delete the segments again. + +my $oldest_needed_segment = $node_master->safe_psql('postgres', + qq{SELECT pg_xlogfile_name(( + SELECT restart_lsn + FROM pg_replication_slots + ORDER BY restart_lsn ASC + LIMIT 1 + ));} + ); + +diag "oldest needed xlog seg is $oldest_needed_segment "; + +# WAL segment names sort lexically so we can just grab everything > than this +# segment. +opendir(my $pg_xlog, $node_master->data_dir . "/pg_xlog") or die $!; +while (my $seg = readdir $pg_xlog) +{ + next unless $seg >= $oldest_needed_segment && $seg =~ /^[0-9]{24}/; + diag "copying xlog seg $seg"; + copy($node_master->data_dir . "/pg_xlog/" . $seg, + $node_replica->data_dir . "/pg_xlog/" . $seg) + or die "copy of xlog seg $seg failed: $!"; +} +closedir $pg_xlog; + +# Boom, crash the master +$node_master->stop('immediate'); + +$node_replica->promote; +$node_replica->poll_query_until('postgres', + "SELECT NOT pg_is_in_recovery();"); + +$node_replica->safe_psql('postgres', + "INSERT INTO decoding(blah) VALUES ('after failover');"); + +# This time we can read from both slots +($ret, $stdout, $stderr) = $node_replica->psql('postgres', +"SELECT data FROM pg_logical_slot_peek_changes('after_basebackup', NULL, NULL, 'include-xids', '0', 'skip-empty-xacts', '1');", +timeout => 30); +is($ret, 0, 'replay from slot after_basebackup succeeds'); +is( $stdout, q(BEGIN +table public.decoding: INSERT: blah[text]:'afterbb' +COMMIT +BEGIN +table public.decoding: INSERT: blah[text]:'after failover' +COMMIT), 'decoded expected data from slot after_basebackup'); +is($stderr, '', 'replay from slot after_basebackup produces no stderr'); + +# Should be able to read from slot created before base backup +# +# This would fail with an error about missing WAL segments if we hadn't +# copied extra WAL earlier. +($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 => 30); +is($ret, 0, 'replay from slot before_basebackup succeeds'); +is( $stdout, q(BEGIN +table public.decoding: INSERT: blah[text]:'beforebb' +COMMIT +BEGIN +table public.decoding: INSERT: blah[text]:'afterbb' +COMMIT +BEGIN +table public.decoding: INSERT: blah[text]:'after failover' +COMMIT), 'decoded expected data from slot before_basebackup'); +is($stderr, '', 'replay from slot before_basebackup produces no stderr'); + +($ret, $stdout, $stderr) = $node_replica->psql('postgres', 'SELECT pg_drop_replication_slot(slot_name) FROM pg_replication_slots;'); +is($ret, 0, 'dropping slots succeeds via pg_drop_replication_slot'); +is($stderr, '', 'dropping slots produces no stderr output'); + +1; -- 2.1.0