def cib_runner_nodes(lib_env: LibraryEnvironment, wait: WaitType):
wait_timeout = lib_env.ensure_wait_satisfiable(wait)
yield (
lib_env.get_cib(),
lib_env.cmd_runner(),
ClusterState(lib_env.get_cluster_state()).node_section.nodes,
)
lib_env.push_cib(wait_timeout=wait_timeout)
def verify(lib_env: LibraryEnvironment):
"""
Check if all cluster nodes and stonith devices used in fencing levels exist
LibraryEnvironment lib_env -- environment
"""
cib = lib_env.get_cib()
lib_env.report_processor.report_list(
cib_fencing_topology.verify(
get_fencing_topology(cib),
get_resources(cib),
ClusterState(lib_env.get_cluster_state()).node_section.nodes,
))
if lib_env.report_processor.has_errors:
raise LibraryError()
def update_scsi_devices_add_remove(
env: LibraryEnvironment,
stonith_id: str,
add_device_list: Iterable[str],
remove_device_list: Iterable[str],
force_flags: Container[reports.types.ForceCode] = (),
) -> None:
"""
Update scsi fencing devices without restart and affecting other resources.
env -- provides all for communication with externals
stonith_id -- id of stonith resource
add_device_list -- paths to the scsi devices that would be added to the
stonith resource
remove_device_list -- paths to the scsi devices that would be removed from
the stonith resource
force_flags -- list of flags codes
"""
runner = env.cmd_runner()
(
stonith_el,
current_device_list,
) = _update_scsi_devices_get_element_and_devices(runner,
env.report_processor,
env.get_cib(), stonith_id)
if env.report_processor.report_list(
validate_add_remove_items(
add_device_list,
remove_device_list,
current_device_list,
reports.const.ADD_REMOVE_CONTAINER_TYPE_STONITH_RESOURCE,
reports.const.ADD_REMOVE_ITEM_TYPE_DEVICE,
stonith_el.get("id", ""),
)).has_errors:
raise LibraryError()
updated_device_set = (set(current_device_list).union(
add_device_list).difference(remove_device_list))
resource.stonith.update_scsi_devices_without_restart(
env.cmd_runner(),
env.get_cluster_state(),
stonith_el,
IdProvider(stonith_el),
updated_device_set,
)
_unfencing_scsi_devices(env, stonith_el, current_device_list,
updated_device_set, force_flags)
env.push_cib()
def update_scsi_devices(
env: LibraryEnvironment,
stonith_id: str,
set_device_list: Iterable[str],
force_flags: Container[reports.types.ForceCode] = (),
) -> None:
"""
Update scsi fencing devices without restart and affecting other resources.
env -- provides all for communication with externals
stonith_id -- id of stonith resource
set_device_list -- paths to the scsi devices that would be set for stonith
resource
force_flags -- list of flags codes
"""
if not set_device_list:
env.report_processor.report(
ReportItem.error(
reports.messages.InvalidOptionValue("devices",
"",
None,
cannot_be_empty=True)))
runner = env.cmd_runner()
(
stonith_el,
current_device_list,
) = _update_scsi_devices_get_element_and_devices(runner,
env.report_processor,
env.get_cib(), stonith_id)
if env.report_processor.has_errors:
raise LibraryError()
resource.stonith.update_scsi_devices_without_restart(
runner,
env.get_cluster_state(),
stonith_el,
IdProvider(stonith_el),
set_device_list,
)
_unfencing_scsi_devices(env, stonith_el, current_device_list,
set_device_list, force_flags)
env.push_cib()
def add_level(
lib_env: LibraryEnvironment,
level,
target_type,
target_value,
devices,
force_device=False,
force_node=False,
):
"""
Validate and add a new fencing level
LibraryEnvironment lib_env -- environment
int|string level -- level (index) of the new fencing level
constant target_type -- the new fencing level target value type
mixed target_value -- the new fencing level target value
Iterable devices -- list of stonith devices for the new fencing level
bool force_device -- continue even if a stonith device does not exist
bool force_node -- continue even if a node (target) does not exist
"""
cib = lib_env.get_cib()
cib_fencing_topology.add_level(
lib_env.report_processor,
get_fencing_topology(cib),
get_resources(cib),
level,
target_type,
target_value,
devices,
ClusterState(lib_env.get_cluster_state()).node_section.nodes,
force_device,
force_node,
)
if lib_env.report_processor.has_errors:
raise LibraryError()
lib_env.push_cib()
def _ensure_resource_running(env: LibraryEnvironment, resource_id):
if env.report_processor.report(
state.ensure_resource_running(env.get_cluster_state(),
resource_id)).has_errors:
raise LibraryError()
def update_scsi_devices(
env: LibraryEnvironment,
stonith_id: str,
set_device_list: Iterable[str],
force_flags: Container[reports.types.ForceCode] = (),
) -> None:
"""
Update scsi fencing devices without restart and affecting other resources.
env -- provides all for communication with externals
stonith_id -- id of stonith resource
set_device_list -- paths to the scsi devices that would be set for stonith
resource
force_flags -- list of flags codes
"""
if not is_getting_resource_digest_supported(env.cmd_runner()):
raise LibraryError(
ReportItem.error(
reports.messages.StonithRestartlessUpdateOfScsiDevicesNotSupported()
)
)
cib = env.get_cib()
if not set_device_list:
env.report_processor.report(
ReportItem.error(
reports.messages.InvalidOptionValue(
"devices", "", None, cannot_be_empty=True
)
)
)
(
stonith_el,
report_list,
) = stonith.validate_stonith_restartless_update(cib, stonith_id)
if env.report_processor.report_list(report_list).has_errors:
raise LibraryError()
# for mypy, this should not happen because exeption would be raised
if stonith_el is None:
raise AssertionError("stonith element is None")
stonith.update_scsi_devices_without_restart(
env.cmd_runner(),
env.get_cluster_state(),
stonith_el,
IdProvider(cib),
set_device_list,
)
# Unfencing
cluster_nodes_names, nodes_report_list = get_existing_nodes_names(
env.get_corosync_conf(),
error_on_missing_name=True,
)
env.report_processor.report_list(nodes_report_list)
(
target_report_list,
cluster_nodes_target_list,
) = env.get_node_target_factory().get_target_list_with_reports(
cluster_nodes_names,
allow_skip=False,
)
env.report_processor.report_list(target_report_list)
if env.report_processor.has_errors:
raise LibraryError()
com_cmd: AllSameDataMixin = GetCorosyncOnlineTargets(
env.report_processor,
skip_offline_targets=reports.codes.SKIP_OFFLINE_NODES in force_flags,
)
com_cmd.set_targets(cluster_nodes_target_list)
online_corosync_target_list = run_and_raise(
env.get_node_communicator(), com_cmd
)
com_cmd = Unfence(env.report_processor, sorted(set_device_list))
com_cmd.set_targets(online_corosync_target_list)
run_and_raise(env.get_node_communicator(), com_cmd)
env.push_cib()
