def update_device(lib_env,
model_options,
generic_options,
heuristics_options,
force_options=False,
skip_offline_nodes=False):
"""
Change quorum device settings, distribute and reload configs if live
dict model_options -- model specific options
dict generic_options -- generic quorum device options
dict heuristics_options -- heuristics options
bool force_options -- continue even if options are not valid
bool skip_offline_nodes -- continue even if not all nodes are accessible
"""
cfg = lib_env.get_corosync_conf()
if not cfg.has_quorum_device():
raise LibraryError(reports.qdevice_not_defined())
lib_env.report_processor.process_list(
corosync_conf_validators.update_quorum_device(
cfg.get_quorum_device_model(),
model_options,
generic_options,
heuristics_options, [node.nodeid for node in cfg.get_nodes()],
force_options=force_options))
cfg.update_quorum_device(model_options, generic_options,
heuristics_options)
if cfg.is_quorum_device_heuristics_enabled_with_no_exec():
lib_env.report_processor.process(
reports.corosync_quorum_heuristics_enabled_with_no_exec())
lib_env.push_corosync_conf(cfg, skip_offline_nodes)
def remove_device(lib_env: LibraryEnvironment, 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
"""
cfg = lib_env.get_corosync_conf()
if not cfg.has_quorum_device():
raise LibraryError(reports.qdevice_not_defined())
model = cfg.get_quorum_device_model()
cfg.remove_quorum_device()
if lib_env.is_corosync_conf_live:
report_processor = lib_env.report_processor
# get nodes for communication
cluster_nodes_names, report_list = get_existing_nodes_names(
cfg,
# Pcs is unable to communicate with nodes missing names. It cannot
# send new corosync.conf to them. That might break the cluster.
# Hence we error out.
error_on_missing_name=True)
if report_processor.report_list(report_list).has_errors:
raise LibraryError()
target_list = lib_env.get_node_target_factory().get_target_list(
cluster_nodes_names,
skip_non_existing=skip_offline_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.report(
reports.corosync_quorum_atb_will_be_enabled_due_to_sbd())
cfg.set_quorum_options({"auto_tie_breaker": "1"})
# disable qdevice
lib_env.report_processor.report(
reports.service_disable_started("corosync-qdevice"))
com_cmd_disable = qdevice_com.Disable(lib_env.report_processor,
skip_offline_nodes)
com_cmd_disable.set_targets(target_list)
run_and_raise(lib_env.get_node_communicator(), com_cmd_disable)
# stop qdevice
lib_env.report_processor.report(
reports.service_stop_started("corosync-qdevice"))
com_cmd_stop = qdevice_com.Stop(lib_env.report_processor,
skip_offline_nodes)
com_cmd_stop.set_targets(target_list)
run_and_raise(lib_env.get_node_communicator(), com_cmd_stop)
# handle model specific configuration
if model == "net":
lib_env.report_processor.report(
reports.qdevice_certificate_removal_started())
com_cmd_client_destroy = qdevice_net_com.ClientDestroy(
lib_env.report_processor, skip_offline_nodes)
com_cmd_client_destroy.set_targets(target_list)
run_and_raise(lib_env.get_node_communicator(),
com_cmd_client_destroy)
lib_env.push_corosync_conf(cfg, skip_offline_nodes)
def remove_quorum_device(self):
"""
Remove all quorum device configuration
"""
if not self.has_quorum_device():
raise LibraryError(reports.qdevice_not_defined())
for quorum in self.config.get_sections("quorum"):
for device in quorum.get_sections("device"):
quorum.del_section(device)
self.__update_two_node()
self.__remove_empty_sections(self.config)
def remove_quorum_device(self):
"""
Remove all quorum device configuration
"""
if not self.has_quorum_device():
raise LibraryError(reports.qdevice_not_defined())
for quorum in self.config.get_sections("quorum"):
for device in quorum.get_sections("device"):
quorum.del_section(device)
self.__update_two_node()
self.__remove_empty_sections(self.config)
def remove_device_heuristics(lib_env, skip_offline_nodes=False):
"""
Stop using quorum device heuristics, distribute and reload configs if live
bool skip_offline_nodes -- continue even if not all nodes are accessible
"""
cfg = lib_env.get_corosync_conf()
if not cfg.has_quorum_device():
raise LibraryError(reports.qdevice_not_defined())
cfg.remove_quorum_device_heuristics()
lib_env.push_corosync_conf(cfg, skip_offline_nodes)
def remove_device_heuristics(lib_env, skip_offline_nodes=False):
"""
Stop using quorum device heuristics, distribute and reload configs if live
bool skip_offline_nodes -- continue even if not all nodes are accessible
"""
cfg = lib_env.get_corosync_conf()
if not cfg.has_quorum_device():
raise LibraryError(reports.qdevice_not_defined())
cfg.remove_quorum_device_heuristics()
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()
if not cfg.has_quorum_device():
raise LibraryError(reports.qdevice_not_defined())
model = cfg.get_quorum_device_model()
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_names(), skip_non_existing=skip_offline_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.corosync_quorum_atb_will_be_enabled_due_to_sbd()
)
cfg.set_quorum_options({"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":
lib_env.report_processor.process(
reports.qdevice_certificate_removal_started()
)
com_cmd = qdevice_net_com.ClientDestroy(
lib_env.report_processor, skip_offline_nodes
)
com_cmd.set_targets(target_list)
run_and_raise(lib_env.get_node_communicator(), com_cmd)
lib_env.push_corosync_conf(cfg, skip_offline_nodes)
def remove_quorum_device_heuristics(self):
"""
Remove quorum device heuristics configuration
"""
if not self.has_quorum_device():
raise LibraryError(reports.qdevice_not_defined())
for quorum in self.config.get_sections("quorum"):
for device in quorum.get_sections("device"):
for heuristics in device.get_sections("heuristics"):
device.del_section(heuristics)
self.__remove_empty_sections(self.config)
self._need_qdevice_reload = True
def remove_quorum_device_heuristics(self):
"""
Remove quorum device heuristics configuration
"""
if not self.has_quorum_device():
raise LibraryError(reports.qdevice_not_defined())
for quorum in self.config.get_sections("quorum"):
for device in quorum.get_sections("device"):
for heuristics in device.get_sections("heuristics"):
device.del_section(heuristics)
self.__remove_empty_sections(self.config)
self._need_qdevice_reload = True
def update_quorum_device(
self, report_processor, model_options, generic_options,
force_options=False
):
"""
Update existing quorum device configuration
model_options model specific options dict
generic_options generic quorum device options dict
force_options continue even if options are not valid
"""
# validation
if not self.has_quorum_device():
raise LibraryError(reports.qdevice_not_defined())
model = None
for quorum in self.config.get_sections("quorum"):
for device in quorum.get_sections("device"):
for dummy_name, value in device.get_attributes("model"):
model = value
report_processor.process_list(
self.__validate_quorum_device_model_options(
model,
model_options,
need_required=False,
force=force_options
)
+
self.__validate_quorum_device_generic_options(
generic_options,
force=force_options
)
)
# set new configuration
device_sections = []
model_sections = []
for quorum in self.config.get_sections("quorum"):
device_sections.extend(quorum.get_sections("device"))
for device in quorum.get_sections("device"):
model_sections.extend(device.get_sections(model))
self.__set_section_options(device_sections, generic_options)
self.__set_section_options(model_sections, model_options)
self.__update_qdevice_votes()
self.__update_two_node()
self.__remove_empty_sections(self.config)
self._need_qdevice_reload = True
def update_quorum_device(
self, report_processor, model_options, generic_options,
force_options=False
):
"""
Update existing quorum device configuration
model_options model specific options dict
generic_options generic quorum device options dict
force_options continue even if options are not valid
"""
# validation
if not self.has_quorum_device():
raise LibraryError(reports.qdevice_not_defined())
model = None
for quorum in self.config.get_sections("quorum"):
for device in quorum.get_sections("device"):
for dummy_name, value in device.get_attributes("model"):
model = value
report_processor.process_list(
self.__validate_quorum_device_model_options(
model,
model_options,
need_required=False,
force=force_options
)
+
self.__validate_quorum_device_generic_options(
generic_options,
force=force_options
)
)
# set new configuration
device_sections = []
model_sections = []
for quorum in self.config.get_sections("quorum"):
device_sections.extend(quorum.get_sections("device"))
for device in quorum.get_sections("device"):
model_sections.extend(device.get_sections(model))
self.__set_section_options(device_sections, generic_options)
self.__set_section_options(model_sections, model_options)
self.__update_qdevice_votes()
self.__update_two_node()
self.__remove_empty_sections(self.config)
self._need_qdevice_reload = True
def update_quorum_device(
self, model_options, generic_options, heuristics_options
):
"""
Update existing quorum device configuration
dict model_options -- model specific options
dict generic_options -- generic quorum device options
dict heuristics_options -- heuristics options
"""
if not self.has_quorum_device():
raise LibraryError(reports.qdevice_not_defined())
model = self.get_quorum_device_model()
# set new configuration
device_sections = []
model_sections = []
heuristics_sections = []
for quorum in self.config.get_sections("quorum"):
device_sections.extend(quorum.get_sections("device"))
for device in quorum.get_sections("device"):
model_sections.extend(device.get_sections(model))
heuristics_sections.extend(device.get_sections("heuristics"))
# we know device sections exist, otherwise the function would exit at
# has_quorum_device line above
if not model_sections:
new_model = config_parser.Section(model)
device_sections[-1].add_section(new_model)
model_sections.append(new_model)
if not heuristics_sections:
new_heuristics = config_parser.Section("heuristics")
device_sections[-1].add_section(new_heuristics)
heuristics_sections.append(new_heuristics)
self.__set_section_options(device_sections, generic_options)
self.__set_section_options(model_sections, model_options)
self.__set_section_options(heuristics_sections, heuristics_options)
self.__update_qdevice_votes()
self.__update_two_node()
self.__remove_empty_sections(self.config)
self._need_qdevice_reload = True
def update_quorum_device(
self, model_options, generic_options, heuristics_options
):
"""
Update existing quorum device configuration
dict model_options -- model specific options
dict generic_options -- generic quorum device options
dict heuristics_options -- heuristics options
"""
if not self.has_quorum_device():
raise LibraryError(reports.qdevice_not_defined())
model = self.get_quorum_device_model()
# set new configuration
device_sections = []
model_sections = []
heuristics_sections = []
for quorum in self.config.get_sections("quorum"):
device_sections.extend(quorum.get_sections("device"))
for device in quorum.get_sections("device"):
model_sections.extend(device.get_sections(model))
heuristics_sections.extend(device.get_sections("heuristics"))
# we know device sections exist, otherwise the function would exit at
# has_quorum_device line above
if not model_sections:
new_model = config_parser.Section(model)
device_sections[-1].add_section(new_model)
model_sections.append(new_model)
if not heuristics_sections:
new_heuristics = config_parser.Section("heuristics")
device_sections[-1].add_section(new_heuristics)
heuristics_sections.append(new_heuristics)
self.__set_section_options(device_sections, generic_options)
self.__set_section_options(model_sections, model_options)
self.__set_section_options(heuristics_sections, heuristics_options)
self.__update_qdevice_votes()
self.__update_two_node()
self.__remove_empty_sections(self.config)
self._need_qdevice_reload = True
def update_device(
lib_env, model_options, generic_options, heuristics_options,
force_options=False, skip_offline_nodes=False
):
"""
Change quorum device settings, distribute and reload configs if live
dict model_options -- model specific options
dict generic_options -- generic quorum device options
dict heuristics_options -- heuristics options
bool force_options -- continue even if options are not valid
bool skip_offline_nodes -- continue even if not all nodes are accessible
"""
cfg = lib_env.get_corosync_conf()
if not cfg.has_quorum_device():
raise LibraryError(reports.qdevice_not_defined())
lib_env.report_processor.process_list(
corosync_conf_validators.update_quorum_device(
cfg.get_quorum_device_model(),
model_options,
generic_options,
heuristics_options,
[node.nodeid for node in cfg.get_nodes()],
force_options=force_options
)
)
cfg.update_quorum_device(
model_options,
generic_options,
heuristics_options
)
if cfg.is_quorum_device_heuristics_enabled_with_no_exec():
lib_env.report_processor.process(
reports.corosync_quorum_heuristics_enabled_with_no_exec()
)
lib_env.push_corosync_conf(cfg, skip_offline_nodes)
def update_quorum_device(
self, report_processor, model_options, generic_options,
heuristics_options, force_options=False
):
"""
Update existing quorum device configuration
dict model_options -- model specific options
dict generic_options -- generic quorum device options
dict heuristics_options -- heuristics options
bool force_options -- continue even if options are not valid
"""
# validation
if not self.has_quorum_device():
raise LibraryError(reports.qdevice_not_defined())
model = None
for quorum in self.config.get_sections("quorum"):
for device in quorum.get_sections("device"):
for dummy_name, value in device.get_attributes("model"):
model = value
report_processor.process_list(
self.__validate_quorum_device_model_options(
model,
model_options,
need_required=False,
force=force_options
)
+
self.__validate_quorum_device_generic_options(
generic_options,
force=force_options
)
+
self.__validate_quorum_device_update_heuristics(
heuristics_options,
force_options=force_options
)
)
# set new configuration
device_sections = []
model_sections = []
heuristics_sections = []
for quorum in self.config.get_sections("quorum"):
device_sections.extend(quorum.get_sections("device"))
for device in quorum.get_sections("device"):
model_sections.extend(device.get_sections(model))
heuristics_sections.extend(device.get_sections("heuristics"))
# we know device sections exist, otherwise the function would exit at
# has_quorum_device line above
if not model_sections:
new_model = config_parser.Section(model)
device_sections[-1].add_section(new_model)
model_sections.append(new_model)
if not heuristics_sections:
new_heuristics = config_parser.Section("heuristics")
device_sections[-1].add_section(new_heuristics)
heuristics_sections.append(new_heuristics)
self.__set_section_options(device_sections, generic_options)
self.__set_section_options(model_sections, model_options)
self.__set_section_options(heuristics_sections, heuristics_options)
if self.__is_heuristics_enabled_with_no_exec():
report_processor.process(
reports.corosync_quorum_heuristics_enabled_with_no_exec()
)
self.__update_qdevice_votes()
self.__update_two_node()
self.__remove_empty_sections(self.config)
self._need_qdevice_reload = True
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
"""
cfg = lib_env.get_corosync_conf()
if not cfg.has_quorum_device():
raise LibraryError(reports.qdevice_not_defined())
model = cfg.get_quorum_device_model()
cfg.remove_quorum_device()
if lib_env.is_corosync_conf_live:
report_processor = SimpleReportProcessor(lib_env.report_processor)
# get nodes for communication
cluster_nodes_names, report_list = get_existing_nodes_names(
cfg,
# Pcs is unable to communicate with nodes missing names. It cannot
# send new corosync.conf to them. That might break the cluster.
# Hence we error out.
error_on_missing_name=True
)
report_processor.report_list(report_list)
if report_processor.has_errors:
raise LibraryError()
target_list = lib_env.get_node_target_factory().get_target_list(
cluster_nodes_names, skip_non_existing=skip_offline_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.corosync_quorum_atb_will_be_enabled_due_to_sbd()
)
cfg.set_quorum_options({"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":
lib_env.report_processor.process(
reports.qdevice_certificate_removal_started()
)
com_cmd = qdevice_net_com.ClientDestroy(
lib_env.report_processor, skip_offline_nodes
)
com_cmd.set_targets(target_list)
run_and_raise(lib_env.get_node_communicator(), com_cmd)
lib_env.push_corosync_conf(cfg, skip_offline_nodes)
