def remove_device(lib_env, skip_offline_nodes=False):
"""
Stop using quorum device, distribute and reload configs if live
skip_offline_nodes continue even if not all nodes are accessible
"""
__ensure_not_cman(lib_env)
cfg = lib_env.get_corosync_conf()
model, dummy_options, dummy_options = cfg.get_quorum_device_settings()
cfg.remove_quorum_device()
if lib_env.is_corosync_conf_live:
communicator = lib_env.node_communicator()
# fix quorum options for SBD to work properly
if sbd.atb_has_to_be_enabled(lib_env.cmd_runner(), cfg):
lib_env.report_processor.process(reports.sbd_requires_atb())
cfg.set_quorum_options(
lib_env.report_processor, {"auto_tie_breaker": "1"}
)
# disable qdevice
lib_env.report_processor.process(
reports.service_disable_started("corosync-qdevice")
)
parallel_nodes_communication_helper(
qdevice_client.remote_client_disable,
[
[(lib_env.report_processor, communicator, node), {}]
for node in cfg.get_nodes()
],
lib_env.report_processor,
skip_offline_nodes
)
# stop qdevice
lib_env.report_processor.process(
reports.service_stop_started("corosync-qdevice")
)
parallel_nodes_communication_helper(
qdevice_client.remote_client_stop,
[
[(lib_env.report_processor, communicator, node), {}]
for node in cfg.get_nodes()
],
lib_env.report_processor,
skip_offline_nodes
)
# handle model specific configuration
if model == "net":
_remove_device_model_net(
lib_env,
cfg.get_nodes(),
skip_offline_nodes
)
lib_env.push_corosync_conf(cfg, skip_offline_nodes)
def remove_device(lib_env, skip_offline_nodes=False):
"""
Stop using quorum device, distribute and reload configs if live
skip_offline_nodes continue even if not all nodes are accessible
"""
__ensure_not_cman(lib_env)
cfg = lib_env.get_corosync_conf()
model, dummy_options, dummy_options, dummy_options = (
cfg.get_quorum_device_settings()
)
cfg.remove_quorum_device()
if lib_env.is_corosync_conf_live:
target_list = lib_env.get_node_target_factory().get_target_list(
cfg.get_nodes()
)
# fix quorum options for SBD to work properly
if sbd.atb_has_to_be_enabled(lib_env.cmd_runner(), cfg):
lib_env.report_processor.process(reports.sbd_requires_atb())
cfg.set_quorum_options(
lib_env.report_processor, {"auto_tie_breaker": "1"}
)
# disable qdevice
lib_env.report_processor.process(
reports.service_disable_started("corosync-qdevice")
)
com_cmd = qdevice_com.Disable(
lib_env.report_processor, skip_offline_nodes
)
com_cmd.set_targets(target_list)
run_and_raise(lib_env.get_node_communicator(), com_cmd)
# stop qdevice
lib_env.report_processor.process(
reports.service_stop_started("corosync-qdevice")
)
com_cmd = qdevice_com.Stop(
lib_env.report_processor, skip_offline_nodes
)
com_cmd.set_targets(target_list)
run_and_raise(lib_env.get_node_communicator(), com_cmd)
# handle model specific configuration
if model == "net":
_remove_device_model_net(
lib_env,
cfg.get_nodes(),
skip_offline_nodes
)
lib_env.push_corosync_conf(cfg, skip_offline_nodes)
def remove_device(lib_env, skip_offline_nodes=False):
"""
Stop using quorum device, distribute and reload configs if live
skip_offline_nodes continue even if not all nodes are accessible
"""
__ensure_not_cman(lib_env)
cfg = lib_env.get_corosync_conf()
model, dummy_options, dummy_options = cfg.get_quorum_device_settings()
cfg.remove_quorum_device()
if lib_env.is_corosync_conf_live:
communicator = lib_env.node_communicator()
# fix quorum options for SBD to work properly
if sbd.atb_has_to_be_enabled(lib_env.cmd_runner(), cfg):
lib_env.report_processor.process(reports.sbd_requires_atb())
cfg.set_quorum_options(lib_env.report_processor,
{"auto_tie_breaker": "1"})
# disable qdevice
lib_env.report_processor.process(
reports.service_disable_started("corosync-qdevice"))
parallel_nodes_communication_helper(
qdevice_client.remote_client_disable,
[[(lib_env.report_processor, communicator, node), {}]
for node in cfg.get_nodes()], lib_env.report_processor,
skip_offline_nodes)
# stop qdevice
lib_env.report_processor.process(
reports.service_stop_started("corosync-qdevice"))
parallel_nodes_communication_helper(
qdevice_client.remote_client_stop,
[[(lib_env.report_processor, communicator, node), {}]
for node in cfg.get_nodes()], lib_env.report_processor,
skip_offline_nodes)
# handle model specific configuration
if model == "net":
_remove_device_model_net(lib_env, cfg.get_nodes(),
skip_offline_nodes)
lib_env.push_corosync_conf(cfg, skip_offline_nodes)
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,
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())
