You've already forked pg_probackup
mirror of
https://github.com/postgrespro/pg_probackup.git
synced 2025-07-17 07:22:20 +02:00
tests fixes
This commit is contained in:
Grigory Smolkin
@ -11,31 +11,31 @@ from . import init_test, option_test, show_test, \
|
||||
|
||||
def load_tests(loader, tests, pattern):
|
||||
suite = unittest.TestSuite()
|
||||
# suite.addTests(loader.loadTestsFromModule(init_test))
|
||||
# suite.addTests(loader.loadTestsFromModule(option_test))
|
||||
# suite.addTests(loader.loadTestsFromModule(show_test))
|
||||
# suite.addTests(loader.loadTestsFromModule(backup_test))
|
||||
# suite.addTests(loader.loadTestsFromModule(delete_test))
|
||||
# suite.addTests(loader.loadTestsFromModule(restore_test))
|
||||
# suite.addTests(loader.loadTestsFromModule(validate_test))
|
||||
# suite.addTests(loader.loadTestsFromModule(retention_test))
|
||||
suite.addTests(loader.loadTestsFromModule(init_test))
|
||||
suite.addTests(loader.loadTestsFromModule(option_test))
|
||||
suite.addTests(loader.loadTestsFromModule(show_test))
|
||||
suite.addTests(loader.loadTestsFromModule(backup_test))
|
||||
suite.addTests(loader.loadTestsFromModule(delete_test))
|
||||
suite.addTests(loader.loadTestsFromModule(restore_test))
|
||||
suite.addTests(loader.loadTestsFromModule(validate_test))
|
||||
suite.addTests(loader.loadTestsFromModule(retention_test))
|
||||
suite.addTests(loader.loadTestsFromModule(ptrack))
|
||||
# suite.addTests(loader.loadTestsFromModule(ptrack_clean))
|
||||
# suite.addTests(loader.loadTestsFromModule(ptrack_cluster))
|
||||
# suite.addTests(loader.loadTestsFromModule(ptrack_move_to_tablespace))
|
||||
# suite.addTests(loader.loadTestsFromModule(ptrack_recovery))
|
||||
# suite.addTests(loader.loadTestsFromModule(ptrack_vacuum))
|
||||
# suite.addTests(loader.loadTestsFromModule(ptrack_vacuum_bits_frozen))
|
||||
# suite.addTests(loader.loadTestsFromModule(ptrack_vacuum_bits_visibility))
|
||||
# suite.addTests(loader.loadTestsFromModule(ptrack_vacuum_full))
|
||||
# suite.addTests(loader.loadTestsFromModule(ptrack_vacuum_truncate))
|
||||
# suite.addTests(loader.loadTestsFromModule(replica))
|
||||
# suite.addTests(loader.loadTestsFromModule(pgpro560))
|
||||
# suite.addTests(loader.loadTestsFromModule(pgpro589))
|
||||
# suite.addTests(loader.loadTestsFromModule(false_positive))
|
||||
# suite.addTests(loader.loadTestsFromModule(compression))
|
||||
# suite.addTests(loader.loadTestsFromModule(page))
|
||||
# suite.addTests(loader.loadTestsFromModule(archive))
|
||||
suite.addTests(loader.loadTestsFromModule(ptrack_clean))
|
||||
suite.addTests(loader.loadTestsFromModule(ptrack_cluster))
|
||||
suite.addTests(loader.loadTestsFromModule(ptrack_move_to_tablespace))
|
||||
suite.addTests(loader.loadTestsFromModule(ptrack_recovery))
|
||||
suite.addTests(loader.loadTestsFromModule(ptrack_vacuum))
|
||||
suite.addTests(loader.loadTestsFromModule(ptrack_vacuum_bits_frozen))
|
||||
suite.addTests(loader.loadTestsFromModule(ptrack_vacuum_bits_visibility))
|
||||
suite.addTests(loader.loadTestsFromModule(ptrack_vacuum_full))
|
||||
suite.addTests(loader.loadTestsFromModule(ptrack_vacuum_truncate))
|
||||
suite.addTests(loader.loadTestsFromModule(replica))
|
||||
suite.addTests(loader.loadTestsFromModule(pgpro560))
|
||||
suite.addTests(loader.loadTestsFromModule(pgpro589))
|
||||
suite.addTests(loader.loadTestsFromModule(false_positive))
|
||||
suite.addTests(loader.loadTestsFromModule(compression))
|
||||
suite.addTests(loader.loadTestsFromModule(page))
|
||||
suite.addTests(loader.loadTestsFromModule(archive))
|
||||
|
||||
return suite
|
||||
|
||||
@ -50,5 +50,5 @@ def load_tests(loader, tests, pattern):
|
||||
# https://jira.postgrespro.ru/secure/attachment/20420/20420_doc_logging.md
|
||||
# ptrack:
|
||||
# ptrack backup on replica should work correctly
|
||||
#
|
||||
# function to compare original instance and restored
|
||||
# archive:
|
||||
# immediate recovery and full recovery
|
||||
|
||||
@ -46,6 +46,7 @@ class ArchiveTest(ProbackupTest, unittest.TestCase):
|
||||
self.add_instance(backup_dir, 'node', node)
|
||||
|
||||
# Make backup
|
||||
sleep(5)
|
||||
self.backup_node(backup_dir, 'node', node)
|
||||
node.cleanup()
|
||||
|
||||
@ -59,8 +60,9 @@ class ArchiveTest(ProbackupTest, unittest.TestCase):
|
||||
self.del_test_dir(module_name, fname)
|
||||
|
||||
# @unittest.skip("skip")
|
||||
@unittest.expectedFailure
|
||||
def test_pgpro434_2(self):
|
||||
"""Check that timelines are correct"""
|
||||
"""Check that timelines are correct. WAITING PGPRO-1053 for --immediate. replace time"""
|
||||
fname = self.id().split('.')[3]
|
||||
backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
|
||||
node = self.make_simple_node(base_dir="{0}/{1}/node".format(module_name, fname),
|
||||
@ -81,15 +83,19 @@ class ArchiveTest(ProbackupTest, unittest.TestCase):
|
||||
recovery_time = self.show_pb(backup_dir, 'node', backup_id)["recovery-time"]
|
||||
node.safe_psql(
|
||||
"postgres",
|
||||
"insert into t_heap select 100501 as id, md5(i::text) as text, md5(repeat(i::text,10))::tsvector as tsvector from generate_series(0,256) i")
|
||||
"insert into t_heap select 100501 as id, md5(i::text) as text, md5(repeat(i::text,10))::tsvector as tsvector from generate_series(0,1) i")
|
||||
|
||||
# SECOND TIMELIN
|
||||
node.cleanup()
|
||||
self.restore_node(backup_dir, 'node', node, options=["--time={0}".format(recovery_time)])
|
||||
node.start()
|
||||
while node.safe_psql("postgres", "select pg_is_in_recovery()") == 't\n':
|
||||
sleep(1)
|
||||
if self.verbose:
|
||||
print('Second timeline')
|
||||
print(node.safe_psql("postgres","select redo_wal_file from pg_control_checkpoint()"))
|
||||
self.assertFalse(node.execute("postgres","select exists(select 1 from t_heap where id = 100501)")[0][0],
|
||||
'data after restore not equal to original data')
|
||||
node.safe_psql(
|
||||
"postgres",
|
||||
"insert into t_heap select 2 as id, md5(i::text) as text, md5(repeat(i::text,10))::tsvector as tsvector from generate_series(100,200) i")
|
||||
@ -103,6 +109,8 @@ class ArchiveTest(ProbackupTest, unittest.TestCase):
|
||||
node.cleanup()
|
||||
self.restore_node(backup_dir, 'node', node, options=["--time={0}".format(recovery_time)])
|
||||
node.start()
|
||||
while node.safe_psql("postgres", "select pg_is_in_recovery()") == 't\n':
|
||||
sleep(1)
|
||||
if self.verbose:
|
||||
print('third timeline')
|
||||
print(node.safe_psql("postgres","select redo_wal_file from pg_control_checkpoint()"))
|
||||
@ -120,6 +128,8 @@ class ArchiveTest(ProbackupTest, unittest.TestCase):
|
||||
node.cleanup()
|
||||
self.restore_node(backup_dir, 'node', node, options=["--time={0}".format(recovery_time)])
|
||||
node.start()
|
||||
while node.safe_psql("postgres", "select pg_is_in_recovery()") == 't\n':
|
||||
sleep(1)
|
||||
if self.verbose:
|
||||
print('Fourth timeline')
|
||||
print(node.safe_psql("postgres","select redo_wal_file from pg_control_checkpoint()"))
|
||||
@ -128,6 +138,8 @@ class ArchiveTest(ProbackupTest, unittest.TestCase):
|
||||
node.cleanup()
|
||||
self.restore_node(backup_dir, 'node', node, options=["--time={0}".format(recovery_time)])
|
||||
node.start()
|
||||
while node.safe_psql("postgres", "select pg_is_in_recovery()") == 't\n':
|
||||
sleep(1)
|
||||
if self.verbose:
|
||||
print('Fifth timeline')
|
||||
print(node.safe_psql("postgres","select redo_wal_file from pg_control_checkpoint()"))
|
||||
@ -136,6 +148,8 @@ class ArchiveTest(ProbackupTest, unittest.TestCase):
|
||||
node.cleanup()
|
||||
self.restore_node(backup_dir, 'node', node, options=["--time={0}".format(recovery_time)])
|
||||
node.start()
|
||||
while node.safe_psql("postgres", "select pg_is_in_recovery()") == 't\n':
|
||||
sleep(1)
|
||||
if self.verbose:
|
||||
print('Sixth timeline')
|
||||
print(node.safe_psql("postgres","select redo_wal_file from pg_control_checkpoint()"))
|
||||
@ -147,7 +161,7 @@ class ArchiveTest(ProbackupTest, unittest.TestCase):
|
||||
'data after restore not equal to original data')
|
||||
|
||||
# Clean after yourself
|
||||
# self.del_test_dir(module_name, fname)
|
||||
self.del_test_dir(module_name, fname)
|
||||
|
||||
# @unittest.skip("skip")
|
||||
def test_pgpro434_3(self):
|
||||
@ -219,7 +233,7 @@ class ArchiveTest(ProbackupTest, unittest.TestCase):
|
||||
|
||||
os.remove(file)
|
||||
sleep(5)
|
||||
node.safe_psql('postgres', 'select pg_switch_xlog()')
|
||||
node.safe_psql('postgres', 'select pg_switch_wal()')
|
||||
|
||||
with open(log_file, 'r') as f:
|
||||
log_content = f.read()
|
||||
@ -230,8 +244,9 @@ class ArchiveTest(ProbackupTest, unittest.TestCase):
|
||||
self.del_test_dir(module_name, fname)
|
||||
|
||||
# @unittest.expectedFailure
|
||||
# @unittest.skip("skip")
|
||||
def test_replica_archive(self):
|
||||
"""make node withput archiving, take stream backup and turn it into replica, set replica with archiving, make archive backup from replica"""
|
||||
"""make node without archiving, take stream backup and turn it into replica, set replica with archiving, make archive backup from replica"""
|
||||
fname = self.id().split('.')[3]
|
||||
backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
|
||||
master = self.make_simple_node(base_dir="{0}/{1}/master".format(module_name, fname),
|
||||
@ -240,6 +255,7 @@ class ArchiveTest(ProbackupTest, unittest.TestCase):
|
||||
pg_options={'wal_level': 'replica', 'max_wal_senders': '2', 'checkpoint_timeout': '30s'}
|
||||
)
|
||||
self.init_pb(backup_dir)
|
||||
# ADD INSTANCE 'MASTER'
|
||||
self.add_instance(backup_dir, 'master', master)
|
||||
# force more frequent wal switch
|
||||
master.start()
|
||||
@ -258,7 +274,7 @@ class ArchiveTest(ProbackupTest, unittest.TestCase):
|
||||
self.restore_node(backup_dir, 'master', replica)
|
||||
self.set_replica(master, replica, synchronous=True)
|
||||
self.set_archiving(backup_dir, 'replica', replica, replica=True)
|
||||
replica.start({"-t": "600"})
|
||||
replica.start()
|
||||
|
||||
# Check data correctness on replica
|
||||
after = replica.safe_psql("postgres", "SELECT * FROM t_heap")
|
||||
@ -269,6 +285,7 @@ class ArchiveTest(ProbackupTest, unittest.TestCase):
|
||||
"postgres",
|
||||
"insert into t_heap as select i as id, md5(i::text) as text, md5(repeat(i::text,10))::tsvector as tsvector from generate_series(256,512) i")
|
||||
before = master.safe_psql("postgres", "SELECT * FROM t_heap")
|
||||
# ADD INSTANCE 'REPLICA'
|
||||
self.add_instance(backup_dir, 'replica', replica)
|
||||
backup_id = self.backup_node(backup_dir, 'replica', replica, options=['--archive-timeout=30',
|
||||
'--master-host=localhost', '--master-db=postgres','--master-port={0}'.format(master.port)])
|
||||
@ -306,3 +323,62 @@ class ArchiveTest(ProbackupTest, unittest.TestCase):
|
||||
|
||||
# Clean after yourself
|
||||
self.del_test_dir(module_name, fname)
|
||||
|
||||
# @unittest.expectedFailure
|
||||
# @unittest.skip("skip")
|
||||
def test_master_and_replica_concurrent_archiving(self):
|
||||
"""make node 'master 'with archiving, take archive backup and turn it into replica, set replica with archiving, make archive backup from replica, make archive backup from master"""
|
||||
fname = self.id().split('.')[3]
|
||||
backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
|
||||
master = self.make_simple_node(base_dir="{0}/{1}/master".format(module_name, fname),
|
||||
set_replication=True,
|
||||
initdb_params=['--data-checksums'],
|
||||
pg_options={'wal_level': 'replica', 'max_wal_senders': '2', 'checkpoint_timeout': '30s'}
|
||||
)
|
||||
replica = self.make_simple_node(base_dir="{0}/{1}/replica".format(module_name, fname))
|
||||
replica.cleanup()
|
||||
|
||||
self.init_pb(backup_dir)
|
||||
# ADD INSTANCE 'MASTER'
|
||||
self.add_instance(backup_dir, 'master', master)
|
||||
self.set_archiving(backup_dir, 'master', master)
|
||||
master.start()
|
||||
|
||||
master.psql(
|
||||
"postgres",
|
||||
"create table t_heap as select i as id, md5(i::text) as text, md5(repeat(i::text,10))::tsvector as tsvector from generate_series(0,256) i")
|
||||
|
||||
# TAKE FULL ARCHIVE BACKUP FROM MASTER
|
||||
self.backup_node(backup_dir, 'master', master)
|
||||
# GET LOGICAL CONTENT FROM MASTER
|
||||
before = master.safe_psql("postgres", "SELECT * FROM t_heap")
|
||||
# GET PHYSICAL CONTENT FROM MASTER
|
||||
pgdata_master = self.pgdata_content(master.data_dir)
|
||||
|
||||
# Settings for Replica
|
||||
self.restore_node(backup_dir, 'master', replica)
|
||||
# CHECK PHYSICAL CORRECTNESS on REPLICA
|
||||
pgdata_replica = self.pgdata_content(replica.data_dir)
|
||||
self.compare_pgdata(pgdata_master, pgdata_replica)
|
||||
|
||||
self.set_replica(master, replica, synchronous=True)
|
||||
# ADD INSTANCE REPLICA
|
||||
self.add_instance(backup_dir, 'replica', replica)
|
||||
# SET ARCHIVING FOR REPLICA
|
||||
self.set_archiving(backup_dir, 'replica', replica, replica=True)
|
||||
replica.start()
|
||||
|
||||
# CHECK LOGICAL CORRECTNESS on REPLICA
|
||||
after = replica.safe_psql("postgres", "SELECT * FROM t_heap")
|
||||
self.assertEqual(before, after)
|
||||
|
||||
# TAKE FULL ARCHIVE BACKUP FROM REPLICA
|
||||
backup_id = self.backup_node(backup_dir, 'replica', replica, options=['--archive-timeout=30',
|
||||
'--master-host=localhost', '--master-db=postgres','--master-port={0}'.format(master.port)])
|
||||
self.validate_pb(backup_dir, 'replica')
|
||||
self.assertEqual('OK', self.show_pb(backup_dir, 'replica', backup_id)['status'])
|
||||
|
||||
# TAKE FULL ARCHIVE BACKUP FROM MASTER
|
||||
backup_id = self.backup_node(backup_dir, 'master', master)
|
||||
self.validate_pb(backup_dir, 'master')
|
||||
self.assertEqual('OK', self.show_pb(backup_dir, 'master', backup_id)['status'])
|
||||
|
||||
@ -4,7 +4,7 @@ from .helpers.ptrack_helpers import ProbackupTest, ProbackupException
|
||||
from datetime import datetime, timedelta
|
||||
import subprocess
|
||||
from testgres import ClusterException
|
||||
import shutil, sys
|
||||
import shutil, sys, time
|
||||
|
||||
|
||||
module_name = 'ptrack'
|
||||
@ -129,6 +129,8 @@ class PtrackBackupTest(ProbackupTest, unittest.TestCase):
|
||||
self.restore_node(backup_dir, 'node', node, backup_id=full_backup_id, options=["-j", "4"]),
|
||||
'\n Unexpected Error Message: {0}\n CMD: {1}'.format(repr(self.output), self.cmd))
|
||||
node.start()
|
||||
while node.safe_psql("postgres", "select pg_is_in_recovery()") == 't\n':
|
||||
time.sleep(1)
|
||||
full_result_new = node.safe_psql("postgres", "SELECT * FROM t_heap")
|
||||
self.assertEqual(full_result, full_result_new)
|
||||
node.cleanup()
|
||||
@ -140,6 +142,8 @@ class PtrackBackupTest(ProbackupTest, unittest.TestCase):
|
||||
pgdata_restored = self.pgdata_content(node.data_dir)
|
||||
self.compare_pgdata(pgdata, pgdata_restored)
|
||||
node.start()
|
||||
while node.safe_psql("postgres", "select pg_is_in_recovery()") == 't\n':
|
||||
time.sleep(1)
|
||||
ptrack_result_new = node.safe_psql("postgres", "SELECT * FROM t_heap")
|
||||
self.assertEqual(ptrack_result, ptrack_result_new)
|
||||
|
||||
@ -169,6 +173,7 @@ class PtrackBackupTest(ProbackupTest, unittest.TestCase):
|
||||
"create table t_heap as select i as id, md5(i::text) as text, md5(i::text)::tsvector as tsvector from generate_series(0,100) i")
|
||||
full_result = node.safe_psql("postgres", "SELECT * FROM t_heap")
|
||||
full_backup_id = self.backup_node(backup_dir, 'node', node)
|
||||
full_target_time = self.show_pb(backup_dir, 'node', full_backup_id)['recovery-time']
|
||||
|
||||
# PTRACK BACKUP
|
||||
node.safe_psql(
|
||||
@ -176,6 +181,7 @@ class PtrackBackupTest(ProbackupTest, unittest.TestCase):
|
||||
"insert into t_heap select i as id, md5(i::text) as text, md5(i::text)::tsvector as tsvector from generate_series(100,200) i")
|
||||
ptrack_result = node.safe_psql("postgres", "SELECT * FROM t_heap")
|
||||
ptrack_backup_id = self.backup_node(backup_dir, 'node', node, backup_type='ptrack')
|
||||
ptrack_target_time = self.show_pb(backup_dir, 'node', ptrack_backup_id)['recovery-time']
|
||||
pgdata = self.pgdata_content(node.data_dir)
|
||||
|
||||
# Drop Node
|
||||
@ -183,20 +189,24 @@ class PtrackBackupTest(ProbackupTest, unittest.TestCase):
|
||||
|
||||
# Check full backup
|
||||
self.assertIn("INFO: Restore of backup {0} completed.".format(full_backup_id),
|
||||
self.restore_node(backup_dir, 'node', node, backup_id=full_backup_id, options=["-j", "4"]),
|
||||
self.restore_node(backup_dir, 'node', node, backup_id=full_backup_id, options=["-j", "4", "--time={0}".format(full_target_time)]),
|
||||
'\n Unexpected Error Message: {0}\n CMD: {1}'.format(repr(self.output), self.cmd))
|
||||
node.start()
|
||||
while node.safe_psql("postgres", "select pg_is_in_recovery()") == 't\n':
|
||||
time.sleep(1)
|
||||
full_result_new = node.safe_psql("postgres", "SELECT * FROM t_heap")
|
||||
self.assertEqual(full_result, full_result_new)
|
||||
node.cleanup()
|
||||
|
||||
# Check ptrack backup
|
||||
self.assertIn("INFO: Restore of backup {0} completed.".format(ptrack_backup_id),
|
||||
self.restore_node(backup_dir, 'node', node, backup_id=ptrack_backup_id, options=["-j", "4"]),
|
||||
self.restore_node(backup_dir, 'node', node, backup_id=ptrack_backup_id, options=["-j", "4", "--time={0}".format(ptrack_target_time)]),
|
||||
'\n Unexpected Error Message: {0}\n CMD: {1}'.format(repr(self.output), self.cmd))
|
||||
pgdata_restored = self.pgdata_content(node.data_dir)
|
||||
self.compare_pgdata(pgdata, pgdata_restored)
|
||||
node.start()
|
||||
while node.safe_psql("postgres", "select pg_is_in_recovery()") == 't\n':
|
||||
time.sleep(1)
|
||||
ptrack_result_new = node.safe_psql("postgres", "SELECT * FROM t_heap")
|
||||
self.assertEqual(ptrack_result, ptrack_result_new)
|
||||
node.cleanup()
|
||||
@ -304,7 +314,7 @@ class PtrackBackupTest(ProbackupTest, unittest.TestCase):
|
||||
'\n Unexpected Error Message: {0}\n CMD: {1}'.format(repr(e.message), self.cmd))
|
||||
|
||||
# Clean after yourself
|
||||
# self.del_test_dir(module_name, fname)
|
||||
self.del_test_dir(module_name, fname)
|
||||
|
||||
# @unittest.skip("skip")
|
||||
def test_full_pgpro417(self):
|
||||
@ -463,6 +473,7 @@ class PtrackBackupTest(ProbackupTest, unittest.TestCase):
|
||||
self.backup_node(backup_dir, 'node', node, backup_type='ptrack', options=["--stream"])
|
||||
pgdata_content = self.pgdata_content(node.data_dir)
|
||||
node.stop()
|
||||
node.cleanup()
|
||||
|
||||
# RESTORE
|
||||
node_restored = self.make_simple_node(base_dir="{0}/{1}/node_restored".format(module_name, fname))
|
||||
@ -477,8 +488,12 @@ class PtrackBackupTest(ProbackupTest, unittest.TestCase):
|
||||
pgdata_content_new = self.pgdata_content(node_restored.data_dir)
|
||||
self.compare_pgdata(pgdata_content, pgdata_content_new)
|
||||
# START RESTORED NODE
|
||||
node_restored.append_conf('postgresql.auto.conf', 'port = {0}'.format(node_restored.port))
|
||||
node_restored.start()
|
||||
result_new = node.safe_psql("postgres", "select * from t_heap")
|
||||
time.sleep(5)
|
||||
while node_restored.safe_psql("postgres", "select pg_is_in_recovery()") == 't\n':
|
||||
time.sleep(1)
|
||||
result_new = node_restored.safe_psql("postgres", "select * from t_heap")
|
||||
|
||||
self.assertEqual(result, result_new, 'lost some data after restore')
|
||||
|
||||
@ -593,7 +608,7 @@ class PtrackBackupTest(ProbackupTest, unittest.TestCase):
|
||||
self.del_test_dir(module_name, fname)
|
||||
|
||||
# @unittest.skip("skip")
|
||||
def test_alter_tablespace(self):
|
||||
def test_ptrack_alter_tablespace(self):
|
||||
"""Make node, create table, alter table tablespace, take ptrack backup, move table from tablespace, take ptrack backup"""
|
||||
self.maxDiff = None
|
||||
fname = self.id().split('.')[3]
|
||||
@ -622,9 +637,8 @@ class PtrackBackupTest(ProbackupTest, unittest.TestCase):
|
||||
node.safe_psql(
|
||||
"postgres", "alter table t_heap set tablespace somedata")
|
||||
# FIRTS PTRACK BACKUP
|
||||
node.safe_psql("postgres", "checkpoint")
|
||||
self.backup_node(backup_dir, 'node', node, backup_type='ptrack', options=["--stream"])
|
||||
pgdata_content = self.pgdata_content(node.data_dir)
|
||||
pgdata = self.pgdata_content(node.data_dir)
|
||||
|
||||
# Restore ptrack backup and check table consistency
|
||||
restored_node = self.make_simple_node(base_dir="{0}/{1}/restored_node".format(module_name, fname))
|
||||
@ -635,10 +649,14 @@ class PtrackBackupTest(ProbackupTest, unittest.TestCase):
|
||||
"-j", "4", "-T", "{0}={1}".format(tblspc_path, tblspc_path_new)])
|
||||
result = node.safe_psql("postgres", "select * from t_heap")
|
||||
|
||||
pgdata_content_new = self.pgdata_content(restored_node.data_dir)
|
||||
self.compare_pgdata(pgdata_content, pgdata_content_new)
|
||||
pgdata_new = self.pgdata_content(restored_node.data_dir)
|
||||
# COMPARE PHYSICAL CONTENT
|
||||
self.compare_pgdata(pgdata, pgdata_new)
|
||||
# START RESTORED NODE
|
||||
restored_node.append_conf("postgresql.auto.conf", "port = {0}".format(restored_node.port))
|
||||
restored_node.start()
|
||||
while restored_node.safe_psql("postgres", "select pg_is_in_recovery()") == 't\n':
|
||||
time.sleep(1)
|
||||
|
||||
result_new = restored_node.safe_psql("postgres", "select * from t_heap")
|
||||
self.assertEqual(result, result_new)
|
||||
@ -650,16 +668,22 @@ class PtrackBackupTest(ProbackupTest, unittest.TestCase):
|
||||
"postgres", "alter table t_heap set tablespace pg_default")
|
||||
# SECOND PTRACK BACKUP
|
||||
self.backup_node(backup_dir, 'node', node, backup_type='ptrack', options=["--stream"])
|
||||
pgdata = self.pgdata_content(node.data_dir)
|
||||
|
||||
# Restore second ptrack backup and check table consistency
|
||||
self.restore_node(backup_dir, 'node', restored_node, options=[
|
||||
"-j", "4", "-T", "{0}={1}".format(tblspc_path, tblspc_path_new)])
|
||||
restored_node.append_conf("postgresql.auto.conf", "port = {0}".format(restored_node.port))
|
||||
restored_node.start()
|
||||
|
||||
# COMPARE PHYSICAL CONTENT
|
||||
#pgdata = self.pgdata_content(node.data_dir)
|
||||
#pgdata_new = self.pgdata_content(restored_node.data_dir)
|
||||
#self.compare_pgdata(pgdata, pgdata_new)
|
||||
pgdata_new = self.pgdata_content(restored_node.data_dir)
|
||||
self.compare_pgdata(pgdata, pgdata_new)
|
||||
|
||||
# START RESTORED NODE
|
||||
restored_node.start()
|
||||
while restored_node.safe_psql("postgres", "select pg_is_in_recovery()") == 't\n':
|
||||
time.sleep(1)
|
||||
|
||||
result_new = restored_node.safe_psql("postgres", "select * from t_heap")
|
||||
self.assertEqual(result, result_new)
|
||||
|
||||
@ -675,7 +699,9 @@ class PtrackBackupTest(ProbackupTest, unittest.TestCase):
|
||||
node = self.make_simple_node(base_dir="{0}/{1}/node".format(module_name, fname),
|
||||
set_replication=True,
|
||||
initdb_params=['--data-checksums'],
|
||||
pg_options={'wal_level': 'replica', 'max_wal_senders': '2', 'ptrack_enable': 'on', 'fsync': 'off', 'shared_buffers': '1GB', 'maintenance_work_mem': '1GB'}
|
||||
pg_options={'wal_level': 'replica', 'max_wal_senders': '2',
|
||||
'ptrack_enable': 'on', 'fsync': 'off', 'shared_buffers': '1GB',
|
||||
'maintenance_work_mem': '1GB', 'autovacuum': 'off'}
|
||||
)
|
||||
|
||||
self.init_pb(backup_dir)
|
||||
@ -685,17 +711,18 @@ class PtrackBackupTest(ProbackupTest, unittest.TestCase):
|
||||
self.create_tblspace_in_node(node, 'somedata')
|
||||
|
||||
# CREATE TABLE
|
||||
node.pgbench_init(scale=300, options=['--tablespace=somedata'])
|
||||
node.pgbench_init(scale=100, options=['--tablespace=somedata'])
|
||||
# FULL BACKUP
|
||||
self.backup_node(backup_dir, 'node', node, options=["--stream"])
|
||||
|
||||
pgbench = node.pgbench(options=['-T', '50', '-c', '2', '--no-vacuum'])
|
||||
pgbench.wait()
|
||||
|
||||
# GET PHYSICAL CONTENT FROM NODE
|
||||
# FIRTS PTRACK BACKUP
|
||||
# GET LOGICAL CONTENT FROM NODE
|
||||
result = node.safe_psql("postgres", "select * from pgbench_accounts")
|
||||
# FIRTS PTRACK BACKUP
|
||||
self.backup_node(backup_dir, 'node', node, backup_type='ptrack', options=["--stream"])
|
||||
# GET PHYSICAL CONTENT FROM NODE
|
||||
pgdata = self.pgdata_content(node.data_dir)
|
||||
|
||||
# RESTORE NODE
|
||||
@ -706,18 +733,19 @@ class PtrackBackupTest(ProbackupTest, unittest.TestCase):
|
||||
|
||||
self.restore_node(backup_dir, 'node', restored_node, options=[
|
||||
"-j", "4", "-T", "{0}={1}".format(tblspc_path, tblspc_path_new)])
|
||||
# self.restore_node(backup_dir, 'node', restored_node, options=[
|
||||
# "-j", "4"])
|
||||
|
||||
# GET PHYSICAL CONTENT FROM NODE_RESTORED
|
||||
pgdata_restored = self.pgdata_content(restored_node.data_dir)
|
||||
self.compare_pgdata(pgdata, pgdata_restored)
|
||||
|
||||
# START RESTORED NODE
|
||||
restored_node.append_conf("postgresql.auto.conf", "port = {0}".format(restored_node.port))
|
||||
restored_node.start()
|
||||
while restored_node.safe_psql("postgres", "select pg_is_in_recovery()") == 't\n':
|
||||
time.sleep(1)
|
||||
|
||||
result_new = restored_node.safe_psql("postgres", "select * from pgbench_accounts")
|
||||
self.assertEqual(result, result_new)
|
||||
self.compare_pgdata(pgdata, pgdata_restored)
|
||||
|
||||
# Clean after yourself
|
||||
self.del_test_dir(module_name, fname)
|
||||
|
||||
@ -36,6 +36,7 @@ class SimpleTest(ProbackupTest, unittest.TestCase):
|
||||
|
||||
# Take FULL backup to clean every ptrack
|
||||
self.backup_node(backup_dir, 'node', node, options=['-j10', '--stream'])
|
||||
node.safe_psql('postgres', 'checkpoint')
|
||||
|
||||
for i in idx_ptrack:
|
||||
# get fork size and calculate it in pages
|
||||
@ -53,6 +54,7 @@ class SimpleTest(ProbackupTest, unittest.TestCase):
|
||||
|
||||
# Take PTRACK backup to clean every ptrack
|
||||
backup_id = self.backup_node(backup_dir, 'node', node, backup_type='ptrack', options=['-j100'])
|
||||
node.safe_psql('postgres', 'checkpoint')
|
||||
|
||||
for i in idx_ptrack:
|
||||
# get new size of heap and indexes and calculate it in pages
|
||||
@ -125,6 +127,7 @@ class SimpleTest(ProbackupTest, unittest.TestCase):
|
||||
# Take FULL backup to clean every ptrack
|
||||
self.backup_node(backup_dir, 'replica', replica, options=['-j100', '--stream',
|
||||
'--master-host=localhost', '--master-db=postgres', '--master-port={0}'.format(master.port)])
|
||||
master.safe_psql('postgres', 'checkpoint')
|
||||
|
||||
for i in idx_ptrack:
|
||||
# get fork size and calculate it in pages
|
||||
@ -143,8 +146,8 @@ class SimpleTest(ProbackupTest, unittest.TestCase):
|
||||
# Take PTRACK backup to clean every ptrack
|
||||
backup_id = self.backup_node(backup_dir, 'replica', replica, backup_type='ptrack', options=['-j100', '--stream',
|
||||
'--master-host=localhost', '--master-db=postgres', '--master-port={0}'.format(master.port)])
|
||||
|
||||
master.safe_psql('postgres', 'checkpoint')
|
||||
|
||||
for i in idx_ptrack:
|
||||
# get new size of heap and indexes and calculate it in pages
|
||||
idx_ptrack[i]['size'] = self.get_fork_size(replica, i)
|
||||
@ -164,6 +167,9 @@ class SimpleTest(ProbackupTest, unittest.TestCase):
|
||||
# Take PAGE backup to clean every ptrack
|
||||
self.backup_node(backup_dir, 'replica', replica, backup_type='page', options=['-j100',
|
||||
'--master-host=localhost', '--master-db=postgres', '--master-port={0}'.format(master.port)])
|
||||
master.safe_psql('postgres', 'checkpoint')
|
||||
|
||||
|
||||
for i in idx_ptrack:
|
||||
# get new size of heap and indexes and calculate it in pages
|
||||
idx_ptrack[i]['size'] = self.get_fork_size(replica, i)
|
||||
|
||||
@ -3,7 +3,7 @@ import unittest
|
||||
from .helpers.ptrack_helpers import ProbackupTest, ProbackupException
|
||||
import subprocess
|
||||
from datetime import datetime
|
||||
import sys
|
||||
import sys, time
|
||||
|
||||
|
||||
module_name = 'restore'
|
||||
@ -46,6 +46,8 @@ class RestoreTest(ProbackupTest, unittest.TestCase):
|
||||
self.assertEqual(os.path.isfile(recovery_conf), True)
|
||||
|
||||
node.start()
|
||||
while node.safe_psql("postgres", "select pg_is_in_recovery()") == 't\n':
|
||||
time.sleep(1)
|
||||
|
||||
after = node.execute("postgres", "SELECT * FROM pgbench_branches")
|
||||
self.assertEqual(before, after)
|
||||
@ -87,6 +89,8 @@ class RestoreTest(ProbackupTest, unittest.TestCase):
|
||||
'\n Unexpected Error Message: {0}\n CMD: {1}'.format(repr(self.output), self.cmd))
|
||||
|
||||
node.start()
|
||||
while node.safe_psql("postgres", "select pg_is_in_recovery()") == 't\n':
|
||||
time.sleep(1)
|
||||
|
||||
after = node.execute("postgres", "SELECT * FROM pgbench_branches")
|
||||
self.assertEqual(before, after)
|
||||
@ -122,9 +126,12 @@ class RestoreTest(ProbackupTest, unittest.TestCase):
|
||||
self.restore_node(backup_dir, 'node', node, options=["-j", "4"]),
|
||||
'\n Unexpected Error Message: {0}\n CMD: {1}'.format(repr(self.output), self.cmd))
|
||||
|
||||
node.start()
|
||||
node.start(params={'-t':'10'})
|
||||
while node.safe_psql("postgres", "select pg_is_in_recovery()") == 't\n':
|
||||
time.sleep(1)
|
||||
|
||||
pgbench = node.pgbench(stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
|
||||
pgbench = node.pgbench(stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
|
||||
options=['-T', '10', '-c', '2', '--no-vacuum'])
|
||||
pgbench.wait()
|
||||
pgbench.stdout.close()
|
||||
|
||||
@ -142,6 +149,8 @@ class RestoreTest(ProbackupTest, unittest.TestCase):
|
||||
self.assertEqual(int(recovery_target_timeline), target_tli)
|
||||
|
||||
node.start()
|
||||
while node.safe_psql("postgres", "select pg_is_in_recovery()") == 't\n':
|
||||
time.sleep(1)
|
||||
|
||||
after = node.execute("postgres", "SELECT * FROM pgbench_branches")
|
||||
self.assertEqual(before, after)
|
||||
@ -161,6 +170,7 @@ class RestoreTest(ProbackupTest, unittest.TestCase):
|
||||
self.init_pb(backup_dir)
|
||||
self.add_instance(backup_dir, 'node', node)
|
||||
self.set_archiving(backup_dir, 'node', node)
|
||||
node.append_conf("postgresql.auto.conf", "TimeZone = Europe/Moscow")
|
||||
node.start()
|
||||
|
||||
node.pgbench_init(scale=2)
|
||||
@ -177,19 +187,21 @@ class RestoreTest(ProbackupTest, unittest.TestCase):
|
||||
node.cleanup()
|
||||
|
||||
self.assertIn("INFO: Restore of backup {0} completed.".format(backup_id),
|
||||
self.restore_node(backup_dir, 'node', node, options=["-j", "4", '--time="{0}"'.format(target_time)]),
|
||||
self.restore_node(backup_dir, 'node', node, options=["-j", "4", '--time={0}'.format(target_time)]),
|
||||
'\n Unexpected Error Message: {0}\n CMD: {1}'.format(repr(self.output), self.cmd))
|
||||
|
||||
node.start()
|
||||
while node.safe_psql("postgres", "select pg_is_in_recovery()") == 't\n':
|
||||
time.sleep(1)
|
||||
|
||||
after = node.execute("postgres", "SELECT * FROM pgbench_branches")
|
||||
self.assertEqual(before, after)
|
||||
|
||||
# Clean after yourself
|
||||
self.del_test_dir(module_name, fname)
|
||||
# self.del_test_dir(module_name, fname)
|
||||
|
||||
# @unittest.skip("skip")
|
||||
def test_restore_to_xid(self):
|
||||
def test_restore_to_xid_inclusive(self):
|
||||
"""recovery to target xid"""
|
||||
fname = self.id().split('.')[3]
|
||||
node = self.make_simple_node(base_dir="{0}/{1}/node".format(module_name, fname),
|
||||
@ -213,7 +225,7 @@ class RestoreTest(ProbackupTest, unittest.TestCase):
|
||||
pgbench.wait()
|
||||
pgbench.stdout.close()
|
||||
|
||||
before = node.execute("postgres", "SELECT * FROM pgbench_branches")
|
||||
before = node.safe_psql("postgres", "SELECT * FROM pgbench_branches")
|
||||
with node.connect("postgres") as con:
|
||||
res = con.execute("INSERT INTO tbl0005 VALUES ('inserted') RETURNING (xmin)")
|
||||
con.commit()
|
||||
@ -223,11 +235,6 @@ class RestoreTest(ProbackupTest, unittest.TestCase):
|
||||
pgbench.wait()
|
||||
pgbench.stdout.close()
|
||||
|
||||
# Enforce segment to be archived to ensure that recovery goes up to the
|
||||
# wanted point. There is no way to ensure that all segments needed have
|
||||
# been archived up to the xmin point saved earlier without that.
|
||||
#node.execute("postgres", "SELECT pg_switch_xlog()")
|
||||
|
||||
node.stop()
|
||||
node.cleanup()
|
||||
|
||||
@ -236,9 +243,66 @@ class RestoreTest(ProbackupTest, unittest.TestCase):
|
||||
'\n Unexpected Error Message: {0}\n CMD: {1}'.format(repr(self.output), self.cmd))
|
||||
|
||||
node.start()
|
||||
while node.safe_psql("postgres", "select pg_is_in_recovery()") == 't\n':
|
||||
time.sleep(1)
|
||||
|
||||
after = node.safe_psql("postgres", "SELECT * FROM pgbench_branches")
|
||||
self.assertEqual(before, after)
|
||||
self.assertEqual(len(node.execute("postgres", "SELECT * FROM tbl0005")), 1)
|
||||
|
||||
# Clean after yourself
|
||||
self.del_test_dir(module_name, fname)
|
||||
|
||||
# @unittest.skip("skip")
|
||||
def test_restore_to_xid_not_inclusive(self):
|
||||
"""recovery with target inclusive false"""
|
||||
fname = self.id().split('.')[3]
|
||||
node = self.make_simple_node(base_dir="{0}/{1}/node".format(module_name, fname),
|
||||
initdb_params=['--data-checksums'],
|
||||
pg_options={'wal_level': 'replica', 'ptrack_enable': 'on', 'max_wal_senders': '2'}
|
||||
)
|
||||
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.start()
|
||||
|
||||
node.pgbench_init(scale=2)
|
||||
with node.connect("postgres") as con:
|
||||
con.execute("CREATE TABLE tbl0005 (a text)")
|
||||
con.commit()
|
||||
|
||||
backup_id = self.backup_node(backup_dir, 'node', node)
|
||||
|
||||
pgbench = node.pgbench(stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
|
||||
pgbench.wait()
|
||||
pgbench.stdout.close()
|
||||
|
||||
before = node.execute("postgres", "SELECT * FROM pgbench_branches")
|
||||
with node.connect("postgres") as con:
|
||||
result = con.execute("INSERT INTO tbl0005 VALUES ('inserted') RETURNING (xmin)")
|
||||
con.commit()
|
||||
target_xid = result[0][0]
|
||||
|
||||
pgbench = node.pgbench(stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
|
||||
pgbench.wait()
|
||||
pgbench.stdout.close()
|
||||
|
||||
node.stop()
|
||||
node.cleanup()
|
||||
|
||||
self.assertIn("INFO: Restore of backup {0} completed.".format(backup_id),
|
||||
self.restore_node(backup_dir, 'node', node,
|
||||
options=["-j", "4", '--xid={0}'.format(target_xid), "--inclusive=false"]),
|
||||
'\n Unexpected Error Message: {0}\n CMD: {1}'.format(repr(self.output), self.cmd))
|
||||
|
||||
node.start()
|
||||
while node.safe_psql("postgres", "select pg_is_in_recovery()") == 't\n':
|
||||
time.sleep(1)
|
||||
|
||||
after = node.execute("postgres", "SELECT * FROM pgbench_branches")
|
||||
self.assertEqual(before, after)
|
||||
self.assertEqual(len(node.execute("postgres", "SELECT * FROM tbl0005")), 0)
|
||||
|
||||
# Clean after yourself
|
||||
self.del_test_dir(module_name, fname)
|
||||
@ -277,6 +341,8 @@ class RestoreTest(ProbackupTest, unittest.TestCase):
|
||||
'\n Unexpected Error Message: {0}\n CMD: {1}'.format(repr(self.output), self.cmd))
|
||||
|
||||
node.start()
|
||||
while node.safe_psql("postgres", "select pg_is_in_recovery()") == 't\n':
|
||||
time.sleep(1)
|
||||
|
||||
after = node.execute("postgres", "SELECT * FROM pgbench_branches")
|
||||
self.assertEqual(before, after)
|
||||
@ -324,6 +390,8 @@ class RestoreTest(ProbackupTest, unittest.TestCase):
|
||||
'\n Unexpected Error Message: {0}\n CMD: {1}'.format(repr(self.output), self.cmd))
|
||||
|
||||
node.start()
|
||||
while node.safe_psql("postgres", "select pg_is_in_recovery()") == 't\n':
|
||||
time.sleep(1)
|
||||
|
||||
after = node.execute("postgres", "SELECT * FROM pgbench_branches")
|
||||
self.assertEqual(before, after)
|
||||
@ -366,6 +434,8 @@ class RestoreTest(ProbackupTest, unittest.TestCase):
|
||||
'\n Unexpected Error Message: {0}\n CMD: {1}'.format(repr(self.output), self.cmd))
|
||||
|
||||
node.start()
|
||||
while node.safe_psql("postgres", "select pg_is_in_recovery()") == 't\n':
|
||||
time.sleep(1)
|
||||
|
||||
after = node.execute("postgres", "SELECT * FROM pgbench_branches")
|
||||
self.assertEqual(before, after)
|
||||
@ -415,6 +485,8 @@ class RestoreTest(ProbackupTest, unittest.TestCase):
|
||||
'\n Unexpected Error Message: {0}\n CMD: {1}'.format(repr(self.output), self.cmd))
|
||||
|
||||
node.start()
|
||||
while node.safe_psql("postgres", "select pg_is_in_recovery()") == 't\n':
|
||||
time.sleep(1)
|
||||
|
||||
bbalance = node.execute("postgres", "SELECT sum(bbalance) FROM pgbench_branches")
|
||||
delta = node.execute("postgres", "SELECT sum(delta) FROM pgbench_history")
|
||||
@ -467,6 +539,8 @@ class RestoreTest(ProbackupTest, unittest.TestCase):
|
||||
self.restore_node(backup_dir, 'node', node, options=["-j", "4"]),
|
||||
'\n Unexpected Error Message: {0}\n CMD: {1}'.format(repr(self.output), self.cmd))
|
||||
node.start()
|
||||
while node.safe_psql("postgres", "select pg_is_in_recovery()") == 't\n':
|
||||
time.sleep(1)
|
||||
|
||||
bbalance = node.execute("postgres", "SELECT sum(bbalance) FROM pgbench_branches")
|
||||
delta = node.execute("postgres", "SELECT sum(delta) FROM pgbench_history")
|
||||
@ -475,63 +549,6 @@ class RestoreTest(ProbackupTest, unittest.TestCase):
|
||||
# Clean after yourself
|
||||
self.del_test_dir(module_name, fname)
|
||||
|
||||
# @unittest.skip("skip")
|
||||
def test_restore_to_xid_inclusive(self):
|
||||
"""recovery with target inclusive false"""
|
||||
fname = self.id().split('.')[3]
|
||||
node = self.make_simple_node(base_dir="{0}/{1}/node".format(module_name, fname),
|
||||
initdb_params=['--data-checksums'],
|
||||
pg_options={'wal_level': 'replica', 'ptrack_enable': 'on', 'max_wal_senders': '2'}
|
||||
)
|
||||
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.start()
|
||||
|
||||
node.pgbench_init(scale=2)
|
||||
with node.connect("postgres") as con:
|
||||
con.execute("CREATE TABLE tbl0005 (a text)")
|
||||
con.commit()
|
||||
|
||||
backup_id = self.backup_node(backup_dir, 'node', node)
|
||||
|
||||
pgbench = node.pgbench(stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
|
||||
pgbench.wait()
|
||||
pgbench.stdout.close()
|
||||
|
||||
before = node.execute("postgres", "SELECT * FROM pgbench_branches")
|
||||
with node.connect("postgres") as con:
|
||||
result = con.execute("INSERT INTO tbl0005 VALUES ('inserted') RETURNING (xmin)")
|
||||
con.commit()
|
||||
target_xid = result[0][0]
|
||||
|
||||
pgbench = node.pgbench(stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
|
||||
pgbench.wait()
|
||||
pgbench.stdout.close()
|
||||
|
||||
# Enforce segment to be archived to ensure that recovery goes up to the
|
||||
# wanted point. There is no way to ensure that all segments needed have
|
||||
# been archived up to the xmin point saved earlier without that.
|
||||
# node.execute("postgres", "SELECT pg_switch_xlog()")
|
||||
|
||||
node.stop()
|
||||
node.cleanup()
|
||||
|
||||
self.assertIn("INFO: Restore of backup {0} completed.".format(backup_id),
|
||||
self.restore_node(backup_dir, 'node', node,
|
||||
options=["-j", "4", '--xid={0}'.format(target_xid), "--inclusive=false"]),
|
||||
'\n Unexpected Error Message: {0}\n CMD: {1}'.format(repr(self.output), self.cmd))
|
||||
|
||||
node.start()
|
||||
|
||||
after = node.execute("postgres", "SELECT * FROM pgbench_branches")
|
||||
self.assertEqual(before, after)
|
||||
self.assertEqual(len(node.execute("postgres", "SELECT * FROM tbl0005")), 0)
|
||||
|
||||
# Clean after yourself
|
||||
self.del_test_dir(module_name, fname)
|
||||
|
||||
# @unittest.skip("skip")
|
||||
def test_restore_with_tablespace_mapping_1(self):
|
||||
"""recovery using tablespace-mapping option"""
|
||||
@ -591,6 +608,8 @@ class RestoreTest(ProbackupTest, unittest.TestCase):
|
||||
'\n Unexpected Error Message: {0}\n CMD: {1}'.format(repr(self.output), self.cmd))
|
||||
|
||||
node.start()
|
||||
while node.safe_psql("postgres", "select pg_is_in_recovery()") == 't\n':
|
||||
time.sleep(1)
|
||||
result = node.execute("postgres", "SELECT id FROM test")
|
||||
self.assertEqual(result[0][0], 1)
|
||||
|
||||
@ -614,6 +633,8 @@ class RestoreTest(ProbackupTest, unittest.TestCase):
|
||||
'\n Unexpected Error Message: {0}\n CMD: {1}'.format(repr(self.output), self.cmd))
|
||||
|
||||
node.start()
|
||||
while node.safe_psql("postgres", "select pg_is_in_recovery()") == 't\n':
|
||||
time.sleep(1)
|
||||
result = node.execute("postgres", "SELECT id FROM test OFFSET 1")
|
||||
self.assertEqual(result[0][0], 2)
|
||||
|
||||
@ -676,6 +697,8 @@ class RestoreTest(ProbackupTest, unittest.TestCase):
|
||||
self.restore_node(backup_dir, 'node', node, options=["-T", "%s=%s" % (tblspc_path, tblspc_path_new)]),
|
||||
'\n Unexpected Error Message: {0}\n CMD: {1}'.format(repr(self.output), self.cmd))
|
||||
node.start()
|
||||
while node.safe_psql("postgres", "select pg_is_in_recovery()") == 't\n':
|
||||
time.sleep(1)
|
||||
|
||||
count = node.execute("postgres", "SELECT count(*) FROM tbl")
|
||||
self.assertEqual(count[0][0], 4)
|
||||
@ -709,10 +732,12 @@ class RestoreTest(ProbackupTest, unittest.TestCase):
|
||||
recovery_time = self.show_pb(backup_dir, 'node', backup_id)['recovery-time']
|
||||
|
||||
self.assertIn("INFO: Restore of backup {0} completed.".format(backup_id),
|
||||
self.restore_node(backup_dir, 'node', node, options=["-j", "4", '--time="{0}"'.format(recovery_time)]),
|
||||
self.restore_node(backup_dir, 'node', node, options=["-j", "4", '--time={0}'.format(recovery_time)]),
|
||||
'\n Unexpected Error Message: {0}\n CMD: {1}'.format(repr(self.output), self.cmd))
|
||||
|
||||
node.start()
|
||||
while node.safe_psql("postgres", "select pg_is_in_recovery()") == 't\n':
|
||||
time.sleep(1)
|
||||
|
||||
result = node.psql("postgres", 'select * from t_heap')
|
||||
self.assertTrue('does not exist' in result[2].decode("utf-8"))
|
||||
@ -722,7 +747,7 @@ class RestoreTest(ProbackupTest, unittest.TestCase):
|
||||
|
||||
|
||||
# @unittest.skip("skip")
|
||||
@unittest.expectedFailure
|
||||
# @unittest.expectedFailure
|
||||
def test_archive_node_backup_stream_restore_to_recovery_time(self):
|
||||
"""make node with archiving, make stream backup, make PITR to Recovery Time"""
|
||||
fname = self.id().split('.')[3]
|
||||
@ -745,10 +770,12 @@ class RestoreTest(ProbackupTest, unittest.TestCase):
|
||||
recovery_time = self.show_pb(backup_dir, 'node', backup_id)['recovery-time']
|
||||
|
||||
self.assertIn("INFO: Restore of backup {0} completed.".format(backup_id),
|
||||
self.restore_node(backup_dir, 'node', node, options=["-j", "4", '--time="{0}"'.format(recovery_time)]),
|
||||
self.restore_node(backup_dir, 'node', node, options=["-j", "4", '--time={0}'.format(recovery_time)]),
|
||||
'\n Unexpected Error Message: {0}\n CMD: {1}'.format(repr(self.output), self.cmd))
|
||||
|
||||
node.start()
|
||||
while node.safe_psql("postgres", "select pg_is_in_recovery()") == 't\n':
|
||||
time.sleep(1)
|
||||
|
||||
result = node.psql("postgres", 'select * from t_heap')
|
||||
self.assertTrue('does not exist' in result[2].decode("utf-8"))
|
||||
@ -757,7 +784,7 @@ class RestoreTest(ProbackupTest, unittest.TestCase):
|
||||
self.del_test_dir(module_name, fname)
|
||||
|
||||
# @unittest.skip("skip")
|
||||
@unittest.expectedFailure
|
||||
# @unittest.expectedFailure
|
||||
def test_archive_node_backup_stream_pitr(self):
|
||||
"""make node with archiving, make stream backup, create table t_heap, make pitr to Recovery Time, check that t_heap do not exists"""
|
||||
fname = self.id().split('.')[3]
|
||||
@ -780,10 +807,12 @@ class RestoreTest(ProbackupTest, unittest.TestCase):
|
||||
|
||||
self.assertIn("INFO: Restore of backup {0} completed.".format(backup_id),
|
||||
self.restore_node(backup_dir, 'node', node,
|
||||
options=["-j", "4", '--time="{0}"'.format(recovery_time)]),
|
||||
options=["-j", "4", '--time={0}'.format(recovery_time)]),
|
||||
'\n Unexpected Error Message: {0}\n CMD: {1}'.format(repr(self.output), self.cmd))
|
||||
|
||||
node.start()
|
||||
while node.safe_psql("postgres", "select pg_is_in_recovery()") == 't\n':
|
||||
time.sleep(1)
|
||||
|
||||
result = node.psql("postgres", 'select * from t_heap')
|
||||
self.assertEqual(True, 'does not exist' in result[2].decode("utf-8"))
|
||||
@ -792,7 +821,7 @@ class RestoreTest(ProbackupTest, unittest.TestCase):
|
||||
self.del_test_dir(module_name, fname)
|
||||
|
||||
# @unittest.skip("skip")
|
||||
@unittest.expectedFailure
|
||||
# @unittest.expectedFailure
|
||||
def test_archive_node_backup_archive_pitr_2(self):
|
||||
"""make node with archiving, make archive backup, create table t_heap, make pitr to Recovery Time, check that t_heap do not exists"""
|
||||
fname = self.id().split('.')[3]
|
||||
@ -815,10 +844,12 @@ class RestoreTest(ProbackupTest, unittest.TestCase):
|
||||
|
||||
self.assertIn("INFO: Restore of backup {0} completed.".format(backup_id),
|
||||
self.restore_node(backup_dir, 'node', node,
|
||||
options=["-j", "4", '--time="{0}"'.format(recovery_time)]),
|
||||
options=["-j", "4", '--time={0}'.format(recovery_time)]),
|
||||
'\n Unexpected Error Message: {0}\n CMD: {1}'.format(repr(self.output), self.cmd))
|
||||
|
||||
node.start()
|
||||
while node.safe_psql("postgres", "select pg_is_in_recovery()") == 't\n':
|
||||
time.sleep(1)
|
||||
|
||||
result = node.psql("postgres", 'select * from t_heap')
|
||||
self.assertTrue('does not exist' in result[2].decode("utf-8"))
|
||||
|
||||
@ -47,13 +47,13 @@ class ValidateTest(ProbackupTest, unittest.TestCase):
|
||||
|
||||
# Validate to real time
|
||||
self.assertIn("INFO: backup validation completed successfully",
|
||||
self.validate_pb(backup_dir, 'node', options=["--time='{0}'".format(target_time)]),
|
||||
self.validate_pb(backup_dir, 'node', options=["--time={0}".format(target_time)]),
|
||||
'\n Unexpected Error Message: {0}\n CMD: {1}'.format(repr(self.output), self.cmd))
|
||||
|
||||
# Validate to unreal time
|
||||
unreal_time_1 = after_backup_time - timedelta(days=2)
|
||||
try:
|
||||
self.validate_pb(backup_dir, 'node', options=["--time='{0}'".format(unreal_time_1)])
|
||||
self.validate_pb(backup_dir, 'node', options=["--time={0}".format(unreal_time_1)])
|
||||
self.assertEqual(1, 0, "Expecting Error because of validation to unreal time.\n Output: {0} \n CMD: {1}".format(
|
||||
repr(self.output), self.cmd))
|
||||
except ProbackupException as e:
|
||||
@ -63,7 +63,7 @@ class ValidateTest(ProbackupTest, unittest.TestCase):
|
||||
# Validate to unreal time #2
|
||||
unreal_time_2 = after_backup_time + timedelta(days=2)
|
||||
try:
|
||||
self.validate_pb(backup_dir, 'node', options=["--time='{0}'".format(unreal_time_2)])
|
||||
self.validate_pb(backup_dir, 'node', options=["--time={0}".format(unreal_time_2)])
|
||||
self.assertEqual(1, 0, "Expecting Error because of validation to unreal time.\n Output: {0} \n CMD: {1}".format(
|
||||
repr(self.output), self.cmd))
|
||||
except ProbackupException as e:
|
||||
@ -76,7 +76,7 @@ class ValidateTest(ProbackupTest, unittest.TestCase):
|
||||
res = con.execute("INSERT INTO tbl0005 VALUES ('inserted') RETURNING (xmin)")
|
||||
con.commit()
|
||||
target_xid = res[0][0]
|
||||
node.execute("postgres", "SELECT pg_switch_xlog()")
|
||||
node.execute("postgres", "SELECT pg_switch_wal()")
|
||||
|
||||
self.assertIn("INFO: backup validation completed successfully",
|
||||
self.validate_pb(backup_dir, 'node', options=["--xid={0}".format(target_xid)]),
|
||||
@ -320,10 +320,15 @@ class ValidateTest(ProbackupTest, unittest.TestCase):
|
||||
node.start()
|
||||
|
||||
backup_id = self.backup_node(backup_dir, 'node', node, options=["--stream"])
|
||||
recovery_time = self.show_pb(backup_dir, 'node', backup_id)['recovery-time']
|
||||
recovery_time = self.show_pb(backup_dir, 'node', backup_id=backup_id)['recovery-time']
|
||||
|
||||
self.assertIn("INFO: backup validation completed successfully on",
|
||||
self.validate_pb(backup_dir, 'node', node, options=["--time='{0}'".format(recovery_time)]))
|
||||
try:
|
||||
self.validate_pb(backup_dir, 'node', options=["--time={0}".format(recovery_time)])
|
||||
self.assertEqual(1, 0, "Expecting Error because of wal segment disappearance.\n Output: {0} \n CMD: {1}".format(
|
||||
self.output, self.cmd))
|
||||
except ProbackupException as e:
|
||||
self.assertIn('WAL archive is empty. You cannot restore backup to a recovery target without WAL archive', e.message,
|
||||
'\n Unexpected Error Message: {0}\n CMD: {1}'.format(repr(e.message), self.cmd))
|
||||
|
||||
# Clean after yourself
|
||||
self.del_test_dir(module_name, fname)
|
||||
@ -346,20 +351,7 @@ class ValidateTest(ProbackupTest, unittest.TestCase):
|
||||
backup_id = self.backup_node(backup_dir, 'node', node)
|
||||
recovery_time = self.show_pb(backup_dir, 'node', backup_id)['recovery-time']
|
||||
|
||||
# Uncommenting this section will make this test True Positive
|
||||
#node.safe_psql("postgres", "select pg_create_restore_point('123')")
|
||||
#node.safe_psql("postgres", "select txid_current()")
|
||||
#node.safe_psql("postgres", "select pg_switch_xlog()")
|
||||
####
|
||||
|
||||
#try:
|
||||
self.validate_pb(backup_dir, 'node', options=["--time='{0}'".format(recovery_time)])
|
||||
# we should die here because exception is what we expect to happen
|
||||
# self.assertEqual(1, 0, "Expecting Error because it should not be possible safely validate 'Recovery Time' without wal record with timestamp.\n Output: {0} \n CMD: {1}".format(
|
||||
# repr(self.output), self.cmd))
|
||||
# except ProbackupException as e:
|
||||
# self.assertTrue('WARNING: recovery can be done up to time {0}'.format(recovery_time) in e.message,
|
||||
# '\n Unexpected Error Message: {0}\n CMD: {1}'.format(repr(e.message), self.cmd))
|
||||
self.validate_pb(backup_dir, 'node', options=["--time={0}".format(recovery_time)])
|
||||
|
||||
# Clean after yourself
|
||||
self.del_test_dir(module_name, fname)
|
||||
@ -367,9 +359,7 @@ class ValidateTest(ProbackupTest, unittest.TestCase):
|
||||
# @unittest.skip("skip")
|
||||
# @unittest.expectedFailure
|
||||
def test_pgpro561(self):
|
||||
"""
|
||||
make node with archiving, make stream backup, restore it to node1,
|
||||
check that archiving is not successful on node1
|
||||
"""make node with archiving, make stream backup, restore it to node1, check that archiving is not successful on node1
|
||||
"""
|
||||
fname = self.id().split('.')[3]
|
||||
node1 = self.make_simple_node(base_dir="{0}/{1}/node1".format(module_name, fname),
|
||||
|
||||
Reference in New Issue
Block a user