/* * pg_archivecleanup.c * * To be used as archive_cleanup_command to clean an archive when using * standby mode. * * src/bin/pg_archivecleanup/pg_archivecleanup.c */ #include "postgres_fe.h" #include #include #include #include #include #include #include "access/xlog_internal.h" #include "common/logging.h" #include "getopt_long.h" static const char *progname; /* Options and defaults */ static bool dryrun = false; /* are we performing a dry-run operation? */ static bool cleanBackupHistory = false; /* remove files including backup * history files */ static char *additional_ext = NULL; /* Extension to remove from filenames */ static char *archiveLocation; /* where to find the archive? */ static char *restartWALFileName; /* the file from which we can restart * restore */ static char exclusiveCleanupFileName[MAXFNAMELEN]; /* the oldest file we want * to remain in archive */ /* ===================================================================== * * 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 archive cleanup program. * * You may wish to add code to check for tape libraries, etc.. */ static void Initialize(void) { /* * This code assumes that archiveLocation is a directory, so we use stat * to test if it's accessible. */ struct stat stat_buf; if (stat(archiveLocation, &stat_buf) != 0 || !S_ISDIR(stat_buf.st_mode)) { pg_log_error("archive location \"%s\" does not exist", archiveLocation); exit(2); } } static void TrimExtension(char *filename, char *extension) { int flen; int elen; if (extension == NULL) return; elen = strlen(extension); flen = strlen(filename); if (flen > elen && strcmp(filename + flen - elen, extension) == 0) filename[flen - elen] = '\0'; } static void CleanupPriorWALFiles(void) { int rc; DIR *xldir; struct dirent *xlde; char walfile[MAXPGPATH]; xldir = opendir(archiveLocation); if (xldir == NULL) pg_fatal("could not open archive location \"%s\": %m", archiveLocation); while (errno = 0, (xlde = readdir(xldir)) != NULL) { char WALFilePath[MAXPGPATH * 2]; /* the file path including * archive */ /* * Truncation is essentially harmless, because we skip files whose * format is different from WAL files and backup history files. (In * principle, one could use a 1000-character additional_ext and get * trouble.) */ strlcpy(walfile, xlde->d_name, MAXPGPATH); TrimExtension(walfile, additional_ext); /* * Ignore anything does that not look like a WAL segment, a .partial * WAL segment or a backup history file (if requested). */ if (!IsXLogFileName(walfile) && !IsPartialXLogFileName(walfile) && !(cleanBackupHistory && IsBackupHistoryFileName(walfile))) continue; /* * 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 (strcmp(walfile + 8, exclusiveCleanupFileName + 8) >= 0) continue; /* * Use the original file name again now, including any extension that * might have been chopped off before testing the sequence. */ snprintf(WALFilePath, sizeof(WALFilePath), "%s/%s", archiveLocation, xlde->d_name); if (dryrun) { /* * Prints the name of the file to be removed and skips the actual * removal. The regular printout is so that the user can pipe the * output into some other program. */ printf("%s\n", WALFilePath); pg_log_debug("file \"%s\" would be removed", WALFilePath); continue; } pg_log_debug("removing file \"%s\"", WALFilePath); rc = unlink(WALFilePath); if (rc != 0) pg_fatal("could not remove file \"%s\": %m", WALFilePath); } if (errno) pg_fatal("could not read archive location \"%s\": %m", archiveLocation); if (closedir(xldir)) pg_fatal("could not close archive location \"%s\": %m", archiveLocation); } /* * SetWALFileNameForCleanup() * * Set the earliest WAL filename that we want to keep on the archive * and decide whether we need cleanup */ static void SetWALFileNameForCleanup(void) { bool fnameOK = false; TrimExtension(restartWALFileName, additional_ext); /* * If restartWALFileName is a WAL file name then just use it directly. If * restartWALFileName is a .partial or .backup filename, make sure we use * the prefix of the filename, otherwise we will remove wrong files since * 000000010000000000000010.partial and * 000000010000000000000010.00000020.backup are after * 000000010000000000000010. */ if (IsXLogFileName(restartWALFileName)) { strcpy(exclusiveCleanupFileName, restartWALFileName); fnameOK = true; } else if (IsPartialXLogFileName(restartWALFileName)) { int args; uint32 tli = 1, log = 0, seg = 0; args = sscanf(restartWALFileName, "%08X%08X%08X.partial", &tli, &log, &seg); if (args == 3) { fnameOK = true; /* * Use just the prefix of the filename, ignore everything after * first period */ XLogFileNameById(exclusiveCleanupFileName, tli, log, seg); } } else if (IsBackupHistoryFileName(restartWALFileName)) { int args; uint32 tli = 1, log = 0, seg = 0, offset = 0; args = sscanf(restartWALFileName, "%08X%08X%08X.%08X.backup", &tli, &log, &seg, &offset); if (args == 4) { fnameOK = true; /* * Use just the prefix of the filename, ignore everything after * first period */ XLogFileNameById(exclusiveCleanupFileName, tli, log, seg); } } if (!fnameOK) { pg_log_error("invalid file name argument"); pg_log_error_hint("Try \"%s --help\" for more information.", progname); exit(2); } } /* ===================================================================== * End of Customizable section * ===================================================================== */ static void usage(void) { printf(_("%s removes older WAL files from PostgreSQL archives.\n\n"), progname); printf(_("Usage:\n")); printf(_(" %s [OPTION]... ARCHIVELOCATION OLDESTKEPTWALFILE\n"), progname); printf(_("\nOptions:\n")); printf(_(" -b, --clean-backup-history clean up files including backup history files\n")); printf(_(" -d, --debug generate debug output (verbose mode)\n")); printf(_(" -n, --dry-run dry run, show the names of the files that would be\n" " removed\n")); printf(_(" -V, --version output version information, then exit\n")); printf(_(" -x, --strip-extension=EXT strip this extension before identifying files for\n" " clean up\n")); printf(_(" -?, --help show this help, then exit\n")); printf(_("\n" "For use as \"archive_cleanup_command\" in postgresql.conf:\n" " archive_cleanup_command = 'pg_archivecleanup [OPTION]... ARCHIVELOCATION %%r'\n" "e.g.\n" " archive_cleanup_command = 'pg_archivecleanup /mnt/server/archiverdir %%r'\n")); printf(_("\n" "Or for use as a standalone archive cleaner:\n" "e.g.\n" " pg_archivecleanup /mnt/server/archiverdir 000000010000000000000010.00000020.backup\n")); printf(_("\nReport bugs to <%s>.\n"), PACKAGE_BUGREPORT); printf(_("%s home page: <%s>\n"), PACKAGE_NAME, PACKAGE_URL); } /*------------ MAIN ----------------------------------------*/ int main(int argc, char **argv) { static struct option long_options[] = { {"clean-backup-history", no_argument, NULL, 'b'}, {"debug", no_argument, NULL, 'd'}, {"dry-run", no_argument, NULL, 'n'}, {"strip-extension", required_argument, NULL, 'x'}, {NULL, 0, NULL, 0} }; int c; pg_logging_init(argv[0]); set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("pg_archivecleanup")); 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_archivecleanup (PostgreSQL) " PG_VERSION); exit(0); } } while ((c = getopt_long(argc, argv, "bdnx:", long_options, NULL)) != -1) { switch (c) { case 'b': /* Remove backup history files as well */ cleanBackupHistory = true; break; case 'd': /* Debug mode */ pg_logging_increase_verbosity(); break; case 'n': /* Dry-Run mode */ dryrun = true; break; case 'x': additional_ext = pg_strdup(optarg); /* Extension to remove * from xlogfile names */ break; default: /* getopt already emitted a complaint */ pg_log_error_hint("Try \"%s --help\" for more information.", progname); exit(2); } } /* * We will go to the archiveLocation to check restartWALFileName. * restartWALFileName may not exist anymore, which would not be an error, * so we separate the archiveLocation and restartWALFileName so we can * check separately whether archiveLocation exists, if not that is an * error */ if (optind < argc) { archiveLocation = argv[optind]; optind++; } else { pg_log_error("must specify archive location"); pg_log_error_hint("Try \"%s --help\" for more information.", progname); exit(2); } if (optind < argc) { restartWALFileName = argv[optind]; optind++; } else { pg_log_error("must specify oldest kept WAL file"); pg_log_error_hint("Try \"%s --help\" for more information.", progname); exit(2); } if (optind < argc) { pg_log_error("too many command-line arguments"); pg_log_error_hint("Try \"%s --help\" for more information.", progname); exit(2); } /* * Check archive exists and other initialization if required. */ Initialize(); /* * Check filename is a valid name, then process to find cut-off */ SetWALFileNameForCleanup(); pg_log_debug("keeping WAL file \"%s/%s\" and later", archiveLocation, exclusiveCleanupFileName); /* * Remove WAL files older than cut-off */ CleanupPriorWALFiles(); exit(0); }