Add tests for --start-time option on the one and few nodes

tests/backup.py

@@ -1,6 +1,6 @@
 import unittest
 import os
-from time import sleep
+from time import sleep, time
 from .helpers.ptrack_helpers import ProbackupTest, ProbackupException
 import shutil
 from distutils.dir_util import copy_tree
@@ -3400,3 +3400,372 @@ class BackupTest(ProbackupTest, unittest.TestCase):
 
         # Clean after yourself
         self.del_test_dir(module_name, fname)
+
+    # @unittest.skip("skip")
+    def test_start_time(self):
+
+        fname = self.id().split('.')[3]
+        node = self.make_simple_node(
+            base_dir=os.path.join(module_name, fname, 'node'),
+            ptrack_enable=self.ptrack,
+            initdb_params=['--data-checksums'])
+
+        backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+        self.init_pb(backup_dir)
+        self.add_instance(backup_dir, 'node', node)
+        self.set_archiving(backup_dir, 'node', node)
+        node.slow_start()
+
+        # FULL backup
+        startTime = int(time())
+        self.backup_node(
+            backup_dir, 'node', node, backup_type="full",
+            options=['--stream', '--start-time', str(startTime)])
+
+        # DELTA backup
+        startTime = int(time())
+        self.backup_node(
+            backup_dir, 'node', node, backup_type="delta",
+            options=['--stream', '--start-time', str(startTime)])
+
+        # PAGE backup
+        startTime = int(time())
+        self.backup_node(
+            backup_dir, 'node', node, backup_type="page",
+            options=['--stream', '--start-time', str(startTime)])
+
+        if self.ptrack and node.major_version > 11:
+            node.safe_psql(
+                "postgres",
+                "create extension ptrack")
+
+            # PTRACK backup
+            startTime = int(time())
+            self.backup_node(
+                backup_dir, 'node', node, backup_type="ptrack",
+                options=['--stream', '--start-time', str(startTime)])
+
+        # Clean after yourself
+        self.del_test_dir(module_name, fname)
+
+    # @unittest.skip("skip")
+    def test_start_time_incorrect_time(self):
+
+        fname = self.id().split('.')[3]
+        node = self.make_simple_node(
+            base_dir=os.path.join(module_name, fname, 'node'),
+            ptrack_enable=self.ptrack,
+            initdb_params=['--data-checksums'])
+
+        backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
+        self.init_pb(backup_dir)
+        self.add_instance(backup_dir, 'node', node)
+        self.set_archiving(backup_dir, 'node', node)
+        node.slow_start()
+
+        startTime = int(time())
+        #backup with correct start time
+        self.backup_node(
+            backup_dir, 'node', node,
+            options=['--stream', '--start-time', str(startTime)])
+        #backups with incorrect start time
+        try:
+            self.backup_node(
+            backup_dir, 'node', node, backup_type="full",
+            options=['--stream', '--start-time', str(startTime-10000)])
+            # we should die here because exception is what we expect to happen
+            self.assertEqual(
+                1, 0,
+                "Expecting Error because start time for new backup must be newer "
+                "\n Output: {0} \n CMD: {1}".format(
+                    repr(self.output), self.cmd))
+        except ProbackupException as e:
+            self.assertRegex(
+                e.message,
+                "ERROR: Cannot create directory for older backup",
+                "\n Unexpected Error Message: {0}\n CMD: {1}".format(
+                    repr(e.message), self.cmd))
+
+        try:
+            self.backup_node(
+            backup_dir, 'node', node, backup_type="delta",
+            options=['--stream', '--start-time', str(startTime-10000)])
+            # we should die here because exception is what we expect to happen
+            self.assertEqual(
+                1, 0,
+                "Expecting Error because start time for new backup must be newer "
+                "\n Output: {0} \n CMD: {1}".format(
+                    repr(self.output), self.cmd))
+        except ProbackupException as e:
+            self.assertRegex(
+                e.message,
+                "ERROR: Cannot create directory for older backup",
+                "\n Unexpected Error Message: {0}\n CMD: {1}".format(
+                    repr(e.message), self.cmd))
+
+        try:
+            self.backup_node(
+            backup_dir, 'node', node, backup_type="page",
+            options=['--stream', '--start-time', str(startTime-10000)])
+            # we should die here because exception is what we expect to happen
+            self.assertEqual(
+                1, 0,
+                "Expecting Error because start time for new backup must be newer "
+                "\n Output: {0} \n CMD: {1}".format(
+                    repr(self.output), self.cmd))
+        except ProbackupException as e:
+            self.assertRegex(
+                e.message,
+                "ERROR: Cannot create directory for older backup",
+                "\n Unexpected Error Message: {0}\n CMD: {1}".format(
+                    repr(e.message), self.cmd))
+
+        if self.ptrack and node.major_version > 11:
+            node.safe_psql(
+                "postgres",
+                "create extension ptrack")
+
+            try:
+                self.backup_node(
+                backup_dir, 'node', node, backup_type="page",
+                options=['--stream', '--start-time', str(startTime-10000)])
+                # we should die here because exception is what we expect to happen
+                self.assertEqual(
+                    1, 0,
+                    "Expecting Error because start time for new backup must be newer "
+                    "\n Output: {0} \n CMD: {1}".format(
+                        repr(self.output), self.cmd))
+            except ProbackupException as e:
+                self.assertRegex(
+                    e.message,
+                    "ERROR: Cannot create directory for older backup",
+                    "\n Unexpected Error Message: {0}\n CMD: {1}".format(
+                        repr(e.message), self.cmd))
+
+        # Clean after yourself
+        self.del_test_dir(module_name, fname)
+
+    # @unittest.skip("skip")
+    def test_start_time_few_nodes(self):
+
+        fname = self.id().split('.')[3]
+        node1 = self.make_simple_node(
+            base_dir=os.path.join(module_name, fname, 'node1'),
+            ptrack_enable=self.ptrack,
+            initdb_params=['--data-checksums'])
+
+        backup_dir1 = os.path.join(self.tmp_path, module_name, fname, 'backup1')
+        self.init_pb(backup_dir1)
+        self.add_instance(backup_dir1, 'node1', node1)
+        self.set_archiving(backup_dir1, 'node1', node1)
+        node1.slow_start()
+
+        node2 = self.make_simple_node(
+            base_dir=os.path.join(module_name, fname, 'node2'),
+            ptrack_enable=self.ptrack,
+            initdb_params=['--data-checksums'])
+
+        backup_dir2 = os.path.join(self.tmp_path, module_name, fname, 'backup2')
+        self.init_pb(backup_dir2)
+        self.add_instance(backup_dir2, 'node2', node2)
+        self.set_archiving(backup_dir2, 'node2', node2)
+        node2.slow_start()
+
+        # FULL backup
+        startTime = int(time())
+        self.backup_node(
+            backup_dir1, 'node1', node1, backup_type="full",
+            options=['--stream', '--start-time', str(startTime)])
+        self.backup_node(
+            backup_dir2, 'node2', node2, backup_type="full",
+            options=['--stream', '--start-time', str(startTime)])
+
+        show_backup1 = self.show_pb(backup_dir1, 'node1')[0]
+        show_backup2 = self.show_pb(backup_dir2, 'node2')[0]
+        self.assertEqual(show_backup1['id'], show_backup2['id'])
+
+        # DELTA backup
+        startTime = int(time())
+        self.backup_node(
+            backup_dir1, 'node1', node1, backup_type="delta",
+            options=['--stream', '--start-time', str(startTime)])
+        self.backup_node(
+            backup_dir2, 'node2', node2, backup_type="delta",
+            options=['--stream', '--start-time', str(startTime)])
+        show_backup1 = self.show_pb(backup_dir1, 'node1')[1]
+        show_backup2 = self.show_pb(backup_dir2, 'node2')[1]
+        self.assertEqual(show_backup1['id'], show_backup2['id'])
+
+        # PAGE backup
+        startTime = int(time())
+        self.backup_node(
+            backup_dir1, 'node1', node1, backup_type="page",
+            options=['--stream', '--start-time', str(startTime)])
+        self.backup_node(
+            backup_dir2, 'node2', node2, backup_type="page",
+            options=['--stream', '--start-time', str(startTime)])
+        show_backup1 = self.show_pb(backup_dir1, 'node1')[2]
+        show_backup2 = self.show_pb(backup_dir2, 'node2')[2]
+        self.assertEqual(show_backup1['id'], show_backup2['id'])
+
+        # PTRACK backup
+        startTime = int(time())
+        if self.ptrack and node1.major_version > 11:
+            node1.safe_psql(
+                "postgres",
+                "create extension ptrack")
+            self.backup_node(
+                backup_dir1, 'node1', node1, backup_type="ptrack",
+                options=['--stream', '--start-time', str(startTime)])
+
+        if self.ptrack and node2.major_version > 11:
+            node2.safe_psql(
+                "postgres",
+                "create extension ptrack")
+            self.backup_node(
+                backup_dir2, 'node2', node2, backup_type="ptrack",
+                options=['--stream', '--start-time', str(startTime)])
+        show_backup1 = self.show_pb(backup_dir1, 'node1')[3]
+        show_backup2 = self.show_pb(backup_dir2, 'node2')[3]
+        self.assertEqual(show_backup1['id'], show_backup2['id'])
+
+        # Clean after yourself
+        self.del_test_dir(module_name, fname)
+
+    # @unittest.skip("skip")
+    def test_start_time_few_nodes_incorrect_time(self):
+
+        fname = self.id().split('.')[3]
+        node1 = self.make_simple_node(
+            base_dir=os.path.join(module_name, fname, 'node1'),
+            ptrack_enable=self.ptrack,
+            initdb_params=['--data-checksums'])
+
+        backup_dir1 = os.path.join(self.tmp_path, module_name, fname, 'backup1')
+        self.init_pb(backup_dir1)
+        self.add_instance(backup_dir1, 'node1', node1)
+        self.set_archiving(backup_dir1, 'node1', node1)
+        node1.slow_start()
+
+        node2 = self.make_simple_node(
+            base_dir=os.path.join(module_name, fname, 'node2'),
+            ptrack_enable=self.ptrack,
+            initdb_params=['--data-checksums'])
+
+        backup_dir2 = os.path.join(self.tmp_path, module_name, fname, 'backup2')
+        self.init_pb(backup_dir2)
+        self.add_instance(backup_dir2, 'node2', node2)
+        self.set_archiving(backup_dir2, 'node2', node2)
+        node2.slow_start()
+
+        # FULL backup
+        startTime = int(time())
+        self.backup_node(
+            backup_dir1, 'node1', node1, backup_type="full",
+            options=['--stream', '--start-time', str(startTime)])
+        self.backup_node(
+            backup_dir2, 'node2', node2, backup_type="full",
+            options=['--stream', '--start-time', str(startTime-10000)])
+
+        show_backup1 = self.show_pb(backup_dir1, 'node1')[0]
+        show_backup2 = self.show_pb(backup_dir2, 'node2')[0]
+        self.assertGreater(show_backup1['id'], show_backup2['id'])
+
+        # DELTA backup
+        startTime = int(time())
+        self.backup_node(
+            backup_dir1, 'node1', node1, backup_type="delta",
+            options=['--stream', '--start-time', str(startTime)])
+        # make backup with start time definitelly earlier, than existing
+        try:
+            self.backup_node(
+                backup_dir2, 'node2', node2, backup_type="delta",
+                options=['--stream', '--start-time', str(10000)])
+            self.assertEqual(
+                    1, 0,
+                    "Expecting Error because start time for new backup must be newer "
+                    "\n Output: {0} \n CMD: {1}".format(
+                        repr(self.output), self.cmd))
+        except ProbackupException as e:
+            self.assertRegex(
+                e.message,
+                "ERROR: Cannot create directory for older backup",
+                "\n Unexpected Error Message: {0}\n CMD: {1}".format(
+                    repr(e.message), self.cmd))
+
+        show_backup1 = self.show_pb(backup_dir1, 'node1')[1]
+        show_backup2 = self.show_pb(backup_dir2, 'node2')[0]
+        self.assertGreater(show_backup1['id'], show_backup2['id'])
+
+        # PAGE backup
+        startTime = int(time())
+        self.backup_node(
+            backup_dir1, 'node1', node1, backup_type="page",
+            options=['--stream', '--start-time', str(startTime)])
+        # make backup with start time definitelly earlier, than existing
+        try:
+            self.backup_node(
+                backup_dir2, 'node2', node2, backup_type="page",
+                options=['--stream', '--start-time', str(10000)])
+            self.assertEqual(
+                    1, 0,
+                    "Expecting Error because start time for new backup must be newer "
+                    "\n Output: {0} \n CMD: {1}".format(
+                        repr(self.output), self.cmd))
+        except ProbackupException as e:
+            self.assertRegex(
+                e.message,
+                "ERROR: Cannot create directory for older backup",
+                "\n Unexpected Error Message: {0}\n CMD: {1}".format(
+                    repr(e.message), self.cmd))
+
+        show_backup1 = self.show_pb(backup_dir1, 'node1')[2]
+        show_backup2 = self.show_pb(backup_dir2, 'node2')[0]
+        self.assertGreater(show_backup1['id'], show_backup2['id'])
+
+        # PTRACK backup
+        startTime = int(time())
+        if self.ptrack and node1.major_version > 11:
+            node1.safe_psql(
+                "postgres",
+                "create extension ptrack")
+            self.backup_node(
+                backup_dir1, 'node1', node1, backup_type="ptrack",
+                options=['--stream', '--start-time', str(startTime)])
+
+        if self.ptrack and node2.major_version > 11:
+            node2.safe_psql(
+                "postgres",
+                "create extension ptrack")
+            # make backup with start time definitelly earlier, than existing
+            try:
+                self.backup_node(
+                    backup_dir2, 'node2', node2, backup_type="ptrack",
+                    options=['--stream', '--start-time', str(10000)])
+                self.assertEqual(
+                    1, 0,
+                    "Expecting Error because start time for new backup must be newer "
+                    "\n Output: {0} \n CMD: {1}".format(
+                        repr(self.output), self.cmd))
+            except ProbackupException as e:
+                self.assertRegex(
+                    e.message,
+                    "ERROR: Cannot create directory for older backup",
+                    "\n Unexpected Error Message: {0}\n CMD: {1}".format(
+                        repr(e.message), self.cmd))
+
+        # FULL backup
+        startTime = int(time())
+        self.backup_node(
+            backup_dir1, 'node1', node1, backup_type="full",
+            options=['--stream', '--start-time', str(startTime)])
+        self.backup_node(
+            backup_dir2, 'node2', node2, backup_type="full",
+            options=['--stream', '--start-time', str(startTime)])
+
+        show_backup1 = self.show_pb(backup_dir1, 'node1')[4]
+        show_backup2 = self.show_pb(backup_dir2, 'node2')[1]
+        self.assertEqual(show_backup1['id'], show_backup2['id'])
+
+        # Clean after yourself
+        self.del_test_dir(module_name, fname)

tests/helpers/ptrack_helpers.py

@@ -938,7 +938,7 @@ class ProbackupTest(object):
             backup_type='full', datname=False, options=[],
             asynchronous=False, gdb=False,
             old_binary=False, return_id=True, no_remote=False,
-            env=None
+            env=None, startTime=None
             ):
         if not node and not data_dir:
             print('You must provide ether node or data_dir for backup')
@@ -971,6 +971,9 @@ class ProbackupTest(object):
         if not old_binary:
             cmd_list += ['--no-sync']
 
+        if startTime:
+            cmd_list += ['--start-time', startTime]
+
         return self.run_pb(cmd_list + options, asynchronous, gdb, old_binary, return_id, env=env)
 
     def checkdb_node(