summaryrefslogtreecommitdiffstats
path: root/contrib/pg_standby
diff options
context:
space:
mode:
Diffstat (limited to 'contrib/pg_standby')
-rw-r--r--contrib/pg_standby/.gitignore1
-rw-r--r--contrib/pg_standby/Makefile20
-rw-r--r--contrib/pg_standby/pg_standby.c907
3 files changed, 928 insertions, 0 deletions
diff --git a/contrib/pg_standby/.gitignore b/contrib/pg_standby/.gitignore
new file mode 100644
index 0000000..a401b08
--- /dev/null
+++ b/contrib/pg_standby/.gitignore
@@ -0,0 +1 @@
+/pg_standby
diff --git a/contrib/pg_standby/Makefile b/contrib/pg_standby/Makefile
new file mode 100644
index 0000000..87732be
--- /dev/null
+++ b/contrib/pg_standby/Makefile
@@ -0,0 +1,20 @@
+# contrib/pg_standby/Makefile
+
+PGFILEDESC = "pg_standby - supports creation of a warm standby"
+PGAPPICON = win32
+
+PROGRAM = pg_standby
+OBJS = \
+ $(WIN32RES) \
+ pg_standby.o
+
+ifdef USE_PGXS
+PG_CONFIG = pg_config
+PGXS := $(shell $(PG_CONFIG) --pgxs)
+include $(PGXS)
+else
+subdir = contrib/pg_standby
+top_builddir = ../..
+include $(top_builddir)/src/Makefile.global
+include $(top_srcdir)/contrib/contrib-global.mk
+endif
diff --git a/contrib/pg_standby/pg_standby.c b/contrib/pg_standby/pg_standby.c
new file mode 100644
index 0000000..c9f33e4
--- /dev/null
+++ b/contrib/pg_standby/pg_standby.c
@@ -0,0 +1,907 @@
+/*
+ * contrib/pg_standby/pg_standby.c
+ *
+ *
+ * pg_standby.c
+ *
+ * Production-ready example of how to create a Warm Standby
+ * database server using continuous archiving as a
+ * replication mechanism
+ *
+ * We separate the parameters for archive and nextWALfile
+ * so that we can check the archive exists, even if the
+ * WAL file doesn't (yet).
+ *
+ * This program will be executed once in full for each file
+ * requested by the warm standby server.
+ *
+ * It is designed to cater to a variety of needs, as well
+ * providing a customizable section.
+ *
+ * Original author: Simon Riggs simon@2ndquadrant.com
+ * Current maintainer: Simon Riggs
+ */
+#include "postgres_fe.h"
+
+#include <ctype.h>
+#include <dirent.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <signal.h>
+#include <sys/time.h>
+
+#include "access/xlog_internal.h"
+#include "pg_getopt.h"
+
+const char *progname;
+
+int WalSegSz = -1;
+
+/* Options and defaults */
+int sleeptime = 5; /* amount of time to sleep between file checks */
+int waittime = -1; /* how long we have been waiting, -1 no wait
+ * yet */
+int maxwaittime = 0; /* how long are we prepared to wait for? */
+int keepfiles = 0; /* number of WAL files to keep, 0 keep all */
+int maxretries = 3; /* number of retries on restore command */
+bool debug = false; /* are we debugging? */
+bool need_cleanup = false; /* do we need to remove files from
+ * archive? */
+
+#ifndef WIN32
+static volatile sig_atomic_t signaled = false;
+#endif
+
+char *archiveLocation; /* where to find the archive? */
+char *triggerPath; /* where to find the trigger file? */
+char *xlogFilePath; /* where we are going to restore to */
+char *nextWALFileName; /* the file we need to get from archive */
+char *restartWALFileName; /* the file from which we can restart restore */
+char WALFilePath[MAXPGPATH * 2]; /* the file path including archive */
+char restoreCommand[MAXPGPATH]; /* run this to restore */
+char exclusiveCleanupFileName[MAXFNAMELEN]; /* the file we need to get
+ * from archive */
+
+/*
+ * Two types of failover are supported (smart and fast failover).
+ *
+ * The content of the trigger file determines the type of failover. If the
+ * trigger file contains the word "smart" (or the file is empty), smart
+ * failover is chosen: pg_standby acts as cp or ln command itself, on
+ * successful completion all the available WAL records will be applied
+ * resulting in zero data loss. But, it might take a long time to finish
+ * recovery if there's a lot of unapplied WAL.
+ *
+ * On the other hand, if the trigger file contains the word "fast", the
+ * recovery is finished immediately even if unapplied WAL files remain. Any
+ * transactions in the unapplied WAL files are lost.
+ *
+ * An empty trigger file performs smart failover. SIGUSR or SIGINT triggers
+ * fast failover. A timeout causes fast failover (smart failover would have
+ * the same effect, since if the timeout is reached there is no unapplied WAL).
+ */
+#define NoFailover 0
+#define SmartFailover 1
+#define FastFailover 2
+
+static int Failover = NoFailover;
+
+#define RESTORE_COMMAND_COPY 0
+#define RESTORE_COMMAND_LINK 1
+int restoreCommandType;
+
+#define XLOG_DATA 0
+#define XLOG_HISTORY 1
+int nextWALFileType;
+
+#define SET_RESTORE_COMMAND(cmd, arg1, arg2) \
+ snprintf(restoreCommand, MAXPGPATH, cmd " \"%s\" \"%s\"", arg1, arg2)
+
+struct stat stat_buf;
+
+static bool SetWALFileNameForCleanup(void);
+static bool SetWALSegSize(void);
+
+
+/* =====================================================================
+ *
+ * Customizable section
+ *
+ * =====================================================================
+ *
+ * Currently, this section assumes that the Archive is a locally
+ * accessible directory. If you want to make other assumptions,
+ * such as using a vendor-specific archive and access API, these
+ * routines are the ones you'll need to change. You're
+ * encouraged to submit any changes to pgsql-hackers@lists.postgresql.org
+ * or personally to the current maintainer. Those changes may be
+ * folded in to later versions of this program.
+ */
+
+/*
+ * Initialize allows customized commands into the warm standby program.
+ *
+ * As an example, and probably the common case, we use either
+ * cp/ln commands on *nix, or copy/move command on Windows.
+ */
+static void
+CustomizableInitialize(void)
+{
+#ifdef WIN32
+ snprintf(WALFilePath, MAXPGPATH, "%s\\%s", archiveLocation, nextWALFileName);
+ switch (restoreCommandType)
+ {
+ case RESTORE_COMMAND_LINK:
+ SET_RESTORE_COMMAND("mklink", WALFilePath, xlogFilePath);
+ break;
+ case RESTORE_COMMAND_COPY:
+ default:
+ SET_RESTORE_COMMAND("copy", WALFilePath, xlogFilePath);
+ break;
+ }
+#else
+ snprintf(WALFilePath, MAXPGPATH, "%s/%s", archiveLocation, nextWALFileName);
+ switch (restoreCommandType)
+ {
+ case RESTORE_COMMAND_LINK:
+ SET_RESTORE_COMMAND("ln -s -f", WALFilePath, xlogFilePath);
+ break;
+ case RESTORE_COMMAND_COPY:
+ default:
+ SET_RESTORE_COMMAND("cp", WALFilePath, xlogFilePath);
+ break;
+ }
+#endif
+
+ /*
+ * This code assumes that archiveLocation is a directory You may wish to
+ * add code to check for tape libraries, etc.. So, since it is a
+ * directory, we use stat to test if it's accessible
+ */
+ if (stat(archiveLocation, &stat_buf) != 0)
+ {
+ fprintf(stderr, "%s: archive location \"%s\" does not exist\n", progname, archiveLocation);
+ fflush(stderr);
+ exit(2);
+ }
+}
+
+/*
+ * CustomizableNextWALFileReady()
+ *
+ * Is the requested file ready yet?
+ */
+static bool
+CustomizableNextWALFileReady(void)
+{
+ if (stat(WALFilePath, &stat_buf) == 0)
+ {
+ /*
+ * If we've not seen any WAL segments, we don't know the WAL segment
+ * size, which we need. If it looks like a WAL segment, determine size
+ * of segments for the cluster.
+ */
+ if (WalSegSz == -1 && IsXLogFileName(nextWALFileName))
+ {
+ if (SetWALSegSize())
+ {
+ /*
+ * Successfully determined WAL segment size. Can compute
+ * cleanup cutoff now.
+ */
+ need_cleanup = SetWALFileNameForCleanup();
+ if (debug)
+ {
+ fprintf(stderr,
+ _("WAL segment size: %d \n"), WalSegSz);
+ fprintf(stderr, "Keep archive history: ");
+
+ if (need_cleanup)
+ fprintf(stderr, "%s and later\n",
+ exclusiveCleanupFileName);
+ else
+ fprintf(stderr, "no cleanup required\n");
+ }
+ }
+ }
+
+ /*
+ * Return only if it's the right size already.
+ */
+ if (WalSegSz > 0 && stat_buf.st_size == WalSegSz)
+ {
+#ifdef WIN32
+
+ /*
+ * Windows 'cp' sets the final file size before the copy is
+ * complete, and not yet ready to be opened by pg_standby. So we
+ * wait for sleeptime secs before attempting to restore. If that
+ * is not enough, we will rely on the retry/holdoff mechanism.
+ * GNUWin32's cp does not have this problem.
+ */
+ pg_usleep(sleeptime * 1000000L);
+#endif
+ nextWALFileType = XLOG_DATA;
+ return true;
+ }
+
+ /*
+ * If still too small, wait until it is the correct size
+ */
+ if (WalSegSz > 0 && stat_buf.st_size > WalSegSz)
+ {
+ if (debug)
+ {
+ fprintf(stderr, "file size greater than expected\n");
+ fflush(stderr);
+ }
+ exit(3);
+ }
+ }
+
+ return false;
+}
+
+static void
+CustomizableCleanupPriorWALFiles(void)
+{
+ /*
+ * Work out name of prior file from current filename
+ */
+ if (nextWALFileType == XLOG_DATA)
+ {
+ int rc;
+ DIR *xldir;
+ struct dirent *xlde;
+
+ /*
+ * Assume it's OK to keep failing. The failure situation may change
+ * over time, so we'd rather keep going on the main processing than
+ * fail because we couldn't clean up yet.
+ */
+ if ((xldir = opendir(archiveLocation)) != NULL)
+ {
+ while (errno = 0, (xlde = readdir(xldir)) != NULL)
+ {
+ /*
+ * We ignore the timeline part of the XLOG segment identifiers
+ * in deciding whether a segment is still needed. This
+ * ensures that we won't prematurely remove a segment from a
+ * parent timeline. We could probably be a little more
+ * proactive about removing segments of non-parent timelines,
+ * but that would be a whole lot more complicated.
+ *
+ * We use the alphanumeric sorting property of the filenames
+ * to decide which ones are earlier than the
+ * exclusiveCleanupFileName file. Note that this means files
+ * are not removed in the order they were originally written,
+ * in case this worries you.
+ */
+ if (IsXLogFileName(xlde->d_name) &&
+ strcmp(xlde->d_name + 8, exclusiveCleanupFileName + 8) < 0)
+ {
+#ifdef WIN32
+ snprintf(WALFilePath, sizeof(WALFilePath), "%s\\%s", archiveLocation, xlde->d_name);
+#else
+ snprintf(WALFilePath, sizeof(WALFilePath), "%s/%s", archiveLocation, xlde->d_name);
+#endif
+
+ if (debug)
+ fprintf(stderr, "\nremoving file \"%s\"", WALFilePath);
+
+ rc = unlink(WALFilePath);
+ if (rc != 0)
+ {
+ fprintf(stderr, "\n%s: ERROR: could not remove file \"%s\": %s\n",
+ progname, WALFilePath, strerror(errno));
+ break;
+ }
+ }
+ }
+
+ if (errno)
+ fprintf(stderr, "%s: could not read archive location \"%s\": %s\n",
+ progname, archiveLocation, strerror(errno));
+ if (debug)
+ fprintf(stderr, "\n");
+ }
+ else
+ fprintf(stderr, "%s: could not open archive location \"%s\": %s\n",
+ progname, archiveLocation, strerror(errno));
+
+ if (closedir(xldir))
+ fprintf(stderr, "%s: could not close archive location \"%s\": %s\n",
+ progname, archiveLocation, strerror(errno));
+
+ fflush(stderr);
+ }
+}
+
+/* =====================================================================
+ * End of Customizable section
+ * =====================================================================
+ */
+
+/*
+ * SetWALFileNameForCleanup()
+ *
+ * Set the earliest WAL filename that we want to keep on the archive
+ * and decide whether we need_cleanup
+ */
+static bool
+SetWALFileNameForCleanup(void)
+{
+ uint32 tli = 1,
+ log = 0,
+ seg = 0;
+ uint32 log_diff = 0,
+ seg_diff = 0;
+ bool cleanup = false;
+ int max_segments_per_logfile = (0xFFFFFFFF / WalSegSz);
+
+ if (restartWALFileName)
+ {
+ /*
+ * Don't do cleanup if the restartWALFileName provided is later than
+ * the xlog file requested. This is an error and we must not remove
+ * these files from archive. This shouldn't happen, but better safe
+ * than sorry.
+ */
+ if (strcmp(restartWALFileName, nextWALFileName) > 0)
+ return false;
+
+ strlcpy(exclusiveCleanupFileName, restartWALFileName, sizeof(exclusiveCleanupFileName));
+ return true;
+ }
+
+ if (keepfiles > 0)
+ {
+ sscanf(nextWALFileName, "%08X%08X%08X", &tli, &log, &seg);
+ if (tli > 0 && seg > 0)
+ {
+ log_diff = keepfiles / max_segments_per_logfile;
+ seg_diff = keepfiles % max_segments_per_logfile;
+ if (seg_diff > seg)
+ {
+ log_diff++;
+ seg = max_segments_per_logfile - (seg_diff - seg);
+ }
+ else
+ seg -= seg_diff;
+
+ if (log >= log_diff)
+ {
+ log -= log_diff;
+ cleanup = true;
+ }
+ else
+ {
+ log = 0;
+ seg = 0;
+ }
+ }
+ }
+
+ XLogFileNameById(exclusiveCleanupFileName, tli, log, seg);
+
+ return cleanup;
+}
+
+/*
+ * Try to set the wal segment size from the WAL file specified by WALFilePath.
+ *
+ * Return true if size could be determined, false otherwise.
+ */
+static bool
+SetWALSegSize(void)
+{
+ bool ret_val = false;
+ int fd;
+ PGAlignedXLogBlock buf;
+
+ Assert(WalSegSz == -1);
+
+ if ((fd = open(WALFilePath, O_RDWR, 0)) < 0)
+ {
+ fprintf(stderr, "%s: could not open WAL file \"%s\": %s\n",
+ progname, WALFilePath, strerror(errno));
+ return false;
+ }
+
+ errno = 0;
+ if (read(fd, buf.data, XLOG_BLCKSZ) == XLOG_BLCKSZ)
+ {
+ XLogLongPageHeader longhdr = (XLogLongPageHeader) buf.data;
+
+ WalSegSz = longhdr->xlp_seg_size;
+
+ if (IsValidWalSegSize(WalSegSz))
+ {
+ /* successfully retrieved WAL segment size */
+ ret_val = true;
+ }
+ else
+ fprintf(stderr,
+ "%s: WAL segment size must be a power of two between 1MB and 1GB, but the WAL file header specifies %d bytes\n",
+ progname, WalSegSz);
+ }
+ else
+ {
+ /*
+ * Don't complain loudly, this is to be expected for segments being
+ * created.
+ */
+ if (errno != 0)
+ {
+ if (debug)
+ fprintf(stderr, "could not read file \"%s\": %s\n",
+ WALFilePath, strerror(errno));
+ }
+ else
+ {
+ if (debug)
+ fprintf(stderr, "not enough data in file \"%s\"\n",
+ WALFilePath);
+ }
+ }
+
+ fflush(stderr);
+
+ close(fd);
+ return ret_val;
+}
+
+/*
+ * CheckForExternalTrigger()
+ *
+ * Is there a trigger file? Sets global 'Failover' variable to indicate
+ * what kind of a trigger file it was. A "fast" trigger file is turned
+ * into a "smart" file as a side-effect.
+ */
+static void
+CheckForExternalTrigger(void)
+{
+ char buf[32];
+ int fd;
+ int len;
+
+ /*
+ * Look for a trigger file, if that option has been selected
+ *
+ * We use stat() here because triggerPath is always a file rather than
+ * potentially being in an archive
+ */
+ if (!triggerPath || stat(triggerPath, &stat_buf) != 0)
+ return;
+
+ /*
+ * An empty trigger file performs smart failover. There's a little race
+ * condition here: if the writer of the trigger file has just created the
+ * file, but not yet written anything to it, we'll treat that as smart
+ * shutdown even if the other process was just about to write "fast" to
+ * it. But that's fine: we'll restore one more WAL file, and when we're
+ * invoked next time, we'll see the word "fast" and fail over immediately.
+ */
+ if (stat_buf.st_size == 0)
+ {
+ Failover = SmartFailover;
+ fprintf(stderr, "trigger file found: smart failover\n");
+ fflush(stderr);
+ return;
+ }
+
+ if ((fd = open(triggerPath, O_RDWR, 0)) < 0)
+ {
+ fprintf(stderr, "WARNING: could not open \"%s\": %s\n",
+ triggerPath, strerror(errno));
+ fflush(stderr);
+ return;
+ }
+
+ if ((len = read(fd, buf, sizeof(buf) - 1)) < 0)
+ {
+ fprintf(stderr, "WARNING: could not read \"%s\": %s\n",
+ triggerPath, strerror(errno));
+ fflush(stderr);
+ close(fd);
+ return;
+ }
+ buf[len] = '\0';
+
+ if (strncmp(buf, "smart", 5) == 0)
+ {
+ Failover = SmartFailover;
+ fprintf(stderr, "trigger file found: smart failover\n");
+ fflush(stderr);
+ close(fd);
+ return;
+ }
+
+ if (strncmp(buf, "fast", 4) == 0)
+ {
+ Failover = FastFailover;
+
+ fprintf(stderr, "trigger file found: fast failover\n");
+ fflush(stderr);
+
+ /*
+ * Turn it into a "smart" trigger by truncating the file. Otherwise if
+ * the server asks us again to restore a segment that was restored
+ * already, we would return "not found" and upset the server.
+ */
+ if (ftruncate(fd, 0) < 0)
+ {
+ fprintf(stderr, "WARNING: could not read \"%s\": %s\n",
+ triggerPath, strerror(errno));
+ fflush(stderr);
+ }
+ close(fd);
+
+ return;
+ }
+ close(fd);
+
+ fprintf(stderr, "WARNING: invalid content in \"%s\"\n", triggerPath);
+ fflush(stderr);
+}
+
+/*
+ * RestoreWALFileForRecovery()
+ *
+ * Perform the action required to restore the file from archive
+ */
+static bool
+RestoreWALFileForRecovery(void)
+{
+ int rc = 0;
+ int numretries = 0;
+
+ if (debug)
+ {
+ fprintf(stderr, "running restore: ");
+ fflush(stderr);
+ }
+
+ while (numretries <= maxretries)
+ {
+ rc = system(restoreCommand);
+ if (rc == 0)
+ {
+ if (debug)
+ {
+ fprintf(stderr, "OK\n");
+ fflush(stderr);
+ }
+ return true;
+ }
+ pg_usleep(numretries++ * sleeptime * 1000000L);
+ }
+
+ /*
+ * Allow caller to add additional info
+ */
+ if (debug)
+ fprintf(stderr, "not restored\n");
+ return false;
+}
+
+static void
+usage(void)
+{
+ printf("%s allows PostgreSQL warm standby servers to be configured.\n\n", progname);
+ printf("Usage:\n");
+ printf(" %s [OPTION]... ARCHIVELOCATION NEXTWALFILE XLOGFILEPATH [RESTARTWALFILE]\n", progname);
+ printf("\nOptions:\n");
+ printf(" -c copy file from archive (default)\n");
+ printf(" -d generate lots of debugging output (testing only)\n");
+ printf(" -k NUMFILESTOKEEP if RESTARTWALFILE is not used, remove files prior to limit\n"
+ " (0 keeps all)\n");
+ printf(" -l does nothing; use of link is now deprecated\n");
+ printf(" -r MAXRETRIES max number of times to retry, with progressive wait\n"
+ " (default=3)\n");
+ printf(" -s SLEEPTIME seconds to wait between file checks (min=1, max=60,\n"
+ " default=5)\n");
+ printf(" -t TRIGGERFILE trigger file to initiate failover (no default)\n");
+ printf(" -V, --version output version information, then exit\n");
+ printf(" -w MAXWAITTIME max seconds to wait for a file (0=no limit) (default=0)\n");
+ printf(" -?, --help show this help, then exit\n");
+ printf("\n"
+ "Main intended use as restore_command in postgresql.conf:\n"
+ " restore_command = 'pg_standby [OPTION]... ARCHIVELOCATION %%f %%p %%r'\n"
+ "e.g.\n"
+ " restore_command = 'pg_standby /mnt/server/archiverdir %%f %%p %%r'\n");
+ printf("\nReport bugs to <%s>.\n", PACKAGE_BUGREPORT);
+ printf("%s home page: <%s>\n", PACKAGE_NAME, PACKAGE_URL);
+}
+
+#ifndef WIN32
+static void
+sighandler(int sig)
+{
+ signaled = true;
+}
+
+/* We don't want SIGQUIT to core dump */
+static void
+sigquit_handler(int sig)
+{
+ pqsignal(SIGINT, SIG_DFL);
+ kill(getpid(), SIGINT);
+}
+#endif
+
+/*------------ MAIN ----------------------------------------*/
+int
+main(int argc, char **argv)
+{
+ int c;
+
+ progname = get_progname(argv[0]);
+
+ if (argc > 1)
+ {
+ if (strcmp(argv[1], "--help") == 0 || strcmp(argv[1], "-?") == 0)
+ {
+ usage();
+ exit(0);
+ }
+ if (strcmp(argv[1], "--version") == 0 || strcmp(argv[1], "-V") == 0)
+ {
+ puts("pg_standby (PostgreSQL) " PG_VERSION);
+ exit(0);
+ }
+ }
+
+#ifndef WIN32
+
+ /*
+ * You can send SIGUSR1 to trigger failover.
+ *
+ * Postmaster uses SIGQUIT to request immediate shutdown. The default
+ * action is to core dump, but we don't want that, so trap it and commit
+ * suicide without core dump.
+ *
+ * We used to use SIGINT and SIGQUIT to trigger failover, but that turned
+ * out to be a bad idea because postmaster uses SIGQUIT to request
+ * immediate shutdown. We still trap SIGINT, but that may change in a
+ * future release.
+ *
+ * There's no way to trigger failover via signal on Windows.
+ */
+ (void) pqsignal(SIGUSR1, sighandler);
+ (void) pqsignal(SIGINT, sighandler); /* deprecated, use SIGUSR1 */
+ (void) pqsignal(SIGQUIT, sigquit_handler);
+#endif
+
+ while ((c = getopt(argc, argv, "cdk:lr:s:t:w:")) != -1)
+ {
+ switch (c)
+ {
+ case 'c': /* Use copy */
+ restoreCommandType = RESTORE_COMMAND_COPY;
+ break;
+ case 'd': /* Debug mode */
+ debug = true;
+ break;
+ case 'k': /* keepfiles */
+ keepfiles = atoi(optarg);
+ if (keepfiles < 0)
+ {
+ fprintf(stderr, "%s: -k keepfiles must be >= 0\n", progname);
+ exit(2);
+ }
+ break;
+ case 'l': /* Use link */
+
+ /*
+ * Link feature disabled, possibly permanently. Linking causes
+ * a problem after recovery ends that is not currently
+ * resolved by PostgreSQL. 25 Jun 2009
+ */
+#ifdef NOT_USED
+ restoreCommandType = RESTORE_COMMAND_LINK;
+#endif
+ break;
+ case 'r': /* Retries */
+ maxretries = atoi(optarg);
+ if (maxretries < 0)
+ {
+ fprintf(stderr, "%s: -r maxretries must be >= 0\n", progname);
+ exit(2);
+ }
+ break;
+ case 's': /* Sleep time */
+ sleeptime = atoi(optarg);
+ if (sleeptime <= 0 || sleeptime > 60)
+ {
+ fprintf(stderr, "%s: -s sleeptime incorrectly set\n", progname);
+ exit(2);
+ }
+ break;
+ case 't': /* Trigger file */
+ triggerPath = pg_strdup(optarg);
+ break;
+ case 'w': /* Max wait time */
+ maxwaittime = atoi(optarg);
+ if (maxwaittime < 0)
+ {
+ fprintf(stderr, "%s: -w maxwaittime incorrectly set\n", progname);
+ exit(2);
+ }
+ break;
+ default:
+ fprintf(stderr, "Try \"%s --help\" for more information.\n", progname);
+ exit(2);
+ break;
+ }
+ }
+
+ /*
+ * Parameter checking - after checking to see if trigger file present
+ */
+ if (argc == 1)
+ {
+ fprintf(stderr, "%s: not enough command-line arguments\n", progname);
+ exit(2);
+ }
+
+ /*
+ * We will go to the archiveLocation to get nextWALFileName.
+ * nextWALFileName may not exist yet, which would not be an error, so we
+ * separate the archiveLocation and nextWALFileName so we can check
+ * separately whether archiveLocation exists, if not that is an error
+ */
+ if (optind < argc)
+ {
+ archiveLocation = argv[optind];
+ optind++;
+ }
+ else
+ {
+ fprintf(stderr, "%s: must specify archive location\n", progname);
+ fprintf(stderr, "Try \"%s --help\" for more information.\n", progname);
+ exit(2);
+ }
+
+ if (optind < argc)
+ {
+ nextWALFileName = argv[optind];
+ optind++;
+ }
+ else
+ {
+ fprintf(stderr, "%s: must specify WAL file name as second non-option argument (use \"%%f\")\n", progname);
+ fprintf(stderr, "Try \"%s --help\" for more information.\n", progname);
+ exit(2);
+ }
+
+ if (optind < argc)
+ {
+ xlogFilePath = argv[optind];
+ optind++;
+ }
+ else
+ {
+ fprintf(stderr, "%s: must specify xlog destination as third non-option argument (use \"%%p\")\n", progname);
+ fprintf(stderr, "Try \"%s --help\" for more information.\n", progname);
+ exit(2);
+ }
+
+ if (optind < argc)
+ {
+ restartWALFileName = argv[optind];
+ optind++;
+ }
+
+ CustomizableInitialize();
+
+ if (debug)
+ {
+ fprintf(stderr, "Trigger file: %s\n", triggerPath ? triggerPath : "<not set>");
+ fprintf(stderr, "Waiting for WAL file: %s\n", nextWALFileName);
+ fprintf(stderr, "WAL file path: %s\n", WALFilePath);
+ fprintf(stderr, "Restoring to: %s\n", xlogFilePath);
+ fprintf(stderr, "Sleep interval: %d second%s\n",
+ sleeptime, (sleeptime > 1 ? "s" : " "));
+ fprintf(stderr, "Max wait interval: %d %s\n",
+ maxwaittime, (maxwaittime > 0 ? "seconds" : "forever"));
+ fprintf(stderr, "Command for restore: %s\n", restoreCommand);
+ fflush(stderr);
+ }
+
+ /*
+ * Check for initial history file: always the first file to be requested
+ * It's OK if the file isn't there - all other files need to wait
+ */
+ if (IsTLHistoryFileName(nextWALFileName))
+ {
+ nextWALFileType = XLOG_HISTORY;
+ if (RestoreWALFileForRecovery())
+ exit(0);
+ else
+ {
+ if (debug)
+ {
+ fprintf(stderr, "history file not found\n");
+ fflush(stderr);
+ }
+ exit(1);
+ }
+ }
+
+ /*
+ * Main wait loop
+ */
+ for (;;)
+ {
+ /* Check for trigger file or signal first */
+ CheckForExternalTrigger();
+#ifndef WIN32
+ if (signaled)
+ {
+ Failover = FastFailover;
+ if (debug)
+ {
+ fprintf(stderr, "signaled to exit: fast failover\n");
+ fflush(stderr);
+ }
+ }
+#endif
+
+ /*
+ * Check for fast failover immediately, before checking if the
+ * requested WAL file is available
+ */
+ if (Failover == FastFailover)
+ exit(1);
+
+ if (CustomizableNextWALFileReady())
+ {
+ /*
+ * Once we have restored this file successfully we can remove some
+ * prior WAL files. If this restore fails we mustn't remove any
+ * file because some of them will be requested again immediately
+ * after the failed restore, or when we restart recovery.
+ */
+ if (RestoreWALFileForRecovery())
+ {
+ if (need_cleanup)
+ CustomizableCleanupPriorWALFiles();
+
+ exit(0);
+ }
+ else
+ {
+ /* Something went wrong in copying the file */
+ exit(1);
+ }
+ }
+
+ /* Check for smart failover if the next WAL file was not available */
+ if (Failover == SmartFailover)
+ exit(1);
+
+ if (sleeptime <= 60)
+ pg_usleep(sleeptime * 1000000L);
+
+ waittime += sleeptime;
+ if (waittime >= maxwaittime && maxwaittime > 0)
+ {
+ Failover = FastFailover;
+ if (debug)
+ {
+ fprintf(stderr, "Timed out after %d seconds: fast failover\n",
+ waittime);
+ fflush(stderr);
+ }
+ }
+ if (debug)
+ {
+ fprintf(stderr, "WAL file not present yet.");
+ if (triggerPath)
+ fprintf(stderr, " Checking for trigger file...");
+ fprintf(stderr, "\n");
+ fflush(stderr);
+ }
+ }
+}