action_at_recovery_target recovery config option

action_at_recovery_target = pause | promote | shutdown

Petr Jelinek

Reviewed by Muhammad Asif Naeem, Fujji Masao and
Simon Riggs

diff --git a/doc/src/sgml/recovery-config.sgml b/doc/src/sgml/recovery-config.sgml
index 0f1ff343a6c8da2bc17ac1cc415683ae48f7b16b..a145a3fee2b8f0998416611bfcab8e674d8966ca 100644 (file)
--- a/doc/src/sgml/recovery-config.sgml
+++ b/doc/src/sgml/recovery-config.sgml
@@ -289,12 +289,39 @@ restore_command = 'copy "C:\\server\\archivedir\\%f" "%p"'  # Windows
       </term>
       <listitem>
        <para>
-        Specifies whether recovery should pause when the recovery target
-        is reached. The default is true.
-        This is intended to allow queries to be executed against the
-        database to check if this recovery target is the most desirable
-        point for recovery. The paused state can be resumed by using
-        <function>pg_xlog_replay_resume()</> (See
+        Alias for action_at_recovery_target, <literal>true</> is same as
+        action_at_recovery_target = <literal>pause</> and <literal>false</>
+        is same as action_at_recovery_target = <literal>promote</>.
+       </para>
+       <para>
+        This setting has no effect if <xref linkend="guc-hot-standby"> is not
+        enabled, or if no recovery target is set.
+       </para>
+      </listitem>
+     </varlistentry>
+
+     </variablelist>
+
+     <varlistentry id="action-at-recovery-target"
+                   xreflabel="action_at_recovery_target">
+      <term><varname>action_at_recovery_target</varname> (<type>enum</type>)
+      <indexterm>
+        <primary><varname>action_at_recovery_target</> recovery parameter</primary>
+      </indexterm>
+      </term>
+      <listitem>
+       <para>
+        Specifies what action the server should take once the recovery target is
+        reached. The default is <literal>pause</>, which means recovery will
+        be paused. <literal>promote</> means recovery process will finish and
+        the server will start to accept connections.
+        Finally <literal>shutdown</> will stop the server after reaching the
+        recovery target.
+       </para>
+        The intended use of <literal>pause</> setting is to allow queries to be
+        executed against the database to check if this recovery target is the
+        most desirable point for recovery. The paused state can be resumed by
+        using <function>pg_xlog_replay_resume()</> (See
         <xref linkend="functions-recovery-control-table">), which then
         causes recovery to end. If this recovery target is not the
         desired stopping point, then shutdown the server, change the
@@ -302,8 +329,23 @@ restore_command = 'copy "C:\\server\\archivedir\\%f" "%p"'  # Windows
         continue recovery.
        </para>
        <para>
-        This setting has no effect if <xref linkend="guc-hot-standby"> is not
-        enabled, or if no recovery target is set.
+        The <literal>shutdown</> setting is useful to have instance ready at
+        exact replay point desired.
+        The instance will still be able to replay more WAL records (and in fact
+        will have to replay WAL records since last checkpoint next time it is
+        started).
+       </para>
+       <para>
+        Note that because <filename>recovery.conf</> will not be renamed when
+        <varname>action_at_recovery_target</> is set to <literal>shutdown</>,
+        any subsequent start will end with immediate shutdown unless the
+        configuration is changed or the <filename>recovery.conf</> is removed
+        manually.
+       </para>
+       <para>
+        This setting has no effect if no recovery target is set.
+        If <xref linkend="guc-hot-standby"> is not enabled, a setting of
+        <literal>pause</> will act the same as <literal>shutdown</>.
        </para>
       </listitem>
      </varlistentry>

diff --git a/src/backend/access/transam/xlog.c b/src/backend/access/transam/xlog.c
index 8e712b793f33db6591ef36c79fd10ea8785d69b1..0f661f5010c7685282afb892ee17b300c5e9b4bc 100644 (file)
--- a/src/backend/access/transam/xlog.c
+++ b/src/backend/access/transam/xlog.c
@@ -228,7 +228,7 @@ static char *recoveryEndCommand = NULL;
 static char *archiveCleanupCommand = NULL;
 static RecoveryTargetType recoveryTarget = RECOVERY_TARGET_UNSET;
 static bool recoveryTargetInclusive = true;
-static bool recoveryPauseAtTarget = true;
+static RecoveryTargetAction actionAtRecoveryTarget = RECOVERY_TARGET_ACTION_PAUSE;
 static TransactionId recoveryTargetXid;
 static TimestampTz recoveryTargetTime;
 static char *recoveryTargetName;
@@ -4647,6 +4647,9 @@ readRecoveryCommandFile(void)
    ConfigVariable *item,
               *head = NULL,
               *tail = NULL;
+   bool        recoveryPauseAtTargetSet = false;
+   bool        actionAtRecoveryTargetSet = false;
+
 
    fd = AllocateFile(RECOVERY_COMMAND_FILE, "r");
    if (fd == NULL)
@@ -4692,13 +4695,43 @@ readRecoveryCommandFile(void)
        }
        else if (strcmp(item->name, "pause_at_recovery_target") == 0)
        {
+           bool recoveryPauseAtTarget;
+
            if (!parse_bool(item->value, &recoveryPauseAtTarget))
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                         errmsg("parameter \"%s\" requires a Boolean value", "pause_at_recovery_target")));
+
            ereport(DEBUG2,
                    (errmsg_internal("pause_at_recovery_target = '%s'",
                                     item->value)));
+
+           actionAtRecoveryTarget = recoveryPauseAtTarget ?
+                                    RECOVERY_TARGET_ACTION_PAUSE :
+                                    RECOVERY_TARGET_ACTION_PROMOTE;
+
+           recoveryPauseAtTargetSet = true;
+       }
+       else if (strcmp(item->name, "action_at_recovery_target") == 0)
+       {
+           if (strcmp(item->value, "pause") == 0)
+               actionAtRecoveryTarget = RECOVERY_TARGET_ACTION_PAUSE;
+           else if (strcmp(item->value, "promote") == 0)
+               actionAtRecoveryTarget = RECOVERY_TARGET_ACTION_PROMOTE;
+           else if (strcmp(item->value, "shutdown") == 0)
+               actionAtRecoveryTarget = RECOVERY_TARGET_ACTION_SHUTDOWN;
+           else
+               ereport(ERROR,
+                       (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+                        errmsg("invalid value for recovery parameter \"%s\"",
+                               "action_at_recovery_target"),
+                        errhint("The allowed values are \"pause\", \"promote\" and \"shutdown\".")));
+
+           ereport(DEBUG2,
+                   (errmsg_internal("action_at_recovery_target = '%s'",
+                                    item->value)));
+
+           actionAtRecoveryTargetSet = true;
        }
        else if (strcmp(item->name, "recovery_target_timeline") == 0)
        {
@@ -4863,6 +4896,28 @@ readRecoveryCommandFile(void)
                            RECOVERY_COMMAND_FILE)));
    }
 
+   /*
+    * Check for mutually exclusive parameters
+    */
+   if (recoveryPauseAtTargetSet && actionAtRecoveryTargetSet)
+       ereport(ERROR,
+               (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+                errmsg("cannot set both \"%s\" and \"%s\" recovery parameters",
+                       "pause_at_recovery_target",
+                       "action_at_recovery_target"),
+                errhint("The \"pause_at_recovery_target\" is deprecated.")));
+
+
+   /*
+    * Override any inconsistent requests. Not that this is a change
+    * of behaviour in 9.5; prior to this we simply ignored a request
+    * to pause if hot_standby = off, which was surprising behaviour.
+    */
+   if (actionAtRecoveryTarget == RECOVERY_TARGET_ACTION_PAUSE &&
+       actionAtRecoveryTargetSet &&
+       standbyState == STANDBY_DISABLED)
+           actionAtRecoveryTarget = RECOVERY_TARGET_ACTION_SHUTDOWN;
+
    /* Enable fetching from archive recovery area */
    ArchiveRecoveryRequested = true;
 
@@ -6415,10 +6470,37 @@ StartupXLOG(void)
             * end of main redo apply loop
             */
 
-           if (recoveryPauseAtTarget && reachedStopPoint)
+           if (reachedStopPoint)
            {
-               SetRecoveryPause(true);
-               recoveryPausesHere();
+               if (!reachedConsistency)
+                   ereport(FATAL,
+                       (errmsg("requested recovery stop point is before consistent recovery point")));
+
+               /*
+                * This is the last point where we can restart recovery with a
+                * new recovery target, if we shutdown and begin again. After
+                * this, Resource Managers may choose to do permanent corrective
+                * actions at end of recovery.
+                */
+               switch (actionAtRecoveryTarget)
+               {
+                   case RECOVERY_TARGET_ACTION_SHUTDOWN:
+                           /*
+                            * exit with special return code to request shutdown
+                            * of postmaster.  Log messages issued from
+                            * postmaster.
+                            */
+                           proc_exit(3);
+
+                   case RECOVERY_TARGET_ACTION_PAUSE:
+                           SetRecoveryPause(true);
+                           recoveryPausesHere();
+
+                           /* drop into promote */
+
+                   case RECOVERY_TARGET_ACTION_PROMOTE:
+                           break;
+               }
            }
 
            /* Allow resource managers to do any required cleanup. */
@@ -6436,6 +6518,7 @@ StartupXLOG(void)
                ereport(LOG,
                     (errmsg("last completed transaction was at log time %s",
                             timestamptz_to_str(xtime))));
+
            InRedo = false;
        }
        else
@@ -6496,13 +6579,6 @@ StartupXLOG(void)
        (EndOfLog < minRecoveryPoint ||
         !XLogRecPtrIsInvalid(ControlFile->backupStartPoint)))
    {
-       if (reachedStopPoint)
-       {
-           /* stopped because of stop request */
-           ereport(FATAL,
-                   (errmsg("requested recovery stop point is before consistent recovery point")));
-       }
-
        /*
         * Ran off end of WAL before reaching end-of-backup WAL record, or
         * minRecoveryPoint. That's usually a bad sign, indicating that you

diff --git a/src/backend/postmaster/postmaster.c b/src/backend/postmaster/postmaster.c
index 6220a8e6e471e6d7f39331e2b3b42cc2acaa8001..5106f52e0e0d49e56d9cc0050df72e5c7fef8a61 100644 (file)
--- a/src/backend/postmaster/postmaster.c
+++ b/src/backend/postmaster/postmaster.c
@@ -509,6 +509,7 @@ static void ShmemBackendArrayRemove(Backend *bn);
 /* Macros to check exit status of a child process */
 #define EXIT_STATUS_0(st)  ((st) == 0)
 #define EXIT_STATUS_1(st)  (WIFEXITED(st) && WEXITSTATUS(st) == 1)
+#define EXIT_STATUS_3(st)  (WIFEXITED(st) && WEXITSTATUS(st) == 3)
 
 #ifndef WIN32
 /*
@@ -2555,6 +2556,17 @@ reaper(SIGNAL_ARGS)
                continue;
            }
 
+           if (EXIT_STATUS_3(exitstatus))
+           {
+               ereport(LOG,
+                   (errmsg("shutdown at recovery target")));
+               Shutdown = SmartShutdown;
+               TerminateChildren(SIGTERM);
+               pmState = PM_WAIT_BACKENDS;
+               /* PostmasterStateMachine logic does the rest */
+               continue;
+           }
+
            /*
             * Unexpected exit of startup process (including FATAL exit)
             * during PM_STARTUP is treated as catastrophic. There are no

diff --git a/src/include/access/xlog_internal.h b/src/include/access/xlog_internal.h
index 423ef4d7fa0d63414cd8122b009677ca504cf5da..85b3fe76bb67f272a9559423ce9dbcab2bac78ba 100644 (file)
--- a/src/include/access/xlog_internal.h
+++ b/src/include/access/xlog_internal.h
@@ -214,6 +214,16 @@ typedef struct XLogRecData
    uint32      len;            /* length of rmgr data to include */
 } XLogRecData;
 
+/*
+ * Recovery target action.
+ */
+typedef enum
+{
+   RECOVERY_TARGET_ACTION_PAUSE,
+   RECOVERY_TARGET_ACTION_PROMOTE,
+   RECOVERY_TARGET_ACTION_SHUTDOWN,
+} RecoveryTargetAction;
+
 /*
  * Method table for resource managers.
  *