1
0
mirror of https://github.com/pgbackrest/pgbackrest.git synced 2025-02-05 13:25:00 +02:00

Break up scripts in db unit test module.

Long scripts followed by a number of tests are really challenging to debug and update.

Instead, break up the scripts to be inline with the tests that they drive. This should make maintenance of the tests much simpler.
This commit is contained in:
David Steele 2024-01-03 18:15:50 -03:00
parent 7c17eec3db
commit 55f2248963

View File

@ -264,47 +264,47 @@ testRun(void)
HRN_PG_CONTROL_PUT(storagePgIdxWrite(0), PG_VERSION_95, .checkpoint = pgLsnFromStr(STRDEF("2/3")));
// Connect to primary
HRN_PQ_SCRIPT_SET(
// Connect to primary
HRN_PQ_SCRIPT_OPEN_GE_93(1, "dbname='backupdb' port=5432", PG_VERSION_95, TEST_PATH "/pg1", false, NULL, NULL),
// Get start time
HRN_PQ_SCRIPT_TIME_QUERY(1, 1000),
// Start backup errors on advisory lock
HRN_PQ_SCRIPT_ADVISORY_LOCK(1, false),
// Start backup
HRN_PQ_SCRIPT_ADVISORY_LOCK(1, true),
HRN_PQ_SCRIPT_IS_IN_BACKUP(1, false),
HRN_PQ_SCRIPT_START_BACKUP_LE_95(1, false, "2/3", "000000010000000200000003"),
HRN_PQ_SCRIPT_DATABASE_LIST_1(1, "test1"),
HRN_PQ_SCRIPT_TABLESPACE_LIST_0(1),
// Stop backup
HRN_PQ_SCRIPT_STOP_BACKUP_LE_95(1, "2/4", "000000010000000200000004"),
// Close primary
HRN_PQ_SCRIPT_CLOSE(1));
HRN_PQ_SCRIPT_OPEN_GE_93(1, "dbname='backupdb' port=5432", PG_VERSION_95, TEST_PATH "/pg1", false, NULL, NULL));
DbGetResult db = {0};
TEST_ASSIGN(db, dbGet(true, true, false), "get primary");
// Get start time
HRN_PQ_SCRIPT_SET(HRN_PQ_SCRIPT_TIME_QUERY(1, 1000));
TEST_RESULT_UINT(dbTimeMSec(db.primary), 1000, "check time");
// Start backup errors on advisory lock
HRN_PQ_SCRIPT_SET(HRN_PQ_SCRIPT_ADVISORY_LOCK(1, false));
TEST_ERROR(
dbBackupStart(db.primary, false, false, false), LockAcquireError,
"unable to acquire pgBackRest advisory lock\n"
"HINT: is another pgBackRest backup already running on this cluster?");
// Start backup
HRN_PQ_SCRIPT_SET(
HRN_PQ_SCRIPT_ADVISORY_LOCK(1, true),
HRN_PQ_SCRIPT_IS_IN_BACKUP(1, false),
HRN_PQ_SCRIPT_START_BACKUP_LE_95(1, false, "2/3", "000000010000000200000003"));
DbBackupStartResult backupStartResult = {0};
TEST_ASSIGN(backupStartResult, dbBackupStart(db.primary, false, true, false), "start backup");
TEST_RESULT_STR_Z(backupStartResult.lsn, "2/3", "check lsn");
TEST_RESULT_STR_Z(backupStartResult.walSegmentName, "000000010000000200000003", "check wal segment name");
// Get database list
HRN_PQ_SCRIPT_SET(HRN_PQ_SCRIPT_DATABASE_LIST_1(1, "test1"));
TEST_RESULT_STR_Z(hrnPackToStr(dbList(db.primary)), "1:array:[1:u32:16384, 2:str:test1, 3:u32:13777]", "check db list");
// Get tablespace ist
HRN_PQ_SCRIPT_SET(HRN_PQ_SCRIPT_TABLESPACE_LIST_0(1));
TEST_RESULT_STR_Z(hrnPackToStr(dbTablespaceList(db.primary)), "", "check tablespace list");
// Stop backup
HRN_PQ_SCRIPT_SET(HRN_PQ_SCRIPT_STOP_BACKUP_LE_95(1, "2/4", "000000010000000200000004"));
DbBackupStopResult backupStopResult = {.lsn = NULL};
TEST_ASSIGN(backupStopResult, dbBackupStop(db.primary), "stop backup");
TEST_RESULT_STR_Z(backupStopResult.lsn, "2/4", "check lsn");
@ -312,6 +312,8 @@ testRun(void)
TEST_RESULT_STR_Z(backupStopResult.backupLabel, NULL, "check backup label is not set");
TEST_RESULT_STR_Z(backupStopResult.tablespaceMap, NULL, "check tablespace map is not set");
// Close primary
HRN_PQ_SCRIPT_SET(HRN_PQ_SCRIPT_CLOSE(1));
TEST_RESULT_VOID(dbFree(db.primary), "free primary");
// -------------------------------------------------------------------------------------------------------------------------
@ -319,11 +321,14 @@ testRun(void)
HRN_PG_CONTROL_PUT(storagePgIdxWrite(0), PG_VERSION_95, .checkpoint = pgLsnFromStr(STRDEF("2/5")));
// Connect to primary
HRN_PQ_SCRIPT_SET(
// Connect to primary
HRN_PQ_SCRIPT_OPEN_GE_93(1, "dbname='backupdb' port=5432", PG_VERSION_95, TEST_PATH "/pg1", false, NULL, NULL),
HRN_PQ_SCRIPT_OPEN_GE_93(1, "dbname='backupdb' port=5432", PG_VERSION_95, TEST_PATH "/pg1", false, NULL, NULL));
// Start backup when backup is in progress
TEST_ASSIGN(db, dbGet(true, true, false), "get primary");
// Start backup when backup is in progress
HRN_PQ_SCRIPT_SET(
HRN_PQ_SCRIPT_ADVISORY_LOCK(1, true),
HRN_PQ_SCRIPT_IS_IN_BACKUP(1, true),
@ -331,15 +336,7 @@ testRun(void)
HRN_PQ_SCRIPT_STOP_BACKUP_LE_95(1, "1/1", "000000010000000100000001"),
// Start backup
HRN_PQ_SCRIPT_START_BACKUP_LE_95(1, true, "2/5", "000000010000000200000005"),
// Stop backup
HRN_PQ_SCRIPT_STOP_BACKUP_LE_95(1, "2/6", "000000010000000200000006"),
// Close primary
HRN_PQ_SCRIPT_CLOSE(1));
TEST_ASSIGN(db, dbGet(true, true, false), "get primary");
HRN_PQ_SCRIPT_START_BACKUP_LE_95(1, true, "2/5", "000000010000000200000005"));
TEST_RESULT_STR_Z(dbBackupStart(db.primary, true, true, false).lsn, "2/5", "start backup");
@ -347,8 +344,12 @@ testRun(void)
"P00 WARN: the cluster is already in backup mode but no pgBackRest backup process is running."
" pg_stop_backup() will be called so a new backup can be started.");
// Stop backup
HRN_PQ_SCRIPT_SET(HRN_PQ_SCRIPT_STOP_BACKUP_LE_95(1, "2/6", "000000010000000200000006"));
TEST_RESULT_STR_Z(dbBackupStop(db.primary).lsn, "2/6", "stop backup");
// Close primary
HRN_PQ_SCRIPT_SET(HRN_PQ_SCRIPT_CLOSE(1));
TEST_RESULT_VOID(dbFree(db.primary), "free primary");
// -------------------------------------------------------------------------------------------------------------------------
@ -356,50 +357,53 @@ testRun(void)
HRN_PG_CONTROL_PUT(storagePgIdxWrite(0), PG_VERSION_96, .checkpoint = pgLsnFromStr(STRDEF("3/3")));
// Connect to primary
HRN_PQ_SCRIPT_SET(
// Connect to primary
HRN_PQ_SCRIPT_OPEN_GE_96(1, "dbname='backupdb' port=5432", PG_VERSION_96, TEST_PATH "/pg1", false, NULL, NULL),
// Start backup with timeline error
HRN_PQ_SCRIPT_ADVISORY_LOCK(1, true),
HRN_PQ_SCRIPT_CURRENT_WAL_LE_96(1, "000000020000000300000002"),
HRN_PQ_SCRIPT_START_BACKUP_96(1, false, "3/3", "000000020000000300000003"),
// Start backup with checkpoint error
HRN_PQ_SCRIPT_ADVISORY_LOCK(1, true),
HRN_PQ_SCRIPT_CURRENT_WAL_LE_96(1, "000000010000000400000003"),
HRN_PQ_SCRIPT_START_BACKUP_96(1, false, "4/4", "000000010000000400000004"),
// Start backup
HRN_PQ_SCRIPT_ADVISORY_LOCK(1, true),
HRN_PQ_SCRIPT_CURRENT_WAL_LE_96(1, "000000010000000300000002"),
HRN_PQ_SCRIPT_START_BACKUP_96(1, false, "3/3", "000000010000000300000003"),
// Stop backup
HRN_PQ_SCRIPT_STOP_BACKUP_96(1, "3/4", "000000010000000300000004", false),
// Close primary
HRN_PQ_SCRIPT_CLOSE(1));
HRN_PQ_SCRIPT_OPEN_GE_96(1, "dbname='backupdb' port=5432", PG_VERSION_96, TEST_PATH "/pg1", false, NULL, NULL));
TEST_ASSIGN(db, dbGet(true, true, false), "get primary");
// Start backup with timeline error
HRN_PQ_SCRIPT_SET(
HRN_PQ_SCRIPT_ADVISORY_LOCK(1, true),
HRN_PQ_SCRIPT_CURRENT_WAL_LE_96(1, "000000020000000300000002"),
HRN_PQ_SCRIPT_START_BACKUP_96(1, false, "3/3", "000000020000000300000003"));
TEST_ERROR(
dbBackupStart(db.primary, false, true, true), DbMismatchError, "WAL timeline 2 does not match pg_control timeline 1");
// Start backup with checkpoint error
HRN_PQ_SCRIPT_SET(
HRN_PQ_SCRIPT_ADVISORY_LOCK(1, true),
HRN_PQ_SCRIPT_CURRENT_WAL_LE_96(1, "000000010000000400000003"),
HRN_PQ_SCRIPT_START_BACKUP_96(1, false, "4/4", "000000010000000400000004"));
TEST_ERROR(
dbBackupStart(db.primary, false, true, true), DbMismatchError,
"current checkpoint '3/3' is less than backup start '4/4'");
// Start backup
HRN_PQ_SCRIPT_SET(
HRN_PQ_SCRIPT_ADVISORY_LOCK(1, true),
HRN_PQ_SCRIPT_CURRENT_WAL_LE_96(1, "000000010000000300000002"),
HRN_PQ_SCRIPT_START_BACKUP_96(1, false, "3/3", "000000010000000300000003"));
TEST_ASSIGN(backupStartResult, dbBackupStart(db.primary, false, true, true), "start backup");
TEST_RESULT_STR_Z(backupStartResult.lsn, "3/3", "check lsn");
TEST_RESULT_STR_Z(backupStartResult.walSegmentName, "000000010000000300000003", "check wal segment name");
TEST_RESULT_STR_Z(backupStartResult.walSegmentCheck, "000000010000000300000002", "check wal segment check");
// Stop backup
HRN_PQ_SCRIPT_SET(HRN_PQ_SCRIPT_STOP_BACKUP_96(1, "3/4", "000000010000000300000004", false));
TEST_ASSIGN(backupStopResult, dbBackupStop(db.primary), "stop backup");
TEST_RESULT_STR_Z(backupStopResult.lsn, "3/4", "check lsn");
TEST_RESULT_STR_Z(backupStopResult.walSegmentName, "000000010000000300000004", "check wal segment name");
TEST_RESULT_STR_Z(backupStopResult.backupLabel, "BACKUP_LABEL_DATA", "check backup label");
TEST_RESULT_STR_Z(backupStopResult.tablespaceMap, NULL, "check tablespace map is not set");
// Close primary
HRN_PQ_SCRIPT_SET(HRN_PQ_SCRIPT_CLOSE(1));
TEST_RESULT_VOID(dbFree(db.primary), "free primary");
// -------------------------------------------------------------------------------------------------------------------------
@ -417,58 +421,58 @@ testRun(void)
HRN_PG_CONTROL_PUT(storagePgIdxWrite(0), PG_VERSION_95, .timeline = 5, .checkpoint = pgLsnFromStr(STRDEF("5/4")));
HRN_PG_CONTROL_PUT(storagePgIdxWrite(1), PG_VERSION_95, .timeline = 5, .checkpoint = pgLsnFromStr(STRDEF("5/4")));
// Connect to primary and standby
HRN_PQ_SCRIPT_SET(
// Connect to primary
HRN_PQ_SCRIPT_OPEN_GE_93(1, "dbname='postgres' port=5432", PG_VERSION_95, TEST_PATH "/pg1", false, NULL, NULL),
// Connect to standby
HRN_PQ_SCRIPT_OPEN_GE_93(2, "dbname='postgres' port=5433", PG_VERSION_95, TEST_PATH "/pg2", true, NULL, NULL),
// Start backup
HRN_PQ_SCRIPT_ADVISORY_LOCK(1, true),
HRN_PQ_SCRIPT_START_BACKUP_LE_95(1, false, "5/4", "000000050000000500000004"),
// Wait for standby to sync
HRN_PQ_SCRIPT_REPLAY_WAIT_LE_95(2, "5/4"),
// Ping
HRN_PQ_SCRIPT_IS_STANDBY_QUERY(1, true),
HRN_PQ_SCRIPT_IS_STANDBY_QUERY(1, false),
HRN_PQ_SCRIPT_IS_STANDBY_QUERY(1, false),
HRN_PQ_SCRIPT_IS_STANDBY_QUERY(2, false),
HRN_PQ_SCRIPT_IS_STANDBY_QUERY(2, true),
HRN_PQ_SCRIPT_IS_STANDBY_QUERY(2, true),
HRN_PQ_SCRIPT_IS_STANDBY_QUERY(2, true),
// Close standby
HRN_PQ_SCRIPT_CLOSE(2),
// Close primary
HRN_PQ_SCRIPT_CLOSE(1));
HRN_PQ_SCRIPT_OPEN_GE_93(2, "dbname='postgres' port=5433", PG_VERSION_95, TEST_PATH "/pg2", true, NULL, NULL));
TEST_ASSIGN(db, dbGet(false, true, true), "get primary and standby");
// Start backup
HRN_PQ_SCRIPT_SET(
HRN_PQ_SCRIPT_ADVISORY_LOCK(1, true),
HRN_PQ_SCRIPT_START_BACKUP_LE_95(1, false, "5/4", "000000050000000500000004"));
TEST_RESULT_STR_Z(dbBackupStart(db.primary, false, false, false).lsn, "5/4", "start backup");
// Wait for standby to sync
HRN_PQ_SCRIPT_SET(HRN_PQ_SCRIPT_REPLAY_WAIT_LE_95(2, "5/4"));
TEST_RESULT_VOID(dbReplayWait(db.standby, STRDEF("5/4"), dbPgControl(db.primary).timeline, 1000), "sync standby");
// Ping
HRN_PQ_SCRIPT_SET(HRN_PQ_SCRIPT_IS_STANDBY_QUERY(1, true));
TEST_ERROR(dbPing(db.primary, false), AssertError, "primary has switched to recovery");
HRN_PQ_SCRIPT_SET(HRN_PQ_SCRIPT_IS_STANDBY_QUERY(1, false));
TEST_RESULT_VOID(dbPing(db.primary, false), "ping primary cluster");
TEST_RESULT_VOID(dbPing(db.primary, false), "ping primary cluster (noop)");
HRN_PQ_SCRIPT_SET(HRN_PQ_SCRIPT_IS_STANDBY_QUERY(1, false));
TEST_RESULT_VOID(dbPing(db.primary, true), "ping primary cluster (force)");
HRN_PQ_SCRIPT_SET(HRN_PQ_SCRIPT_IS_STANDBY_QUERY(2, false));
TEST_ERROR(
dbPing(db.standby, false), DbMismatchError,
"standby is no longer in recovery\n"
"HINT: was the standby promoted during the backup?");
HRN_PQ_SCRIPT_SET(HRN_PQ_SCRIPT_IS_STANDBY_QUERY(2, true));
TEST_RESULT_VOID(dbPing(db.standby, false), "ping standby cluster");
TEST_RESULT_VOID(dbPing(db.standby, false), "ping standby cluster (noop)");
HRN_PQ_SCRIPT_SET(HRN_PQ_SCRIPT_IS_STANDBY_QUERY(2, true));
TEST_RESULT_VOID(dbPing(db.standby, true), "ping standby cluster (force)");
db.standby->pingTimeLast -= DB_PING_SEC * 2;
HRN_PQ_SCRIPT_SET(HRN_PQ_SCRIPT_IS_STANDBY_QUERY(2, true));
TEST_RESULT_VOID(dbPing(db.standby, false), "ping standby cluster");
// Close primary and standby
HRN_PQ_SCRIPT_SET(HRN_PQ_SCRIPT_CLOSE(2));
TEST_RESULT_VOID(dbFree(db.standby), "free standby");
HRN_PQ_SCRIPT_SET(HRN_PQ_SCRIPT_CLOSE(1));
TEST_RESULT_VOID(dbFree(db.primary), "free primary");
// -------------------------------------------------------------------------------------------------------------------------
@ -478,23 +482,36 @@ testRun(void)
HRN_PG_CONTROL_PUT(storagePgIdxWrite(0), PG_VERSION_10, .timeline = 5, .checkpoint = pgLsnFromStr(STRDEF("5/5")));
HRN_PG_CONTROL_PUT(storagePgIdxWrite(1), PG_VERSION_10, .timeline = 5, .checkpoint = pgLsnFromStr(STRDEF("5/5")));
// Connect to primary and standby
HRN_PQ_SCRIPT_SET(
// Connect to primary
HRN_PQ_SCRIPT_OPEN_GE_96(1, "dbname='postgres' port=5432", PG_VERSION_10, TEST_PATH "/pg1", false, NULL, NULL),
HRN_PQ_SCRIPT_OPEN_GE_96(2, "dbname='postgres' port=5433", PG_VERSION_10, TEST_PATH "/pg2", true, NULL, NULL));
// Connect to standby
HRN_PQ_SCRIPT_OPEN_GE_96(2, "dbname='postgres' port=5433", PG_VERSION_10, TEST_PATH "/pg2", true, NULL, NULL),
TEST_ASSIGN(db, dbGet(false, true, true), "get primary and standby");
// Start backup
TEST_RESULT_UINT(dbPgControl(db.primary).timeline, 5, "check primary timeline");
TEST_RESULT_UINT(dbPgControl(db.standby).timeline, 5, "check standby timeline");
// Start backup
HRN_PQ_SCRIPT_SET(
HRN_PQ_SCRIPT_ADVISORY_LOCK(1, true),
HRN_PQ_SCRIPT_CURRENT_WAL_GE_10(1, "000000050000000500000005"),
HRN_PQ_SCRIPT_START_BACKUP_GE_10(1, false, "5/5", "000000050000000500000005"),
// Switch WAL segment so it can be checked
HRN_PQ_SCRIPT_CREATE_RESTORE_POINT(1, "5/5"),
HRN_PQ_SCRIPT_WAL_SWITCH(1, "wal", "000000050000000500000005"),
HRN_PQ_SCRIPT_WAL_SWITCH(1, "wal", "000000050000000500000005"));
// Standby returns NULL lsn
TEST_ASSIGN(backupStartResult, dbBackupStart(db.primary, false, false, true), "start backup");
TEST_RESULT_STR_Z(backupStartResult.lsn, "5/5", "check lsn");
TEST_RESULT_STR_Z(backupStartResult.walSegmentName, "000000050000000500000005", "check wal segment name");
TEST_RESULT_STR_Z(backupStartResult.walSegmentCheck, "000000050000000500000005", "check wal segment check");
TEST_ERROR(
dbReplayWait(db.standby, STRDEF("4/4"), 5, 1000), DbMismatchError, "standby checkpoint '5/5' is ahead of target '4/4'");
// Standby returns NULL lsn
HRN_PQ_SCRIPT_SET(
{.session = 2, .function = HRN_PQ_SENDQUERY,
.param =
"[\"select replayLsn::text,\\n"
@ -513,85 +530,73 @@ testRun(void)
{.session = 2, .function = HRN_PQ_GETISNULL, .param = "[0,0]", .resultInt = 1},
{.session = 2, .function = HRN_PQ_GETVALUE, .param = "[0,1]", .resultZ = "false"},
{.session = 2, .function = HRN_PQ_CLEAR},
{.session = 2, .function = HRN_PQ_GETRESULT, .resultNull = true},
// Timeout waiting for sync
HRN_PQ_SCRIPT_REPLAY_TARGET_REACHED_GE_10(2, "5/5", false, "5/3"),
HRN_PQ_SCRIPT_REPLAY_TARGET_REACHED_PROGRESS_GE_10(2, "5/5", false, "5/3", "5/3", false, 100),
HRN_PQ_SCRIPT_REPLAY_TARGET_REACHED_PROGRESS_GE_10(2, "5/5", false, "5/3", "5/3", false, 100),
// Checkpoint target timeout waiting for sync
HRN_PQ_SCRIPT_REPLAY_TARGET_REACHED_GE_10(2, "5/5", true, "5/5"),
HRN_PQ_SCRIPT_CHECKPOINT(2),
HRN_PQ_SCRIPT_CHECKPOINT_TARGET_REACHED_GE_10(2, "5/5", false, "5/4", 100),
HRN_PQ_SCRIPT_CHECKPOINT_TARGET_REACHED_GE_10(2, "5/5", false, "5/4", 100),
HRN_PQ_SCRIPT_CHECKPOINT_TARGET_REACHED_GE_10(2, "5/5", false, "5/4", 100),
// Wait for standby to sync
HRN_PQ_SCRIPT_REPLAY_TARGET_REACHED_GE_10(2, "5/5", false, "5/3"),
HRN_PQ_SCRIPT_REPLAY_TARGET_REACHED_PROGRESS_GE_10(2, "5/5", false, "5/3", "5/3", false, 0),
HRN_PQ_SCRIPT_REPLAY_TARGET_REACHED_PROGRESS_GE_10(2, "5/5", false, "5/4", "5/3", true, 0),
HRN_PQ_SCRIPT_REPLAY_TARGET_REACHED_PROGRESS_GE_10(2, "5/5", true, "5/5", "5/4", true, 0),
HRN_PQ_SCRIPT_CHECKPOINT(2),
HRN_PQ_SCRIPT_CHECKPOINT_TARGET_REACHED_GE_10(2, "5/5", true, "X/X", 0),
// Fail on timeline mismatch
HRN_PQ_SCRIPT_REPLAY_TARGET_REACHED_GE_10(2, "5/5", false, "5/3"),
HRN_PQ_SCRIPT_REPLAY_TARGET_REACHED_PROGRESS_GE_10(2, "5/5", false, "5/3", "5/3", false, 0),
HRN_PQ_SCRIPT_REPLAY_TARGET_REACHED_PROGRESS_GE_10(2, "5/5", false, "5/4", "5/3", true, 0),
HRN_PQ_SCRIPT_REPLAY_TARGET_REACHED_PROGRESS_GE_10(2, "5/5", true, "5/5", "5/4", true, 0),
HRN_PQ_SCRIPT_CHECKPOINT(2),
HRN_PQ_SCRIPT_CHECKPOINT_TARGET_REACHED_GE_10(2, "5/5", true, "X/X", 0),
// Close standby
HRN_PQ_SCRIPT_CLOSE(2),
// Stop backup
HRN_PQ_SCRIPT_STOP_BACKUP_GE_10(1, "5/6", "000000050000000500000006", true),
// Close primary
HRN_PQ_SCRIPT_CLOSE(1));
TEST_ASSIGN(db, dbGet(false, true, true), "get primary and standby");
TEST_RESULT_UINT(dbPgControl(db.primary).timeline, 5, "check primary timeline");
TEST_RESULT_UINT(dbPgControl(db.standby).timeline, 5, "check standby timeline");
TEST_ASSIGN(backupStartResult, dbBackupStart(db.primary, false, false, true), "start backup");
TEST_RESULT_STR_Z(backupStartResult.lsn, "5/5", "check lsn");
TEST_RESULT_STR_Z(backupStartResult.walSegmentName, "000000050000000500000005", "check wal segment name");
TEST_RESULT_STR_Z(backupStartResult.walSegmentCheck, "000000050000000500000005", "check wal segment check");
TEST_ERROR(
dbReplayWait(db.standby, STRDEF("4/4"), 5, 1000), DbMismatchError, "standby checkpoint '5/5' is ahead of target '4/4'");
{.session = 2, .function = HRN_PQ_GETRESULT, .resultNull = true});
TEST_ERROR(
dbReplayWait(db.standby, STRDEF("5/5"), dbPgControl(db.primary).timeline, 1000), ArchiveTimeoutError,
"unable to query replay lsn on the standby using 'pg_catalog.pg_last_wal_replay_lsn()'\n"
"HINT: Is this a standby?");
// Timeout waiting for sync
HRN_PQ_SCRIPT_SET(
HRN_PQ_SCRIPT_REPLAY_TARGET_REACHED_GE_10(2, "5/5", false, "5/3"),
HRN_PQ_SCRIPT_REPLAY_TARGET_REACHED_PROGRESS_GE_10(2, "5/5", false, "5/3", "5/3", false, 100),
HRN_PQ_SCRIPT_REPLAY_TARGET_REACHED_PROGRESS_GE_10(2, "5/5", false, "5/3", "5/3", false, 100));
TEST_ERROR(
dbReplayWait(db.standby, STRDEF("5/5"), dbPgControl(db.primary).timeline, 200), ArchiveTimeoutError,
"timeout before standby replayed to 5/5 - only reached 5/3\n"
"HINT: is replication running and current on the standby?\n"
"HINT: disable the 'backup-standby' option to backup directly from the primary.");
// Checkpoint target timeout waiting for sync
HRN_PQ_SCRIPT_SET(
HRN_PQ_SCRIPT_REPLAY_TARGET_REACHED_GE_10(2, "5/5", true, "5/5"),
HRN_PQ_SCRIPT_CHECKPOINT(2),
HRN_PQ_SCRIPT_CHECKPOINT_TARGET_REACHED_GE_10(2, "5/5", false, "5/4", 100),
HRN_PQ_SCRIPT_CHECKPOINT_TARGET_REACHED_GE_10(2, "5/5", false, "5/4", 100),
HRN_PQ_SCRIPT_CHECKPOINT_TARGET_REACHED_GE_10(2, "5/5", false, "5/4", 100));
TEST_ERROR(
dbReplayWait(db.standby, STRDEF("5/5"), dbPgControl(db.primary).timeline, 200), ArchiveTimeoutError,
"timeout before standby checkpoint lsn reached 5/5 - only reached 5/4");
// Wait for standby to sync
HRN_PQ_SCRIPT_SET(
HRN_PQ_SCRIPT_REPLAY_TARGET_REACHED_GE_10(2, "5/5", false, "5/3"),
HRN_PQ_SCRIPT_REPLAY_TARGET_REACHED_PROGRESS_GE_10(2, "5/5", false, "5/3", "5/3", false, 0),
HRN_PQ_SCRIPT_REPLAY_TARGET_REACHED_PROGRESS_GE_10(2, "5/5", false, "5/4", "5/3", true, 0),
HRN_PQ_SCRIPT_REPLAY_TARGET_REACHED_PROGRESS_GE_10(2, "5/5", true, "5/5", "5/4", true, 0),
HRN_PQ_SCRIPT_CHECKPOINT(2),
HRN_PQ_SCRIPT_CHECKPOINT_TARGET_REACHED_GE_10(2, "5/5", true, "X/X", 0));
TEST_RESULT_VOID(dbReplayWait(db.standby, STRDEF("5/5"), dbPgControl(db.primary).timeline, 1000), "sync standby");
// Update timeline to demonstrate that it is reloaded in dbReplayWait()
HRN_PG_CONTROL_PUT(storagePgIdxWrite(1), PG_VERSION_10, .timeline = 6, .checkpoint = pgLsnFromStr(STRDEF("5/5")));
// Fail on timeline mismatch
HRN_PQ_SCRIPT_SET(
HRN_PQ_SCRIPT_REPLAY_TARGET_REACHED_GE_10(2, "5/5", false, "5/3"),
HRN_PQ_SCRIPT_REPLAY_TARGET_REACHED_PROGRESS_GE_10(2, "5/5", false, "5/3", "5/3", false, 0),
HRN_PQ_SCRIPT_REPLAY_TARGET_REACHED_PROGRESS_GE_10(2, "5/5", false, "5/4", "5/3", true, 0),
HRN_PQ_SCRIPT_REPLAY_TARGET_REACHED_PROGRESS_GE_10(2, "5/5", true, "5/5", "5/4", true, 0),
HRN_PQ_SCRIPT_CHECKPOINT(2),
HRN_PQ_SCRIPT_CHECKPOINT_TARGET_REACHED_GE_10(2, "5/5", true, "X/X", 0));
TEST_ERROR(
dbReplayWait(db.standby, STRDEF("5/5"), 77, 1000), DbMismatchError, "standby is on timeline 6 but expected 77");
// Close standby
HRN_PQ_SCRIPT_SET(HRN_PQ_SCRIPT_CLOSE(2));
TEST_RESULT_VOID(dbFree(db.standby), "free standby");
// Stop backup
HRN_PQ_SCRIPT_SET(HRN_PQ_SCRIPT_STOP_BACKUP_GE_10(1, "5/6", "000000050000000500000006", true));
TEST_RESULT_STR_Z(dbBackupStop(db.primary).tablespaceMap, "TABLESPACE_MAP_DATA", "stop backup");
// Close primary
HRN_PQ_SCRIPT_SET(HRN_PQ_SCRIPT_CLOSE(1));
TEST_RESULT_VOID(dbFree(db.primary), "free primary");
// -------------------------------------------------------------------------------------------------------------------------
@ -605,25 +610,26 @@ testRun(void)
hrnCfgArgRawZ(argList, cfgOptDbTimeout, "299");
HRN_CFG_LOAD(cfgCmdBackup, argList);
// Connect to primary
HRN_PQ_SCRIPT_SET(
// Connect to primary
HRN_PQ_SCRIPT_OPEN_GE_96(1, "dbname='postgres' port=5432", PG_VERSION_14, TEST_PATH "/pg1", false, NULL, NULL),
// Start backup
HRN_PQ_SCRIPT_ADVISORY_LOCK(1, true),
HRN_PQ_SCRIPT_CURRENT_WAL_GE_10(1, "000000050000000500000004"),
HRN_PQ_SCRIPT_START_BACKUP_GE_10(1, false, "5/5", "000000050000000500000005"),
// Close primary
HRN_PQ_SCRIPT_CLOSE(1));
HRN_PQ_SCRIPT_OPEN_GE_96(1, "dbname='postgres' port=5432", PG_VERSION_14, TEST_PATH "/pg1", false, NULL, NULL));
TEST_ASSIGN(db, dbGet(true, true, false), "get primary");
// Start backup
HRN_PQ_SCRIPT_SET(
HRN_PQ_SCRIPT_ADVISORY_LOCK(1, true),
HRN_PQ_SCRIPT_CURRENT_WAL_GE_10(1, "000000050000000500000004"),
HRN_PQ_SCRIPT_START_BACKUP_GE_10(1, false, "5/5", "000000050000000500000005"));
TEST_ASSIGN(backupStartResult, dbBackupStart(db.primary, false, false, true), "start backup");
TEST_RESULT_LOG(
"P00 WARN: start-fast is disabled and db-timeout (299s) is smaller than the PostgreSQL checkpoint_timeout (300s) -"
" timeout may occur before the backup starts");
// Close primary
HRN_PQ_SCRIPT_SET(HRN_PQ_SCRIPT_CLOSE(1));
TEST_RESULT_VOID(dbFree(db.primary), "free primary");
// -------------------------------------------------------------------------------------------------------------------------
@ -637,27 +643,26 @@ testRun(void)
hrnCfgArgKeyRawZ(argList, cfgOptPgPath, 1, TEST_PATH "/pg1");
HRN_CFG_LOAD(cfgCmdBackup, argList);
// Connect to primary
HRN_PQ_SCRIPT_SET(
// Connect to primary
HRN_PQ_SCRIPT_OPEN_GE_96(1, "dbname='postgres' port=5432", PG_VERSION_15, TEST_PATH "/pg1", false, NULL, NULL),
// Start backup
HRN_PQ_SCRIPT_ADVISORY_LOCK(1, true),
HRN_PQ_SCRIPT_CURRENT_WAL_GE_10(1, "000000060000000600000005"),
HRN_PQ_SCRIPT_START_BACKUP_GE_15(1, false, "6/6", "000000060000000600000006"),
// Stop backup
HRN_PQ_SCRIPT_STOP_BACKUP_GE_15(1, "6/7", "000000060000000600000006", false),
// Close primary
HRN_PQ_SCRIPT_CLOSE(1));
HRN_PQ_SCRIPT_OPEN_GE_96(1, "dbname='postgres' port=5432", PG_VERSION_15, TEST_PATH "/pg1", false, NULL, NULL));
TEST_ASSIGN(db, dbGet(true, true, false), "get primary");
// Start backup
HRN_PQ_SCRIPT_SET(
HRN_PQ_SCRIPT_ADVISORY_LOCK(1, true),
HRN_PQ_SCRIPT_CURRENT_WAL_GE_10(1, "000000060000000600000005"),
HRN_PQ_SCRIPT_START_BACKUP_GE_15(1, false, "6/6", "000000060000000600000006"));
TEST_ASSIGN(backupStartResult, dbBackupStart(db.primary, false, false, true), "start backup");
TEST_RESULT_STR_Z(backupStartResult.lsn, "6/6", "check lsn");
TEST_RESULT_STR_Z(backupStartResult.walSegmentName, "000000060000000600000006", "check wal segment name");
TEST_RESULT_STR_Z(backupStartResult.walSegmentCheck, "000000060000000600000005", "check wal segment check");
// Stop backup
HRN_PQ_SCRIPT_SET(HRN_PQ_SCRIPT_STOP_BACKUP_GE_15(1, "6/7", "000000060000000600000006", false));
backupStopResult = (DbBackupStopResult){.lsn = NULL};
TEST_ASSIGN(backupStopResult, dbBackupStop(db.primary), "stop backup");
TEST_RESULT_STR_Z(backupStopResult.lsn, "6/7", "check lsn");
@ -665,6 +670,8 @@ testRun(void)
TEST_RESULT_STR_Z(backupStopResult.backupLabel, "BACKUP_LABEL_DATA", "check backup label");
TEST_RESULT_STR_Z(backupStopResult.tablespaceMap, NULL, "check tablespace map is not set");
// Close primary
HRN_PQ_SCRIPT_SET(HRN_PQ_SCRIPT_CLOSE(1));
TEST_RESULT_VOID(dbFree(db.primary), "free primary");
}