From: Peter Eisentraut <peter.eisentraut@2ndquadrant.com>
Subject: Improve handling of parameter differences in physical replication
To: pgsql-hackers <pgsql-hackers@postgresql.org>
Organization: 2ndQuadrant
Message-ID: <4ad69a4c-cc9b-0dfe-0352-8b1b0cd36c7b@2ndquadrant.com>
Date: Thu, 27 Feb 2020 09:23:46 +0100
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:52.0)
 Gecko/20100101 Thunderbird/52.9.1
MIME-Version: 1.0
Content-Type: multipart/mixed;
 boundary="------------1669BABE5EE875365FE649C0"
Content-Language: en-US
Precedence: bulk

This is a multi-part message in MIME format.
--------------1669BABE5EE875365FE649C0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 7bit

When certain parameters are changed on a physical replication primary, 
   this is communicated to standbys using the XLOG_PARAMETER_CHANGE WAL 
record.  The standby then checks whether its own settings are at least 
as big as the ones on the primary.  If not, the standby shuts down with 
a fatal error.

The correspondence of settings between primary and standby is required 
because those settings influence certain shared memory sizings that are 
required for processing WAL records that the primary might send.  For 
example, if the primary sends a prepared transaction, the standby must 
have had max_prepared_transaction set appropriately or it won't be able 
to process those WAL records.

However, fatally shutting down the standby immediately upon receipt of 
the parameter change record might be a bit of an overreaction.  The 
resources related to those settings are not required immediately at that 
point, and might never be required if the activity on the primary does 
not exhaust all those resources.  An extreme example is raising 
max_prepared_transactions on the primary but never actually using 
prepared transactions.

Where this becomes a serious problem is if you have many standbys and 
you do a failover.  If the newly promoted standby happens to have a 
higher setting for one of the relevant parameters, all the other 
standbys that have followed it then shut down immediately and won't be 
able to continue until you change all their settings.

If we didn't do the hard shutdown and we just let the standby roll on 
with recovery, nothing bad will happen and it will eventually produce an 
appropriate error when those resources are required (e.g., "maximum 
number of prepared transactions reached").

So I think there are better ways to handle this.  It might be reasonable 
to provide options.  The attached patch doesn't do that but it would be 
pretty easy.  What the attached patch does is:

Upon receipt of XLOG_PARAMETER_CHANGE, we still check the settings but 
only issue a warning and set a global flag if there is a problem.  Then 
when we actually hit the resource issue and the flag was set, we issue 
another warning message with relevant information.  Additionally, at 
that point we pause recovery instead of shutting down, so a hot standby 
remains usable.  (That could certainly be configurable.)

Btw., I think the current setup is slightly buggy.  The MaxBackends 
value that is used to size shared memory is computed as MaxConnections + 
autovacuum_max_workers + 1 + max_worker_processes + max_wal_senders, but 
we don't track autovacuum_max_workers in WAL.

(This patch was developed together with Simon Riggs.)

-- 
Peter Eisentraut              http://www.2ndQuadrant.com/
PostgreSQL Development, 24x7 Support, Remote DBA, Training & Services

--------------1669BABE5EE875365FE649C0
Content-Type: text/plain; charset=UTF-8; x-mac-type="0"; x-mac-creator="0";
 name="v1-0001-Improve-handling-of-parameter-differences-in-phys.patch"
Content-Transfer-Encoding: base64
Content-Disposition: attachment;
 filename*0="v1-0001-Improve-handling-of-parameter-differences-in-phys.pa";
 filename*1="tch"
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--------------1669BABE5EE875365FE649C0--