def test_success(self, mock_func):
lib_sbd.remove_stonith_watchdog_timeout_on_all_nodes(
self.mock_com, self.node_list
)
func_calls = [mock.call(self.mock_com, node) for node in self.node_list]
self.assertEqual(mock_func.call_count, len(func_calls))
mock_func.assert_has_calls(func_calls)
def test_success(self, mock_func):
lib_sbd.remove_stonith_watchdog_timeout_on_all_nodes(
self.mock_com, self.node_list
)
func_calls = [mock.call(self.mock_com, node) for node in self.node_list]
self.assertEqual(mock_func.call_count, len(func_calls))
mock_func.assert_has_calls(func_calls)
def test_communication_error(self, mock_func):
def raiser(_, node):
if node == self.node_list[1]:
raise NodeConnectionException(self.node_list[1], "command",
"reason")
elif node == self.node_list[4]:
raise NodeCommunicationException(self.node_list[4], "command",
"reason")
mock_func.side_effect = raiser
assert_raise_library_error(
lambda: lib_sbd.remove_stonith_watchdog_timeout_on_all_nodes(
self.mock_com, self.node_list),
(Severities.ERROR,
report_codes.NODE_COMMUNICATION_ERROR_UNABLE_TO_CONNECT, {
"node": self.node_list[1],
"command": "command",
"reason": "reason"
}), (Severities.ERROR, report_codes.NODE_COMMUNICATION_ERROR, {
"node": self.node_list[4],
"command": "command",
"reason": "reason"
}))
func_calls = [
mock.call(self.mock_com, node) for node in self.node_list
]
self.assertEqual(mock_func.call_count, len(func_calls))
mock_func.assert_has_calls(func_calls)
def test_communication_error(self, mock_func):
def raiser(_, node):
if node == self.node_list[1]:
raise NodeConnectionException(
self.node_list[1], "command", "reason"
)
elif node == self.node_list[4]:
raise NodeCommunicationException(
self.node_list[4], "command", "reason"
)
mock_func.side_effect = raiser
assert_raise_library_error(
lambda: lib_sbd.remove_stonith_watchdog_timeout_on_all_nodes(
self.mock_com, self.node_list
),
(
Severities.ERROR,
report_codes.NODE_COMMUNICATION_ERROR_UNABLE_TO_CONNECT,
{
"node": self.node_list[1],
"command": "command",
"reason": "reason"
}
),
(
Severities.ERROR,
report_codes.NODE_COMMUNICATION_ERROR,
{
"node": self.node_list[4],
"command": "command",
"reason": "reason"
}
)
)
func_calls = [mock.call(self.mock_com, node) for node in self.node_list]
self.assertEqual(mock_func.call_count, len(func_calls))
mock_func.assert_has_calls(func_calls)
def enable_sbd(lib_env,
default_watchdog,
watchdog_dict,
sbd_options,
allow_unknown_opts=False,
ignore_offline_nodes=False):
"""
Enable SBD on all nodes in cluster.
lib_env -- LibraryEnvironment
default_watchdog -- watchdog for nodes which are not specified in
watchdog_dict. Uses default value from settings if None.
watchdog_dict -- dictionary with NodeAddresses as keys and watchdog path
as value
sbd_options -- dictionary in format: <SBD config option>: <value>
allow_unknown_opts -- if True, accept also unknown options.
ignore_offline_nodes -- if True, omit offline nodes
"""
node_list = _get_cluster_nodes(lib_env)
if not default_watchdog:
default_watchdog = settings.sbd_watchdog_default
# input validation begin
full_watchdog_dict = _get_full_watchdog_list(node_list, default_watchdog,
watchdog_dict)
# config validation
sbd_options = dict([(opt.upper(), val)
for opt, val in sbd_options.items()])
lib_env.report_processor.process_list(
_validate_sbd_options(sbd_options, allow_unknown_opts))
# check nodes status
online_nodes = _get_online_nodes(lib_env, node_list, ignore_offline_nodes)
for node in list(full_watchdog_dict):
if node not in online_nodes:
full_watchdog_dict.pop(node, None)
# input validation end
# check if SBD can be enabled
sbd.check_sbd_on_all_nodes(lib_env.report_processor,
lib_env.node_communicator(), full_watchdog_dict)
# enable ATB if needed
if not lib_env.is_cman_cluster:
corosync_conf = lib_env.get_corosync_conf()
if sbd.atb_has_to_be_enabled_pre_enable_check(corosync_conf):
lib_env.report_processor.process(reports.sbd_requires_atb())
corosync_conf.set_quorum_options(lib_env.report_processor,
{"auto_tie_breaker": "1"})
lib_env.push_corosync_conf(corosync_conf, ignore_offline_nodes)
# distribute SBD configuration
config = sbd.get_default_sbd_config()
config.update(sbd_options)
sbd.set_sbd_config_on_all_nodes(lib_env.report_processor,
lib_env.node_communicator(), online_nodes,
config, full_watchdog_dict)
# remove cluster prop 'stonith_watchdog_timeout'
sbd.remove_stonith_watchdog_timeout_on_all_nodes(
lib_env.node_communicator(), online_nodes)
# enable SBD service an all nodes
sbd.enable_sbd_service_on_all_nodes(lib_env.report_processor,
lib_env.node_communicator(),
online_nodes)
lib_env.report_processor.process(
reports.cluster_restart_required_to_apply_changes())
def enable_sbd(
lib_env, default_watchdog, watchdog_dict, sbd_options,
allow_unknown_opts=False, ignore_offline_nodes=False
):
"""
Enable SBD on all nodes in cluster.
lib_env -- LibraryEnvironment
default_watchdog -- watchdog for nodes which are not specified in
watchdog_dict. Uses default value from settings if None.
watchdog_dict -- dictionary with NodeAddresses as keys and watchdog path
as value
sbd_options -- dictionary in format: <SBD config option>: <value>
allow_unknown_opts -- if True, accept also unknown options.
ignore_offline_nodes -- if True, omit offline nodes
"""
node_list = _get_cluster_nodes(lib_env)
if not default_watchdog:
default_watchdog = settings.sbd_watchdog_default
# input validation begin
full_watchdog_dict = _get_full_watchdog_list(
node_list, default_watchdog, watchdog_dict
)
# config validation
sbd_options = dict([(opt.upper(), val) for opt, val in sbd_options.items()])
lib_env.report_processor.process_list(
_validate_sbd_options(sbd_options, allow_unknown_opts)
)
# check nodes status
online_nodes = _get_online_nodes(lib_env, node_list, ignore_offline_nodes)
for node in list(full_watchdog_dict):
if node not in online_nodes:
full_watchdog_dict.pop(node, None)
# input validation end
# check if SBD can be enabled
sbd.check_sbd_on_all_nodes(
lib_env.report_processor,
lib_env.node_communicator(),
full_watchdog_dict
)
# enable ATB if needed
if not lib_env.is_cman_cluster:
corosync_conf = lib_env.get_corosync_conf()
if sbd.atb_has_to_be_enabled_pre_enable_check(corosync_conf):
lib_env.report_processor.process(reports.sbd_requires_atb())
corosync_conf.set_quorum_options(
lib_env.report_processor, {"auto_tie_breaker": "1"}
)
lib_env.push_corosync_conf(corosync_conf, ignore_offline_nodes)
# distribute SBD configuration
config = sbd.get_default_sbd_config()
config.update(sbd_options)
sbd.set_sbd_config_on_all_nodes(
lib_env.report_processor,
lib_env.node_communicator(),
online_nodes,
config,
full_watchdog_dict
)
# remove cluster prop 'stonith_watchdog_timeout'
sbd.remove_stonith_watchdog_timeout_on_all_nodes(
lib_env.node_communicator(), online_nodes
)
# enable SBD service an all nodes
sbd.enable_sbd_service_on_all_nodes(
lib_env.report_processor, lib_env.node_communicator(), online_nodes
)
lib_env.report_processor.process(
reports.cluster_restart_required_to_apply_changes()
)
def enable_sbd(
lib_env,
default_watchdog,
watchdog_dict,
sbd_options,
default_device_list=None,
node_device_dict=None,
allow_unknown_opts=False,
ignore_offline_nodes=False,
):
"""
Enable SBD on all nodes in cluster.
lib_env -- LibraryEnvironment
default_watchdog -- watchdog for nodes which are not specified in
watchdog_dict. Uses default value from settings if None.
watchdog_dict -- dictionary with node names as keys and watchdog path
as value
sbd_options -- dictionary in format: <SBD config option>: <value>
default_device_list -- list of devices for all nodes
node_device_dict -- dictionary with node names as keys and list of devices
as value
allow_unknown_opts -- if True, accept also unknown options.
ignore_offline_nodes -- if True, omit offline nodes
"""
node_list = _get_cluster_nodes(lib_env)
using_devices = not (default_device_list is None
and node_device_dict is None)
if default_device_list is None:
default_device_list = []
if node_device_dict is None:
node_device_dict = {}
if not default_watchdog:
default_watchdog = settings.sbd_watchdog_default
sbd_options = dict([(opt.upper(), val)
for opt, val in sbd_options.items()])
full_watchdog_dict = _get_full_node_dict(node_list, watchdog_dict,
default_watchdog)
full_device_dict = _get_full_node_dict(node_list, node_device_dict,
default_device_list)
lib_env.report_processor.process_list(
_check_node_names_in_cluster(
node_list,
watchdog_dict.keys() + node_device_dict.keys()) +
_validate_watchdog_dict(full_watchdog_dict) +
_validate_device_dict(full_device_dict) if using_devices else [] +
_validate_sbd_options(sbd_options, allow_unknown_opts))
online_nodes = _get_online_nodes(lib_env, node_list, ignore_offline_nodes)
node_data_dict = {}
for node in online_nodes:
node_data_dict[node] = {
"watchdog": full_watchdog_dict[node],
"device_list": full_device_dict[node] if using_devices else [],
}
# check if SBD can be enabled
sbd.check_sbd_on_all_nodes(
lib_env.report_processor,
lib_env.node_communicator(),
node_data_dict,
)
# enable ATB if needed
if not lib_env.is_cman_cluster and not using_devices:
corosync_conf = lib_env.get_corosync_conf()
if sbd.atb_has_to_be_enabled_pre_enable_check(corosync_conf):
lib_env.report_processor.process(reports.sbd_requires_atb())
corosync_conf.set_quorum_options(lib_env.report_processor,
{"auto_tie_breaker": "1"})
lib_env.push_corosync_conf(corosync_conf, ignore_offline_nodes)
# distribute SBD configuration
config = sbd.get_default_sbd_config()
config.update(sbd_options)
sbd.set_sbd_config_on_all_nodes(
lib_env.report_processor,
lib_env.node_communicator(),
online_nodes,
config,
full_watchdog_dict,
full_device_dict,
)
# remove cluster prop 'stonith_watchdog_timeout'
sbd.remove_stonith_watchdog_timeout_on_all_nodes(
lib_env.node_communicator(), online_nodes)
# enable SBD service an all nodes
sbd.enable_sbd_service_on_all_nodes(lib_env.report_processor,
lib_env.node_communicator(),
online_nodes)
lib_env.report_processor.process(
reports.cluster_restart_required_to_apply_changes())
