mirror of
https://github.com/postgrespro/pg_probackup.git
synced 2024-11-29 09:42:27 +02:00
297 lines
10 KiB
Python
297 lines
10 KiB
Python
import unittest
|
|
import os
|
|
from .helpers.ptrack_helpers import ProbackupTest, ProbackupException
|
|
from datetime import datetime, timedelta
|
|
import subprocess
|
|
|
|
|
|
module_name = 'false_positive'
|
|
|
|
|
|
class FalsePositive(ProbackupTest, unittest.TestCase):
|
|
|
|
# @unittest.skip("skip")
|
|
@unittest.expectedFailure
|
|
def test_validate_wal_lost_segment(self):
|
|
"""
|
|
Loose segment located between backups. ExpectedFailure. This is BUG
|
|
"""
|
|
fname = self.id().split('.')[3]
|
|
node = self.make_simple_node(
|
|
base_dir=os.path.join(module_name, fname, 'node'),
|
|
set_replication=True,
|
|
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()
|
|
|
|
self.backup_node(backup_dir, 'node', node)
|
|
|
|
# make some wals
|
|
node.pgbench_init(scale=5)
|
|
|
|
# delete last wal segment
|
|
wals_dir = os.path.join(backup_dir, "wal", 'node')
|
|
wals = [f for f in os.listdir(wals_dir) if os.path.isfile(
|
|
os.path.join(wals_dir, f)) and not f.endswith('.backup')]
|
|
wals = map(int, wals)
|
|
os.remove(os.path.join(wals_dir, '0000000' + str(max(wals))))
|
|
|
|
# We just lost a wal segment and know nothing about it
|
|
self.backup_node(backup_dir, 'node', node)
|
|
self.assertTrue(
|
|
'validation completed successfully' in self.validate_pb(
|
|
backup_dir, 'node'))
|
|
########
|
|
|
|
# Clean after yourself
|
|
self.del_test_dir(module_name, fname)
|
|
|
|
@unittest.expectedFailure
|
|
# Need to force validation of ancestor-chain
|
|
def test_incremental_backup_corrupt_full_1(self):
|
|
"""page-level backup with corrupted full backup"""
|
|
fname = self.id().split('.')[3]
|
|
node = self.make_simple_node(
|
|
base_dir=os.path.join(module_name, fname, 'node'),
|
|
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()
|
|
|
|
backup_id = self.backup_node(backup_dir, 'node', node)
|
|
file = os.path.join(
|
|
backup_dir, "backups", "node",
|
|
backup_id.decode("utf-8"), "database", "postgresql.conf")
|
|
os.remove(file)
|
|
|
|
try:
|
|
self.backup_node(backup_dir, 'node', node, backup_type="page")
|
|
# we should die here because exception is what we expect to happen
|
|
self.assertEqual(
|
|
1, 0,
|
|
"Expecting Error because page backup should not be "
|
|
"possible without valid full backup.\n "
|
|
"Output: {0} \n CMD: {1}".format(
|
|
repr(self.output), self.cmd))
|
|
except ProbackupException as e:
|
|
self.assertEqual(
|
|
e.message,
|
|
'ERROR: Valid backup on current timeline is not found. '
|
|
'Create new FULL backup before an incremental one.\n',
|
|
'\n Unexpected Error Message: {0}\n CMD: {1}'.format(
|
|
repr(e.message), self.cmd))
|
|
|
|
sleep(1)
|
|
self.assertFalse(
|
|
True,
|
|
"Expecting Error because page backup should not be "
|
|
"possible without valid full backup.\n "
|
|
"Output: {0} \n CMD: {1}".format(
|
|
repr(self.output), self.cmd))
|
|
except ProbackupException as e:
|
|
self.assertEqual(
|
|
e.message,
|
|
'ERROR: Valid backup on current timeline is not found. '
|
|
'Create new FULL backup before an incremental one.\n',
|
|
'\n Unexpected Error Message: {0}\n CMD: {1}'.format(
|
|
repr(e.message), self.cmd))
|
|
|
|
self.assertEqual(
|
|
self.show_pb(backup_dir, 'node')[0]['Status'], "ERROR")
|
|
|
|
# Clean after yourself
|
|
self.del_test_dir(module_name, fname)
|
|
|
|
@unittest.expectedFailure
|
|
def test_ptrack_concurrent_get_and_clear_1(self):
|
|
"""make node, make full and ptrack stream backups,"
|
|
" restore them and check data correctness"""
|
|
|
|
if not self.ptrack:
|
|
return unittest.skip('Skipped because ptrack support is disabled')
|
|
|
|
fname = self.id().split('.')[3]
|
|
backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
|
|
node = self.make_simple_node(
|
|
base_dir=os.path.join(module_name, fname, 'node'),
|
|
set_replication=True,
|
|
initdb_params=['--data-checksums'],
|
|
pg_options={
|
|
'checkpoint_timeout': '300s',
|
|
'ptrack_enable': 'on'
|
|
}
|
|
)
|
|
self.init_pb(backup_dir)
|
|
self.add_instance(backup_dir, 'node', node)
|
|
self.set_archiving(backup_dir, 'node', node)
|
|
node.slow_start()
|
|
|
|
node.safe_psql(
|
|
"postgres",
|
|
"create table t_heap as select i"
|
|
" as id from generate_series(0,1) i"
|
|
)
|
|
|
|
self.backup_node(backup_dir, 'node', node, options=['--stream'])
|
|
gdb = self.backup_node(
|
|
backup_dir, 'node', node, backup_type='ptrack',
|
|
options=['--stream'],
|
|
gdb=True
|
|
)
|
|
|
|
gdb.set_breakpoint('make_pagemap_from_ptrack')
|
|
gdb.run_until_break()
|
|
|
|
node.safe_psql(
|
|
"postgres",
|
|
"update t_heap set id = 100500")
|
|
|
|
tablespace_oid = node.safe_psql(
|
|
"postgres",
|
|
"select oid from pg_tablespace where spcname = 'pg_default'").rstrip()
|
|
|
|
relfilenode = node.safe_psql(
|
|
"postgres",
|
|
"select 't_heap'::regclass::oid").rstrip()
|
|
|
|
node.safe_psql(
|
|
"postgres",
|
|
"SELECT pg_ptrack_get_and_clear({0}, {1})".format(
|
|
tablespace_oid, relfilenode))
|
|
|
|
gdb.continue_execution_until_exit()
|
|
|
|
self.backup_node(
|
|
backup_dir, 'node', node,
|
|
backup_type='ptrack', options=['--stream']
|
|
)
|
|
if self.paranoia:
|
|
pgdata = self.pgdata_content(node.data_dir)
|
|
|
|
result = node.safe_psql("postgres", "SELECT * FROM t_heap")
|
|
node.cleanup()
|
|
self.restore_node(backup_dir, 'node', node, options=["-j", "4"])
|
|
|
|
# Physical comparison
|
|
if self.paranoia:
|
|
pgdata_restored = self.pgdata_content(
|
|
node.data_dir, ignore_ptrack=False)
|
|
self.compare_pgdata(pgdata, pgdata_restored)
|
|
|
|
node.slow_start()
|
|
# Logical comparison
|
|
self.assertEqual(
|
|
result,
|
|
node.safe_psql("postgres", "SELECT * FROM t_heap"))
|
|
|
|
# Clean after yourself
|
|
self.del_test_dir(module_name, fname)
|
|
|
|
@unittest.expectedFailure
|
|
def test_ptrack_concurrent_get_and_clear_2(self):
|
|
"""make node, make full and ptrack stream backups,"
|
|
" restore them and check data correctness"""
|
|
|
|
if not self.ptrack:
|
|
return unittest.skip('Skipped because ptrack support is disabled')
|
|
|
|
fname = self.id().split('.')[3]
|
|
backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
|
|
node = self.make_simple_node(
|
|
base_dir=os.path.join(module_name, fname, 'node'),
|
|
set_replication=True,
|
|
initdb_params=['--data-checksums'],
|
|
pg_options={
|
|
'checkpoint_timeout': '300s',
|
|
'ptrack_enable': 'on'
|
|
}
|
|
)
|
|
self.init_pb(backup_dir)
|
|
self.add_instance(backup_dir, 'node', node)
|
|
self.set_archiving(backup_dir, 'node', node)
|
|
node.slow_start()
|
|
|
|
node.safe_psql(
|
|
"postgres",
|
|
"create table t_heap as select i"
|
|
" as id from generate_series(0,1) i"
|
|
)
|
|
|
|
self.backup_node(backup_dir, 'node', node, options=['--stream'])
|
|
gdb = self.backup_node(
|
|
backup_dir, 'node', node, backup_type='ptrack',
|
|
options=['--stream'],
|
|
gdb=True
|
|
)
|
|
|
|
gdb.set_breakpoint('pthread_create')
|
|
gdb.run_until_break()
|
|
|
|
node.safe_psql(
|
|
"postgres",
|
|
"update t_heap set id = 100500")
|
|
|
|
tablespace_oid = node.safe_psql(
|
|
"postgres",
|
|
"select oid from pg_tablespace "
|
|
"where spcname = 'pg_default'").rstrip()
|
|
|
|
relfilenode = node.safe_psql(
|
|
"postgres",
|
|
"select 't_heap'::regclass::oid").rstrip()
|
|
|
|
node.safe_psql(
|
|
"postgres",
|
|
"SELECT pg_ptrack_get_and_clear({0}, {1})".format(
|
|
tablespace_oid, relfilenode))
|
|
|
|
gdb._execute("delete breakpoints")
|
|
gdb.continue_execution_until_exit()
|
|
|
|
try:
|
|
self.backup_node(
|
|
backup_dir, 'node', node,
|
|
backup_type='ptrack', options=['--stream']
|
|
)
|
|
# we should die here because exception is what we expect to happen
|
|
self.assertEqual(
|
|
1, 0,
|
|
"Expecting Error because of LSN mismatch from ptrack_control "
|
|
"and previous backup ptrack_lsn.\n"
|
|
" Output: {0} \n CMD: {1}".format(repr(self.output), self.cmd))
|
|
except ProbackupException as e:
|
|
self.assertTrue(
|
|
'ERROR: LSN from ptrack_control' in e.message,
|
|
'\n Unexpected Error Message: {0}\n CMD: {1}'.format(
|
|
repr(e.message), self.cmd))
|
|
|
|
if self.paranoia:
|
|
pgdata = self.pgdata_content(node.data_dir)
|
|
|
|
result = node.safe_psql("postgres", "SELECT * FROM t_heap")
|
|
node.cleanup()
|
|
self.restore_node(backup_dir, 'node', node, options=["-j", "4"])
|
|
|
|
# Physical comparison
|
|
if self.paranoia:
|
|
pgdata_restored = self.pgdata_content(
|
|
node.data_dir, ignore_ptrack=False)
|
|
self.compare_pgdata(pgdata, pgdata_restored)
|
|
|
|
node.slow_start()
|
|
# Logical comparison
|
|
self.assertEqual(
|
|
result,
|
|
node.safe_psql("postgres", "SELECT * FROM t_heap")
|
|
)
|
|
|
|
# Clean after yourself
|
|
self.del_test_dir(module_name, fname)
|