rpms/pcs
7
0
Fork 0
Code Issues Pull Requests Releases Activity
3360aae91e
pcs/SOURCES/add-missing-file-test_stonith_update_scsi_devices.py.patch

1173 lines
43 KiB
Diff
Raw Normal View History

import pcs-0.10.10-4.el8
2021-11-09 09:46:38 +00:00
From e3f9823283517bafa8d309fb6148539e0e8ecdb2 Mon Sep 17 00:00:00 2001
From: Miroslav Lisik <mlisik@redhat.com>
Date: Fri, 10 Sep 2021 11:40:03 +0200
Subject: [PATCH] add missing file test_stonith_update_scsi_devices.py
---
.../test_stonith_update_scsi_devices.py | 1153 +++++++++++++++++
1 file changed, 1153 insertions(+)
create mode 100644 pcs_test/tier0/lib/commands/test_stonith_update_scsi_devices.py
diff --git a/pcs_test/tier0/lib/commands/test_stonith_update_scsi_devices.py b/pcs_test/tier0/lib/commands/test_stonith_update_scsi_devices.py
new file mode 100644
index 0000000..3bc5132
--- /dev/null
+++ b/pcs_test/tier0/lib/commands/test_stonith_update_scsi_devices.py
@@ -0,0 +1,1153 @@
+import json
+from unittest import mock, TestCase
+
+
+from pcs_test.tools import fixture
+from pcs_test.tools.command_env import get_env_tools
+from pcs_test.tools.misc import get_test_resource as rc
+
+from pcs import settings
+from pcs.lib.commands import stonith
+from pcs.common import (
+ communication,
+ reports,
+)
+from pcs.common.interface import dto
+from pcs.common.tools import timeout_to_seconds
+
+from .cluster.common import (
+ corosync_conf_fixture,
+ get_two_node,
+ node_fixture,
+)
+
+SCSI_STONITH_ID = "scsi-fence-device"
+SCSI_NODE = "node1"
+_DIGEST = "0" * 31
+DEFAULT_DIGEST = _DIGEST + "0"
+ALL_DIGEST = _DIGEST + "1"
+NONPRIVATE_DIGEST = _DIGEST + "2"
+NONRELOADABLE_DIGEST = _DIGEST + "3"
+DEVICES_1 = ("/dev/sda",)
+DEVICES_2 = ("/dev/sda", "/dev/sdb")
+DEVICES_3 = ("/dev/sda", "/dev/sdb", "/dev/sdc")
+
+DEFAULT_MONITOR = ("monitor", "60s", None, None)
+DEFAULT_OPS = (DEFAULT_MONITOR,)
+DEFAULT_LRM_START_OPS = (("0", DEFAULT_DIGEST, None, None),)
+DEFAULT_LRM_MONITOR_OPS = (("60000", DEFAULT_DIGEST, None, None),)
+DEFAULT_LRM_START_OPS_UPDATED = (("0", ALL_DIGEST, None, None),)
+DEFAULT_LRM_MONITOR_OPS_UPDATED = (("60000", ALL_DIGEST, None, None),)
+
+
+def _fixture_ops(resource_id, ops):
+ return "\n".join(
+ [
+ (
+ '<op id="{resource_id}-{name}-interval-{_interval}"'
+ ' interval="{interval}" {timeout} name="{name}"/>'
+ ).format(
+ resource_id=resource_id,
+ name=name,
+ _interval=_interval if _interval else interval,
+ interval=interval,
+ timeout=f'timeout="{timeout}"' if timeout else "",
+ )
+ for name, interval, timeout, _interval in ops
+ ]
+ )
+
+
+def _fixture_devices_nvpair(resource_id, devices):
+ if devices is None:
+ return ""
+ return (
+ '<nvpair id="{resource_id}-instance_attributes-devices" name="devices"'
+ ' value="{devices}"/>'
+ ).format(resource_id=resource_id, devices=",".join(sorted(devices)))
+
+
+def fixture_scsi(
+ stonith_id=SCSI_STONITH_ID, devices=DEVICES_1, resource_ops=DEFAULT_OPS
+):
+ return """
+ <resources>
+ <primitive class="stonith" id="{stonith_id}" type="fence_scsi">
+ <instance_attributes id="{stonith_id}-instance_attributes">
+ {devices}
+ <nvpair id="{stonith_id}-instance_attributes-pcmk_host_check" name="pcmk_host_check" value="static-list"/>
+ <nvpair id="{stonith_id}-instance_attributes-pcmk_host_list" name="pcmk_host_list" value="node1 node2 node3"/>
+ <nvpair id="{stonith_id}-instance_attributes-pcmk_reboot_action" name="pcmk_reboot_action" value="off"/>
+ </instance_attributes>
+ <meta_attributes id="{stonith_id}-meta_attributes">
+ <nvpair id="{stonith_id}-meta_attributes-provides" name="provides" value="unfencing"/>
+ </meta_attributes>
+ <operations>
+ {operations}
+ </operations>
+ </primitive>
+ <primitive class="ocf" id="dummy" provider="pacemaker" type="Dummy"/>
+ </resources>
+ """.format(
+ stonith_id=stonith_id,
+ devices=_fixture_devices_nvpair(stonith_id, devices),
+ operations=_fixture_ops(stonith_id, resource_ops),
+ )
+
+
+def _fixture_lrm_rsc_ops(op_type, resource_id, lrm_ops):
+ return [
+ (
+ '<lrm_rsc_op id="{resource_id}_{op_type_id}_{ms}" operation="{op_type}" '
+ 'interval="{ms}" {_all} {secure} {restart}/>'
+ ).format(
+ op_type_id="last" if op_type == "start" else op_type,
+ op_type=op_type,
+ resource_id=resource_id,
+ ms=ms,
+ _all=f'op-digest="{_all}"' if _all else "",
+ secure=f'op-secure-digest="{secure}"' if secure else "",
+ restart=f'op-restart-digest="{restart}"' if restart else "",
+ )
+ for ms, _all, secure, restart in lrm_ops
+ ]
+
+
+def _fixture_lrm_rsc_monitor_ops(resource_id, lrm_monitor_ops):
+ return _fixture_lrm_rsc_ops("monitor", resource_id, lrm_monitor_ops)
+
+
+def _fixture_lrm_rsc_start_ops(resource_id, lrm_start_ops):
+ return _fixture_lrm_rsc_ops("start", resource_id, lrm_start_ops)
+
+
+def _fixture_status_lrm_ops_base(
+ resource_id,
+ lrm_ops,
+):
+ return f"""
+ <status>
+ <node_state id="1" uname="node1">
+ <lrm id="1">
+ <lrm_resources>
+ <lrm_resource id="{resource_id}" type="fence_scsi" class="stonith">
+ {lrm_ops}
+ </lrm_resource>
+ </lrm_resources>
+ </lrm>
+ </node_state>
+ </status>
+ """
+
+
+def _fixture_status_lrm_ops(
+ resource_id,
+ lrm_start_ops=DEFAULT_LRM_START_OPS,
+ lrm_monitor_ops=DEFAULT_LRM_MONITOR_OPS,
+):
+ return _fixture_status_lrm_ops_base(
+ resource_id,
+ "\n".join(
+ _fixture_lrm_rsc_start_ops(resource_id, lrm_start_ops)
+ + _fixture_lrm_rsc_monitor_ops(resource_id, lrm_monitor_ops)
+ ),
+ )
+
+
+def fixture_digests_xml(resource_id, node_name, devices=""):
+ return f"""
+ <pacemaker-result api-version="2.9" request="crm_resource --digests --resource {resource_id} --node {node_name} --output-as xml devices={devices}">
+ <digests resource="{resource_id}" node="{node_name}" task="stop" interval="0ms">
+ <digest type="all" hash="{ALL_DIGEST}">
+ <parameters devices="{devices}" pcmk_host_check="static-list" pcmk_host_list="node1 node2 node3" pcmk_reboot_action="off"/>
+ </digest>
+ <digest type="nonprivate" hash="{NONPRIVATE_DIGEST}">
+ <parameters devices="{devices}"/>
+ </digest>
+ </digests>
+ <status code="0" message="OK"/>
+ </pacemaker-result>
+ """
+
+
+FIXTURE_CRM_MON_RES_RUNNING_1 = f""" <resources> <resource id="{SCSI_STONITH_ID}" resource_agent="stonith:fence_scsi" role="Started" nodes_running_on="1">
+ <node name="{SCSI_NODE}" id="1" cached="true"/>
+ </resource>
+ </resources>
+"""
+
+FIXTURE_CRM_MON_RES_RUNNING_2 = f"""
+ <resources>
+ <resource id="{SCSI_STONITH_ID}" resource_agent="stonith:fence_scsi" role="Started" nodes_running_on="1">
+ <node name="node1" id="1" cached="true"/>
+ <node name="node2" id="2" cached="true"/>
+ </resource>
+ </resources>
+"""
+FIXTURE_CRM_MON_NODES = """
+ <nodes>
+ <node name="node1" id="1" is_dc="true" resources_running="1"/>
+ <node name="node2" id="2"/>
+ <node name="node3" id="3"/>
+ </nodes>
+"""
+
+FIXTURE_CRM_MON_RES_STOPPED = f"""
+ <resource id="{SCSI_STONITH_ID}" resource_agent="stonith:fence_scsi" role="Stopped" nodes_running_on="0"/>
+"""
+
+
+@mock.patch.object(
+ settings,
+ "pacemaker_api_result_schema",
+ rc("pcmk_api_rng/api-result.rng"),
+)
+class UpdateScsiDevices(TestCase):
+ def setUp(self):
+ self.env_assist, self.config = get_env_tools(self)
+
+ self.existing_nodes = ["node1", "node2", "node3"]
+ self.existing_corosync_nodes = [
+ node_fixture(node, node_id)
+ for node_id, node in enumerate(self.existing_nodes, 1)
+ ]
+ self.config.env.set_known_nodes(self.existing_nodes)
+
+ def assert_command_success(
+ self,
+ devices_before=DEVICES_1,
+ devices_updated=DEVICES_2,
+ resource_ops=DEFAULT_OPS,
+ lrm_monitor_ops=DEFAULT_LRM_MONITOR_OPS,
+ lrm_start_ops=DEFAULT_LRM_START_OPS,
+ lrm_monitor_ops_updated=DEFAULT_LRM_MONITOR_OPS_UPDATED,
+ lrm_start_ops_updated=DEFAULT_LRM_START_OPS_UPDATED,
+ ):
+ # pylint: disable=too-many-locals
+ self.config.runner.pcmk.is_resource_digests_supported()
+ self.config.runner.cib.load(
+ resources=fixture_scsi(
+ devices=devices_before, resource_ops=resource_ops
+ ),
+ status=_fixture_status_lrm_ops(
+ SCSI_STONITH_ID,
+ lrm_start_ops=lrm_start_ops,
+ lrm_monitor_ops=lrm_monitor_ops,
+ ),
+ )
+ self.config.runner.pcmk.load_state(
+ resources=FIXTURE_CRM_MON_RES_RUNNING_1, nodes=FIXTURE_CRM_MON_NODES
+ )
+ devices_opt = "devices={}".format(",".join(devices_updated))
+ self.config.runner.pcmk.resource_digests(
+ SCSI_STONITH_ID,
+ SCSI_NODE,
+ name="start.op.digests",
+ stdout=fixture_digests_xml(
+ SCSI_STONITH_ID, SCSI_NODE, devices=",".join(devices_updated)
+ ),
+ args=[devices_opt],
+ )
+
+ for num, op in enumerate(resource_ops, 1):
+ name, interval, timeout, _ = op
+ if name != "monitor":
+ continue
+ args = [devices_opt]
+ args.append(
+ "CRM_meta_interval={}".format(
+ 1000 * timeout_to_seconds(interval)
+ )
+ )
+ if timeout:
+ args.append(
+ "CRM_meta_timeout={}".format(
+ 1000 * timeout_to_seconds(timeout)
+ )
+ )
+ self.config.runner.pcmk.resource_digests(
+ SCSI_STONITH_ID,
+ SCSI_NODE,
+ name=f"{name}-{num}.op.digests",
+ stdout=fixture_digests_xml(
+ SCSI_STONITH_ID,
+ SCSI_NODE,
+ devices=",".join(devices_updated),
+ ),
+ args=args,
+ )
+ self.config.corosync_conf.load_content(
+ corosync_conf_fixture(
+ self.existing_corosync_nodes,
+ get_two_node(len(self.existing_corosync_nodes)),
+ )
+ )
+ self.config.http.corosync.get_corosync_online_targets(
+ node_labels=self.existing_nodes
+ )
+ self.config.http.scsi.unfence_node(
+ devices_updated, node_labels=self.existing_nodes
+ )
+ self.config.env.push_cib(
+ resources=fixture_scsi(
+ devices=devices_updated, resource_ops=resource_ops
+ ),
+ status=_fixture_status_lrm_ops(
+ SCSI_STONITH_ID,
+ lrm_start_ops=lrm_start_ops_updated,
+ lrm_monitor_ops=lrm_monitor_ops_updated,
+ ),
+ )
+ stonith.update_scsi_devices(
+ self.env_assist.get_env(), SCSI_STONITH_ID, devices_updated
+ )
+ self.env_assist.assert_reports([])
+
+ def test_update_1_to_1_devices(self):
+ self.assert_command_success(
+ devices_before=DEVICES_1, devices_updated=DEVICES_1
+ )
+
+ def test_update_2_to_2_devices(self):
+ self.assert_command_success(
+ devices_before=DEVICES_1, devices_updated=DEVICES_1
+ )
+
+ def test_update_1_to_2_devices(self):
+ self.assert_command_success()
+
+ def test_update_1_to_3_devices(self):
+ self.assert_command_success(
+ devices_before=DEVICES_1, devices_updated=DEVICES_3
+ )
+
+ def test_update_3_to_1_devices(self):
+ self.assert_command_success(
+ devices_before=DEVICES_3, devices_updated=DEVICES_1
+ )
+
+ def test_update_3_to_2_devices(self):
+ self.assert_command_success(
+ devices_before=DEVICES_3, devices_updated=DEVICES_2
+ )
+
+ def test_default_monitor(self):
+ self.assert_command_success()
+
+ def test_no_monitor_ops(self):
+ self.assert_command_success(
+ resource_ops=(), lrm_monitor_ops=(), lrm_monitor_ops_updated=()
+ )
+
+ def test_1_monitor_with_timeout(self):
+ self.assert_command_success(
+ resource_ops=(("monitor", "30s", "10s", None),),
+ lrm_monitor_ops=(("30000", DEFAULT_DIGEST, None, None),),
+ lrm_monitor_ops_updated=(("30000", ALL_DIGEST, None, None),),
+ )
+
+ def test_2_monitor_ops_with_timeouts(self):
+ self.assert_command_success(
+ resource_ops=(
+ ("monitor", "30s", "10s", None),
+ ("monitor", "40s", "20s", None),
+ ),
+ lrm_monitor_ops=(
+ ("30000", DEFAULT_DIGEST, None, None),
+ ("40000", DEFAULT_DIGEST, None, None),
+ ),
+ lrm_monitor_ops_updated=(
+ ("30000", ALL_DIGEST, None, None),
+ ("40000", ALL_DIGEST, None, None),
+ ),
+ )
+
+ def test_2_monitor_ops_with_one_timeout(self):
+ self.assert_command_success(
+ resource_ops=(
+ ("monitor", "30s", "10s", None),
+ ("monitor", "60s", None, None),
+ ),
+ lrm_monitor_ops=(
+ ("30000", DEFAULT_DIGEST, None, None),
+ ("60000", DEFAULT_DIGEST, None, None),
+ ),
+ lrm_monitor_ops_updated=(
+ ("30000", ALL_DIGEST, None, None),
+ ("60000", ALL_DIGEST, None, None),
+ ),
+ )
+
+ def test_various_start_ops_one_lrm_start_op(self):
+ self.assert_command_success(
+ resource_ops=(
+ ("monitor", "60s", None, None),
+ ("start", "0s", "40s", None),
+ ("start", "0s", "30s", "1"),
+ ("start", "10s", "5s", None),
+ ("start", "20s", None, None),
+ ),
+ )
+
+ def test_1_nonrecurring_start_op_with_timeout(self):
+ self.assert_command_success(
+ resource_ops=(
+ ("monitor", "60s", None, None),
+ ("start", "0s", "40s", None),
+ ),
+ )
+
+
+@mock.patch.object(
+ settings,
+ "pacemaker_api_result_schema",
+ rc("pcmk_api_rng/api-result.rng"),
+)
+class TestUpdateScsiDevicesFailures(TestCase):
+ # pylint: disable=too-many-public-methods
+ def setUp(self):
+ self.env_assist, self.config = get_env_tools(self)
+
+ self.existing_nodes = ["node1", "node2", "node3"]
+ self.existing_corosync_nodes = [
+ node_fixture(node, node_id)
+ for node_id, node in enumerate(self.existing_nodes, 1)
+ ]
+ self.config.env.set_known_nodes(self.existing_nodes)
+
+ def test_pcmk_doesnt_support_digests(self):
+ self.config.runner.pcmk.is_resource_digests_supported(
+ is_supported=False
+ )
+ self.env_assist.assert_raise_library_error(
+ lambda: stonith.update_scsi_devices(
+ self.env_assist.get_env(), SCSI_STONITH_ID, ()
+ ),
+ [
+ fixture.error(
+ reports.codes.STONITH_RESTARTLESS_UPDATE_OF_SCSI_DEVICES_NOT_SUPPORTED,
+ )
+ ],
+ expected_in_processor=False,
+ )
+
+ def test_devices_cannot_be_empty(self):
+ self.config.runner.pcmk.is_resource_digests_supported()
+ self.config.runner.cib.load(resources=fixture_scsi())
+ self.env_assist.assert_raise_library_error(
+ lambda: stonith.update_scsi_devices(
+ self.env_assist.get_env(), SCSI_STONITH_ID, ()
+ )
+ )
+ self.env_assist.assert_reports(
+ [
+ fixture.error(
+ reports.codes.INVALID_OPTION_VALUE,
+ option_name="devices",
+ option_value="",
+ allowed_values=None,
+ cannot_be_empty=True,
+ forbidden_characters=None,
+ )
+ ]
+ )
+
+ def test_nonexistant_id(self):
+ self.config.runner.pcmk.is_resource_digests_supported()
+ self.config.runner.cib.load(resources=fixture_scsi())
+ self.env_assist.assert_raise_library_error(
+ lambda: stonith.update_scsi_devices(
+ self.env_assist.get_env(), "non-existent-id", DEVICES_2
+ )
+ )
+ self.env_assist.assert_reports(
+ [
+ fixture.error(
+ reports.codes.ID_NOT_FOUND,
+ id="non-existent-id",
+ expected_types=["primitive"],
+ context_type="cib",
+ context_id="",
+ )
+ ]
+ )
+
+ def test_not_a_resource_id(self):
+ self.config.runner.pcmk.is_resource_digests_supported()
+ self.config.runner.cib.load(resources=fixture_scsi())
+ self.env_assist.assert_raise_library_error(
+ lambda: stonith.update_scsi_devices(
+ self.env_assist.get_env(),
+ f"{SCSI_STONITH_ID}-instance_attributes-devices",
+ DEVICES_2,
+ )
+ )
+ self.env_assist.assert_reports(
+ [
+ fixture.error(
+ reports.codes.ID_BELONGS_TO_UNEXPECTED_TYPE,
+ id=f"{SCSI_STONITH_ID}-instance_attributes-devices",
+ expected_types=["primitive"],
+ current_type="nvpair",
+ )
+ ]
+ )
+
+ def test_not_supported_resource_type(self):
+ self.config.runner.pcmk.is_resource_digests_supported()
+ self.config.runner.cib.load(resources=fixture_scsi())
+ self.env_assist.assert_raise_library_error(
+ lambda: stonith.update_scsi_devices(
+ self.env_assist.get_env(), "dummy", DEVICES_2
+ )
+ )
+ self.env_assist.assert_reports(
+ [
+ fixture.error(
+ reports.codes.STONITH_RESTARTLESS_UPDATE_UNSUPPORTED_AGENT,
+ resource_id="dummy",
+ resource_type="Dummy",
+ supported_stonith_types=["fence_scsi"],
+ )
+ ]
+ )
+
+ def test_devices_option_missing(self):
+ self.config.runner.pcmk.is_resource_digests_supported()
+ self.config.runner.cib.load(resources=fixture_scsi(devices=None))
+ self.env_assist.assert_raise_library_error(
+ lambda: stonith.update_scsi_devices(
+ self.env_assist.get_env(), SCSI_STONITH_ID, DEVICES_2
+ )
+ )
+ self.env_assist.assert_reports(
+ [
+ fixture.error(
+ reports.codes.STONITH_RESTARTLESS_UPDATE_UNABLE_TO_PERFORM,
+ reason=(
+ "no devices option configured for stonith device "
+ f"'{SCSI_STONITH_ID}'"
+ ),
+ reason_type=reports.const.STONITH_RESTARTLESS_UPDATE_UNABLE_TO_PERFORM_REASON_OTHER,
+ )
+ ]
+ )
+
+ def test_devices_option_empty(self):
+ self.config.runner.pcmk.is_resource_digests_supported()
+ self.config.runner.cib.load(resources=fixture_scsi(devices=""))
+ self.env_assist.assert_raise_library_error(
+ lambda: stonith.update_scsi_devices(
+ self.env_assist.get_env(), SCSI_STONITH_ID, DEVICES_2
+ )
+ )
+ self.env_assist.assert_reports(
+ [
+ fixture.error(
+ reports.codes.STONITH_RESTARTLESS_UPDATE_UNABLE_TO_PERFORM,
+ reason=(
+ "no devices option configured for stonith device "
+ f"'{SCSI_STONITH_ID}'"
+ ),
+ reason_type=reports.const.STONITH_RESTARTLESS_UPDATE_UNABLE_TO_PERFORM_REASON_OTHER,
+ )
+ ]
+ )
+
+ def test_stonith_resource_is_not_running(self):
+ self.config.runner.pcmk.is_resource_digests_supported()
+ self.config.runner.cib.load(resources=fixture_scsi())
+ self.config.runner.pcmk.load_state(
+ resources=FIXTURE_CRM_MON_RES_STOPPED, nodes=FIXTURE_CRM_MON_NODES
+ )
+ self.env_assist.assert_raise_library_error(
+ lambda: stonith.update_scsi_devices(
+ self.env_assist.get_env(), SCSI_STONITH_ID, DEVICES_2
+ ),
+ [
+ fixture.error(
+ reports.codes.STONITH_RESTARTLESS_UPDATE_UNABLE_TO_PERFORM,
+ reason=f"resource '{SCSI_STONITH_ID}' is not running on any node",
+ reason_type=reports.const.STONITH_RESTARTLESS_UPDATE_UNABLE_TO_PERFORM_REASON_NOT_RUNNING,
+ )
+ ],
+ expected_in_processor=False,
+ )
+
+ def test_stonith_resource_is_running_on_more_than_one_node(self):
+ self.config.runner.pcmk.is_resource_digests_supported()
+ self.config.runner.cib.load(resources=fixture_scsi())
+ self.config.runner.pcmk.load_state(
+ resources=FIXTURE_CRM_MON_RES_RUNNING_2, nodes=FIXTURE_CRM_MON_NODES
+ )
+ self.env_assist.assert_raise_library_error(
+ lambda: stonith.update_scsi_devices(
+ self.env_assist.get_env(), SCSI_STONITH_ID, DEVICES_2
+ ),
+ [
+ fixture.error(
+ reports.codes.STONITH_RESTARTLESS_UPDATE_UNABLE_TO_PERFORM,
+ reason=(
+ f"resource '{SCSI_STONITH_ID}' is running on more than "
+ "1 node"
+ ),
+ reason_type=reports.const.STONITH_RESTARTLESS_UPDATE_UNABLE_TO_PERFORM_REASON_OTHER,
+ )
+ ],
+ expected_in_processor=False,
+ )
+
+ def test_lrm_op_missing_digest_attributes(self):
+ devices = ",".join(DEVICES_2)
+ self.config.runner.pcmk.is_resource_digests_supported()
+ self.config.runner.cib.load(
+ resources=fixture_scsi(),
+ status=_fixture_status_lrm_ops_base(
+ SCSI_STONITH_ID,
+ f'<lrm_rsc_op id="{SCSI_STONITH_ID}_last" operation="start"/>',
+ ),
+ )
+ self.config.runner.pcmk.load_state(
+ resources=FIXTURE_CRM_MON_RES_RUNNING_1, nodes=FIXTURE_CRM_MON_NODES
+ )
+ self.config.runner.pcmk.resource_digests(
+ SCSI_STONITH_ID,
+ SCSI_NODE,
+ name="start.op.digests",
+ stdout=fixture_digests_xml(
+ SCSI_STONITH_ID,
+ SCSI_NODE,
+ devices=devices,
+ ),
+ args=[f"devices={devices}"],
+ )
+ self.env_assist.assert_raise_library_error(
+ lambda: stonith.update_scsi_devices(
+ self.env_assist.get_env(), SCSI_STONITH_ID, DEVICES_2
+ ),
+ [
+ fixture.error(
+ reports.codes.STONITH_RESTARTLESS_UPDATE_UNABLE_TO_PERFORM,
+ reason="no digests attributes in lrm_rsc_op element",
+ reason_type=reports.const.STONITH_RESTARTLESS_UPDATE_UNABLE_TO_PERFORM_REASON_OTHER,
+ )
+ ],
+ expected_in_processor=False,
+ )
+
+ def test_crm_resource_digests_missing(self):
+ devices = ",".join(DEVICES_2)
+ self.config.runner.pcmk.is_resource_digests_supported()
+ self.config.runner.cib.load(
+ resources=fixture_scsi(),
+ status=_fixture_status_lrm_ops_base(
+ SCSI_STONITH_ID,
+ (
+ f'<lrm_rsc_op id="{SCSI_STONITH_ID}_last" '
+ 'operation="start" op-restart-digest="somedigest" />'
+ ),
+ ),
+ )
+ self.config.runner.pcmk.load_state(
+ resources=FIXTURE_CRM_MON_RES_RUNNING_1, nodes=FIXTURE_CRM_MON_NODES
+ )
+ self.config.runner.pcmk.resource_digests(
+ SCSI_STONITH_ID,
+ SCSI_NODE,
+ name="start.op.digests",
+ stdout=fixture_digests_xml(
+ SCSI_STONITH_ID,
+ SCSI_NODE,
+ devices=devices,
+ ),
+ args=[f"devices={devices}"],
+ )
+ self.env_assist.assert_raise_library_error(
+ lambda: stonith.update_scsi_devices(
+ self.env_assist.get_env(), SCSI_STONITH_ID, DEVICES_2
+ ),
+ [
+ fixture.error(
+ reports.codes.STONITH_RESTARTLESS_UPDATE_UNABLE_TO_PERFORM,
+ reason=(
+ "necessary digest for 'op-restart-digest' attribute is "
+ "missing"
+ ),
+ reason_type=reports.const.STONITH_RESTARTLESS_UPDATE_UNABLE_TO_PERFORM_REASON_OTHER,
+ )
+ ],
+ expected_in_processor=False,
+ )
+
+ def test_no_lrm_start_op(self):
+ self.config.runner.pcmk.is_resource_digests_supported()
+ self.config.runner.cib.load(
+ resources=fixture_scsi(),
+ status=_fixture_status_lrm_ops(SCSI_STONITH_ID, lrm_start_ops=()),
+ )
+ self.config.runner.pcmk.load_state(
+ resources=FIXTURE_CRM_MON_RES_RUNNING_1, nodes=FIXTURE_CRM_MON_NODES
+ )
+ self.env_assist.assert_raise_library_error(
+ lambda: stonith.update_scsi_devices(
+ self.env_assist.get_env(), SCSI_STONITH_ID, DEVICES_2
+ ),
+ [
+ fixture.error(
+ reports.codes.STONITH_RESTARTLESS_UPDATE_UNABLE_TO_PERFORM,
+ reason=(
+ "lrm_rsc_op element for start operation was not found"
+ ),
+ reason_type=reports.const.STONITH_RESTARTLESS_UPDATE_UNABLE_TO_PERFORM_REASON_OTHER,
+ )
+ ],
+ expected_in_processor=False,
+ )
+
+ def test_monitor_ops_and_lrm_monitor_ops_do_not_match(self):
+ self.config.runner.pcmk.is_resource_digests_supported()
+ self.config.runner.cib.load(
+ resources=fixture_scsi(
+ resource_ops=(
+ ("monitor", "30s", "10s", None),
+ ("monitor", "30s", "20s", "31"),
+ ("monitor", "60s", None, None),
+ )
+ ),
+ status=_fixture_status_lrm_ops(SCSI_STONITH_ID),
+ )
+ self.config.runner.pcmk.load_state(
+ resources=FIXTURE_CRM_MON_RES_RUNNING_1, nodes=FIXTURE_CRM_MON_NODES
+ )
+ self.config.runner.pcmk.resource_digests(
+ SCSI_STONITH_ID,
+ SCSI_NODE,
+ name="start.op.digests",
+ stdout=fixture_digests_xml(
+ SCSI_STONITH_ID, SCSI_NODE, devices=",".join(DEVICES_2)
+ ),
+ args=["devices={}".format(",".join(DEVICES_2))],
+ )
+ self.env_assist.assert_raise_library_error(
+ lambda: stonith.update_scsi_devices(
+ self.env_assist.get_env(), SCSI_STONITH_ID, DEVICES_2
+ ),
+ [
+ fixture.error(
+ reports.codes.STONITH_RESTARTLESS_UPDATE_UNABLE_TO_PERFORM,
+ reason=(
+ "number of lrm_rsc_op and op elements for monitor "
+ "operation differs"
+ ),
+ reason_type=reports.const.STONITH_RESTARTLESS_UPDATE_UNABLE_TO_PERFORM_REASON_OTHER,
+ )
+ ],
+ expected_in_processor=False,
+ )
+
+ def test_lrm_monitor_ops_not_found(self):
+ self.config.runner.pcmk.is_resource_digests_supported()
+ self.config.runner.cib.load(
+ resources=fixture_scsi(
+ resource_ops=(("monitor", "30s", None, None),)
+ ),
+ status=_fixture_status_lrm_ops(SCSI_STONITH_ID),
+ )
+ self.config.runner.pcmk.load_state(
+ resources=FIXTURE_CRM_MON_RES_RUNNING_1, nodes=FIXTURE_CRM_MON_NODES
+ )
+ self.config.runner.pcmk.resource_digests(
+ SCSI_STONITH_ID,
+ SCSI_NODE,
+ name="start.op.digests",
+ stdout=fixture_digests_xml(
+ SCSI_STONITH_ID, SCSI_NODE, devices=",".join(DEVICES_2)
+ ),
+ args=["devices={}".format(",".join(DEVICES_2))],
+ )
+ self.env_assist.assert_raise_library_error(
+ lambda: stonith.update_scsi_devices(
+ self.env_assist.get_env(), SCSI_STONITH_ID, DEVICES_2
+ ),
+ [
+ fixture.error(
+ reports.codes.STONITH_RESTARTLESS_UPDATE_UNABLE_TO_PERFORM,
+ reason=(
+ "monitor lrm_rsc_op element for resource "
+ f"'{SCSI_STONITH_ID}', node '{SCSI_NODE}' and interval "
+ "'30000' not found"
+ ),
+ reason_type=reports.const.STONITH_RESTARTLESS_UPDATE_UNABLE_TO_PERFORM_REASON_OTHER,
+ )
+ ],
+ expected_in_processor=False,
+ )
+
+ def test_node_missing_name_and_missing_auth_token(self):
+ self.config.runner.pcmk.is_resource_digests_supported()
+ self.config.runner.cib.load(
+ resources=fixture_scsi(),
+ status=_fixture_status_lrm_ops(SCSI_STONITH_ID),
+ )
+ self.config.runner.pcmk.load_state(
+ resources=FIXTURE_CRM_MON_RES_RUNNING_1, nodes=FIXTURE_CRM_MON_NODES
+ )
+ self.config.runner.pcmk.resource_digests(
+ SCSI_STONITH_ID,
+ SCSI_NODE,
+ name="start.op.digests",
+ stdout=fixture_digests_xml(
+ SCSI_STONITH_ID, SCSI_NODE, devices=",".join(DEVICES_2)
+ ),
+ args=["devices={}".format(",".join(DEVICES_2))],
+ )
+ self.config.runner.pcmk.resource_digests(
+ SCSI_STONITH_ID,
+ SCSI_NODE,
+ name="monitor.op.digests",
+ stdout=fixture_digests_xml(
+ SCSI_STONITH_ID, SCSI_NODE, devices=",".join(DEVICES_2)
+ ),
+ args=[
+ "devices={}".format(",".join(DEVICES_2)),
+ "CRM_meta_interval=60000",
+ ],
+ )
+ self.config.corosync_conf.load_content(
+ corosync_conf_fixture(
+ self.existing_corosync_nodes
+ + [[("ring0_addr", "custom_node"), ("nodeid", "5")]],
+ )
+ )
+ self.config.env.set_known_nodes(self.existing_nodes[:-1])
+ self.env_assist.assert_raise_library_error(
+ lambda: stonith.update_scsi_devices(
+ self.env_assist.get_env(), SCSI_STONITH_ID, DEVICES_2
+ ),
+ )
+ self.env_assist.assert_reports(
+ [
+ fixture.error(
+ reports.codes.COROSYNC_CONFIG_MISSING_NAMES_OF_NODES,
+ fatal=True,
+ ),
+ fixture.error(
+ reports.codes.HOST_NOT_FOUND,
+ host_list=[self.existing_nodes[-1]],
+ ),
+ ]
+ )
+
+ def _unfence_failure_common_calls(self):
+ devices = ",".join(DEVICES_2)
+ self.config.runner.pcmk.is_resource_digests_supported()
+ self.config.runner.cib.load(
+ resources=fixture_scsi(),
+ status=_fixture_status_lrm_ops(SCSI_STONITH_ID),
+ )
+ self.config.runner.pcmk.load_state(
+ resources=FIXTURE_CRM_MON_RES_RUNNING_1, nodes=FIXTURE_CRM_MON_NODES
+ )
+ self.config.runner.pcmk.resource_digests(
+ SCSI_STONITH_ID,
+ SCSI_NODE,
+ name="start.op.digests",
+ stdout=fixture_digests_xml(
+ SCSI_STONITH_ID,
+ SCSI_NODE,
+ devices=devices,
+ ),
+ args=[f"devices={devices}"],
+ )
+ self.config.runner.pcmk.resource_digests(
+ SCSI_STONITH_ID,
+ SCSI_NODE,
+ name="monitor.op.digests",
+ stdout=fixture_digests_xml(
+ SCSI_STONITH_ID,
+ SCSI_NODE,
+ devices=devices,
+ ),
+ args=[
+ f"devices={devices}",
+ "CRM_meta_interval=60000",
+ ],
+ )
+ self.config.corosync_conf.load_content(
+ corosync_conf_fixture(self.existing_corosync_nodes)
+ )
+
+ def test_unfence_failure_unable_to_connect(self):
+ self._unfence_failure_common_calls()
+ self.config.http.corosync.get_corosync_online_targets(
+ node_labels=self.existing_nodes
+ )
+ self.config.http.scsi.unfence_node(
+ DEVICES_2,
+ communication_list=[
+ dict(
+ label=self.existing_nodes[0],
+ raw_data=json.dumps(
+ dict(devices=DEVICES_2, node=self.existing_nodes[0])
+ ),
+ was_connected=False,
+ error_msg="errA",
+ ),
+ dict(
+ label=self.existing_nodes[1],
+ raw_data=json.dumps(
+ dict(devices=DEVICES_2, node=self.existing_nodes[1])
+ ),
+ output=json.dumps(
+ dto.to_dict(
+ communication.dto.InternalCommunicationResultDto(
+ status=communication.const.COM_STATUS_ERROR,
+ status_msg="error",
+ report_list=[
+ reports.ReportItem.error(
+ reports.messages.StonithUnfencingFailed(
+ "errB"
+ )
+ ).to_dto()
+ ],
+ data=None,
+ )
+ )
+ ),
+ ),
+ dict(
+ label=self.existing_nodes[2],
+ raw_data=json.dumps(
+ dict(devices=DEVICES_2, node=self.existing_nodes[2])
+ ),
+ ),
+ ],
+ )
+ self.env_assist.assert_raise_library_error(
+ lambda: stonith.update_scsi_devices(
+ self.env_assist.get_env(), SCSI_STONITH_ID, DEVICES_2
+ ),
+ )
+ self.env_assist.assert_reports(
+ [
+ fixture.error(
+ reports.codes.NODE_COMMUNICATION_ERROR_UNABLE_TO_CONNECT,
+ node=self.existing_nodes[0],
+ command="api/v1/scsi-unfence-node/v1",
+ reason="errA",
+ ),
+ fixture.error(
+ reports.codes.STONITH_UNFENCING_FAILED,
+ reason="errB",
+ context=reports.dto.ReportItemContextDto(
+ node=self.existing_nodes[1],
+ ),
+ ),
+ ]
+ )
+
+ def test_unfence_failure_agent_script_failed(self):
+ self._unfence_failure_common_calls()
+ self.config.http.corosync.get_corosync_online_targets(
+ node_labels=self.existing_nodes
+ )
+ self.config.http.scsi.unfence_node(
+ DEVICES_2,
+ communication_list=[
+ dict(
+ label=self.existing_nodes[0],
+ raw_data=json.dumps(
+ dict(devices=DEVICES_2, node=self.existing_nodes[0])
+ ),
+ ),
+ dict(
+ label=self.existing_nodes[1],
+ raw_data=json.dumps(
+ dict(devices=DEVICES_2, node=self.existing_nodes[1])
+ ),
+ output=json.dumps(
+ dto.to_dict(
+ communication.dto.InternalCommunicationResultDto(
+ status=communication.const.COM_STATUS_ERROR,
+ status_msg="error",
+ report_list=[
+ reports.ReportItem.error(
+ reports.messages.StonithUnfencingFailed(
+ "errB"
+ )
+ ).to_dto()
+ ],
+ data=None,
+ )
+ )
+ ),
+ ),
+ dict(
+ label=self.existing_nodes[2],
+ raw_data=json.dumps(
+ dict(devices=DEVICES_2, node=self.existing_nodes[2])
+ ),
+ ),
+ ],
+ )
+ self.env_assist.assert_raise_library_error(
+ lambda: stonith.update_scsi_devices(
+ self.env_assist.get_env(), SCSI_STONITH_ID, DEVICES_2
+ ),
+ )
+ self.env_assist.assert_reports(
+ [
+ fixture.error(
+ reports.codes.STONITH_UNFENCING_FAILED,
+ reason="errB",
+ context=reports.dto.ReportItemContextDto(
+ node=self.existing_nodes[1],
+ ),
+ ),
+ ]
+ )
+
+ def test_corosync_targets_unable_to_connect(self):
+ self._unfence_failure_common_calls()
+ self.config.http.corosync.get_corosync_online_targets(
+ communication_list=[
+ dict(
+ label=self.existing_nodes[0],
+ output='{"corosync":true}',
+ ),
+ ]
+ + [
+ dict(
+ label=node,
+ was_connected=False,
+ errno=7,
+ error_msg="an error",
+ )
+ for node in self.existing_nodes[1:]
+ ]
+ )
+ self.env_assist.assert_raise_library_error(
+ lambda: stonith.update_scsi_devices(
+ self.env_assist.get_env(), SCSI_STONITH_ID, DEVICES_2
+ ),
+ )
+ self.env_assist.assert_reports(
+ [
+ fixture.error(
+ reports.codes.NODE_COMMUNICATION_ERROR_UNABLE_TO_CONNECT,
+ force_code=reports.codes.SKIP_OFFLINE_NODES,
+ node=node,
+ command="remote/status",
+ reason="an error",
+ )
+ for node in self.existing_nodes[1:]
+ ]
+ )
+
+ def test_corosync_targets_skip_offline_unfence_node_running_corosync(
+ self,
+ ):
+ self._unfence_failure_common_calls()
+ self.config.http.corosync.get_corosync_online_targets(
+ communication_list=[
+ dict(
+ label=self.existing_nodes[0],
+ output='{"corosync":true}',
+ ),
+ dict(
+ label=self.existing_nodes[1],
+ output='{"corosync":false}',
+ ),
+ dict(
+ label=self.existing_nodes[2],
+ was_connected=False,
+ errno=7,
+ error_msg="an error",
+ ),
+ ]
+ )
+ self.config.http.scsi.unfence_node(
+ DEVICES_2,
+ communication_list=[
+ dict(
+ label=self.existing_nodes[0],
+ raw_data=json.dumps(
+ dict(devices=DEVICES_2, node=self.existing_nodes[0])
+ ),
+ ),
+ ],
+ )
+ self.config.env.push_cib(
+ resources=fixture_scsi(devices=DEVICES_2),
+ status=_fixture_status_lrm_ops(
+ SCSI_STONITH_ID,
+ lrm_start_ops=DEFAULT_LRM_START_OPS_UPDATED,
+ lrm_monitor_ops=DEFAULT_LRM_MONITOR_OPS_UPDATED,
+ ),
+ )
+ stonith.update_scsi_devices(
+ self.env_assist.get_env(),
+ SCSI_STONITH_ID,
+ DEVICES_2,
+ force_flags=[reports.codes.SKIP_OFFLINE_NODES],
+ )
+ self.env_assist.assert_reports(
+ [
+ fixture.warn(
+ reports.codes.NODE_COMMUNICATION_ERROR_UNABLE_TO_CONNECT,
+ node=self.existing_nodes[2],
+ command="remote/status",
+ reason="an error",
+ ),
+ ]
+ )
+
+ def test_corosync_targets_unable_to_perform_unfencing_operation(
+ self,
+ ):
+ self._unfence_failure_common_calls()
+ self.config.http.corosync.get_corosync_online_targets(
+ communication_list=[
+ dict(
+ label=self.existing_nodes[0],
+ was_connected=False,
+ errno=7,
+ error_msg="an error",
+ ),
+ dict(
+ label=self.existing_nodes[1],
+ was_connected=False,
+ errno=7,
+ error_msg="an error",
+ ),
+ dict(
+ label=self.existing_nodes[2],
+ output='{"corosync":false}',
+ ),
+ ]
+ )
+ self.config.http.scsi.unfence_node(DEVICES_2, communication_list=[])
+ self.env_assist.assert_raise_library_error(
+ lambda: stonith.update_scsi_devices(
+ self.env_assist.get_env(),
+ SCSI_STONITH_ID,
+ DEVICES_2,
+ force_flags=[reports.codes.SKIP_OFFLINE_NODES],
+ ),
+ )
+ self.env_assist.assert_reports(
+ [
+ fixture.warn(
+ reports.codes.NODE_COMMUNICATION_ERROR_UNABLE_TO_CONNECT,
+ node=node,
+ command="remote/status",
+ reason="an error",
+ )
+ for node in self.existing_nodes[0:2]
+ ]
+ + [
+ fixture.error(
+ reports.codes.UNABLE_TO_PERFORM_OPERATION_ON_ANY_NODE,
+ ),
+ ]
+ )
--
2.31.1
Reference in New Issue Copy Permalink