db/pg_probackup
db/pg_probackup
1
0
Fork 0
mirror of https://github.com/postgrespro/pg_probackup.git synced 2025-02-03 14:01:57 +02:00
Code Issues Releases Activity

Strip off archive backup mode

Browse Source 
This mode is not actually necessary if we consider that the core of
pg_rman is the obtention of differential and full backups, the server
being afterwards in charge to recover necessary WAL segments from the
archive.

Regression tests and documentation are updated in accordance to the
changes.
This commit is contained in:
Michael Paquier 2014-01-24 22:36:31 +09:00
parent 5988e6bd10
commit 820485d225
21 changed files with 71 additions and 812 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

383
backup.c
View File

@ -35,24 +35,16 @@ static parray *cleanup_list;
* Backup routines * Backup routines
*/ */
static void backup_cleanup(bool fatal, void *userdata); static void backup_cleanup(bool fatal, void *userdata);
static void delete_old_files(const char *root,
parray *files, int keep_files,
int keep_days, bool is_arclog);
static void backup_files(const char *from_root, const char *to_root, static void backup_files(const char *from_root, const char *to_root,
parray *files, parray *prev_files, const XLogRecPtr *lsn, bool compress, const char *prefix); parray *files, parray *prev_files, const XLogRecPtr *lsn, bool compress, const char *prefix);
static parray *do_backup_database(parray *backup_list, pgBackupOption bkupopt); static parray *do_backup_database(parray *backup_list, pgBackupOption bkupopt);
static parray *do_backup_arclog(parray *backup_list);
static void confirm_block_size(const char *name, int blcksz); static void confirm_block_size(const char *name, int blcksz);
static void pg_start_backup(const char *label, bool smooth, pgBackup *backup); static void pg_start_backup(const char *label, bool smooth, pgBackup *backup);
static void pg_stop_backup(pgBackup *backup); static void pg_stop_backup(pgBackup *backup);
static void pg_switch_xlog(pgBackup *backup);
static bool pg_is_standby(void); static bool pg_is_standby(void);
static void get_lsn(PGresult *res, XLogRecPtr *lsn); static void get_lsn(PGresult *res, XLogRecPtr *lsn);
static void get_xid(PGresult *res, uint32 *xid); static void get_xid(PGresult *res, uint32 *xid);
static void delete_arclog_link(void);
static void delete_online_wal_backup(void);
static bool dirExists(const char *path); static bool dirExists(const char *path);
static void add_files(parray *files, const char *root, bool add_root, bool is_pgdata); static void add_files(parray *files, const char *root, bool add_root, bool is_pgdata);
@ -84,10 +76,6 @@ do_backup_database(parray *backup_list, pgBackupOption bkupopt)
/* repack the options */ /* repack the options */
bool smooth_checkpoint = bkupopt.smooth_checkpoint; bool smooth_checkpoint = bkupopt.smooth_checkpoint;
/* Leave in case of archive mode */
if (current.backup_mode == BACKUP_MODE_ARCHIVE)
return NULL;
/* Block backup operations on a standby */ /* Block backup operations on a standby */
if (pg_is_standby()) if (pg_is_standby())
elog(ERROR_SYSTEM, _("Backup cannot run on a standby.")); elog(ERROR_SYSTEM, _("Backup cannot run on a standby."));
@ -411,16 +399,12 @@ do_backup_database(parray *backup_list, pgBackupOption bkupopt)
current.data_bytes += file->read_size; current.data_bytes += file->read_size;
else if (current.backup_mode == BACKUP_MODE_FULL) else if (current.backup_mode == BACKUP_MODE_FULL)
current.data_bytes += file->size; current.data_bytes += file->size;
/* Count total amount of data for backup */
if (file->write_size != BYTES_INVALID)
current.backup_bytes += file->write_size;
} }
if (verbose) if (verbose)
{ {
printf(_("database backup completed(written: " INT64_FORMAT " Backup: " INT64_FORMAT ")\n"), printf(_("database backup completed(Backup: " INT64_FORMAT ")\n"),
current.data_bytes, current.backup_bytes); current.data_bytes);
printf(_("========================================\n")); printf(_("========================================\n"));
} }
@ -428,155 +412,14 @@ do_backup_database(parray *backup_list, pgBackupOption bkupopt)
} }
/*
* Backup archived WAL incrementally.
*/
static parray *
do_backup_arclog(parray *backup_list)
{
int i;
parray *files;
parray *prev_files = NULL; /* file list of previous database backup */
char path[MAXPGPATH];
char timeline_dir[MAXPGPATH];
char prev_file_txt[MAXPGPATH];
pgBackup *prev_backup;
int64 arclog_write_bytes = 0;
char last_wal[MAXFNAMELEN];
Assert(current.backup_mode == BACKUP_MODE_ARCHIVE ||
current.backup_mode == BACKUP_MODE_INCREMENTAL ||
current.backup_mode == BACKUP_MODE_FULL);
/* Block backup operations on a standby */
if (pg_is_standby())
elog(ERROR_SYSTEM, _("Backup cannot run on a standby."));
if (verbose)
{
printf(_("========================================\n"));
printf(_("archived WAL backup start\n"));
}
/* initialize size summary */
current.arclog_bytes = 0;
/*
* Switch xlog if database is not backed up, current timeline of
* server is obtained here.
*/
if ((uint32) current.stop_lsn == 0)
pg_switch_xlog(&current);
/*
* Check if there is a full backup present on current timeline.
* For an incremental or full backup, we are sure that there is one
* so this error can be bypassed safely.
*/
if (current.backup_mode == BACKUP_MODE_ARCHIVE &&
catalog_get_last_data_backup(backup_list, current.tli) == NULL)
elog(ERROR_SYSTEM, _("No valid full or incremental backup detected "
"on current timeline "));
/*
* To take incremental backup, the file list of the last completed
* database backup is needed.
*/
prev_backup = catalog_get_last_arclog_backup(backup_list, current.tli);
if (verbose && prev_backup == NULL)
printf(_("no previous full backup, performing a full backup instead\n"));
if (prev_backup)
{
pgBackupGetPath(prev_backup, prev_file_txt, lengthof(prev_file_txt),
ARCLOG_FILE_LIST);
prev_files = dir_read_file_list(arclog_path, prev_file_txt);
}
/* list files with the logical path. omit ARCLOG_PATH */
files = parray_new();
dir_list_file(files, arclog_path, NULL, true, false);
/* remove WALs archived after pg_stop_backup()/pg_switch_xlog() */
xlog_fname(last_wal, current.tli, current.stop_lsn);
for (i = 0; i < parray_num(files); i++)
{
pgFile *file = (pgFile *) parray_get(files, i);
char *fname;
if ((fname = last_dir_separator(file->path)))
fname++;
else
fname = file->path;
/* to backup backup history files, compare tli/lsn portion only */
if (strncmp(fname, last_wal, 24) > 0)
{
parray_remove(files, i);
i--;
}
}
pgBackupGetPath(&current, path, lengthof(path), ARCLOG_DIR);
backup_files(arclog_path, path, files, prev_files, NULL,
current.compress_data, NULL);
/* Create file list */
create_file_list(files, arclog_path, ARCLOG_FILE_LIST, NULL, false);
/* Print summary of size of backup files */
for (i = 0; i < parray_num(files); i++)
{
pgFile *file = (pgFile *) parray_get(files, i);
if (!S_ISREG(file->mode))
continue;
current.arclog_bytes += file->read_size;
if (file->write_size != BYTES_INVALID)
{
current.backup_bytes += file->write_size;
arclog_write_bytes += file->write_size;
}
}
/*
* Backup timeline history files to special directory.
* We do this after create file list, because copy_file() update
* pgFile->write_size to actual size.
*/
join_path_components(timeline_dir, backup_path, TIMELINE_HISTORY_DIR);
for (i = 0; i < parray_num(files); i++)
{
pgFile *file = (pgFile *) parray_get(files, i);
if (!S_ISREG(file->mode))
continue;
if (strstr(file->path, ".history") ==
file->path + strlen(file->path) - strlen(".history"))
{
elog(LOG, _("(timeline history) %s"), file->path);
copy_file(arclog_path, timeline_dir, file, NO_COMPRESSION);
}
}
if (verbose)
{
printf(_("archived WAL backup completed(read: " INT64_FORMAT " write: " INT64_FORMAT ")\n"),
current.arclog_bytes, arclog_write_bytes);
printf(_("========================================\n"));
}
return files;
}
int int
do_backup(pgBackupOption bkupopt) do_backup(pgBackupOption bkupopt)
{ {
parray *backup_list; parray *backup_list;
parray *files_database; parray *files_database;
parray *files_arclog;
int ret; int ret;
/* repack the necesary options */ /* repack the necessary options */
int keep_arclog_files = bkupopt.keep_arclog_files;
int keep_arclog_days = bkupopt.keep_arclog_days;
int keep_data_generations = bkupopt.keep_data_generations; int keep_data_generations = bkupopt.keep_data_generations;
int keep_data_days = bkupopt.keep_data_days; int keep_data_days = bkupopt.keep_data_days;
@ -590,12 +433,6 @@ do_backup(pgBackupOption bkupopt)
elog(ERROR_ARGS, _("Required parameter not specified: BACKUP_MODE " elog(ERROR_ARGS, _("Required parameter not specified: BACKUP_MODE "
"(-b, --backup-mode)")); "(-b, --backup-mode)"));
/* ARCLOG_PATH is required for all the modes */
if (arclog_path == NULL)
elog(ERROR_ARGS,
_("Required parameter not specified: ARCLOG_PATH "
"(-A, --arclog-path)"));
#ifndef HAVE_LIBZ #ifndef HAVE_LIBZ
if (current.compress_data) if (current.compress_data)
{ {
@ -637,8 +474,6 @@ do_backup(pgBackupOption bkupopt)
current.start_time = time(NULL); current.start_time = time(NULL);
current.end_time = (time_t) 0; current.end_time = (time_t) 0;
current.data_bytes = BYTES_INVALID; current.data_bytes = BYTES_INVALID;
current.arclog_bytes = BYTES_INVALID;
current.backup_bytes = 0;
current.block_size = BLCKSZ; current.block_size = BLCKSZ;
current.wal_block_size = XLOG_BLCKSZ; current.wal_block_size = XLOG_BLCKSZ;
current.recovery_xid = 0; current.recovery_xid = 0;
@ -664,9 +499,6 @@ do_backup(pgBackupOption bkupopt)
/* backup data */ /* backup data */
files_database = do_backup_database(backup_list, bkupopt); files_database = do_backup_database(backup_list, bkupopt);
/* backup archived WAL */
files_arclog = do_backup_arclog(backup_list);
pgut_atexit_pop(backup_cleanup, NULL); pgut_atexit_pop(backup_cleanup, NULL);
/* update backup status to DONE */ /* update backup status to DONE */
@ -680,28 +512,20 @@ do_backup(pgBackupOption bkupopt)
{ {
int64 total_read = 0; int64 total_read = 0;
/* WAL archives */
total_read += current.arclog_bytes;
/* Database data */ /* Database data */
if (current.backup_mode == BACKUP_MODE_FULL || if (current.backup_mode == BACKUP_MODE_FULL ||
current.backup_mode == BACKUP_MODE_INCREMENTAL) current.backup_mode == BACKUP_MODE_INCREMENTAL)
total_read += current.arclog_bytes; total_read += current.data_bytes;
if (total_read == 0) if (total_read == 0)
printf(_("nothing to backup\n")); printf(_("nothing to backup\n"));
else else
printf(_("all backup completed(read: " INT64_FORMAT " write: " printf(_("all backup completed(read: " INT64_FORMAT " write: "
INT64_FORMAT ")\n"), INT64_FORMAT ")\n"),
total_read, current.backup_bytes); total_read, current.data_bytes);
printf(_("========================================\n")); printf(_("========================================\n"));
} }
/*
* Delete old files (archived WAL) after update of status.
*/
delete_old_files(arclog_path, files_arclog, keep_arclog_files,
keep_arclog_days, true);
/* Delete old backup files after all backup operation. */ /* Delete old backup files after all backup operation. */
pgBackupDelete(keep_data_generations, keep_data_days); pgBackupDelete(keep_data_generations, keep_data_days);
@ -710,21 +534,6 @@ do_backup(pgBackupOption bkupopt)
if (files_database) if (files_database)
parray_walk(files_database, pgFileFree); parray_walk(files_database, pgFileFree);
parray_free(files_database); parray_free(files_database);
if (files_arclog)
parray_walk(files_arclog, pgFileFree);
parray_free(files_arclog);
/*
* If this backup is full backup, delete backup of online WAL.
* Note that sereverlog files which were backed up during first restoration
* don't be delete.
* Also delete symbolic link in the archive directory.
*/
if (current.backup_mode == BACKUP_MODE_FULL)
{
delete_online_wal_backup();
delete_arclog_link();
}
/* release catalog lock */ /* release catalog lock */
catalog_unlock(); catalog_unlock();
@ -885,15 +694,6 @@ pg_stop_backup(pgBackup *backup)
"SELECT * FROM pg_stop_backup()"); "SELECT * FROM pg_stop_backup()");
} }
/*
* Force switch to a new transaction log file
*/
static void
pg_switch_xlog(pgBackup *backup)
{
wait_for_archive(backup,
"SELECT * FROM pg_switch_xlog()");
}
/* /*
* Check if node is a standby by looking at the presence of * Check if node is a standby by looking at the presence of
@ -1202,179 +1002,6 @@ backup_files(const char *from_root,
} }
} }
/*
* Delete files modified before than KEEP_xxx_DAYS or more than KEEP_xxx_FILES
* of newer files exist.
*/
static void
delete_old_files(const char *root,
parray *files,
int keep_files,
int keep_days,
bool is_arclog)
{
int i;
int j;
int file_num = 0;
time_t days_threshold = current.start_time - (keep_days * 60 * 60 * 24);
if (verbose)
{
char files_str[100];
char days_str[100];
if (keep_files == KEEP_INFINITE)
strncpy(files_str, "INFINITE", lengthof(files_str));
else
snprintf(files_str, lengthof(files_str), "%d", keep_files);
if (keep_days == KEEP_INFINITE)
strncpy(days_str, "INFINITE", lengthof(days_str));
else
snprintf(days_str, lengthof(days_str), "%d", keep_days);
printf(_("delete old files from \"%s\" (files=%s, days=%s)\n"),
root, files_str, days_str);
}
/* Leave if both settings are set to infinite, there is nothing to do */
if (keep_files == KEEP_INFINITE && keep_days == KEEP_INFINITE)
{
elog(LOG, "%s() infinite", __FUNCTION__);
return;
}
parray_qsort(files, pgFileCompareMtime);
for (i = parray_num(files) - 1; i >= 0; i--)
{
pgFile *file = (pgFile *) parray_get(files, i);
elog(LOG, "%s() %s", __FUNCTION__, file->path);
/* Delete completed WALs only. */
if (is_arclog && !xlog_is_complete_wal(file))
{
elog(LOG, "%s() not complete WAL", __FUNCTION__);
continue;
}
file_num++;
/*
* If the mtime of the file is older than the threshold and there are
* enough number of files newer than the files, delete the file.
*/
if (file->mtime >= days_threshold &&
keep_days != KEEP_INFINITE)
{
elog(LOG, "%s() %lu is not older than %lu", __FUNCTION__,
file->mtime, days_threshold);
continue;
}
else if (file_num <= keep_files &&
keep_files != KEEP_INFINITE)
{
elog(LOG, "%s() newer files are only %d", __FUNCTION__, file_num);
continue;
}
/* Now we found a file should be deleted. */
if (verbose)
printf(_("delete \"%s\"\n"), file->path + strlen(root) + 1);
/* delete corresponding backup history file if exists */
file = (pgFile *) parray_remove(files, i);
for (j = parray_num(files) - 1; j >= 0; j--)
{
pgFile *file2 = (pgFile *)parray_get(files, j);
if (strstr(file2->path, file->path) == file2->path)
{
file2 = (pgFile *)parray_remove(files, j);
if (verbose)
printf(_("delete \"%s\"\n"),
file2->path + strlen(root) + 1);
if (!check)
pgFileDelete(file2);
pgFileFree(file2);
}
}
if (!check)
pgFileDelete(file);
pgFileFree(file);
}
}
static void
delete_online_wal_backup(void)
{
int i;
parray *files = parray_new();
char work_path[MAXPGPATH];
if (verbose)
{
printf(_("========================================\n"));
printf(_("delete online WAL backup\n"));
}
snprintf(work_path, lengthof(work_path), "%s/%s/%s", backup_path,
RESTORE_WORK_DIR, PG_XLOG_DIR);
/* don't delete root dir */
dir_list_file(files, work_path, NULL, true, false);
if (parray_num(files) == 0)
{
parray_free(files);
return;
}
parray_qsort(files, pgFileComparePathDesc); /* delete from leaf */
for (i = 0; i < parray_num(files); i++)
{
pgFile *file = (pgFile *) parray_get(files, i);
if (verbose)
printf(_("delete \"%s\"\n"), file->path);
if (!check)
pgFileDelete(file);
}
parray_walk(files, pgFileFree);
parray_free(files);
}
/*
* Remove symbolic links point archived WAL in backup catalog.
*/
static void
delete_arclog_link(void)
{
int i;
parray *files = parray_new();
if (verbose)
{
printf(_("========================================\n"));
printf(_("delete symbolic link in archive directory\n"));
}
dir_list_file(files, arclog_path, NULL, false, false);
for (i = 0; i < parray_num(files); i++)
{
pgFile *file = (pgFile *) parray_get(files, i);
if (!S_ISLNK(file->mode))
continue;
if (verbose)
printf(_("delete \"%s\"\n"), file->path);
if (!check && remove(file->path) == -1)
elog(ERROR_SYSTEM, _("can't remove link \"%s\": %s"), file->path,
strerror(errno));
}
parray_walk(files, pgFileFree);
parray_free(files);
}
/* /*
* Append files to the backup list array. * Append files to the backup list array.

43
catalog.c
View File

@ -268,37 +268,13 @@ catalog_get_last_data_backup(parray *backup_list, TimeLineID tli)
return NULL; return NULL;
} }
/*
* Find the last completed archived WAL backup from the backup list
* on current timeline.
*/
pgBackup *
catalog_get_last_arclog_backup(parray *backup_list, TimeLineID tli)
{
int i;
pgBackup *backup = NULL;
/* backup_list is sorted in order of descending ID */
for (i = 0; i < parray_num(backup_list); i++)
{
backup = (pgBackup *) parray_get(backup_list, i);
/* we need completed archived WAL backup */
if (backup->status == BACKUP_STATUS_OK &&
backup->tli == tli)
return backup;
}
return NULL;
}
/* create backup directory in $BACKUP_PATH */ /* create backup directory in $BACKUP_PATH */
int int
pgBackupCreateDir(pgBackup *backup) pgBackupCreateDir(pgBackup *backup)
{ {
int i; int i;
char path[MAXPGPATH]; char path[MAXPGPATH];
char *subdirs[] = { DATABASE_DIR, ARCLOG_DIR, NULL }; char *subdirs[] = { DATABASE_DIR, NULL };
pgBackupGetPath(backup, path, lengthof(path), NULL); pgBackupGetPath(backup, path, lengthof(path), NULL);
dir_create_dir(path, DIR_PERMISSION); dir_create_dir(path, DIR_PERMISSION);
@ -319,7 +295,7 @@ pgBackupCreateDir(pgBackup *backup)
void void
pgBackupWriteConfigSection(FILE *out, pgBackup *backup) pgBackupWriteConfigSection(FILE *out, pgBackup *backup)
{ {
static const char *modes[] = { "", "ARCHIVE", "INCREMENTAL", "FULL"}; static const char *modes[] = { "", "INCREMENTAL", "FULL"};
fprintf(out, "# configuration\n"); fprintf(out, "# configuration\n");
@ -361,13 +337,6 @@ pgBackupWriteResultSection(FILE *out, pgBackup *backup)
if (backup->data_bytes != BYTES_INVALID) if (backup->data_bytes != BYTES_INVALID)
fprintf(out, "DATA_BYTES=" INT64_FORMAT "\n", fprintf(out, "DATA_BYTES=" INT64_FORMAT "\n",
backup->data_bytes); backup->data_bytes);
if (backup->arclog_bytes != BYTES_INVALID)
fprintf(out, "ARCLOG_BYTES=" INT64_FORMAT "\n",
backup->arclog_bytes);
if (backup->backup_bytes != BYTES_INVALID)
fprintf(out, "BACKUP_BYTES=" INT64_FORMAT "\n",
backup->backup_bytes);
fprintf(out, "BLOCK_SIZE=%u\n", backup->block_size); fprintf(out, "BLOCK_SIZE=%u\n", backup->block_size);
fprintf(out, "XLOG_BLOCK_SIZE=%u\n", backup->wal_block_size); fprintf(out, "XLOG_BLOCK_SIZE=%u\n", backup->wal_block_size);
@ -423,8 +392,6 @@ catalog_read_ini(const char *path)
{ 'u', 0, "recovery-xid" , NULL, SOURCE_ENV }, { 'u', 0, "recovery-xid" , NULL, SOURCE_ENV },
{ 't', 0, "recovery-time" , NULL, SOURCE_ENV }, { 't', 0, "recovery-time" , NULL, SOURCE_ENV },
{ 'I', 0, "data-bytes" , NULL, SOURCE_ENV }, { 'I', 0, "data-bytes" , NULL, SOURCE_ENV },
{ 'I', 0, "arclog-bytes" , NULL, SOURCE_ENV },
{ 'I', 0, "backup-bytes" , NULL, SOURCE_ENV },
{ 'u', 0, "block-size" , NULL, SOURCE_ENV }, { 'u', 0, "block-size" , NULL, SOURCE_ENV },
{ 'u', 0, "xlog-block-size" , NULL, SOURCE_ENV }, { 'u', 0, "xlog-block-size" , NULL, SOURCE_ENV },
{ 's', 0, "status" , NULL, SOURCE_ENV }, { 's', 0, "status" , NULL, SOURCE_ENV },
@ -449,8 +416,6 @@ catalog_read_ini(const char *path)
options[i++].var = &backup->recovery_xid; options[i++].var = &backup->recovery_xid;
options[i++].var = &backup->recovery_time; options[i++].var = &backup->recovery_time;
options[i++].var = &backup->data_bytes; options[i++].var = &backup->data_bytes;
options[i++].var = &backup->arclog_bytes;
options[i++].var = &backup->backup_bytes;
options[i++].var = &backup->block_size; options[i++].var = &backup->block_size;
options[i++].var = &backup->wal_block_size; options[i++].var = &backup->wal_block_size;
options[i++].var = &status; options[i++].var = &status;
@ -527,8 +492,6 @@ parse_backup_mode(const char *value)
return BACKUP_MODE_FULL; return BACKUP_MODE_FULL;
else if (len > 0 && pg_strncasecmp("incremental", v, len) == 0) else if (len > 0 && pg_strncasecmp("incremental", v, len) == 0)
return BACKUP_MODE_INCREMENTAL; return BACKUP_MODE_INCREMENTAL;
else if (len > 0 && pg_strncasecmp("archive", v, len) == 0)
return BACKUP_MODE_ARCHIVE;
/* Backup mode is invalid, so leave with an error */ /* Backup mode is invalid, so leave with an error */
elog(ERROR_ARGS, _("invalid backup-mode \"%s\""), value); elog(ERROR_ARGS, _("invalid backup-mode \"%s\""), value);
@ -597,6 +560,4 @@ catalog_init_config(pgBackup *backup)
backup->recovery_xid = 0; backup->recovery_xid = 0;
backup->recovery_time = (time_t) 0; backup->recovery_time = (time_t) 0;
backup->data_bytes = BYTES_INVALID; backup->data_bytes = BYTES_INVALID;
backup->arclog_bytes = BYTES_INVALID;
backup->backup_bytes = BYTES_INVALID;
} }

2
data/sample_backup/20090531/170553/backup.ini
View File

@ -8,8 +8,6 @@ STOP_LSN=0/0b4c8020
START_TIME='2009-05-31 17:05:53' START_TIME='2009-05-31 17:05:53'
END_TIME='2009-05-31 17:09:13' END_TIME='2009-05-31 17:09:13'
DATA_BYTES=1242102558 DATA_BYTES=1242102558
ARCLOG_BYTES=9223372036854775807
BACKUP_BYTES=242102558
BLOCK_SIZE=8192 BLOCK_SIZE=8192
XLOG_BLOCK_SIZE=8192 XLOG_BLOCK_SIZE=8192
STATUS=DONE STATUS=DONE

2
data/sample_backup/20090601/170553/backup.ini
View File

@ -8,8 +8,6 @@ STOP_LSN=0/0b4c8020
START_TIME='2009-06-01 17:05:53' START_TIME='2009-06-01 17:05:53'
END_TIME='2009-06-01 17:09:13' END_TIME='2009-06-01 17:09:13'
DATA_BYTES=9223372036854775807 DATA_BYTES=9223372036854775807
ARCLOG_BYTES=16777216
BACKUP_BYTES=162372983
BLOCK_SIZE=8192 BLOCK_SIZE=8192
XLOG_BLOCK_SIZE=8192 XLOG_BLOCK_SIZE=8192
STATUS=DONE STATUS=DONE

4
data/sample_backup/20090602/170553/backup.ini
View File

@ -1,5 +1,5 @@
# configuration # configuration
BACKUP_MODE=ARCHIVE BACKUP_MODE=FULL
COMPRESS_DATA=NO COMPRESS_DATA=NO
# result # result
TIMELINEID=1 TIMELINEID=1
@ -8,8 +8,6 @@ STOP_LSN=0/0b4c8020
START_TIME='2009-06-02 17:05:03' START_TIME='2009-06-02 17:05:03'
END_TIME='2009-06-02 17:05:03' END_TIME='2009-06-02 17:05:03'
DATA_BYTES=-1 DATA_BYTES=-1
ARCLOG_BYTES=-1
BACKUP_BYTES=162372983
BLOCK_SIZE=8192 BLOCK_SIZE=8192
XLOG_BLOCK_SIZE=8192 XLOG_BLOCK_SIZE=8192
STATUS=DELETED STATUS=DELETED

2
data/sample_backup/20090603/170553/backup.ini
View File

@ -8,8 +8,6 @@ STOP_LSN=0/0b4c8020
START_TIME='2009-06-03 17:05:53' START_TIME='2009-06-03 17:05:53'
END_TIME='2009-06-03 17:05:53' END_TIME='2009-06-03 17:05:53'
DATA_BYTES=-1 DATA_BYTES=-1
ARCLOG_BYTES=-1
BACKUP_BYTES=-1
BLOCK_SIZE=8192 BLOCK_SIZE=8192
XLOG_BLOCK_SIZE=8192 XLOG_BLOCK_SIZE=8192
STATUS=RUNNING STATUS=RUNNING

2
delete.c
View File

@ -197,8 +197,6 @@ pgBackupDeleteFiles(pgBackup *backup)
files = parray_new(); files = parray_new();
pgBackupGetPath(backup, path, lengthof(path), DATABASE_DIR); pgBackupGetPath(backup, path, lengthof(path), DATABASE_DIR);
dir_list_file(files, path, NULL, true, true); dir_list_file(files, path, NULL, true, true);
pgBackupGetPath(backup, path, lengthof(path), ARCLOG_DIR);
dir_list_file(files, path, NULL, true, true);
/* delete leaf node first */ /* delete leaf node first */
parray_qsort(files, pgFileComparePathDesc); parray_qsort(files, pgFileComparePathDesc);

33
doc/pg_rman.txt
View File

@ -21,8 +21,6 @@ files.
== DESCRIPTION == == DESCRIPTION ==
pg_rman is a utility program to backup and restore PostgreSQL database. pg_rman is a utility program to backup and restore PostgreSQL database.
It takes a physical online backup of whole database cluster and archive
WALs.
It proposes the following features: It proposes the following features:
@ -30,7 +28,7 @@ It proposes the following features:
command command
- Recovery from backup with just one command, with customized targets - Recovery from backup with just one command, with customized targets
to facilitate the use of PITR. to facilitate the use of PITR.
- Support for full, incremental and archive backup - Support for full and incremental
- Compression of backup files - Compression of backup files
- Management of backups with integrated catalog - Management of backups with integrated catalog
@ -76,7 +74,6 @@ Backup target can be one of the following types:
- Full backup, backup a whole database cluster. - Full backup, backup a whole database cluster.
- Incremental backup, backup only files or pages modified after the last - Incremental backup, backup only files or pages modified after the last
verified backup. verified backup.
- Archive WAL backup, Backup only archive WAL files.
It is recommended to verify backup files as soon as possible after backup. It is recommended to verify backup files as soon as possible after backup.
Unverified backup cannot be used in restore and in incremental backup. Unverified backup cannot be used in restore and in incremental backup.
@ -143,12 +140,11 @@ Here are some commands to restore from a backup:
The fields are: The fields are:
* Start: start time of backup * Start: start time of backup
* Mode: Mode of backup: FULL (full), INCR (incremental) or ARCH (archive) * Mode: Mode of backup: FULL (full) or INCR (incremental)
* Current TLI: current timeline of backup * Current TLI: current timeline of backup
* Parent TLI: parent timeline of backup * Parent TLI: parent timeline of backup
* Time: total time necessary to take this backup * Time: total time necessary to take this backup
* Data: size of data files * Data: size of data files
* WAL: size of read WAL archive files
* Log: size of read server log files * Log: size of read server log files
* Backup: size of backup (= written size) * Backup: size of backup (= written size)
* Status: status of backup. Possible values are: * Status: status of backup. Possible values are:
@ -175,8 +171,6 @@ When a date is specified, more details about a backup is retrieved:
RECOVERY_XID=1759 RECOVERY_XID=1759
RECOVERY_TIME='2011-11-27 19:15:53' RECOVERY_TIME='2011-11-27 19:15:53'
DATA_BYTES=25420184 DATA_BYTES=25420184
ARCLOG_BYTES=32218912
BACKUP_BYTES=242919520
BLOCK_SIZE=8192 BLOCK_SIZE=8192
XLOG_BLOCK_SIZE=8192 XLOG_BLOCK_SIZE=8192
STATUS=OK STATUS=OK
@ -202,8 +196,8 @@ absolute paths; relative paths are not allowed.
restore. restore.
*-A* _PATH_ / *--arclog-path*=_PATH_:: *-A* _PATH_ / *--arclog-path*=_PATH_::
The absolute path of archive WAL directory. Required on backup The absolute path of archive WAL directory. Required for restore
and restore. and show command.
*-B* _PATH_ / *--backup-path*=_PATH_:: *-B* _PATH_ / *--backup-path*=_PATH_::
The absolute path of backup catalog. This option is mandatory. The absolute path of backup catalog. This option is mandatory.
@ -220,9 +214,8 @@ absolute paths; relative paths are not allowed.
*-b* _BACKUPMODE_ / *--backup-mode*=_BACKUPMODE_:: *-b* _BACKUPMODE_ / *--backup-mode*=_BACKUPMODE_::
Specify backup target files. Available options are: "full", Specify backup target files. Available options are: "full",
"incremental" and "archive". "incremental". Abbreviated forms (prefix match) are also available.
Abbreviated forms (prefix match) are also available. For example, For example, -b f means "full" backup.
-b f means "full" backup.
*-Z* / *--compress-data*:: *-Z* / *--compress-data*::
Compress backup files with zlib if specified. Compress backup files with zlib if specified.
@ -242,12 +235,6 @@ absolute paths; relative paths are not allowed.
--keep-data-days means days to be kept. --keep-data-days means days to be kept.
Only files exceeded one of those settings are deleted. Only files exceeded one of those settings are deleted.
*--keep-arclog-files*=_NUMBER_ / *--keep-arclog-days*=_DAYS_::
Specify how long backuped archive WAL files will be kept.
--keep-arclog-files means number of backup files.
--keep-arclog-days means days to be kept. When backup is run, only
files exceeded one of those settings are deleted from archive storage.
=== RESTORE OPTIONS === === RESTORE OPTIONS ===
The parameters whose name start are started with --recovery refer to The parameters whose name start are started with --recovery refer to
@ -268,11 +255,6 @@ the same parameters as the ones in recovery.confin recovery.conf.
*--recovery-target-inclusive*:: *--recovery-target-inclusive*::
Specifies whether server pauses when recovery target is reached. Specifies whether server pauses when recovery target is reached.
*--hard-copy*::
Archived WAL files are copied to archive WAL storage area. If you
do not specify --hard-copy, pg_rman makes symlink to archive WAL
where are in the backup catalog directory.
=== CATALOG OPTIONS === === CATALOG OPTIONS ===
*-a* / *--show-all*:: *-a* / *--show-all*::
@ -350,7 +332,6 @@ variables or in configuration file as follows:
--recovery-target-xid RECOVERY_TARGET_XID Yes --recovery-target-xid RECOVERY_TARGET_XID Yes
--recovery-target-time RECOVERY_TARGET_TIME Yes --recovery-target-time RECOVERY_TARGET_TIME Yes
--recovery-target-inclusive RECOVERY_TARGET_INCLUSIVE Yes --recovery-target-inclusive RECOVERY_TARGET_INCLUSIVE Yes
--hard-copy HARD_COPY Yes
Variable names in configuration file are the same as long names or names Variable names in configuration file are the same as long names or names
of environment variables. The password can not be specified in command of environment variables. The password can not be specified in command
@ -403,7 +384,7 @@ pg_rman returns exit codes for each error status.
13 ERROR_INTERRUPTED Interrupted by user (Ctrl+C etc.) 13 ERROR_INTERRUPTED Interrupted by user (Ctrl+C etc.)
14 ERROR_PG_COMMAND SQL error 14 ERROR_PG_COMMAND SQL error
15 ERROR_PG_CONNECT Cannot connect to PostgreSQL server 15 ERROR_PG_CONNECT Cannot connect to PostgreSQL server
20 ERROR_ARCHIVE_FAILED Cannot archive WAL files 20 ERROR_ARCHIVE_FAILED Cannot archive WAL file
21 ERROR_NO_BACKUP Backup file not found 21 ERROR_NO_BACKUP Backup file not found
22 ERROR_CORRUPTED Backup file is broken 22 ERROR_CORRUPTED Backup file is broken
23 ERROR_ALREADY_RUNNING Cannot start because another pg_rman 23 ERROR_ALREADY_RUNNING Cannot start because another pg_rman

9
expected/backup_restore.out
View File

@ -8,18 +8,11 @@ CHECKPOINT
incremental database backup incremental database backup
CHECKPOINT CHECKPOINT
CHECKPOINT CHECKPOINT
archived WAL backup
stop DB during running pgbench stop DB during running pgbench
diff files in BACKUP_PATH/backup/pg_xlog
diff files in BACKUP_PATH/backup/pg_xlog
full database backup after recovery full database backup after recovery
CHECKPOINT CHECKPOINT
# of files in BACKUP_PATH/backup/pg_xlog
0
# of symbolic links in ARCLOG_PATH # of symbolic links in ARCLOG_PATH
0 0
# of files in BACKUP_PATH/timeline_history
2
# of recovery target option in recovery.conf # of recovery target option in recovery.conf
3 3
# of deleted backups (show all) # of deleted backups (show all)
@ -30,4 +23,4 @@ delete backup
# of deleted backups # of deleted backups
4 4
# of deleted backups # of deleted backups
9 8

1
expected/init.out
View File

@ -6,7 +6,6 @@ results/init_test/
results/init_test/backup/ results/init_test/backup/
results/init_test/backup/pg_xlog/ results/init_test/backup/pg_xlog/
results/init_test/pg_rman.ini results/init_test/pg_rman.ini
results/init_test/timeline_history/
\! pg_rman init -B ${PWD}/results/init_test --quiet;echo $? \! pg_rman init -B ${PWD}/results/init_test --quiet;echo $?
ERROR: backup catalog already exist. and it's not empty. ERROR: backup catalog already exist. and it's not empty.
2 2

13
expected/option.out
View File

@ -17,21 +17,18 @@ Common Options:
-v, --verbose output process information -v, --verbose output process information
Backup options: Backup options:
-b, --backup-mode=MODE full, incremental, or archive -b, --backup-mode=MODE full or incremental
-Z, --compress-data compress data backup with zlib -Z, --compress-data compress data backup with zlib
-C, --smooth-checkpoint do smooth checkpoint before backup -C, --smooth-checkpoint do smooth checkpoint before backup
--validate validate backup after taking it --validate validate backup after taking it
--keep-data-generations=N keep GENERATION of full data backup --keep-data-generations=N keep GENERATION of full data backup
--keep-data-days=DAY keep enough data backup to recover to DAY days age --keep-data-days=DAY keep enough data backup to recover to DAY days age
--keep-arclog-files=NUM keep NUM of archived WAL
--keep-arclog-days=DAY keep archived WAL modified in DAY days
Restore options: Restore options:
--recovery-target-time time stamp up to which recovery will proceed --recovery-target-time time stamp up to which recovery will proceed
--recovery-target-xid transaction ID up to which recovery will proceed --recovery-target-xid transaction ID up to which recovery will proceed
--recovery-target-inclusive whether we stop just after the recovery target --recovery-target-inclusive whether we stop just after the recovery target
--recovery-target-timeline recovering into a particular timeline --recovery-target-timeline recovering into a particular timeline
--hard-copy copying archivelog not symbolic link
Catalog options: Catalog options:
-a, --show-all show deleted backup too -a, --show-all show deleted backup too
@ -54,10 +51,9 @@ Read the website for details. <https://github.com/michaelpq/pg_rman>
Report bugs to <https://github.com/michaelpq/pg_rman/issues>. Report bugs to <https://github.com/michaelpq/pg_rman/issues>.
pg_rman 1.3dev pg_rman 1.3dev
ERROR: required parameter not specified: BACKUP_PATH (-B, --backup-path) ERROR: required parameter not specified: BACKUP_PATH (-B, --backup-path)
ERROR: required parameter not specified: ARCLOG_PATH (-A, --arclog-path)
ERROR: required parameter not specified: BACKUP_PATH (-B, --backup-path)
ERROR: Required parameter not specified: BACKUP_MODE (-b, --backup-mode) ERROR: Required parameter not specified: BACKUP_MODE (-b, --backup-mode)
ERROR: Required parameter not specified: ARCLOG_PATH (-A, --arclog-path)
ERROR: Required parameter not specified: ARCLOG_PATH (-A, --arclog-path)
ERROR: Required parameter not specified: ARCLOG_PATH (-A, --arclog-path)
ERROR: invalid backup-mode "bad" ERROR: invalid backup-mode "bad"
ERROR: required delete range option not specified: delete DATE ERROR: required delete range option not specified: delete DATE
INFO: validate: 2009-05-31 17:05:53 backup and archive log files by CRC INFO: validate: 2009-05-31 17:05:53 backup and archive log files by CRC
@ -67,11 +63,8 @@ WARNING: backup 2009-06-01 17:05:53 is corrupted
WARNING: syntax error in " = INFINITE" WARNING: syntax error in " = INFINITE"
ERROR: Required parameter not specified: BACKUP_MODE (-b, --backup-mode) ERROR: Required parameter not specified: BACKUP_MODE (-b, --backup-mode)
ERROR: invalid backup-mode "" ERROR: invalid backup-mode ""
ERROR: Required parameter not specified: ARCLOG_PATH (-A, --arclog-path)
ERROR: Required parameter not specified: ARCLOG_PATH (-A, --arclog-path)
ERROR: invalid backup-mode "B" ERROR: invalid backup-mode "B"
ERROR: option -Z, --compress-data should be a boolean: 'FOO' ERROR: option -Z, --compress-data should be a boolean: 'FOO'
ERROR: option --keep-arclog-files should be a 32bit signed integer: 'YES'
ERROR: invalid option "TIMELINEID" ERROR: invalid option "TIMELINEID"
ERROR: invalid option "BACKUP_TARGETS" ERROR: invalid option "BACKUP_TARGETS"
ERROR: invalid backup-mode "ENV_PATH" ERROR: invalid backup-mode "ENV_PATH"

36
expected/show_validate.out
View File

@ -1,35 +1,33 @@
-- test show command -- test show command
\! rm -rf ${PWD}/results/sample_backup \! rm -rf ${PWD}/results/sample_backup
\! cp -rp data/sample_backup ${PWD}/results/sample_backup \! cp -rp data/sample_backup ${PWD}/results/sample_backup
\! pg_rman show -B ${PWD}/results/sample_backup \! pg_rman show -A ${PWD}/results/arclog -B ${PWD}/results/sample_backup
=========================================================================================== ==========================================================================
Start Mode Current TLI Parent TLI Time Data WAL Backup Status Start Mode Current TLI Parent TLI Time Data Status
=========================================================================================== ==========================================================================
2009-06-03 17:05:53 FULL 1 0 0m ---- ---- ---- RUNNING 2009-06-03 17:05:53 FULL 1 0 0m ---- RUNNING
2009-06-01 17:05:53 INCR 1 0 3m 9223PB 16MB 162MB DONE 2009-06-01 17:05:53 INCR 1 0 3m 9223PB DONE
2009-05-31 17:05:53 FULL 1 0 3m 1242MB 9223PB 242MB DONE 2009-05-31 17:05:53 FULL 1 0 3m 1242MB DONE
\! pg_rman validate -B ${PWD}/results/sample_backup 2009-05-31 17:05:53 --debug \! pg_rman validate -B ${PWD}/results/sample_backup 2009-05-31 17:05:53 --debug
INFO: validate: 2009-05-31 17:05:53 backup and archive log files by CRC INFO: validate: 2009-05-31 17:05:53 backup and archive log files by CRC
LOG: database files... LOG: database files...
LOG: (1/1) PG_VERSION LOG: (1/1) PG_VERSION
LOG: archive WAL files...
LOG: backup 2009-05-31 17:05:53 is valid LOG: backup 2009-05-31 17:05:53 is valid
\! pg_rman validate -B ${PWD}/results/sample_backup 2009-06-01 17:05:53 --debug \! pg_rman validate -B ${PWD}/results/sample_backup 2009-06-01 17:05:53 --debug
INFO: validate: 2009-06-01 17:05:53 backup and archive log files by CRC INFO: validate: 2009-06-01 17:05:53 backup and archive log files by CRC
LOG: database files... LOG: database files...
LOG: (1/1) PG_VERSION LOG: (1/1) PG_VERSION
WARNING: CRC of backup file "PG_VERSION" must be 0 but FEF71BC1 WARNING: CRC of backup file "PG_VERSION" must be 0 but FEF71BC1
LOG: archive WAL files...
WARNING: backup 2009-06-01 17:05:53 is corrupted WARNING: backup 2009-06-01 17:05:53 is corrupted
\! pg_rman show -a -B ${PWD}/results/sample_backup \! pg_rman show -a -A ${PWD}/results/arclog -B ${PWD}/results/sample_backup
=========================================================================================== ==========================================================================
Start Mode Current TLI Parent TLI Time Data WAL Backup Status Start Mode Current TLI Parent TLI Time Data Status
=========================================================================================== ==========================================================================
2009-06-03 17:05:53 FULL 1 0 0m ---- ---- ---- RUNNING 2009-06-03 17:05:53 FULL 1 0 0m ---- RUNNING
2009-06-02 17:05:03 ARCH 1 0 0m ---- ---- 162MB DELETED 2009-06-02 17:05:03 FULL 1 0 0m ---- DELETED
2009-06-01 17:05:53 INCR 1 0 3m 9223PB 16MB 162MB CORRUPT 2009-06-01 17:05:53 INCR 1 0 3m 9223PB CORRUPT
2009-05-31 17:05:53 FULL 1 0 3m 1242MB 9223PB 242MB OK 2009-05-31 17:05:53 FULL 1 0 3m 1242MB OK
\! pg_rman show 2009-06-01 17:05:53 -B ${PWD}/results/sample_backup \! pg_rman show 2009-06-01 17:05:53 -A ${PWD}/results/arclog -B ${PWD}/results/sample_backup
# configuration # configuration
BACKUP_MODE=INCREMENTAL BACKUP_MODE=INCREMENTAL
COMPRESS_DATA=false COMPRESS_DATA=false
@ -41,8 +39,6 @@ START_TIME='2009-06-01 17:05:53'
END_TIME='2009-06-01 17:09:13' END_TIME='2009-06-01 17:09:13'
RECOVERY_XID=0 RECOVERY_XID=0
DATA_BYTES=9223372036854775807 DATA_BYTES=9223372036854775807
ARCLOG_BYTES=16777216
BACKUP_BYTES=162372983
BLOCK_SIZE=8192 BLOCK_SIZE=8192
XLOG_BLOCK_SIZE=8192 XLOG_BLOCK_SIZE=8192
STATUS=CORRUPT STATUS=CORRUPT

4
init.c
View File

@ -53,10 +53,6 @@ do_init(void)
PG_XLOG_DIR); PG_XLOG_DIR);
dir_create_dir(path, DIR_PERMISSION); dir_create_dir(path, DIR_PERMISSION);
/* create directory for timeline history files */
join_path_components(path, backup_path, TIMELINE_HISTORY_DIR);
dir_create_dir(path, DIR_PERMISSION);
/* read postgresql.conf */ /* read postgresql.conf */
if (pgdata) if (pgdata)
{ {

25
pg_rman.c
View File

@ -32,8 +32,6 @@ pgBackup current;
/* backup configuration */ /* backup configuration */
static bool smooth_checkpoint; static bool smooth_checkpoint;
static int keep_arclog_files = KEEP_INFINITE;
static int keep_arclog_days = KEEP_INFINITE;
static int keep_data_generations = KEEP_INFINITE; static int keep_data_generations = KEEP_INFINITE;
static int keep_data_days = KEEP_INFINITE; static int keep_data_days = KEEP_INFINITE;
static bool backup_validate = false; static bool backup_validate = false;
@ -43,7 +41,6 @@ static char *target_time;
static char *target_xid; static char *target_xid;
static char *target_inclusive; static char *target_inclusive;
static TimeLineID target_tli; static TimeLineID target_tli;
static bool is_hard_copy = false;
/* show configuration */ /* show configuration */
static bool show_all = false; static bool show_all = false;
@ -67,15 +64,12 @@ static pgut_option options[] =
/* options with only long name (keep-xxx) */ /* options with only long name (keep-xxx) */
{ 'i', 1, "keep-data-generations", &keep_data_generations, SOURCE_ENV }, { 'i', 1, "keep-data-generations", &keep_data_generations, SOURCE_ENV },
{ 'i', 2, "keep-data-days", &keep_data_days, SOURCE_ENV }, { 'i', 2, "keep-data-days", &keep_data_days, SOURCE_ENV },
{ 'i', 3, "keep-arclog-files", &keep_arclog_files, SOURCE_ENV },
{ 'i', 4, "keep-arclog-days", &keep_arclog_days, SOURCE_ENV },
/* restore options */ /* restore options */
{ 's', 7, "recovery-target-time", &target_time, SOURCE_ENV }, { 's', 3, "recovery-target-time", &target_time, SOURCE_ENV },
{ 's', 8, "recovery-target-xid", &target_xid, SOURCE_ENV }, { 's', 4, "recovery-target-xid", &target_xid, SOURCE_ENV },
{ 's', 9, "recovery-target-inclusive", &target_inclusive, SOURCE_ENV }, { 's', 5, "recovery-target-inclusive", &target_inclusive, SOURCE_ENV },
{ 'u', 10, "recovery-target-timeline", &target_tli, SOURCE_ENV }, { 'u', 6, "recovery-target-timeline", &target_tli, SOURCE_ENV },
{ 'b', 11, "hard-copy", &is_hard_copy, SOURCE_ENV }, { 'b', 7, "validate", &backup_validate, SOURCE_ENV },
{ 'b', 12, "validate", &backup_validate, SOURCE_ENV },
/* catalog options */ /* catalog options */
{ 'b', 'a', "show-all", &show_all }, { 'b', 'a', "show-all", &show_all },
{ 0 } { 0 }
@ -171,8 +165,6 @@ main(int argc, char *argv[])
pgBackupOption bkupopt; pgBackupOption bkupopt;
int res; int res;
bkupopt.smooth_checkpoint = smooth_checkpoint; bkupopt.smooth_checkpoint = smooth_checkpoint;
bkupopt.keep_arclog_files = keep_arclog_files;
bkupopt.keep_arclog_days = keep_arclog_days;
bkupopt.keep_data_generations = keep_data_generations; bkupopt.keep_data_generations = keep_data_generations;
bkupopt.keep_data_days = keep_data_days; bkupopt.keep_data_days = keep_data_days;
@ -189,7 +181,7 @@ main(int argc, char *argv[])
} }
else if (pg_strcasecmp(cmd, "restore") == 0){ else if (pg_strcasecmp(cmd, "restore") == 0){
return do_restore(target_time, target_xid, return do_restore(target_time, target_xid,
target_inclusive, target_tli, is_hard_copy); target_inclusive, target_tli);
} }
else if (pg_strcasecmp(cmd, "show") == 0) else if (pg_strcasecmp(cmd, "show") == 0)
return do_show(&range, show_all); return do_show(&range, show_all);
@ -225,20 +217,17 @@ pgut_help(bool details)
printf(_(" -c, --check show what would have been done\n")); printf(_(" -c, --check show what would have been done\n"));
printf(_(" -v, --verbose output process information\n")); printf(_(" -v, --verbose output process information\n"));
printf(_("\nBackup options:\n")); printf(_("\nBackup options:\n"));
printf(_(" -b, --backup-mode=MODE full, incremental, or archive\n")); printf(_(" -b, --backup-mode=MODE full or incremental\n"));
printf(_(" -Z, --compress-data compress data backup with zlib\n")); printf(_(" -Z, --compress-data compress data backup with zlib\n"));
printf(_(" -C, --smooth-checkpoint do smooth checkpoint before backup\n")); printf(_(" -C, --smooth-checkpoint do smooth checkpoint before backup\n"));
printf(_(" --validate validate backup after taking it\n")); printf(_(" --validate validate backup after taking it\n"));
printf(_(" --keep-data-generations=N keep GENERATION of full data backup\n")); printf(_(" --keep-data-generations=N keep GENERATION of full data backup\n"));
printf(_(" --keep-data-days=DAY keep enough data backup to recover to DAY days age\n")); printf(_(" --keep-data-days=DAY keep enough data backup to recover to DAY days age\n"));
printf(_(" --keep-arclog-files=NUM keep NUM of archived WAL\n"));
printf(_(" --keep-arclog-days=DAY keep archived WAL modified in DAY days\n"));
printf(_("\nRestore options:\n")); printf(_("\nRestore options:\n"));
printf(_(" --recovery-target-time time stamp up to which recovery will proceed\n")); printf(_(" --recovery-target-time time stamp up to which recovery will proceed\n"));
printf(_(" --recovery-target-xid transaction ID up to which recovery will proceed\n")); printf(_(" --recovery-target-xid transaction ID up to which recovery will proceed\n"));
printf(_(" --recovery-target-inclusive whether we stop just after the recovery target\n")); printf(_(" --recovery-target-inclusive whether we stop just after the recovery target\n"));
printf(_(" --recovery-target-timeline recovering into a particular timeline\n")); printf(_(" --recovery-target-timeline recovering into a particular timeline\n"));
printf(_(" --hard-copy copying archivelog not symbolic link\n"));
printf(_("\nCatalog options:\n")); printf(_("\nCatalog options:\n"));
printf(_(" -a, --show-all show deleted backup too\n")); printf(_(" -a, --show-all show deleted backup too\n"));
} }

15
pg_rman.h
View File

@ -25,16 +25,13 @@
/* Directory/File names */ /* Directory/File names */
#define DATABASE_DIR "database" #define DATABASE_DIR "database"
#define ARCLOG_DIR "arclog"
#define RESTORE_WORK_DIR "backup" #define RESTORE_WORK_DIR "backup"
#define PG_XLOG_DIR "pg_xlog" #define PG_XLOG_DIR "pg_xlog"
#define PG_TBLSPC_DIR "pg_tblspc" #define PG_TBLSPC_DIR "pg_tblspc"
#define TIMELINE_HISTORY_DIR "timeline_history"
#define BACKUP_INI_FILE "backup.ini" #define BACKUP_INI_FILE "backup.ini"
#define PG_RMAN_INI_FILE "pg_rman.ini" #define PG_RMAN_INI_FILE "pg_rman.ini"
#define MKDIRS_SH_FILE "mkdirs.sh" #define MKDIRS_SH_FILE "mkdirs.sh"
#define DATABASE_FILE_LIST "file_database.txt" #define DATABASE_FILE_LIST "file_database.txt"
#define ARCLOG_FILE_LIST "file_arclog.txt"
#define SNAPSHOT_SCRIPT_FILE "snapshot_script" #define SNAPSHOT_SCRIPT_FILE "snapshot_script"
#define PG_BACKUP_LABEL_FILE "backup_label" #define PG_BACKUP_LABEL_FILE "backup_label"
#define PG_BLACK_LIST "black_list" #define PG_BLACK_LIST "black_list"
@ -113,7 +110,6 @@ typedef enum BackupStatus
typedef enum BackupMode typedef enum BackupMode
{ {
BACKUP_MODE_INVALID, BACKUP_MODE_INVALID,
BACKUP_MODE_ARCHIVE, /* archive only */
BACKUP_MODE_INCREMENTAL, /* incremental backup */ BACKUP_MODE_INCREMENTAL, /* incremental backup */
BACKUP_MODE_FULL /* full backup */ BACKUP_MODE_FULL /* full backup */
} BackupMode; } BackupMode;
@ -148,10 +144,6 @@ typedef struct pgBackup
* of data taken. * of data taken.
*/ */
int64 data_bytes; int64 data_bytes;
/* Amount of data for WAL archives */
int64 arclog_bytes;
/* Total size of backup */
int64 backup_bytes;
/* data/wal block size for compatibility check */ /* data/wal block size for compatibility check */
uint32 block_size; uint32 block_size;
@ -161,8 +153,6 @@ typedef struct pgBackup
typedef struct pgBackupOption typedef struct pgBackupOption
{ {
bool smooth_checkpoint; bool smooth_checkpoint;
int keep_arclog_files;
int keep_arclog_days;
int keep_data_generations; int keep_data_generations;
int keep_data_days; int keep_data_days;
} pgBackupOption; } pgBackupOption;
@ -233,8 +223,7 @@ extern bool fileExists(const char *path);
extern int do_restore(const char *target_time, extern int do_restore(const char *target_time,
const char *target_xid, const char *target_xid,
const char *target_inclusive, const char *target_inclusive,
TimeLineID target_tli, TimeLineID target_tli);
bool is_hard_copy);
/* in init.c */ /* in init.c */
extern int do_init(void); extern int do_init(void);
@ -262,8 +251,6 @@ extern pgBackup *catalog_get_backup(time_t timestamp);
extern parray *catalog_get_backup_list(const pgBackupRange *range); extern parray *catalog_get_backup_list(const pgBackupRange *range);
extern pgBackup *catalog_get_last_data_backup(parray *backup_list, extern pgBackup *catalog_get_last_data_backup(parray *backup_list,
TimeLineID tli); TimeLineID tli);
extern pgBackup *catalog_get_last_arclog_backup(parray *backup_list,
TimeLineID tli);
extern int catalog_lock(void); extern int catalog_lock(void);
extern void catalog_unlock(void); extern void catalog_unlock(void);

214
restore.c
View File

@ -17,9 +17,7 @@
#include "catalog/pg_control.h" #include "catalog/pg_control.h"
static void backup_online_files(bool re_recovery); static void backup_online_files(bool re_recovery);
static void restore_online_files(void);
static void restore_database(pgBackup *backup); static void restore_database(pgBackup *backup);
static void restore_archive_logs(pgBackup *backup, bool is_hard_copy);
static void create_recovery_conf(const char *target_time, static void create_recovery_conf(const char *target_time,
const char *target_xid, const char *target_xid,
const char *target_inclusive, const char *target_inclusive,
@ -43,8 +41,7 @@ int
do_restore(const char *target_time, do_restore(const char *target_time,
const char *target_xid, const char *target_xid,
const char *target_inclusive, const char *target_inclusive,
TimeLineID target_tli, TimeLineID target_tli)
bool is_hard_copy)
{ {
int i; int i;
int base_index; /* index of base (full) backup */ int base_index; /* index of base (full) backup */
@ -56,7 +53,6 @@ do_restore(const char *target_time,
pgBackup *base_backup = NULL; pgBackup *base_backup = NULL;
parray *files; parray *files;
parray *timelines; parray *timelines;
char timeline_dir[MAXPGPATH];
pgRecoveryTarget *rt = NULL; pgRecoveryTarget *rt = NULL;
XLogRecPtr need_lsn; XLogRecPtr need_lsn;
@ -138,14 +134,7 @@ do_restore(const char *target_time,
parray_free(files); parray_free(files);
} }
/* /* Read timeline history files from archives */
* restore timeline history files and get timeline branches can reach
* recovery target point.
*/
join_path_components(timeline_dir, backup_path, TIMELINE_HISTORY_DIR);
if (verbose && !check)
printf(_("restoring timeline history files\n"));
dir_copy_files(timeline_dir, arclog_path);
timelines = readTimeLineHistory(target_tli); timelines = readTimeLineHistory(target_tli);
/* find last full backup which can be used as base backup. */ /* find last full backup which can be used as base backup. */
@ -213,47 +202,7 @@ base_backup_found:
last_restored_index = i; last_restored_index = i;
} }
/*
* Restore archived WAL which backed up with or after last restored backup.
* We don't check the backup->tli because a backup of arhived WAL
* can contain WALs which were archived in multiple timeline.
*/
if (verbose)
printf(_("searching backed-up WAL...\n"));
if (check)
{
pgBackup *backup = (pgBackup *) parray_get(backups, last_restored_index);
need_lsn = backup->start_lsn;
}
for (i = last_restored_index; i >= 0; i--) for (i = last_restored_index; i >= 0; i--)
{
pgBackup *backup = (pgBackup *) parray_get(backups, i);
/* don't use incomplete backup */
if (backup->status != BACKUP_STATUS_OK)
continue;
/* care timeline junction */
if (!satisfy_timeline(timelines, backup))
continue;
restore_archive_logs(backup, is_hard_copy);
if (check)
{
char xlogpath[MAXPGPATH];
pgBackupGetPath(backup, xlogpath, lengthof(xlogpath), ARCLOG_DIR);
search_next_wal(xlogpath, &need_lsn, timelines);
}
}
/* copy online WAL backup to $PGDATA/pg_xlog */
restore_online_files();
if (check)
{ {
char xlogpath[MAXPGPATH]; char xlogpath[MAXPGPATH];
if (verbose) if (verbose)
@ -466,113 +415,6 @@ restore_database(pgBackup *backup)
printf(_("restore backup completed\n")); printf(_("restore backup completed\n"));
} }
/*
* Restore archived WAL by creating symbolic link which linked to backup WAL in
* archive directory.
*/
void
restore_archive_logs(pgBackup *backup, bool is_hard_copy)
{
int i;
char timestamp[100];
parray *files;
char path[MAXPGPATH];
char list_path[MAXPGPATH];
char base_path[MAXPGPATH];
time2iso(timestamp, lengthof(timestamp), backup->start_time);
if (verbose && !check)
{
printf(_("----------------------------------------\n"));
printf(_("restoring WAL from backup %s.\n"), timestamp);
}
/*
* Validate backup files with its size, because load of CRC calculation is
* not light.
*/
pgBackupValidate(backup, true, false);
pgBackupGetPath(backup, list_path, lengthof(list_path), ARCLOG_FILE_LIST);
pgBackupGetPath(backup, base_path, lengthof(list_path), ARCLOG_DIR);
files = dir_read_file_list(base_path, list_path);
for (i = 0; i < parray_num(files); i++)
{
pgFile *file = (pgFile *) parray_get(files, i);
/* check for interrupt */
if (interrupted)
elog(ERROR_INTERRUPTED, _("interrupted during restore WAL"));
/* print progress */
join_path_components(path, arclog_path, file->path + strlen(base_path) + 1);
if (verbose && !check)
printf(_("(%d/%lu) %s "), i + 1, (unsigned long) parray_num(files),
file->path + strlen(base_path) + 1);
/* skip files which are not in backup */
if (file->write_size == BYTES_INVALID)
{
if (verbose && !check)
printf(_("skip(not backed up)\n"));
continue;
}
/*
* skip timeline history files because timeline history files will be
* restored from $BACKUP_PATH/timeline_history.
*/
if (strstr(file->path, ".history") ==
file->path + strlen(file->path) - strlen(".history"))
{
if (verbose && !check)
printf(_("skip(timeline history)\n"));
continue;
}
if (!check)
{
if (backup->compress_data)
{
copy_file(base_path, arclog_path, file, DECOMPRESSION);
if (verbose)
printf(_("decompressed\n"));
continue;
}
/* even same file exist, use backup file */
if ((remove(path) == -1) && errno != ENOENT)
elog(ERROR_SYSTEM, _("can't remove file \"%s\": %s"), path,
strerror(errno));
if (!is_hard_copy)
{
/* create symlink */
if ((symlink(file->path, path) == -1))
elog(ERROR_SYSTEM, _("can't create link to \"%s\": %s"),
file->path, strerror(errno));
if (verbose)
printf(_("linked\n"));
}
else
{
/* create hard-copy */
if (!copy_file(base_path, arclog_path, file, NO_COMPRESSION))
elog(ERROR_SYSTEM, _("can't copy to \"%s\": %s"),
file->path, strerror(errno));
if (verbose)
printf(_("copied\n"));
}
}
}
parray_walk(files, pgFileFree);
parray_free(files);
}
static void static void
create_recovery_conf(const char *target_time, create_recovery_conf(const char *target_time,
@ -654,58 +496,6 @@ backup_online_files(bool re_recovery)
dir_copy_files(pg_xlog_path, work_path); dir_copy_files(pg_xlog_path, work_path);
} }
static void
restore_online_files(void)
{
int i;
char root_backup[MAXPGPATH];
parray *files_backup;
/* get list of files in $BACKUP_PATH/backup/pg_xlog */
files_backup = parray_new();
snprintf(root_backup, lengthof(root_backup), "%s/%s/%s", backup_path,
RESTORE_WORK_DIR, PG_XLOG_DIR);
dir_list_file(files_backup, root_backup, NULL, true, false);
if (verbose && !check)
{
printf(_("----------------------------------------\n"));
printf(_("restoring online WAL\n"));
}
/* restore online WAL */
for (i = 0; i < parray_num(files_backup); i++)
{
pgFile *file = (pgFile *) parray_get(files_backup, i);
if (S_ISDIR(file->mode))
{
char to_path[MAXPGPATH];
snprintf(to_path, lengthof(to_path), "%s/%s/%s", pgdata,
PG_XLOG_DIR, file->path + strlen(root_backup) + 1);
if (verbose && !check)
printf(_("create directory \"%s\"\n"),
file->path + strlen(root_backup) + 1);
if (!check)
dir_create_dir(to_path, DIR_PERMISSION);
continue;
}
else if(S_ISREG(file->mode))
{
char to_root[MAXPGPATH];
join_path_components(to_root, pgdata, PG_XLOG_DIR);
if (verbose && !check)
printf(_("restore \"%s\"\n"),
file->path + strlen(root_backup) + 1);
if (!check)
copy_file(root_backup, to_root, file, NO_COMPRESSION);
}
}
/* cleanup */
parray_walk(files_backup, pgFileFree);
parray_free(files_backup);
}
/* /*
* Try to read a timeline's history file. * Try to read a timeline's history file.

39
show.c
View File

@ -20,6 +20,15 @@ static void show_backup_detail(FILE *out, pgBackup *backup);
int int
do_show(pgBackupRange *range, bool show_all) do_show(pgBackupRange *range, bool show_all)
{ {
/*
* Safety check for archive folder, this is necessary to fetch
* the parent TLI from history field generated by server after
* child timeline is chosen.
*/
if (arclog_path == NULL)
elog(ERROR_ARGS,
_("required parameter not specified: ARCLOG_PATH (-A, --arclog-path)"));
if (pgBackupRangeIsSingle(range)) if (pgBackupRangeIsSingle(range))
{ {
pgBackup *backup; pgBackup *backup;
@ -29,7 +38,7 @@ do_show(pgBackupRange *range, bool show_all)
{ {
char timestamp[100]; char timestamp[100];
time2iso(timestamp, lengthof(timestamp), range->begin); time2iso(timestamp, lengthof(timestamp), range->begin);
elog(INFO, _("backup taken at \"%s\" doesn not exist."), elog(INFO, _("backup taken at \"%s\" does not exist."),
timestamp); timestamp);
/* This is not error case */ /* This is not error case */
return 0; return 0;
@ -111,9 +120,9 @@ get_parent_tli(TimeLineID child_tli)
char fline[MAXPGPATH]; char fline[MAXPGPATH];
FILE *fd; FILE *fd;
/* search from timeline history dir */ /* Search history file in archives */
snprintf(path, lengthof(path), "%s/%s/%08X.history", backup_path, snprintf(path, lengthof(path), "%s/%08X.history", arclog_path,
TIMELINE_HISTORY_DIR, child_tli); child_tli);
fd = fopen(path, "rt"); fd = fopen(path, "rt");
if (fd == NULL) if (fd == NULL)
{ {
@ -161,20 +170,18 @@ show_backup_list(FILE *out, parray *backup_list, bool show_all)
int i; int i;
/* show header */ /* show header */
fputs("===========================================================================================\n", out); fputs("==========================================================================\n", out);
fputs("Start Mode Current TLI Parent TLI Time Data WAL Backup Status \n", out); fputs("Start Mode Current TLI Parent TLI Time Data Status \n", out);
fputs("===========================================================================================\n", out); fputs("==========================================================================\n", out);
for (i = 0; i < parray_num(backup_list); i++) for (i = 0; i < parray_num(backup_list); i++)
{ {
pgBackup *backup; pgBackup *backup;
const char *modes[] = { "", "ARCH", "INCR", "FULL"}; const char *modes[] = { "", "INCR", "FULL"};
TimeLineID parent_tli; TimeLineID parent_tli;
char timestamp[20]; char timestamp[20];
char duration[20] = "----"; char duration[20] = "----";
char data_bytes_str[10] = "----"; char data_bytes_str[10] = "----";
char arclog_bytes_str[10] = "----";
char backup_bytes_str[10];
backup = parray_get(backup_list, i); backup = parray_get(backup_list, i);
@ -195,26 +202,16 @@ show_backup_list(FILE *out, parray *backup_list, bool show_all)
pretty_size(backup->data_bytes, data_bytes_str, pretty_size(backup->data_bytes, data_bytes_str,
lengthof(data_bytes_str)); lengthof(data_bytes_str));
/* Calculate amount of data for archive files */
pretty_size(backup->arclog_bytes, arclog_bytes_str,
lengthof(arclog_bytes_str));
/* Calculate amount of data for total backup */
pretty_size(backup->backup_bytes, backup_bytes_str,
lengthof(backup_bytes_str));
/* Get parent timeline before printing */ /* Get parent timeline before printing */
parent_tli = get_parent_tli(backup->tli); parent_tli = get_parent_tli(backup->tli);
fprintf(out, "%-19s %-4s %10d %10d %5s %6s %6s %6s %s\n", fprintf(out, "%-19s %-4s %10d %10d %5s %6s %s \n",
timestamp, timestamp,
modes[backup->backup_mode], modes[backup->backup_mode],
backup->tli, backup->tli,
parent_tli, parent_tli,
duration, duration,
data_bytes_str, data_bytes_str,
arclog_bytes_str,
backup_bytes_str,
status2str(backup->status)); status2str(backup->status));
} }
} }

19
sql/backup_restore.sh
View File

@ -127,9 +127,6 @@ psql --no-psqlrc -p $TEST_PGPORT postgres -c "checkpoint"
pg_rman -w -p $TEST_PGPORT backup -b i --verbose -d postgres > $BASE_PATH/results/log_incr2 2>&1 pg_rman -w -p $TEST_PGPORT backup -b i --verbose -d postgres > $BASE_PATH/results/log_incr2 2>&1
pgbench -p $TEST_PGPORT -T $DURATION -c 10 pgbench >> $BASE_PATH/results/pgbench.log 2>&1 pgbench -p $TEST_PGPORT -T $DURATION -c 10 pgbench >> $BASE_PATH/results/pgbench.log 2>&1
echo "archived WAL backup"
#pg_rman -p $TEST_PGPORT backup -b a --verbose -d postgres > $BASE_PATH/results/log_arclog 2>&1
pg_rman -w -p $TEST_PGPORT backup -b a --verbose -d postgres > $BASE_PATH/results/log_arclog 2>&1
# stop PG during transaction and get commited info for verifing # stop PG during transaction and get commited info for verifing
echo "stop DB during running pgbench" echo "stop DB during running pgbench"
@ -160,10 +157,6 @@ if [ "$CUR_TLI" != "$CUR_TLI_R" ]; then
echo "failed: bad timeline ID" CUR_TLI=$CUR_TLI CUR_TLI_R=$CUR_TLI_R echo "failed: bad timeline ID" CUR_TLI=$CUR_TLI CUR_TLI_R=$CUR_TLI_R
fi fi
# Backup of online-WAL
echo "diff files in BACKUP_PATH/backup/pg_xlog"
diff -r $PGDATA/pg_xlog $BACKUP_PATH/backup/pg_xlog
# recovery database # recovery database
pg_ctl start -w -t 3600 > /dev/null 2>&1 pg_ctl start -w -t 3600 > /dev/null 2>&1
@ -181,10 +174,6 @@ if [ "$CUR_TLI" != "$CUR_TLI_R" ]; then
echo "failed: bad timeline ID" CUR_TLI=$CUR_TLI CUR_TLI_R=$CUR_TLI_R echo "failed: bad timeline ID" CUR_TLI=$CUR_TLI CUR_TLI_R=$CUR_TLI_R
fi fi
# Backup of online-WAL
echo "diff files in BACKUP_PATH/backup/pg_xlog"
diff -r $PGDATA/pg_xlog $BACKUP_PATH/backup/pg_xlog
# re-recovery database # re-recovery database
pg_ctl start -w -t 3600 > /dev/null 2>&1 pg_ctl start -w -t 3600 > /dev/null 2>&1
@ -199,18 +188,10 @@ psql --no-psqlrc -p $TEST_PGPORT postgres -c "checkpoint"
#pg_rman -p $TEST_PGPORT backup -b f --verbose -d postgres > $BASE_PATH/results/log_full2 2>&1 #pg_rman -p $TEST_PGPORT backup -b f --verbose -d postgres > $BASE_PATH/results/log_full2 2>&1
pg_rman -w -p $TEST_PGPORT backup -b f --verbose -d postgres > $BASE_PATH/results/log_full2 2>&1 pg_rman -w -p $TEST_PGPORT backup -b f --verbose -d postgres > $BASE_PATH/results/log_full2 2>&1
# Backup of online-WAL should been deleted
echo "# of files in BACKUP_PATH/backup/pg_xlog"
find $BACKUP_PATH/backup/pg_xlog -type f | wc -l | tr -d ' '
# Symbolic links in $ARCLOG_PATH should be deleted. # Symbolic links in $ARCLOG_PATH should be deleted.
echo "# of symbolic links in ARCLOG_PATH" echo "# of symbolic links in ARCLOG_PATH"
find $ARCLOG_PATH -type l | wc -l | tr -d ' ' find $ARCLOG_PATH -type l | wc -l | tr -d ' '
# timeline history files are backed up.
echo "# of files in BACKUP_PATH/timeline_history"
find $BACKUP_PATH/timeline_history -type f | wc -l | tr -d ' '
# restore with pg_rman # restore with pg_rman
pg_ctl stop -m immediate > /dev/null 2>&1 pg_ctl stop -m immediate > /dev/null 2>&1

15
sql/option.sh
View File

@ -12,7 +12,6 @@ unset BACKUP_PATH
unset ARCLOG_PATH unset ARCLOG_PATH
unset BACKUP_MODE unset BACKUP_MODE
unset COMPRESS_DATA unset COMPRESS_DATA
unset KEEP_ARCLOG_DAYS
unset KEEP_DATA_GENERATIONS unset KEEP_DATA_GENERATIONS
unset KEEP_DATA_DAYS unset KEEP_DATA_DAYS
@ -29,13 +28,15 @@ cp -rp data/sample_backup $BACKUP_PATH
pg_rman --help pg_rman --help
pg_rman --version pg_rman --version
# show option
# required argument check
pg_rman show
pg_rman show -B $BACKUP_PATH
# backup option # backup option
# required arguments check # required arguments check
pg_rman backup --verbose pg_rman backup --verbose
pg_rman backup --verbose -B $BACKUP_PATH pg_rman backup --verbose -B $BACKUP_PATH
pg_rman backup --verbose -B $BACKUP_PATH -b f
pg_rman backup --verbose -B $BACKUP_PATH -b i
pg_rman backup --verbose -B $BACKUP_PATH -b a
# bad arguments check # bad arguments check
pg_rman backup --verbose -B $BACKUP_PATH -b bad pg_rman backup --verbose -B $BACKUP_PATH -b bad
@ -49,16 +50,10 @@ echo " = INFINITE" > $BACKUP_PATH/pg_rman.ini
pg_rman backup --verbose -B $BACKUP_PATH pg_rman backup --verbose -B $BACKUP_PATH
echo "BACKUP_MODE= " > $BACKUP_PATH/pg_rman.ini echo "BACKUP_MODE= " > $BACKUP_PATH/pg_rman.ini
pg_rman backup --verbose -B $BACKUP_PATH pg_rman backup --verbose -B $BACKUP_PATH
echo "BACKUP_MODE = F#S" > $BACKUP_PATH/pg_rman.ini
pg_rman backup --verbose -B $BACKUP_PATH
echo "BACKUP_MODE = F #comment A" > $BACKUP_PATH/pg_rman.ini
pg_rman backup --verbose -B $BACKUP_PATH
echo "BACKUP_MODE=B" > $BACKUP_PATH/pg_rman.ini echo "BACKUP_MODE=B" > $BACKUP_PATH/pg_rman.ini
pg_rman backup --verbose -B $BACKUP_PATH pg_rman backup --verbose -B $BACKUP_PATH
echo "COMPRESS_DATA=FOO" > $BACKUP_PATH/pg_rman.ini echo "COMPRESS_DATA=FOO" > $BACKUP_PATH/pg_rman.ini
pg_rman backup --verbose -B $BACKUP_PATH pg_rman backup --verbose -B $BACKUP_PATH
echo "KEEP_ARCLOG_FILES=YES" > $BACKUP_PATH/pg_rman.ini
pg_rman backup --verbose -B $BACKUP_PATH
echo "TIMELINEID=-1" > $BACKUP_PATH/pg_rman.ini echo "TIMELINEID=-1" > $BACKUP_PATH/pg_rman.ini
pg_rman backup --verbose -B $BACKUP_PATH pg_rman backup --verbose -B $BACKUP_PATH
echo "BACKUP_TARGETS=F" > $BACKUP_PATH/pg_rman.ini echo "BACKUP_TARGETS=F" > $BACKUP_PATH/pg_rman.ini

6
sql/show_validate.sql
View File

@ -1,8 +1,8 @@
-- test show command -- test show command
\! rm -rf ${PWD}/results/sample_backup \! rm -rf ${PWD}/results/sample_backup
\! cp -rp data/sample_backup ${PWD}/results/sample_backup \! cp -rp data/sample_backup ${PWD}/results/sample_backup
\! pg_rman show -B ${PWD}/results/sample_backup \! pg_rman show -A ${PWD}/results/arclog -B ${PWD}/results/sample_backup
\! pg_rman validate -B ${PWD}/results/sample_backup 2009-05-31 17:05:53 --debug \! pg_rman validate -B ${PWD}/results/sample_backup 2009-05-31 17:05:53 --debug
\! pg_rman validate -B ${PWD}/results/sample_backup 2009-06-01 17:05:53 --debug \! pg_rman validate -B ${PWD}/results/sample_backup 2009-06-01 17:05:53 --debug
\! pg_rman show -a -B ${PWD}/results/sample_backup \! pg_rman show -a -A ${PWD}/results/arclog -B ${PWD}/results/sample_backup
\! pg_rman show 2009-06-01 17:05:53 -B ${PWD}/results/sample_backup \! pg_rman show 2009-06-01 17:05:53 -A ${PWD}/results/arclog -B ${PWD}/results/sample_backup

16
validate.c
View File

@ -84,12 +84,6 @@ pgBackupValidate(pgBackup *backup,
backup->backup_mode == BACKUP_MODE_INCREMENTAL) backup->backup_mode == BACKUP_MODE_INCREMENTAL)
elog(INFO, "validate: %s backup and archive log files by %s", elog(INFO, "validate: %s backup and archive log files by %s",
timestamp, (size_only ? "SIZE" : "CRC")); timestamp, (size_only ? "SIZE" : "CRC"));
else
{
if (backup->backup_mode == BACKUP_MODE_ARCHIVE)
elog(INFO, "validate: %s archive log files by %s",
timestamp, (size_only ? "SIZE" : "CRC"));
}
} }
if (!check) if (!check)
@ -108,16 +102,6 @@ pgBackupValidate(pgBackup *backup,
parray_free(files); parray_free(files);
} }
/* WAL archives are present for all modes */
elog(LOG, "archive WAL files...");
pgBackupGetPath(backup, base_path, lengthof(base_path), ARCLOG_DIR);
pgBackupGetPath(backup, path, lengthof(path), ARCLOG_FILE_LIST);
files = dir_read_file_list(base_path, path);
if (!pgBackupValidateFiles(files, base_path, size_only))
corrupted = true;
parray_walk(files, pgFileFree);
parray_free(files);
/* update status to OK */ /* update status to OK */
if (corrupted) if (corrupted)
backup->status = BACKUP_STATUS_CORRUPT; backup->status = BACKUP_STATUS_CORRUPT;