def test_xlogdb(self, lock_file_mock, os_mock, tmpdir):
"""
Testing the normal execution of xlog-db operations.
:param lock_file_mock: mock for LockFile object
:param os_mock: mock for os module
:param tmpdir: temporary directory unique to the test invocation
"""
# unpatch os.path
os_mock.path = os.path
# Setup temp dir and server
server = Server(self.build_config(tmpdir))
# Test the execution of the fsync on xlogdb file
with server.xlogdb('w') as fxlogdb:
fxlogdb.write("00000000000000000000")
# Check for calls on fsync method. If the call have been issued
# the "exit" method of the contextmanager have been executed
assert os_mock.fsync.called
# Check for enter and exit calls on mocked LockFile
lock_file_mock.return_value.__enter__.assert_called_once_with()
lock_file_mock.return_value.__exit__.assert_called_once_with(
None, None, None)
os_mock.fsync.reset_mock()
with server.xlogdb():
# nothing to do here.
pass
# Check for calls on fsync method.
# If the file is readonly exit method of the context manager must
# skip calls on fsync method
assert not os_mock.fsync.called
def test_bad_init(self):
"""
Check the server is buildable with an empty configuration
"""
server = Server(build_config_from_dicts(
main_conf={
'conninfo': '',
'ssh_command': '',
}
).get_server('main'))
assert server.config.disabled
# ARCHIVER_OFF_BACKCOMPATIBILITY - START OF CODE
# # Check that either archiver or streaming_archiver are set
# server = Server(build_config_from_dicts(
# main_conf={
# 'archiver': 'off',
# 'streaming_archiver': 'off'
# }
# ).get_server('main'))
# assert server.config.disabled
# assert "No archiver enabled for server 'main'. " \
# "Please turn on 'archiver', 'streaming_archiver' or " \
# "both" in server.config.msg_list
# ARCHIVER_OFF_BACKCOMPATIBILITY - START OF CODE
server = Server(build_config_from_dicts(
main_conf={
'archiver': 'off',
'streaming_archiver': 'on',
'slot_name': ''
}
).get_server('main'))
assert server.config.disabled
assert "Streaming-only archiver requires 'streaming_conninfo' and " \
"'slot_name' options to be properly configured" \
in server.config.msg_list
def test_get_wal_full_path(self, tmpdir):
"""
Testing Server.get_wal_full_path() method
"""
wal_name = '0000000B00000A36000000FF'
wal_hash = wal_name[:16]
server = Server(self.build_config(tmpdir))
full_path = server.get_wal_full_path(wal_name)
assert full_path == \
str(tmpdir.join('wals').join(wal_hash).join(wal_name))
def test_check_config_missing(self):
"""
Verify the check method can be called on an empty configuration
"""
server = Server(build_config_from_dicts(
main_conf={
'conninfo': '',
'ssh_command': '',
}
).get_server('main'))
check_strategy = CheckOutputStrategy()
server.check(check_strategy)
assert check_strategy.has_error
def get_server_list(args):
''' Get the server list from the configuration '''
if args.server_name[0] == 'all':
return dict(
(conf.name, Server(conf)) for conf in barman.__config__.servers())
else:
server_dict = {}
for server in args.server_name:
conf = barman.__config__.get_server(server)
if conf == None:
server_dict[server] = None
else:
server_dict[server] = Server(conf)
return server_dict
def test_manage_server_command(self, monkeypatch, capsys):
"""
Test manage_server_command method checking
the various types of error output
:param monkeypatch monkeypatch: pytest patcher
"""
# Build a server with a config with path conflicts
monkeypatch.setattr(
barman,
"__config__",
build_config_from_dicts(
main_conf=build_config_dictionary(
{
"wals_directory": "/some/barman/home/main/wals",
"basebackups_directory": "/some/barman/home/main/wals",
"archiver": "on",
}
)
),
)
server = Server(barman.__config__.get_server("main"))
# Test a not blocking WARNING message
manage_server_command(server)
out, err = capsys.readouterr()
# Expect an ERROR message because of conflicting paths
assert "ERROR: Conflicting path" in err
# Build a server with a config without path conflicts
monkeypatch.setattr(barman, "__config__", build_config_from_dicts())
server = Server(barman.__config__.get_server("main"))
# Set the server as not active
server.config.active = False
# Request to treat inactive as errors
to_be_executed = manage_server_command(server, inactive_is_error=True)
out, err = capsys.readouterr()
# Expect a ERROR message because of a not active server
assert "ERROR: Inactive server" in err
assert not to_be_executed
# Request to treat inactive as warning
to_be_executed = manage_server_command(server, inactive_is_error=False)
out, err = capsys.readouterr()
# Expect no error whatsoever
assert err == ""
assert not to_be_executed
def test_init(self):
"""
Basic initialization test with minimal parameters
"""
server = Server(build_config_from_dicts(
global_conf={
'archiver': 'on'
}).get_server('main'))
assert not server.config.disabled
def main():
parser = argparse.ArgumentParser(description="Barman plugin for NRPE.")
parser.add_argument("-s",
"--server",
dest="server",
help="server to check")
parser.add_argument('-w',
'--warning',
type=int,
dest="warning",
metavar="W",
help="warning threshold.")
parser.add_argument('-c',
'--critical',
type=int,
dest="critical",
metavar="C",
help="critical threshold.")
parser.add_argument(
'-u'
'--user',
dest='user',
metavar='U',
help="user needed to run this script. If the "
"current user is not this one, the script will try " +
"to rerun itself using sudo.")
subparsers = parser.add_subparsers()
for key, value in ACTIONS.items():
(action, help) = value
subparser = subparsers.add_parser(key, help=help)
subparser.set_defaults(action=action)
parser.error = unknown
args = parser.parse_args()
user = pwd.getpwuid(os.getuid())[0]
if args.user and user != args.user:
import subprocess
retval = subprocess.call(["/usr/bin/sudo", "-u", args.user] + sys.argv)
raise SystemExit(retval)
from barman.config import Config
from barman.server import Server
config = Config()
config.load_configuration_files_directory()
server = Server(config.get_server(args.server))
try:
args.action(server, args)
except KeyError:
unknown("The action %s does not exist." % args.action)
def test_check_config_missing(self, tmpdir):
"""
Verify the check method can be called on an empty configuration
"""
server = Server(build_config_from_dicts(
global_conf={
# Required by server.check_archive method
"barman_lock_directory": tmpdir.mkdir('lock').strpath
},
main_conf={
'conninfo': '',
'ssh_command': '',
# Required by server.check_archive method
'wals_directory': tmpdir.mkdir('wals').strpath,
}
).get_server('main'))
check_strategy = CheckOutputStrategy()
server.check(check_strategy)
assert check_strategy.has_error
def test_bad_init(self):
"""
Check the server is buildable with an empty configuration
"""
server = Server(
build_config_from_dicts(main_conf={
'conninfo': '',
'ssh_command': '',
}).get_server('main'))
assert server.config.disabled
def test_xlogdb_with_exception(self, os_mock, tmpdir):
"""
Testing the execution of xlog-db operations with an Exception
:param os_mock: mock for os module
:param tmpdir: temporary directory unique to the test invocation
"""
# unpatch os.path
os_mock.path = os.path
# Setup temp dir and server
server = Server(self.build_config(tmpdir))
# Test the execution of the fsync on xlogdb file forcing an exception
with pytest.raises(ExceptionTest):
with server.xlogdb('w') as fxlogdb:
fxlogdb.write("00000000000000000000")
raise ExceptionTest()
# Check call on fsync method. If the call have been issued,
# the "exit" section of the contextmanager have been executed
assert os_mock.fsync.called
def build_real_server(global_conf=None, main_conf=None):
"""
Build a real Server object built from a real configuration
:param dict[str,str|None]|None global_conf: using this dictionary
it is possible to override or add new values to the [barman] section
:param dict[str,str|None]|None main_conf: using this dictionary
it is possible to override/add new values to the [main] section
:return barman.server.Server: a barman Server object
"""
return Server(build_config_from_dicts(
global_conf=global_conf, main_conf=main_conf).get_server('main'))
def test_check_config_missing(self, tmpdir):
"""
Verify the check method can be called on an empty configuration
"""
server = Server(
build_config_from_dicts(
global_conf={
# Required by server.check_archive method
"barman_lock_directory": tmpdir.mkdir("lock").strpath
},
main_conf={
"conninfo": "",
"ssh_command": "",
# Required by server.check_archive method
"wals_directory": tmpdir.mkdir("wals").strpath,
},
).get_server("main")
)
check_strategy = CheckOutputStrategy()
server.check(check_strategy)
assert check_strategy.has_error
def cron(args):
""" Run maintenance tasks
"""
filename = os.path.join(barman.__config__.barman_home, '.cron.lock')
with lockfile(filename) as locked:
if not locked:
yield "ERROR: Another cron is running"
raise SystemExit, 1
else:
servers = [Server(conf) for conf in barman.__config__.servers()]
for server in servers:
for lines in server.cron(verbose=True):
yield lines
def get_server(args):
''' Get the server from the configuration '''
config = barman.__config__.get_server(args.server_name)
if not config:
return None
return Server(config)
def get_server_list(args=None,
skip_inactive=False,
skip_disabled=False,
on_error_stop=True,
suppress_error=False):
"""
Get the server list from the configuration
If args the parameter is None or arg.server_name is ['all']
returns all defined servers
:param args: an argparse namespace containing a list server_name parameter
:param bool skip_inactive: skip inactive servers when 'all' is required
:param bool skip_disabled: skip disabled servers when 'all' is required
:param bool on_error_stop: stop if an error is found
:param bool suppress_error: suppress display of errors (e.g. diagnose)
:rtype: dict(str,barman.server.Server|None)
"""
server_dict = {}
# This function must to be called with in a multiple-server context
assert not args or isinstance(args.server_name, list)
# Generate the list of servers (required for global errors)
available_servers = barman.__config__.server_names()
# Get a list of configuration errors from all the servers
global_error_list = barman.__config__.servers_msg_list
# Global errors have higher priority
if global_error_list:
# Output the list of global errors
if not suppress_error:
for error in global_error_list:
output.error(error)
# If requested, exit on first error
if on_error_stop:
output.close_and_exit()
# The following return statement will never be reached
# but it is here for clarity
return {}
# Handle special 'all' server cases
# - args is None
# - 'all' special name
if not args or 'all' in args.server_name:
# When 'all' is used, it must be the only specified argument
if args and len(args.server_name) != 1:
output.error("You cannot use 'all' with other server names")
servers = available_servers
else:
servers = args.server_name
# Loop through all the requested servers
for server in servers:
conf = barman.__config__.get_server(server)
if conf is None:
# Unknown server
server_dict[server] = None
else:
server_object = Server(conf)
# Skip inactive servers, if requested
if skip_inactive and not server_object.config.active:
output.info("Skipping inactive server '%s'" % conf.name)
continue
# Skip disabled servers, if requested
if skip_disabled and server_object.config.disabled:
output.info("Skipping temporarily disabled server '%s'" %
conf.name)
continue
server_dict[server] = server_object
return server_dict
