def disable_sbd(lib_env, ignore_offline_nodes=False):
"""
Disable SBD on all nodes in cluster.
lib_env -- LibraryEnvironment
ignore_offline_nodes -- if True, omit offline nodes
"""
node_list, get_nodes_report_list = get_existing_nodes_names(
lib_env.get_corosync_conf())
if not node_list:
get_nodes_report_list.append(
reports.corosync_config_no_nodes_defined())
if lib_env.report_processor.report_list(get_nodes_report_list).has_errors:
raise LibraryError()
com_cmd = GetOnlineTargets(
lib_env.report_processor,
ignore_offline_targets=ignore_offline_nodes,
)
com_cmd.set_targets(lib_env.get_node_target_factory().get_target_list(
node_list,
skip_non_existing=ignore_offline_nodes,
))
online_nodes = run_and_raise(lib_env.get_node_communicator(), com_cmd)
com_cmd = SetStonithWatchdogTimeoutToZero(lib_env.report_processor)
com_cmd.set_targets(online_nodes)
run_and_raise(lib_env.get_node_communicator(), com_cmd)
com_cmd = DisableSbdService(lib_env.report_processor)
com_cmd.set_targets(online_nodes)
run_and_raise(lib_env.get_node_communicator(), com_cmd)
lib_env.report_processor.report(
reports.cluster_restart_required_to_apply_changes())
def disable_sbd(lib_env, ignore_offline_nodes=False):
"""
Disable SBD on all nodes in cluster.
lib_env -- LibraryEnvironment
ignore_offline_nodes -- if True, omit offline nodes
"""
node_list = _get_online_nodes(lib_env, _get_cluster_nodes(lib_env),
ignore_offline_nodes)
if lib_env.is_cman_cluster:
nodes_task.check_corosync_offline_on_nodes(lib_env.node_communicator(),
lib_env.report_processor,
node_list,
ignore_offline_nodes)
sbd.set_stonith_watchdog_timeout_to_zero_on_all_nodes(
lib_env.node_communicator(), node_list)
sbd.disable_sbd_service_on_all_nodes(lib_env.report_processor,
lib_env.node_communicator(),
node_list)
if not lib_env.is_cman_cluster:
lib_env.report_processor.process(
reports.cluster_restart_required_to_apply_changes())
def disable_sbd(lib_env, ignore_offline_nodes=False):
"""
Disable SBD on all nodes in cluster.
lib_env -- LibraryEnvironment
ignore_offline_nodes -- if True, omit offline nodes
"""
node_list = _get_online_nodes(
lib_env, _get_cluster_nodes(lib_env), ignore_offline_nodes
)
if lib_env.is_cman_cluster:
nodes_task.check_corosync_offline_on_nodes(
lib_env.node_communicator(),
lib_env.report_processor,
node_list,
ignore_offline_nodes
)
sbd.set_stonith_watchdog_timeout_to_zero_on_all_nodes(
lib_env.node_communicator(), node_list
)
sbd.disable_sbd_service_on_all_nodes(
lib_env.report_processor,
lib_env.node_communicator(),
node_list
)
if not lib_env.is_cman_cluster:
lib_env.report_processor.process(
reports.cluster_restart_required_to_apply_changes()
)
def disable_sbd(lib_env, ignore_offline_nodes=False):
"""
Disable SBD on all nodes in cluster.
lib_env -- LibraryEnvironment
ignore_offline_nodes -- if True, omit offline nodes
"""
com_cmd = GetOnlineTargets(
lib_env.report_processor,
ignore_offline_targets=ignore_offline_nodes,
)
com_cmd.set_targets(lib_env.get_node_target_factory().get_target_list(
_get_cluster_nodes(lib_env)))
online_nodes = run_and_raise(lib_env.get_node_communicator(), com_cmd)
if lib_env.is_cman_cluster:
com_cmd = CheckCorosyncOffline(
lib_env.report_processor,
skip_offline_targets=ignore_offline_nodes,
)
com_cmd.set_targets(online_nodes)
run_and_raise(lib_env.get_node_communicator(), com_cmd)
com_cmd = SetStonithWatchdogTimeoutToZero(lib_env.report_processor)
com_cmd.set_targets(online_nodes)
run_and_raise(lib_env.get_node_communicator(), com_cmd)
com_cmd = DisableSbdService(lib_env.report_processor)
com_cmd.set_targets(online_nodes)
run_and_raise(lib_env.get_node_communicator(), com_cmd)
if not lib_env.is_cman_cluster:
lib_env.report_processor.process(
reports.cluster_restart_required_to_apply_changes())
def disable_sbd(lib_env, ignore_offline_nodes=False):
"""
Disable SBD on all nodes in cluster.
lib_env -- LibraryEnvironment
ignore_offline_nodes -- if True, omit offline nodes
"""
node_list, get_nodes_report_list = get_existing_nodes_names(
lib_env.get_corosync_conf()
)
if not node_list:
get_nodes_report_list.append(reports.corosync_config_no_nodes_defined())
lib_env.report_processor.process_list(get_nodes_report_list)
com_cmd = GetOnlineTargets(
lib_env.report_processor, ignore_offline_targets=ignore_offline_nodes,
)
com_cmd.set_targets(
lib_env.get_node_target_factory().get_target_list(
node_list,
skip_non_existing=ignore_offline_nodes,
)
)
online_nodes = run_and_raise(lib_env.get_node_communicator(), com_cmd)
com_cmd = SetStonithWatchdogTimeoutToZero(lib_env.report_processor)
com_cmd.set_targets(online_nodes)
run_and_raise(lib_env.get_node_communicator(), com_cmd)
com_cmd = DisableSbdService(lib_env.report_processor)
com_cmd.set_targets(online_nodes)
run_and_raise(lib_env.get_node_communicator(), com_cmd)
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)
target_list = lib_env.get_node_target_factory().get_target_list(node_list)
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_target_dict(
target_list, watchdog_dict, default_watchdog
)
full_device_dict = _get_full_target_dict(
target_list, node_device_dict, default_device_list
)
lib_env.report_processor.process_list(
_check_node_names_in_cluster(
node_list,
list(watchdog_dict.keys()) + list(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)
)
com_cmd = GetOnlineTargets(
lib_env.report_processor, ignore_offline_targets=ignore_offline_nodes,
)
com_cmd.set_targets(target_list)
online_targets = run_and_raise(lib_env.get_node_communicator(), com_cmd)
# check if SBD can be enabled
com_cmd = CheckSbd(lib_env.report_processor)
for target in online_targets:
com_cmd.add_request(
target,
full_watchdog_dict[target.label],
full_device_dict[target.label] if using_devices else [],
)
run_and_raise(lib_env.get_node_communicator(), com_cmd)
# enable ATB if neede
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)
com_cmd = SetSbdConfig(lib_env.report_processor)
for target in online_targets:
com_cmd.add_request(
target,
sbd.create_sbd_config(
config,
target.label,
full_watchdog_dict[target.label],
full_device_dict[target.label]
)
)
run_and_raise(lib_env.get_node_communicator(), com_cmd)
# remove cluster prop 'stonith_watchdog_timeout'
com_cmd = RemoveStonithWatchdogTimeout(lib_env.report_processor)
com_cmd.set_targets(online_targets)
run_and_raise(lib_env.get_node_communicator(), com_cmd)
# enable SBD service an all nodes
com_cmd = EnableSbdService(lib_env.report_processor)
com_cmd.set_targets(online_targets)
run_and_raise(lib_env.get_node_communicator(), com_cmd)
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,
no_watchdog_validation=False,
allow_invalid_option_values=False,
):
# pylint: disable=too-many-arguments, too-many-locals
"""
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
no_watchdog_validation -- it True, do not validate existance of a watchdog
on the nodes
allow_invalid_option_values -- if True, invalid values of some options will
be treated as warning instead of errors
"""
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 = {opt.upper(): val for opt, val in sbd_options.items()}
corosync_conf = lib_env.get_corosync_conf()
node_list, get_nodes_report_list = get_existing_nodes_names(corosync_conf)
if not node_list:
get_nodes_report_list.append(
reports.corosync_config_no_nodes_defined())
target_list = lib_env.get_node_target_factory().get_target_list(
node_list,
skip_non_existing=ignore_offline_nodes,
)
full_watchdog_dict = _get_full_target_dict(target_list, watchdog_dict,
default_watchdog)
full_device_dict = _get_full_target_dict(target_list, node_device_dict,
default_device_list)
if lib_env.report_processor.report_list(
get_nodes_report_list +
[
reports.node_not_found(node) for node in
(set(list(watchdog_dict.keys()) + list(node_device_dict.keys())) -
set(node_list))
] + _validate_watchdog_dict(full_watchdog_dict) +
(sbd.validate_nodes_devices(full_device_dict) if using_devices else []
) + _validate_sbd_options(sbd_options, allow_unknown_opts,
allow_invalid_option_values)).has_errors:
raise LibraryError()
com_cmd = GetOnlineTargets(
lib_env.report_processor,
ignore_offline_targets=ignore_offline_nodes,
)
com_cmd.set_targets(target_list)
online_targets = run_and_raise(lib_env.get_node_communicator(), com_cmd)
# check if SBD can be enabled
if no_watchdog_validation:
lib_env.report_processor.report(
reports.sbd_watchdog_validation_inactive())
com_cmd = CheckSbd(lib_env.report_processor)
for target in online_targets:
com_cmd.add_request(
target,
(
# Do not send watchdog if validation is turned off. Listing of
# available watchdogs in pcsd may restart the machine in some
# corner cases.
"" if no_watchdog_validation else
full_watchdog_dict[target.label]),
full_device_dict[target.label] if using_devices else [],
)
run_and_raise(lib_env.get_node_communicator(), com_cmd)
# enable ATB if needed
if not using_devices:
if sbd.atb_has_to_be_enabled_pre_enable_check(corosync_conf):
lib_env.report_processor.report(
reports.corosync_quorum_atb_will_be_enabled_due_to_sbd())
corosync_conf.set_quorum_options({"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)
com_cmd = SetSbdConfig(lib_env.report_processor)
for target in online_targets:
com_cmd.add_request(
target,
sbd.create_sbd_config(config, target.label,
full_watchdog_dict[target.label],
full_device_dict[target.label]))
run_and_raise(lib_env.get_node_communicator(), com_cmd)
# remove cluster prop 'stonith_watchdog_timeout'
com_cmd = RemoveStonithWatchdogTimeout(lib_env.report_processor)
com_cmd.set_targets(online_targets)
run_and_raise(lib_env.get_node_communicator(), com_cmd)
# enable SBD service an all nodes
com_cmd = EnableSbdService(lib_env.report_processor)
com_cmd.set_targets(online_targets)
run_and_raise(lib_env.get_node_communicator(), com_cmd)
lib_env.report_processor.report(
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, no_watchdog_validation=False,
allow_invalid_option_values=False,
):
# pylint: disable=too-many-arguments, too-many-locals
"""
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
no_watchdog_validation -- it True, do not validate existance of a watchdog
on the nodes
allow_invalid_option_values -- if True, invalid values of some options will
be treated as warning instead of errors
"""
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 = {opt.upper(): val for opt, val in sbd_options.items()}
corosync_conf = lib_env.get_corosync_conf()
node_list, get_nodes_report_list = get_existing_nodes_names(corosync_conf)
if not node_list:
get_nodes_report_list.append(reports.corosync_config_no_nodes_defined())
target_list = lib_env.get_node_target_factory().get_target_list(
node_list, skip_non_existing=ignore_offline_nodes,
)
full_watchdog_dict = _get_full_target_dict(
target_list, watchdog_dict, default_watchdog
)
full_device_dict = _get_full_target_dict(
target_list, node_device_dict, default_device_list
)
lib_env.report_processor.process_list(
get_nodes_report_list
+
[
reports.node_not_found(node)
for node in (
set(list(watchdog_dict.keys()) + list(node_device_dict.keys()))
-
set(node_list)
)
]
+
_validate_watchdog_dict(full_watchdog_dict)
+
(sbd.validate_nodes_devices(full_device_dict) if using_devices else [])
+
_validate_sbd_options(
sbd_options, allow_unknown_opts, allow_invalid_option_values
)
)
com_cmd = GetOnlineTargets(
lib_env.report_processor, ignore_offline_targets=ignore_offline_nodes,
)
com_cmd.set_targets(target_list)
online_targets = run_and_raise(lib_env.get_node_communicator(), com_cmd)
# check if SBD can be enabled
if no_watchdog_validation:
lib_env.report_processor.report(
reports.sbd_watchdog_validation_inactive()
)
com_cmd = CheckSbd(lib_env.report_processor)
for target in online_targets:
com_cmd.add_request(
target,
(
# Do not send watchdog if validation is turned off. Listing of
# available watchdogs in pcsd may restart the machine in some
# corner cases.
"" if no_watchdog_validation
else full_watchdog_dict[target.label]
),
full_device_dict[target.label] if using_devices else [],
)
run_and_raise(lib_env.get_node_communicator(), com_cmd)
# enable ATB if needed
if not using_devices:
if sbd.atb_has_to_be_enabled_pre_enable_check(corosync_conf):
lib_env.report_processor.process(
reports.corosync_quorum_atb_will_be_enabled_due_to_sbd()
)
corosync_conf.set_quorum_options({"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)
com_cmd = SetSbdConfig(lib_env.report_processor)
for target in online_targets:
com_cmd.add_request(
target,
sbd.create_sbd_config(
config,
target.label,
full_watchdog_dict[target.label],
full_device_dict[target.label]
)
)
run_and_raise(lib_env.get_node_communicator(), com_cmd)
# remove cluster prop 'stonith_watchdog_timeout'
com_cmd = RemoveStonithWatchdogTimeout(lib_env.report_processor)
com_cmd.set_targets(online_targets)
run_and_raise(lib_env.get_node_communicator(), com_cmd)
# enable SBD service an all nodes
com_cmd = EnableSbdService(lib_env.report_processor)
com_cmd.set_targets(online_targets)
run_and_raise(lib_env.get_node_communicator(), com_cmd)
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())
