[PBCKP-232] remove 9.5-9.6 support, part 2

Author: kulaginm

.travis.yml

@@ -32,8 +32,6 @@ env:
     - PG_VERSION=12 PG_BRANCH=REL_12_STABLE PTRACK_PATCH_PG_BRANCH=REL_12_STABLE
     - PG_VERSION=11 PG_BRANCH=REL_11_STABLE PTRACK_PATCH_PG_BRANCH=REL_11_STABLE
     - PG_VERSION=10 PG_BRANCH=REL_10_STABLE
-    - PG_VERSION=9.6 PG_BRANCH=REL9_6_STABLE
-    - PG_VERSION=9.5 PG_BRANCH=REL9_5_STABLE
 #    - PG_VERSION=13 PG_BRANCH=REL_13_STABLE PTRACK_PATCH_PG_BRANCH=OFF MODE=archive
 #    - PG_VERSION=13 PG_BRANCH=REL_13_STABLE PTRACK_PATCH_PG_BRANCH=REL_13_STABLE MODE=backup
 #    - PG_VERSION=13 PG_BRANCH=REL_13_STABLE PTRACK_PATCH_PG_BRANCH=REL_13_STABLE MODE=catchup
@@ -52,8 +50,6 @@ env:
 jobs:
     allow_failures:
         - if: env(PG_BRANCH) = master
-        - if: env(PG_BRANCH) = REL9_6_STABLE
-        - if: env(PG_BRANCH) = REL9_5_STABLE
 #        - if: env(MODE) IN (archive, backup, delta, locking, merge, replica, retention, restore)
 
 # Only run CI for master branch commits to limit our travis usage

src/backup.c

@@ -32,9 +32,6 @@ parray *backup_files_list = NULL;
 /* We need critical section for datapagemap_add() in case of using threads */
 static pthread_mutex_t backup_pagemap_mutex = PTHREAD_MUTEX_INITIALIZER;
 
-// TODO: move to PGnodeInfo
-bool exclusive_backup = false;
-
 /* Is pg_start_backup() was executed */
 bool backup_in_progress = false;
 
@@ -80,7 +77,7 @@ backup_stopbackup_callback(bool fatal, void *userdata)
 	{
 		elog(WARNING, "backup in progress, stop backup");
 		/* don't care about stop_lsn in case of error */
-		pg_stop_backup_send(st->conn, st->server_version, current.from_replica, exclusive_backup, NULL);
+		pg_stop_backup_send(st->conn, st->server_version, current.from_replica, NULL);
 	}
 }
 
@@ -493,10 +490,10 @@ do_backup_pg(InstanceState *instanceState, PGconn *backup_conn,
 	/* Notify end of backup */
 	pg_stop_backup(instanceState, &current, backup_conn, nodeInfo);
 
-	/* In case of backup from replica >= 9.6 we must fix minRecPoint,
+	/* In case of backup from replica we must fix minRecPoint,
 	 * First we must find pg_control in backup_files_list.
 	 */
-	if (current.from_replica && !exclusive_backup)
+	if (current.from_replica)
 	{
 		pgFile	   *pg_control = NULL;
 
@@ -781,11 +778,6 @@ do_backup(InstanceState *instanceState, pgSetBackupParams *set_backup_params,
 		}
 	}
 
-	if (current.from_replica && exclusive_backup)
-		/* Check master connection options */
-		if (instance_config.master_conn_opt.pghost == NULL)
-			elog(ERROR, "Options for connection to master must be provided to perform backup from replica");
-
 	/* add note to backup if requested */
 	if (set_backup_params && set_backup_params->note)
 		add_note(&current, set_backup_params->note);
@@ -866,22 +858,12 @@ check_server_version(PGconn *conn, PGNodeInfo *nodeInfo)
 		elog(ERROR, "Unknown server version %d", nodeInfo->server_version);
 
 	if (nodeInfo->server_version < 100000)
-		sprintf(nodeInfo->server_version_str, "%d.%d",
-				nodeInfo->server_version / 10000,
-				(nodeInfo->server_version / 100) % 100);
-	else
-		sprintf(nodeInfo->server_version_str, "%d",
-				nodeInfo->server_version / 10000);
-
-	if (nodeInfo->server_version < 90500)
 		elog(ERROR,
 			 "server version is %s, must be %s or higher",
-			 nodeInfo->server_version_str, "9.5");
+			 nodeInfo->server_version_str, "10");
 
-	if (current.from_replica && nodeInfo->server_version < 90600)
-		elog(ERROR,
-			 "server version is %s, must be %s or higher for backup from replica",
-			 nodeInfo->server_version_str, "9.6");
+	sprintf(nodeInfo->server_version_str, "%d",
+			nodeInfo->server_version / 10000);
 
 	if (nodeInfo->pgpro_support)
 		res = pgut_execute(conn, "SELECT pg_catalog.pgpro_edition()", 0, NULL);
@@ -922,9 +904,6 @@ check_server_version(PGconn *conn, PGNodeInfo *nodeInfo)
 
 	if (res)
 		PQclear(res);
-
-	/* Do exclusive backup only for PostgreSQL 9.5 */
-	exclusive_backup = nodeInfo->server_version < 90600;
 }
 
 /*
@@ -1006,16 +985,10 @@ pg_start_backup(const char *label, bool smooth, pgBackup *backup,
 
 	/* 2nd argument is 'fast'*/
 	params[1] = smooth ? "false" : "true";
-	if (!exclusive_backup)
-		res = pgut_execute(conn,
-						   "SELECT pg_catalog.pg_start_backup($1, $2, false)",
-						   2,
-						   params);
-	else
-		res = pgut_execute(conn,
-						   "SELECT pg_catalog.pg_start_backup($1, $2)",
-						   2,
-						   params);
+	res = pgut_execute(conn,
+					   "SELECT pg_catalog.pg_start_backup($1, $2, false)",
+					   2,
+					   params);
 
 	/*
 	 * Set flag that pg_start_backup() was called. If an error will happen it
@@ -1034,14 +1007,10 @@ pg_start_backup(const char *label, bool smooth, pgBackup *backup,
 	PQclear(res);
 
 	if ((!backup->stream || backup->backup_mode == BACKUP_MODE_DIFF_PAGE) &&
-		!backup->from_replica &&
-		!(nodeInfo->server_version < 90600 &&
-		  !nodeInfo->is_superuser))
+		!backup->from_replica)
 		/*
 		 * Switch to a new WAL segment. It is necessary to get archived WAL
 		 * segment, which includes start LSN of current backup.
-		 * Don`t do this for replica backups and for PG 9.5 if pguser is not superuser
-		 * (because in 9.5 only superuser can switch WAL)
 		 */
 		pg_switch_wal(conn);
 }
@@ -1546,20 +1515,9 @@ pg_create_restore_point(PGconn *conn, time_t backup_start_time)
 }
 
 void
-pg_stop_backup_send(PGconn *conn, int server_version, bool is_started_on_replica, bool is_exclusive, char **query_text)
+pg_stop_backup_send(PGconn *conn, int server_version, bool is_started_on_replica, char **query_text)
 {
 	static const char
-		stop_exlusive_backup_query[] =
-			/*
-			 * Stop the non-exclusive backup. Besides stop_lsn it returns from
-			 * pg_stop_backup(false) copy of the backup label and tablespace map
-			 * so they can be written to disk by the caller.
-			 * TODO, question: add NULLs as backup_label and tablespace_map?
-			 */
-			"SELECT"
-			" pg_catalog.txid_snapshot_xmax(pg_catalog.txid_current_snapshot()),"
-			" current_timestamp(0)::timestamptz,"
-			" pg_catalog.pg_stop_backup() as lsn",
 		stop_backup_on_master_query[] =
 			"SELECT"
 			" pg_catalog.txid_snapshot_xmax(pg_catalog.txid_current_snapshot()),"
@@ -1568,16 +1526,8 @@ pg_stop_backup_send(PGconn *conn, int server_version, bool is_started_on_replica
 			" labelfile,"
 			" spcmapfile"
 			" FROM pg_catalog.pg_stop_backup(false, false)",
-		stop_backup_on_master_before10_query[] =
-			"SELECT"
-			" pg_catalog.txid_snapshot_xmax(pg_catalog.txid_current_snapshot()),"
-			" current_timestamp(0)::timestamptz,"
-			" lsn,"
-			" labelfile,"
-			" spcmapfile"
-			" FROM pg_catalog.pg_stop_backup(false)",
 		/*
-		 * In case of backup from replica >= 9.6 we do not trust minRecPoint
+		 * In case of backup from replica we do not trust minRecPoint
 		 * and stop_backup LSN, so we use latest replayed LSN as STOP LSN.
 		 */
 		stop_backup_on_replica_query[] =
@@ -1587,28 +1537,12 @@ pg_stop_backup_send(PGconn *conn, int server_version, bool is_started_on_replica
 			" pg_catalog.pg_last_wal_replay_lsn(),"
 			" labelfile,"
 			" spcmapfile"
-			" FROM pg_catalog.pg_stop_backup(false, false)",
-		stop_backup_on_replica_before10_query[] =
-			"SELECT"
-			" pg_catalog.txid_snapshot_xmax(pg_catalog.txid_current_snapshot()),"
-			" current_timestamp(0)::timestamptz,"
-			" pg_catalog.pg_last_xlog_replay_location(),"
-			" labelfile,"
-			" spcmapfile"
-			" FROM pg_catalog.pg_stop_backup(false)";
+			" FROM pg_catalog.pg_stop_backup(false, false)";
 
 	const char * const stop_backup_query =
-		is_exclusive ?
-			stop_exlusive_backup_query :
-			server_version >= 100000 ?
-				(is_started_on_replica ?
+				is_started_on_replica ?
 					stop_backup_on_replica_query :
-					stop_backup_on_master_query
-				) :
-				(is_started_on_replica ?
-					stop_backup_on_replica_before10_query :
-					stop_backup_on_master_before10_query
-				);
+					stop_backup_on_master_query;
 	bool		sent = false;
 
 	/* Make proper timestamp format for parse_time(recovery_time) */
@@ -1641,7 +1575,7 @@ pg_stop_backup_send(PGconn *conn, int server_version, bool is_started_on_replica
  */
 void
 pg_stop_backup_consume(PGconn *conn, int server_version,
-		bool is_exclusive, uint32 timeout, const char *query_text,
+		uint32 timeout, const char *query_text,
 		PGStopBackupResult *result)
 {
 	PGresult	*query_result;
@@ -1743,28 +1677,18 @@ pg_stop_backup_consume(PGconn *conn, int server_version,
 	/* get backup_label_content */
 	result->backup_label_content = NULL;
 	// if (!PQgetisnull(query_result, 0, backup_label_colno))
-	if (!is_exclusive)
-	{
-		result->backup_label_content_len = PQgetlength(query_result, 0, backup_label_colno);
-		if (result->backup_label_content_len > 0)
-			result->backup_label_content = pgut_strndup(PQgetvalue(query_result, 0, backup_label_colno),
-								result->backup_label_content_len);
-	} else {
-		result->backup_label_content_len = 0;
-	}
+	result->backup_label_content_len = PQgetlength(query_result, 0, backup_label_colno);
+	if (result->backup_label_content_len > 0)
+		result->backup_label_content = pgut_strndup(PQgetvalue(query_result, 0, backup_label_colno),
+							result->backup_label_content_len);
 
 	/* get tablespace_map_content */
 	result->tablespace_map_content = NULL;
 	// if (!PQgetisnull(query_result, 0, tablespace_map_colno))
-	if (!is_exclusive)
-	{
-		result->tablespace_map_content_len = PQgetlength(query_result, 0, tablespace_map_colno);
-		if (result->tablespace_map_content_len > 0)
-			result->tablespace_map_content = pgut_strndup(PQgetvalue(query_result, 0, tablespace_map_colno),
-								result->tablespace_map_content_len);
-	} else {
-		result->tablespace_map_content_len = 0;
-	}
+	result->tablespace_map_content_len = PQgetlength(query_result, 0, tablespace_map_colno);
+	if (result->tablespace_map_content_len > 0)
+		result->tablespace_map_content = pgut_strndup(PQgetvalue(query_result, 0, tablespace_map_colno),
+							result->tablespace_map_content_len);
 }
 
 /*
@@ -1832,21 +1756,18 @@ pg_stop_backup(InstanceState *instanceState, pgBackup *backup, PGconn *pg_startb
 
 	/* Create restore point
 	 * Only if backup is from master.
-	 * For PG 9.5 create restore point only if pguser is superuser.
 	 */
-	if (!backup->from_replica &&
-		!(nodeInfo->server_version < 90600 &&
-		  !nodeInfo->is_superuser)) //TODO: check correctness
+	if (!backup->from_replica)
 		pg_create_restore_point(pg_startbackup_conn, backup->start_time);
 
 	/* Execute pg_stop_backup using PostgreSQL connection */
-	pg_stop_backup_send(pg_startbackup_conn, nodeInfo->server_version, backup->from_replica, exclusive_backup, &query_text);
+	pg_stop_backup_send(pg_startbackup_conn, nodeInfo->server_version, backup->from_replica, &query_text);
 
 	/*
 	 * Wait for the result of pg_stop_backup(), but no longer than
 	 * archive_timeout seconds
 	 */
-	pg_stop_backup_consume(pg_startbackup_conn, nodeInfo->server_version, exclusive_backup, timeout, query_text, &stop_backup_result);
+	pg_stop_backup_consume(pg_startbackup_conn, nodeInfo->server_version, timeout, query_text, &stop_backup_result);
 
 	if (backup->stream)
 	{
@@ -1859,28 +1780,25 @@ pg_stop_backup(InstanceState *instanceState, pgBackup *backup, PGconn *pg_startb
 	wait_wal_and_calculate_stop_lsn(xlog_path, stop_backup_result.lsn, backup);
 
 	/* Write backup_label and tablespace_map */
-	if (!exclusive_backup)
+	Assert(stop_backup_result.backup_label_content != NULL);
+
+	/* Write backup_label */
+	pg_stop_backup_write_file_helper(backup->database_dir, PG_BACKUP_LABEL_FILE, "backup label",
+		stop_backup_result.backup_label_content, stop_backup_result.backup_label_content_len,
+		backup_files_list);
+	free(stop_backup_result.backup_label_content);
+	stop_backup_result.backup_label_content = NULL;
+	stop_backup_result.backup_label_content_len = 0;
+
+	/* Write tablespace_map */
+	if (stop_backup_result.tablespace_map_content != NULL)
 	{
-		Assert(stop_backup_result.backup_label_content != NULL);
-
-		/* Write backup_label */
-		pg_stop_backup_write_file_helper(backup->database_dir, PG_BACKUP_LABEL_FILE, "backup label",
-			stop_backup_result.backup_label_content, stop_backup_result.backup_label_content_len,
+		pg_stop_backup_write_file_helper(backup->database_dir, PG_TABLESPACE_MAP_FILE, "tablespace map",
+			stop_backup_result.tablespace_map_content, stop_backup_result.tablespace_map_content_len,
 			backup_files_list);
-		free(stop_backup_result.backup_label_content);
-		stop_backup_result.backup_label_content = NULL;
-		stop_backup_result.backup_label_content_len = 0;
-
-		/* Write tablespace_map */
-		if (stop_backup_result.tablespace_map_content != NULL)
-		{
-			pg_stop_backup_write_file_helper(backup->database_dir, PG_TABLESPACE_MAP_FILE, "tablespace map",
-				stop_backup_result.tablespace_map_content, stop_backup_result.tablespace_map_content_len,
-				backup_files_list);
-			free(stop_backup_result.tablespace_map_content);
-			stop_backup_result.tablespace_map_content = NULL;
-			stop_backup_result.tablespace_map_content_len = 0;
-		}
+		free(stop_backup_result.tablespace_map_content);
+		stop_backup_result.tablespace_map_content = NULL;
+		stop_backup_result.tablespace_map_content_len = 0;
 	}
 
 	if (backup->stream)

src/catchup.c

@@ -185,9 +185,6 @@ catchup_preflight_checks(PGNodeInfo *source_node_info, PGconn *source_conn,
 			elog(ERROR, "Ptrack is disabled");
 	}
 
-	if (current.from_replica && exclusive_backup)
-		elog(ERROR, "Catchup from standby is only available for PostgreSQL >= 9.6");
-
 	/* check that we don't overwrite tablespace in source pgdata */
 	catchup_check_tablespaces_existance_in_tbsmapping(source_conn);
 
@@ -1012,13 +1009,13 @@ do_catchup(const char *source_pgdata, const char *dest_pgdata, int num_threads,
 		pg_silent_client_messages(source_conn);
 
 		/* Execute pg_stop_backup using PostgreSQL connection */
-		pg_stop_backup_send(source_conn, source_node_info.server_version, current.from_replica, exclusive_backup, &stop_backup_query_text);
+		pg_stop_backup_send(source_conn, source_node_info.server_version, current.from_replica, &stop_backup_query_text);
 
 		/*
 		 * Wait for the result of pg_stop_backup(), but no longer than
 		 * archive_timeout seconds
 		 */
-		pg_stop_backup_consume(source_conn, source_node_info.server_version, exclusive_backup, timeout, stop_backup_query_text, &stop_backup_result);
+		pg_stop_backup_consume(source_conn, source_node_info.server_version, timeout, stop_backup_query_text, &stop_backup_result);
 
 		/* Cleanup */
 		pg_free(stop_backup_query_text);
@@ -1076,12 +1073,10 @@ do_catchup(const char *source_pgdata, const char *dest_pgdata, int num_threads,
 	}
 
 	/*
-	 * In case of backup from replica >= 9.6 we must fix minRecPoint
+	 * In case of backup from replica we must fix minRecPoint
 	 */
-	if (current.from_replica && !exclusive_backup)
-	{
+	if (current.from_replica)
 		set_min_recovery_point(source_pg_control_file, dest_pgdata, current.stop_lsn);
-	}
 
 	/* close ssh session in main thread */
 	fio_disconnect();

src/dir.c

@@ -83,11 +83,7 @@ static char *pgdata_exclude_files[] =
 	"probackup_recovery.conf",
 	"recovery.signal",
 	"standby.signal",
-	NULL
-};
 
-static char *pgdata_exclude_files_non_exclusive[] =
-{
 	/*skip in non-exclusive backup */
 	"backup_label",
 	"tablespace_map",
@@ -571,18 +567,6 @@ dir_check_file(pgFile *file, bool backup_logs)
 	/* Check if we need to exclude file by name */
 	if (S_ISREG(file->mode))
 	{
-		if (!exclusive_backup)
-		{
-			for (i = 0; pgdata_exclude_files_non_exclusive[i]; i++)
-				if (strcmp(file->rel_path,
-						   pgdata_exclude_files_non_exclusive[i]) == 0)
-				{
-					/* Skip */
-					elog(VERBOSE, "Excluding file: %s", file->name);
-					return CHECK_FALSE;
-				}
-		}
-
 		for (i = 0; pgdata_exclude_files[i]; i++)
 			if (strcmp(file->rel_path, pgdata_exclude_files[i]) == 0)
 			{