On Sat, Oct 21, 2023 at 11:59 PM Bharath Rupireddy <bharath.rupireddyforpostg...@gmail.com> wrote: > > On Fri, Jul 21, 2023 at 12:38 PM Bharath Rupireddy > <bharath.rupireddyforpostg...@gmail.com> wrote: > > > > Needed a rebase. I'm attaching the v13 patch for further consideration. > > Needed a rebase. I'm attaching the v14 patch. It also has the following > changes: > > - Ran pgindent on the new source code. > - Ran pgperltidy on the new TAP test. > - Improved the newly added TAP test a bit. Used the new wait_for_log > core TAP function in place of custom find_in_log. > > Thoughts?
I took a closer look at v14 and came up with the following changes: 1. Used advance_wal introduced by commit c161ab74f7. 2. Simplified the core logic and new TAP tests. 3. Reworded the comments and docs. 4. Simplified new DEBUG messages. I've attached the v15 patch for further review. -- Bharath Rupireddy PostgreSQL Contributors Team RDS Open Source Databases Amazon Web Services: https://aws.amazon.com
From 8bdd3b999343c02ae01a7d15ef7fdd0be25623bd Mon Sep 17 00:00:00 2001 From: Bharath Rupireddy <bharath.rupireddyforpostgres@gmail.com> Date: Thu, 28 Dec 2023 11:14:05 +0000 Subject: [PATCH v15] Allow standby to switch WAL source from archive to streaming A standby typically switches to streaming replication (get WAL from primary), only when receive from WAL archive finishes (no more WAL left there) or fails for any reason. Reading WAL from archive may not always be as efficient and fast as reading from primary. This can be due to the differences in disk types, IO costs, network latencies etc.. All of these can impact the recovery performance on standby and increase the replication lag on primary. In addition, the primary keeps accumulating WAL needed for the standby while the standby reads WAL from archive because the standby replication slot stays inactive. To avoid these problems, one can use this parameter to make standby switch to stream mode sooner. This feature adds a new GUC that specifies amount of time after which standby attempts to switch WAL source from WAL archive to streaming replication (getting WAL from primary). However, standby exhausts all the WAL present in pg_wal before switching. If standby fails to switch to stream mode, it falls back to archive mode. Author: Bharath Rupireddy Reviewed-by: Cary Huang, Nathan Bossart Reviewed-by: Kyotaro Horiguchi, SATYANARAYANA NARLAPURAM Discussion: https://www.postgresql.org/message-id/CAHg+QDdLmfpS0n0U3U+e+dw7X7jjEOsJJ0aLEsrtxs-tUyf5Ag@mail.gmail.com --- doc/src/sgml/config.sgml | 47 +++++++ doc/src/sgml/high-availability.sgml | 15 ++- src/backend/access/transam/xlogrecovery.c | 115 ++++++++++++++++-- src/backend/utils/misc/guc_tables.c | 12 ++ src/backend/utils/misc/postgresql.conf.sample | 4 + src/include/access/xlogrecovery.h | 1 + src/test/recovery/meson.build | 1 + src/test/recovery/t/040_wal_source_switch.pl | 93 ++++++++++++++ 8 files changed, 269 insertions(+), 19 deletions(-) create mode 100644 src/test/recovery/t/040_wal_source_switch.pl diff --git a/doc/src/sgml/config.sgml b/doc/src/sgml/config.sgml index b5624ca884..04aa2fa8d2 100644 --- a/doc/src/sgml/config.sgml +++ b/doc/src/sgml/config.sgml @@ -4866,6 +4866,53 @@ ANY <replaceable class="parameter">num_sync</replaceable> ( <replaceable class=" </listitem> </varlistentry> + <varlistentry id="guc-streaming-replication-retry-interval" xreflabel="streaming_replication_retry_interval"> + <term><varname>streaming_replication_retry_interval</varname> (<type>integer</type>) + <indexterm> + <primary><varname>streaming_replication_retry_interval</varname> configuration parameter</primary> + </indexterm> + </term> + <listitem> + <para> + Specifies amount of time after which standby attempts to switch WAL + source from archive to streaming replication (i.e., getting WAL from + primary). However, the standby exhausts all the WAL present in pg_wal + before switching. If the standby fails to switch to stream mode, it + falls back to archive mode. If this parameter value is specified + without units, it is taken as milliseconds. Default is + <literal>5min</literal>. With a lower value for this parameter, the + standby makes frequent WAL source switch attempts. To avoid this, it is + recommended to set a reasonable value. A setting of <literal>0</literal> + disables the feature. When disabled, the standby typically switches to + stream mode only after receiving WAL from archive finishes (i.e., no + more WAL left there) or fails for any reason. This parameter can only + be set in the <filename>postgresql.conf</filename> file or on the + server command line. + </para> + <note> + <para> + Standby may not always attempt to switch source from WAL archive to + streaming replication at exact + <varname>streaming_replication_retry_interval</varname> intervals. For + example, if the parameter is set to <literal>1min</literal> and + fetching WAL file from archive takes about <literal>2min</literal>, + then the source switch attempt happens for the next WAL file after + current WAL file fetched from archive is fully applied. + </para> + </note> + <para> + Reading WAL from archive may not always be as efficient and fast as + reading from primary. This can be due to the differences in disk types, + IO costs, network latencies etc.. All of these can impact the recovery + performance on standby and increase the replication lag on primary. In + addition, the primary keeps accumulating WAL needed for the standby + while the standby reads WAL from archive because the standby + replication slot stays inactive. To avoid these problems, one can use + this parameter to make standby switch to stream mode sooner. + </para> + </listitem> + </varlistentry> + <varlistentry id="guc-recovery-min-apply-delay" xreflabel="recovery_min_apply_delay"> <term><varname>recovery_min_apply_delay</varname> (<type>integer</type>) <indexterm> diff --git a/doc/src/sgml/high-availability.sgml b/doc/src/sgml/high-availability.sgml index 9dd52ff275..35926e1df3 100644 --- a/doc/src/sgml/high-availability.sgml +++ b/doc/src/sgml/high-availability.sgml @@ -628,12 +628,15 @@ protocol to make nodes agree on a serializable transactional order. In standby mode, the server continuously applies WAL received from the primary server. The standby server can read WAL from a WAL archive (see <xref linkend="guc-restore-command"/>) or directly from the primary - over a TCP connection (streaming replication). The standby server will - also attempt to restore any WAL found in the standby cluster's - <filename>pg_wal</filename> directory. That typically happens after a server - restart, when the standby replays again WAL that was streamed from the - primary before the restart, but you can also manually copy files to - <filename>pg_wal</filename> at any time to have them replayed. + over a TCP connection (streaming replication) or attempt to switch to + streaming replication after reading from archive when + <xref linkend="guc-streaming-replication-retry-interval"/> parameter is + set. The standby server will also attempt to restore any WAL found in the + standby cluster's <filename>pg_wal</filename> directory. That typically + happens after a server restart, when the standby replays again WAL that was + streamed from the primary before the restart, but you can also manually + copy files to <filename>pg_wal</filename> at any time to have them + replayed. </para> <para> diff --git a/src/backend/access/transam/xlogrecovery.c b/src/backend/access/transam/xlogrecovery.c index 6f4f81f992..e59057558e 100644 --- a/src/backend/access/transam/xlogrecovery.c +++ b/src/backend/access/transam/xlogrecovery.c @@ -91,6 +91,7 @@ TimestampTz recoveryTargetTime; const char *recoveryTargetName; XLogRecPtr recoveryTargetLSN; int recovery_min_apply_delay = 0; +int streaming_replication_retry_interval = 300000; /* options formerly taken from recovery.conf for XLOG streaming */ char *PrimaryConnInfo = NULL; @@ -297,6 +298,8 @@ bool reachedConsistency = false; static char *replay_image_masked = NULL; static char *primary_image_masked = NULL; +/* Holds the timestamp at which standby switched WAL source to archive */ +static TimestampTz switched_to_archive_at = 0; /* * Shared-memory state for WAL recovery. @@ -440,6 +443,8 @@ static bool HotStandbyActiveInReplay(void); static void SetCurrentChunkStartTime(TimestampTz xtime); static void SetLatestXTime(TimestampTz xtime); +static bool SwitchWALSourceToPrimary(void); + /* * Initialization of shared memory for WAL recovery */ @@ -3492,8 +3497,11 @@ WaitForWALToBecomeAvailable(XLogRecPtr RecPtr, bool randAccess, bool nonblocking) { static TimestampTz last_fail_time = 0; + static bool canSwitchSource = false; + bool switchSource = false; TimestampTz now; bool streaming_reply_sent = false; + XLogSource readFrom; /*------- * Standby mode is implemented by a state machine: @@ -3513,6 +3521,12 @@ WaitForWALToBecomeAvailable(XLogRecPtr RecPtr, bool randAccess, * those actions are taken when reading from the previous source fails, as * part of advancing to the next state. * + * Try reading WAL from primary after being in XLOG_FROM_ARCHIVE state for + * at least streaming_replication_retry_interval milliseconds. However, + * exhaust all the WAL present in pg_wal before switching. If successful, + * the state machine moves to XLOG_FROM_STREAM state, otherwise it falls + * back to XLOG_FROM_ARCHIVE state. + * * If standby mode is turned off while reading WAL from stream, we move * to XLOG_FROM_ARCHIVE and reset lastSourceFailed, to force fetching * the files (which would be required at end of recovery, e.g., timeline @@ -3536,19 +3550,20 @@ WaitForWALToBecomeAvailable(XLogRecPtr RecPtr, bool randAccess, bool startWalReceiver = false; /* - * First check if we failed to read from the current source, and - * advance the state machine if so. The failure to read might've + * First check if we failed to read from the current source or we + * intentionally want to switch the source from archive to primary, + * and advance the state machine if so. The failure to read might've * happened outside this function, e.g when a CRC check fails on a * record, or within this loop. */ - if (lastSourceFailed) + if (lastSourceFailed || switchSource) { /* * Don't allow any retry loops to occur during nonblocking - * readahead. Let the caller process everything that has been - * decoded already first. + * readahead if we failed to read from the current source. Let the + * caller process everything that has been decoded already first. */ - if (nonblocking) + if (nonblocking && lastSourceFailed) return XLREAD_WOULDBLOCK; switch (currentSource) @@ -3680,9 +3695,27 @@ WaitForWALToBecomeAvailable(XLogRecPtr RecPtr, bool randAccess, } if (currentSource != oldSource) - elog(DEBUG2, "switched WAL source from %s to %s after %s", - xlogSourceNames[oldSource], xlogSourceNames[currentSource], - lastSourceFailed ? "failure" : "success"); + { + /* Save the timestamp at which we are switching to archive */ + if (currentSource == XLOG_FROM_ARCHIVE) + switched_to_archive_at = GetCurrentTimestamp(); + + ereport(DEBUG1, + errmsg_internal("switched WAL source from %s to %s after %s", + xlogSourceNames[oldSource], + xlogSourceNames[currentSource], + (switchSource ? "timeout" : (lastSourceFailed ? "failure" : "success")))); + + /* Reset the WAL source switch state */ + if (switchSource) + { + Assert(canSwitchSource); + Assert(currentSource == XLOG_FROM_STREAM); + Assert(oldSource == XLOG_FROM_ARCHIVE); + switchSource = false; + canSwitchSource = false; + } + } /* * We've now handled possible failure. Try to read from the chosen @@ -3711,13 +3744,23 @@ WaitForWALToBecomeAvailable(XLogRecPtr RecPtr, bool randAccess, if (randAccess) curFileTLI = 0; + /* See if we can switch WAL source to streaming */ + if (!canSwitchSource) + canSwitchSource = SwitchWALSourceToPrimary(); + /* * Try to restore the file from archive, or read an existing - * file from pg_wal. + * file from pg_wal. However, before switching WAL source to + * streaming, give it a chance to read all the WAL from + * pg_wal. */ - readFile = XLogFileReadAnyTLI(readSegNo, DEBUG2, - currentSource == XLOG_FROM_ARCHIVE ? XLOG_FROM_ANY : - currentSource); + if (canSwitchSource) + readFrom = XLOG_FROM_PG_WAL; + else + readFrom = currentSource == XLOG_FROM_ARCHIVE ? + XLOG_FROM_ANY : currentSource; + + readFile = XLogFileReadAnyTLI(readSegNo, DEBUG2, readFrom); if (readFile >= 0) return XLREAD_SUCCESS; /* success! */ @@ -3725,6 +3768,14 @@ WaitForWALToBecomeAvailable(XLogRecPtr RecPtr, bool randAccess, * Nope, not found in archive or pg_wal. */ lastSourceFailed = true; + + /* + * Read all the WAL in pg_wal. Now ready to switch to + * streaming. + */ + if (canSwitchSource) + switchSource = true; + break; case XLOG_FROM_STREAM: @@ -3955,6 +4006,44 @@ WaitForWALToBecomeAvailable(XLogRecPtr RecPtr, bool randAccess, return XLREAD_FAIL; /* not reached */ } +/* + * Check if standby can make an attempt to read WAL from primary after reading + * from archive for at least a configurable duration. + * + * Reading WAL from archive may not always be as efficient and fast as reading + * from primary. This can be due to the differences in disk types, IO costs, + * network latencies etc.. All of these can impact the recovery performance on + * standby and increase the replication lag on primary. In addition, the + * primary keeps accumulating WAL needed for the standby while the standby + * reads WAL from archive because the standby replication slot stays inactive. + * To avoid these problems, the standby will try to switch to stream mode + * sooner. + */ +static bool +SwitchWALSourceToPrimary(void) +{ + TimestampTz now; + + if (streaming_replication_retry_interval <= 0 || + !StandbyMode || + currentSource != XLOG_FROM_ARCHIVE) + return false; + + now = GetCurrentTimestamp(); + + /* First time through */ + if (switched_to_archive_at == 0) + { + switched_to_archive_at = now; + return false; + } + + if (TimestampDifferenceExceeds(switched_to_archive_at, now, + streaming_replication_retry_interval)) + return true; + + return false; +} /* * Determine what log level should be used to report a corrupt WAL record diff --git a/src/backend/utils/misc/guc_tables.c b/src/backend/utils/misc/guc_tables.c index 9f59440526..127029e3e4 100644 --- a/src/backend/utils/misc/guc_tables.c +++ b/src/backend/utils/misc/guc_tables.c @@ -3200,6 +3200,18 @@ struct config_int ConfigureNamesInt[] = NULL, NULL, NULL }, + { + {"streaming_replication_retry_interval", PGC_SIGHUP, REPLICATION_STANDBY, + gettext_noop("Sets the time after which standby attempts to switch WAL " + "source from archive to streaming replication."), + gettext_noop("0 turns this feature off."), + GUC_UNIT_MS + }, + &streaming_replication_retry_interval, + 300000, 0, INT_MAX, + NULL, NULL, NULL + }, + { {"wal_segment_size", PGC_INTERNAL, PRESET_OPTIONS, gettext_noop("Shows the size of write ahead log segments."), diff --git a/src/backend/utils/misc/postgresql.conf.sample b/src/backend/utils/misc/postgresql.conf.sample index b2809c711a..4dd27554aa 100644 --- a/src/backend/utils/misc/postgresql.conf.sample +++ b/src/backend/utils/misc/postgresql.conf.sample @@ -360,6 +360,10 @@ # in milliseconds; 0 disables #wal_retrieve_retry_interval = 5s # time to wait before retrying to # retrieve WAL after a failed attempt +#streaming_replication_retry_interval = 5min # time after which standby + # attempts to switch WAL source from archive to + # streaming replication + # in milliseconds; 0 disables #recovery_min_apply_delay = 0 # minimum delay for applying changes during recovery # - Subscribers - diff --git a/src/include/access/xlogrecovery.h b/src/include/access/xlogrecovery.h index ee0bc74278..2e9fb8dfe6 100644 --- a/src/include/access/xlogrecovery.h +++ b/src/include/access/xlogrecovery.h @@ -57,6 +57,7 @@ extern PGDLLIMPORT char *PrimarySlotName; extern PGDLLIMPORT char *recoveryRestoreCommand; extern PGDLLIMPORT char *recoveryEndCommand; extern PGDLLIMPORT char *archiveCleanupCommand; +extern PGDLLIMPORT int streaming_replication_retry_interval; /* indirectly set via GUC system */ extern PGDLLIMPORT TransactionId recoveryTargetXid; diff --git a/src/test/recovery/meson.build b/src/test/recovery/meson.build index 9d8039684a..06041a5f74 100644 --- a/src/test/recovery/meson.build +++ b/src/test/recovery/meson.build @@ -45,6 +45,7 @@ tests += { 't/037_invalid_database.pl', 't/038_save_logical_slots_shutdown.pl', 't/039_end_of_wal.pl', + 't/040_wal_source_switch.pl', ], }, } diff --git a/src/test/recovery/t/040_wal_source_switch.pl b/src/test/recovery/t/040_wal_source_switch.pl new file mode 100644 index 0000000000..5586019eae --- /dev/null +++ b/src/test/recovery/t/040_wal_source_switch.pl @@ -0,0 +1,93 @@ +# Copyright (c) 2023, PostgreSQL Global Development Group +# +# Test for WAL source switch feature. +use strict; +use warnings; + +use PostgreSQL::Test::Utils; +use PostgreSQL::Test::Cluster; +use Test::More; + +# Initialize primary node, setting wal-segsize to 1MB +my $node_primary = PostgreSQL::Test::Cluster->new('primary'); +$node_primary->init( + allows_streaming => 1, + has_archiving => 1, + extra => ['--wal-segsize=1']); + +# Ensure checkpoint doesn't come in our way +$node_primary->append_conf('postgresql.conf', qq( + min_wal_size = 2MB + max_wal_size = 1GB + checkpoint_timeout = 1h + autovacuum = off +)); +$node_primary->start; + +$node_primary->safe_psql('postgres', + "SELECT pg_create_physical_replication_slot('standby_slot')"); + +# Take backup +my $backup_name = 'my_backup'; +$node_primary->backup($backup_name); + +# Create a streaming standby +my $node_standby = PostgreSQL::Test::Cluster->new('standby'); +$node_standby->init_from_backup( + $node_primary, $backup_name, + has_streaming => 1, + has_restoring => 1); +$node_standby->append_conf('postgresql.conf', qq( + primary_slot_name = 'standby_slot' + streaming_replication_retry_interval = 1ms + log_min_messages = 'debug1' +)); +$node_standby->start; + +# Wait until standby has replayed enough data +$node_primary->wait_for_catchup($node_standby); + +$node_standby->stop; + +# Advance WAL by 5 segments (= 5MB) on primary +$node_primary->advance_wal(5); + +# Wait for primary to generate requested WAL files +$node_primary->poll_query_until('postgres', + "SELECT COUNT(*) >= 5 FROM pg_ls_waldir();") + or die "Timed out while waiting for primary to generate WAL"; + +# Wait until generated WAL files have been stored on the archives of the +# primary. This ensures that the standby created below will be able to restore +# the WAL files. +my $primary_archive = $node_primary->archive_dir; +$node_primary->poll_query_until('postgres', + "SELECT COUNT(*) >= 5 FROM pg_ls_dir('$primary_archive', false, false) a WHERE a ~ '^[0-9A-F]{24}\$';" +) or die "Timed out while waiting for archiving of WAL by primary"; + +# Generate some data on the primary +$node_primary->safe_psql('postgres', + "CREATE TABLE test_tbl AS SELECT a FROM generate_series(1,5) AS a;"); + +my $offset = -s $node_standby->logfile; + +# Standby now connects to primary during inital recovery after fetching WAL +# from archive for about streaming_replication_retry_interval milliseconds. +$node_standby->start; + +# Wait until standby has replayed enough data +$node_primary->wait_for_catchup($node_standby); + +$node_standby->wait_for_log( + qr/DEBUG: ( [A-Z0-9]+:)? switched WAL source from archive to stream after timeout/, + $offset); +$node_standby->wait_for_log( + qr/LOG: ( [A-Z0-9]+:)? started streaming WAL from primary at .* on timeline .*/, + $offset); + +# Check that the data from primary is streamed to standby +my $result = + $node_standby->safe_psql('postgres', "SELECT COUNT(*) FROM test_tbl;"); +is($result, '5', 'data from primary is streamed to standby'); + +done_testing(); -- 2.34.1
