def test_receive_wal(self, receivexlog_mock, remote_mock, tmpdir):
backup_manager = build_backup_manager(
main_conf={"backup_directory": tmpdir},
)
streaming_mock = backup_manager.server.streaming
streaming_mock.server_txt_version = "9.4.0"
streaming_mock.get_connection_string.return_value = (
"host=pg01.nowhere user=postgres port=5432 "
"application_name=barman_receive_wal"
)
streaming_mock.get_remote_status.return_value = {
"streaming_supported": True,
"timeline": 1,
}
postgres_mock = backup_manager.server.postgres
replication_slot_status = MagicMock(restart_lsn="F/A12D687", active=False)
postgres_mock.get_remote_status.return_value = {
"current_xlog": "000000010000000F0000000A",
"current_lsn": "F/A12D687",
"replication_slot": replication_slot_status,
"xlog_segment_size": 16777216,
}
backup_manager.server.streaming.conn_parameters = {
"host": "pg01.nowhere",
"user": "******",
"port": "5432",
}
streaming_dir = tmpdir.join("streaming")
streaming_dir.ensure(dir=True)
# Test: normal run
archiver = StreamingWalArchiver(backup_manager)
archiver.server.streaming.server_version = 90400
remote_mock.return_value = {
"pg_receivexlog_installed": True,
"pg_receivexlog_compatible": True,
"pg_receivexlog_synchronous": None,
"pg_receivexlog_path": "fake/path",
"pg_receivexlog_supports_slots": True,
"pg_receivexlog_version": "9.4",
}
# Test: execute a reset request
partial = streaming_dir.join("000000010000000100000001.partial")
partial.ensure()
archiver.receive_wal(reset=True)
assert not partial.check()
assert streaming_dir.join("000000010000000F0000000A.partial").check()
archiver.receive_wal(reset=False)
receivexlog_mock.assert_called_once_with(
app_name="barman_receive_wal",
synchronous=None,
connection=ANY,
destination=streaming_dir.strpath,
err_handler=ANY,
out_handler=ANY,
path=ANY,
slot_name=None,
command="fake/path",
version="9.4",
)
receivexlog_mock.return_value.execute.assert_called_once_with()
# Test: pg_receivexlog from 9.2
receivexlog_mock.reset_mock()
remote_mock.return_value = {
"pg_receivexlog_installed": True,
"pg_receivexlog_compatible": True,
"pg_receivexlog_synchronous": False,
"pg_receivexlog_path": "fake/path",
"pg_receivexlog_supports_slots": False,
"pg_receivexlog_version": "9.2",
}
archiver.receive_wal(reset=False)
receivexlog_mock.assert_called_once_with(
app_name="barman_receive_wal",
synchronous=False,
connection=ANY,
destination=streaming_dir.strpath,
err_handler=ANY,
out_handler=ANY,
path=ANY,
command="fake/path",
slot_name=None,
version="9.2",
)
receivexlog_mock.return_value.execute.assert_called_once_with()
# Test: incompatible pg_receivexlog
with pytest.raises(ArchiverFailure):
remote_mock.return_value = {
"pg_receivexlog_installed": True,
"pg_receivexlog_compatible": False,
"pg_receivexlog_supports_slots": False,
"pg_receivexlog_synchronous": False,
"pg_receivexlog_path": "fake/path",
}
archiver.receive_wal()
# Test: missing pg_receivexlog
with pytest.raises(ArchiverFailure):
remote_mock.return_value = {
"pg_receivexlog_installed": False,
"pg_receivexlog_compatible": True,
"pg_receivexlog_supports_slots": False,
"pg_receivexlog_synchronous": False,
"pg_receivexlog_path": "fake/path",
}
archiver.receive_wal()
# Test: impossible to connect with streaming protocol
with pytest.raises(ArchiverFailure):
backup_manager.server.streaming.get_remote_status.return_value = {
"streaming_supported": None
}
remote_mock.return_value = {
"pg_receivexlog_installed": True,
"pg_receivexlog_supports_slots": False,
"pg_receivexlog_compatible": True,
"pg_receivexlog_synchronous": False,
"pg_receivexlog_path": "fake/path",
}
archiver.receive_wal()
# Test: PostgreSQL too old
with pytest.raises(ArchiverFailure):
backup_manager.server.streaming.get_remote_status.return_value = {
"streaming_supported": False
}
remote_mock.return_value = {
"pg_receivexlog_installed": True,
"pg_receivexlog_compatible": True,
"pg_receivexlog_synchronous": False,
"pg_receivexlog_path": "fake/path",
}
archiver.receive_wal()
# Test: general failure executing pg_receivexlog
with pytest.raises(ArchiverFailure):
remote_mock.return_value = {
"pg_receivexlog_installed": True,
"pg_receivexlog_compatible": True,
"pg_receivexlog_synchronous": False,
"pg_receivexlog_path": "fake/path",
}
receivexlog_mock.return_value.execute.side_effect = CommandFailedException
archiver.receive_wal()
def test_receive_wal(self, receivexlog_mock, remote_mock, tmpdir):
backup_manager = build_backup_manager(
main_conf={
'backup_directory': tmpdir
},
)
streaming_mock = backup_manager.server.streaming
streaming_mock.server_txt_version = "9.4.0"
streaming_mock.get_connection_string.return_value = (
'host=pg01.nowhere user=postgres port=5432 '
'application_name=barman_receive_wal')
streaming_mock.get_remote_status.return_value = {
"streaming_supported": True
}
backup_manager.server.streaming.conn_parameters = {
'host': 'pg01.nowhere',
'user': '******',
'port': '5432',
}
streaming_dir = tmpdir.join('streaming')
streaming_dir.ensure(dir=True)
# Test: normal run
archiver = StreamingWalArchiver(backup_manager)
archiver.server.streaming.server_version = 90400
remote_mock.return_value = {
'pg_receivexlog_installed': True,
'pg_receivexlog_compatible': True,
'pg_receivexlog_synchronous': None,
'pg_receivexlog_path': 'fake/path',
'pg_receivexlog_supports_slots': True,
'pg_receivexlog_version': '9.4',
}
# Test: execute a reset request
partial = streaming_dir.join('test.partial')
partial.ensure()
archiver.receive_wal(reset=True)
assert not partial.check()
archiver.receive_wal(reset=False)
receivexlog_mock.assert_called_once_with(
app_name='barman_receive_wal',
synchronous=None,
connection=ANY,
destination=streaming_dir.strpath,
err_handler=ANY,
out_handler=ANY,
path=ANY,
slot_name=None,
command='fake/path',
version='9.4')
receivexlog_mock.return_value.execute.assert_called_once_with()
# Test: pg_receivexlog from 9.2
receivexlog_mock.reset_mock()
remote_mock.return_value = {
'pg_receivexlog_installed': True,
'pg_receivexlog_compatible': True,
'pg_receivexlog_synchronous': False,
'pg_receivexlog_path': 'fake/path',
'pg_receivexlog_supports_slots': False,
'pg_receivexlog_version': '9.2',
}
archiver.receive_wal(reset=False)
receivexlog_mock.assert_called_once_with(
app_name='barman_receive_wal',
synchronous=False,
connection=ANY,
destination=streaming_dir.strpath,
err_handler=ANY,
out_handler=ANY,
path=ANY,
command='fake/path',
slot_name=None,
version='9.2'
)
receivexlog_mock.return_value.execute.assert_called_once_with()
# Test: incompatible pg_receivexlog
with pytest.raises(ArchiverFailure):
remote_mock.return_value = {
'pg_receivexlog_installed': True,
'pg_receivexlog_compatible': False,
'pg_receivexlog_supports_slots': False,
'pg_receivexlog_synchronous': False,
'pg_receivexlog_path': 'fake/path'
}
archiver.receive_wal()
# Test: missing pg_receivexlog
with pytest.raises(ArchiverFailure):
remote_mock.return_value = {
'pg_receivexlog_installed': False,
'pg_receivexlog_compatible': True,
'pg_receivexlog_supports_slots': False,
'pg_receivexlog_synchronous': False,
'pg_receivexlog_path': 'fake/path'
}
archiver.receive_wal()
# Test: impossible to connect with streaming protocol
with pytest.raises(ArchiverFailure):
backup_manager.server.streaming.get_remote_status.return_value = {
'streaming_supported': None
}
remote_mock.return_value = {
'pg_receivexlog_installed': True,
'pg_receivexlog_supports_slots': False,
'pg_receivexlog_compatible': True,
'pg_receivexlog_synchronous': False,
'pg_receivexlog_path': 'fake/path'
}
archiver.receive_wal()
# Test: PostgreSQL too old
with pytest.raises(ArchiverFailure):
backup_manager.server.streaming.get_remote_status.return_value = {
'streaming_supported': False
}
remote_mock.return_value = {
'pg_receivexlog_installed': True,
'pg_receivexlog_compatible': True,
'pg_receivexlog_synchronous': False,
'pg_receivexlog_path': 'fake/path'
}
archiver.receive_wal()
# Test: general failure executing pg_receivexlog
with pytest.raises(ArchiverFailure):
remote_mock.return_value = {
'pg_receivexlog_installed': True,
'pg_receivexlog_compatible': True,
'pg_receivexlog_synchronous': False,
'pg_receivexlog_path': 'fake/path'
}
receivexlog_mock.return_value.execute.side_effect = \
CommandFailedException
archiver.receive_wal()
def test_receive_wal(self, receivexlog_mock, remote_mock, tmpdir):
backup_manager = build_backup_manager(
main_conf={
'backup_directory': tmpdir
},
)
backup_manager.server.streaming.server_txt_version = "9.4.0"
backup_manager.server.streaming.get_remote_status.return_value = {
"streaming_supported": True
}
backup_manager.server.streaming.conn_parameters = {
'host': 'pg01.nowhere',
'user': '******',
'port': '5432',
}
streaming_dir = tmpdir.join('streaming')
streaming_dir.ensure(dir=True)
# Test: normal run
archiver = StreamingWalArchiver(backup_manager)
remote_mock.return_value = {
'pg_receivexlog_installed': True,
'pg_receivexlog_compatible': True,
'pg_receivexlog_path': 'fake/path',
'pg_receivexlog_version': '9.4',
}
# Test: execute a reset request
partial = streaming_dir.join('test.partial')
partial.ensure()
archiver.receive_wal(reset=True)
assert not partial.check()
archiver.receive_wal(reset=False)
receivexlog_mock.assert_called_once_with(
'fake/path',
conn_string='host=pg01.nowhere user=postgres port=5432 '
'application_name=barman_receive_wal',
dest=streaming_dir.strpath,
out_handler=ANY,
err_handler=ANY,
)
receivexlog_mock.return_value.execute.assert_called_once_with()
# Test: pg_receivexlog from 9.2
receivexlog_mock.reset_mock()
remote_mock.return_value = {
'pg_receivexlog_installed': True,
'pg_receivexlog_compatible': True,
'pg_receivexlog_path': 'fake/path',
'pg_receivexlog_version': '9.2',
}
archiver.receive_wal(reset=False)
receivexlog_mock.assert_called_once_with(
'fake/path',
host='pg01.nowhere',
user='******',
port='5432',
dest=streaming_dir.strpath,
out_handler=ANY,
err_handler=ANY,
)
receivexlog_mock.return_value.execute.assert_called_once_with()
# Test: incompatible pg_receivexlog
with pytest.raises(ArchiverFailure):
remote_mock.return_value = {
'pg_receivexlog_installed': True,
'pg_receivexlog_compatible': False,
'pg_receivexlog_path': 'fake/path'
}
archiver.receive_wal()
# Test: missing pg_receivexlog
with pytest.raises(ArchiverFailure):
remote_mock.return_value = {
'pg_receivexlog_installed': False,
'pg_receivexlog_compatible': True,
'pg_receivexlog_path': 'fake/path'
}
archiver.receive_wal()
# Test: impossible to connect with streaming protocol
with pytest.raises(ArchiverFailure):
backup_manager.server.streaming.get_remote_status.return_value = {
'streaming_supported': None
}
remote_mock.return_value = {
'pg_receivexlog_installed': True,
'pg_receivexlog_compatible': True,
'pg_receivexlog_path': 'fake/path'
}
archiver.receive_wal()
# Test: PostgreSQL too old
with pytest.raises(ArchiverFailure):
backup_manager.server.streaming.get_remote_status.return_value = {
'streaming_supported': False
}
remote_mock.return_value = {
'pg_receivexlog_installed': True,
'pg_receivexlog_compatible': True,
'pg_receivexlog_path': 'fake/path'
}
archiver.receive_wal()
# Test: general failure executing pg_receivexlog
with pytest.raises(ArchiverFailure):
remote_mock.return_value = {
'pg_receivexlog_installed': True,
'pg_receivexlog_compatible': True,
'pg_receivexlog_path': 'fake/path'
}
receivexlog_mock.return_value.execute.side_effect = \
CommandFailedException
archiver.receive_wal()
def test_receive_wal(self, receivexlog_mock, remote_mock):
backup_manager = build_backup_manager()
backup_manager.server.streaming.server_txt_version = "9.4.0"
backup_manager.server.streaming.get_remote_status.return_value = {"streaming_supported": True}
# Test: normal run
archiver = StreamingWalArchiver(backup_manager)
remote_mock.return_value = {
"pg_receivexlog_installed": True,
"pg_receivexlog_compatible": True,
"pg_receivexlog_path": "fake/path",
}
archiver.receive_wal()
receivexlog_mock.assert_called_once_with(
"fake/path", "host=pg01.nowhere user=postgres port=5432", "/some/barman/home/main/streaming"
)
receivexlog_mock.return_value.execute.assert_called_once_with()
# Test: incompatible pg_receivexlog
with pytest.raises(ArchiverFailure):
remote_mock.return_value = {
"pg_receivexlog_installed": True,
"pg_receivexlog_compatible": False,
"pg_receivexlog_path": "fake/path",
}
archiver.receive_wal()
# Test: missing pg_receivexlog
with pytest.raises(ArchiverFailure):
remote_mock.return_value = {
"pg_receivexlog_installed": False,
"pg_receivexlog_compatible": True,
"pg_receivexlog_path": "fake/path",
}
archiver.receive_wal()
# Test: impossible to connect with streaming protocol
with pytest.raises(ArchiverFailure):
backup_manager.server.streaming.get_remote_status.return_value = {"streaming_supported": None}
remote_mock.return_value = {
"pg_receivexlog_installed": True,
"pg_receivexlog_compatible": True,
"pg_receivexlog_path": "fake/path",
}
archiver.receive_wal()
# Test: PostgreSQL too old
with pytest.raises(ArchiverFailure):
backup_manager.server.streaming.get_remote_status.return_value = {"streaming_supported": False}
remote_mock.return_value = {
"pg_receivexlog_installed": True,
"pg_receivexlog_compatible": True,
"pg_receivexlog_path": "fake/path",
}
archiver.receive_wal()
# Test: general failure executing pg_receivexlog
with pytest.raises(ArchiverFailure):
remote_mock.return_value = {
"pg_receivexlog_installed": True,
"pg_receivexlog_compatible": True,
"pg_receivexlog_path": "fake/path",
}
receivexlog_mock.return_value.execute.side_effect = CommandFailedException
archiver.receive_wal()
