def setUp(self):
self.known_hosts = {
"host{}".format(i):
PcsKnownHost("host{}".format(i), "token{}".format(i), [
Destination("addr{}{}".format(i, j), "port{}{}".format(i, j))
for j in range(2)
])
for i in range(2)
}
self.report_processor = MockLibraryReportProcessor()
self.factory = lib.NodeTargetLibFactory(self.known_hosts,
self.report_processor)
def setUp(self):
self.name = "booth_name"
self.mock_env = _env_fixture(self.name)
self.mock_rep = MockLibraryReportProcessor()
self.mock_run = mock.MagicMock(spec_set=CommandRunner)
self.mock_env.cmd_runner.return_value = self.mock_run
self.mock_env.report_processor = self.mock_rep
def setUp(self):
self.mock_reporter = MockLibraryReportProcessor()
self.alert = etree.Element("alert", id="alert-1")
self.recipient = etree.SubElement(self.alert,
"recipient",
id="rec-1",
value="value1")
def test_failures(self):
resources = etree.fromstring("<resources />")
reporter = MockLibraryReportProcessor()
lib.verify(reporter, self.get_cib(), resources, [])
report = [
(
severity.ERROR,
report_codes.STONITH_RESOURCES_DO_NOT_EXIST,
{
"stonith_ids": [
"d1", "d2", "d3", "d4", "d5", "dR", "dR-special"
],
},
None
),
(
severity.ERROR,
report_codes.NODE_NOT_FOUND,
{
"node": "nodeA",
},
None
),
(
severity.ERROR,
report_codes.NODE_NOT_FOUND,
{
"node": "nodeB",
},
None
),
]
assert_report_item_list_equal(reporter.report_item_list, report)
def fixture_env(cib):
env = mock.MagicMock()
env.get_cib = mock.Mock()
env.get_cib.return_value = cib
env.push_cib = mock.Mock()
env.report_processor = MockLibraryReportProcessor()
return env
def wrap_element_by_master(cib_file, resource_id, master_id=None):
cib_tree = etree.parse(cib_file, etree.XMLParser(huge_tree=True)).getroot()
element = cib_tree.find(f'.//*[@id="{resource_id}"]')
final_master_id = (master_id
if master_id is not None else f"{resource_id}-master")
master_element = _xml_to_element(f"""
<master id="{final_master_id}">
</master>
""")
element.getparent().append(master_element)
master_element.append(element)
final_xml = etree_to_str(cib_tree)
environ = dict(os.environ)
environ["CIB_file"] = cib_file
runner = CommandRunner(mock.MagicMock(logging.Logger),
MockLibraryReportProcessor(), environ)
stdout, stderr, retval = runner.run([
"cibadmin",
"--replace",
"--scope",
"resources",
"--xml-pipe",
],
stdin_string=final_xml)
assert retval == 0, ("Error running wrap_element_by_master:\n" + stderr +
"\n" + stdout)
def test_unknown_options_are_forceable(self):
report_processor = MockLibraryReportProcessor()
expected_errors = [
(
severities.ERROR,
report_codes.INVALID_OPTION,
{
"option_name": "site",
"option_type": "booth ticket",
"allowed": list(config_structure.TICKET_KEYS),
},
),
]
assert_raise_library_error(
lambda: config_structure.validate_ticket_options(
report_processor,
{
"site": "a",
"unknown": "c",
},
allow_unknown_options=True,
), *expected_errors)
assert_report_item_list_equal(
report_processor.report_item_list, expected_errors + [
(
severities.WARNING,
report_codes.INVALID_OPTION,
{
"option_name": "unknown",
"option_type": "booth ticket",
"allowed": list(config_structure.TICKET_KEYS),
},
),
])
def test_report_when_duplication_allowed(self, export_with_set):
export_with_set.return_value = "exported_duplicate_element"
element = mock.MagicMock()
element.tag = "constraint_type"
report_processor = MockLibraryReportProcessor()
constraint.check_is_without_duplication(
report_processor,
fixture_constraint_section(["duplicate_element"]), element,
are_duplicate=lambda e1, e2: True,
export_element=constraint.export_with_set,
duplication_alowed=True,
)
assert_report_item_list_equal(
report_processor.report_item_list,
[
(
severities.WARNING,
report_codes.DUPLICATE_CONSTRAINTS_EXIST,
{
'constraint_info_list': ['exported_duplicate_element'],
'constraint_type': 'constraint_type'
},
)
]
)
def test_success(self, mock_func):
mock_com = mock.MagicMock(spec_set=NodeCommunicator)
mock_rep = MockLibraryReportProcessor()
watchdog_dict = dict([
(NodeAddresses("node" + str(i)), "/dev/watchdog" + str(i))
for i in range(5)
])
device_dict = dict([
(NodeAddresses("node" + str(i)), ["/dev/sdb" + str(i)])
for i in range(5)
])
node_list = list(watchdog_dict.keys())
config = {
"opt1": "val1",
"opt2": "val2"
}
lib_sbd.set_sbd_config_on_all_nodes(
mock_rep, mock_com, node_list, config, watchdog_dict, device_dict
)
mock_func.assert_called_once_with(
lib_sbd.set_sbd_config_on_node,
[
(
[
mock_rep, mock_com, node, config, watchdog_dict[node],
device_dict[node]
], {}
)
for node in node_list
]
)
def test_success(self, mock_func):
mock_com = mock.MagicMock(spec_set=NodeCommunicator)
mock_rep = MockLibraryReportProcessor()
node_list = [NodeAddresses("node" + str(i)) for i in range(2)]
data = {
node_list[0]: {
"watchdog": "/dev/watchdog1",
"device_list": ["/dev/sdb", "/dev/vda1"],
},
node_list[1]: {
"watchdog": "/dev/watchdog2",
"device_list": ["/dev/sda2"],
}
}
lib_sbd.check_sbd_on_all_nodes(mock_rep, mock_com, data)
items = sorted(data.items())
mock_func.assert_called_once_with(
lib_sbd.check_sbd_on_node,
[
(
[
mock_rep, mock_com, node, data["watchdog"],
data["device_list"]
],
{}
)
for node, data in items
]
)
def setUp(self):
self.mock_logger = mock.MagicMock(logging.Logger)
self.mock_reporter = MockLibraryReportProcessor()
self.lib_env = LibraryEnvironment(self.mock_logger, self.mock_reporter)
self.metadata = """
<resource-agent>
<shortdesc>short desc</shortdesc>
<longdesc>long desc</longdesc>
<parameters>
</parameters>
<actions>
</actions>
</resource-agent>
"""
self.description = {
"name": "ocf:test:Dummy",
"shortdesc": "short desc",
"longdesc": "long desc",
"parameters": [],
"actions": [],
"default_actions": [{
"interval": "60s",
"name": "monitor"
}],
}
def setUp(self):
self.mock_log = mock.MagicMock(spec_set=logging.Logger)
self.mock_run = mock.MagicMock(spec_set=CommandRunner)
self.mock_rep = MockLibraryReportProcessor()
self.mock_env = LibraryEnvironment(self.mock_log,
self.mock_rep,
cib_data="<cib/>")
def test_success_on_valid_options(self):
report_processor = MockLibraryReportProcessor()
config_structure.validate_ticket_options(
report_processor,
{"timeout": "10"},
allow_unknown_options=False,
)
assert_report_item_list_equal(report_processor.report_item_list, [])
def test_empty(self):
reporter = MockLibraryReportProcessor()
lib._validate_devices(reporter, self.resources_el, [])
report = [(severity.ERROR, report_codes.REQUIRED_OPTION_IS_MISSING, {
"option_type": None,
"option_names": ["stonith devices"],
}, None)]
assert_report_item_list_equal(reporter.report_item_list, report)
def test_success(self, mock_func):
mock_com = mock.MagicMock(spec_set=NodeCommunicator)
mock_rep = MockLibraryReportProcessor()
node_list = [NodeAddresses("node" + str(i)) for i in range(5)]
lib_sbd.disable_sbd_service_on_all_nodes(mock_rep, mock_com, node_list)
mock_func.assert_called_once_with(lib_sbd.disable_sbd_service_on_node,
[([mock_rep, mock_com, node], {})
for node in node_list])
def test_invalid(self):
reporter = MockLibraryReportProcessor()
lib._validate_devices(reporter, self.resources_el, ["dummy", "fenceX"])
report = [(severity.ERROR, report_codes.STONITH_RESOURCES_DO_NOT_EXIST,
{
"stonith_ids": ["dummy", "fenceX"],
}, report_codes.FORCE_STONITH_RESOURCE_DOES_NOT_EXIST)]
assert_report_item_list_equal(reporter.report_item_list, report)
def test_node_invalid(self):
reporter = MockLibraryReportProcessor()
lib._validate_target_valuewise(reporter, self.state, TARGET_TYPE_NODE,
"rh7-x")
report = [(severity.ERROR, report_codes.NODE_NOT_FOUND, {
"node": "rh7-x",
}, report_codes.FORCE_NODE_DOES_NOT_EXIST)]
assert_report_item_list_equal(reporter.report_item_list, report)
def test_success(self):
reporter = MockLibraryReportProcessor()
lib._validate_level(reporter, 1)
lib._validate_level(reporter, "1")
lib._validate_level(reporter, 9)
lib._validate_level(reporter, "9")
lib._validate_level(reporter, "05")
assert_report_item_list_equal(reporter.report_item_list, [])
def test_empty(self):
resources = etree.fromstring("<resources />")
topology = etree.fromstring("<fencing-topology />")
reporter = MockLibraryReportProcessor()
lib.verify(reporter, topology, resources, self.get_status())
assert_report_item_list_equal(reporter.report_item_list, [])
def test_remove_config_even_if_cannot_get_its_content_when_forced(self):
env = _env_fixture("somename")
env.report_processor = MockLibraryReportProcessor()
commands.config_destroy(env, ignore_config_load_problems=True)
env.booth.remove_config.assert_called_once_with()
assert_report_item_list_equal(
env.report_processor.report_item_list,
[(Severities.WARNING, report_codes.BOOTH_CANNOT_IDENTIFY_KEYFILE,
{})])
def test_success(self):
resources = etree.fromstring("<resources />")
for name in ["d1", "d2", "d3", "d4", "d5", "dR", "dR-special"]:
self.fixture_resource(resources, name)
reporter = MockLibraryReportProcessor()
lib.verify(reporter, self.get_cib(), resources, self.get_status())
assert_report_item_list_equal(reporter.report_item_list, [])
def fixture_to_cib(cib_file, xml):
environ = dict(os.environ)
environ["CIB_file"] = cib_file
runner = CommandRunner(mock.MagicMock(logging.Logger),
MockLibraryReportProcessor(), environ)
stdout, stderr, retval = runner.run(
["cibadmin", "--create", "--scope", "resources", "--xml-text", xml])
assert retval == 0, ("Error running fixture_to_cib:\n" + stderr + "\n" +
stdout)
def test_success(self):
reporter = MockLibraryReportProcessor()
lib._validate_devices(
reporter, self.resources_el, ["stonith1"]
)
lib._validate_devices(
reporter, self.resources_el, ["stonith1", "stonith2"]
)
assert_report_item_list_equal(reporter.report_item_list, [])
def setUp(self):
self.cib = "cib"
self.report_processor = MockLibraryReportProcessor()
self.find = partial(
constraint.find_valid_resource_id,
self.report_processor,
self.cib,
in_clone_allowed=False,
)
def test_invalid(self):
reporter = MockLibraryReportProcessor()
lib._validate_target_typewise(reporter, "bad_target")
report = [(severity.ERROR, report_codes.INVALID_OPTION_TYPE, {
"option_name":
"target",
"allowed_types":
["node", "regular expression", "attribute_name=value"],
}, None)]
assert_report_item_list_equal(reporter.report_item_list, report)
def test_warn_when_config_exists_and_overwrite_allowed(self, mock_exists):
report_processor = MockLibraryReportProcessor()
self.check(report_processor, can_overwrite_existing=True)
assert_report_item_list_equal(report_processor.report_item_list, [(
severities.WARNING,
report_codes.FILE_ALREADY_EXISTS,
{
"file_path": CONF_PATH
},
)])
def test_node_invalid_not_forceable(self):
reporter = MockLibraryReportProcessor()
lib._validate_devices(reporter,
self.resources_el, ["dummy", "fenceX"],
allow_force=False)
report = [(severity.ERROR, report_codes.STONITH_RESOURCES_DO_NOT_EXIST,
{
"stonith_ids": ["dummy", "fenceX"],
}, None)]
assert_report_item_list_equal(reporter.report_item_list, report)
def test_invalid_forced(self):
reporter = MockLibraryReportProcessor()
lib._validate_devices(reporter,
self.resources_el, ["dummy", "fenceX"],
force_device=True)
report = [(severity.WARNING,
report_codes.STONITH_RESOURCES_DO_NOT_EXIST, {
"stonith_ids": ["dummy", "fenceX"],
}, None)]
assert_report_item_list_equal(reporter.report_item_list, report)
def setUp(self):
self.report_processor = MockLibraryReportProcessor(
raise_on_errors=False
)
self.cluster_state = "state"
patcher = mock.patch(
"pcs.lib.pacemaker.state.get_resource_roles_with_nodes"
)
self.addCleanup(patcher.stop)
self.get_resource_roles_with_nodes = patcher.start()
def test_success(self, mock_find):
mock_find.return_value = []
reporter = MockLibraryReportProcessor()
lib._validate_level_target_devices_does_not_exist(
reporter, "tree", "level", "target_type", "target_value",
"devices")
mock_find.assert_called_once_with("tree", "level", "target_type",
"target_value", "devices")
assert_report_item_list_equal(reporter.report_item_list, [])
def test_node_invalid_not_forceable(self):
reporter = MockLibraryReportProcessor()
lib._validate_target_valuewise(reporter,
self.state,
TARGET_TYPE_NODE,
"rh7-x",
allow_force=False)
report = [(severity.ERROR, report_codes.NODE_NOT_FOUND, {
"node": "rh7-x",
}, None)]
assert_report_item_list_equal(reporter.report_item_list, report)
class EnsureResourceState(TestCase):
resource_id = "R"
def setUp(self):
self.report_processor = MockLibraryReportProcessor(
raise_on_errors=False
)
self.cluster_state = "state"
patcher = mock.patch(
"pcs.lib.pacemaker.state.get_resource_roles_with_nodes"
)
self.addCleanup(patcher.stop)
self.get_resource_roles_with_nodes = patcher.start()
def fixture_running_state_info(self):
return {
"Started": ["node1"],
"Master": ["node2"],
"Slave": ["node3", "node4"],
}
def fixture_running_report(self, severity):
return (severity, report_codes.RESOURCE_RUNNING_ON_NODES, {
"resource_id": self.resource_id,
"roles_with_nodes": self.fixture_running_state_info(),
})
def fixture_not_running_report(self, severity):
return (severity, report_codes.RESOURCE_DOES_NOT_RUN, {
"resource_id": self.resource_id
})
def assert_running_info_transform(self, run_info, report, expected_running):
self.get_resource_roles_with_nodes.return_value = run_info
state.ensure_resource_state(
expected_running,
self.report_processor,
self.cluster_state,
self.resource_id
)
self.report_processor.assert_reports([report])
self.get_resource_roles_with_nodes.assert_called_once_with(
self.cluster_state,
self.resource_id
)
def test_report_info_running(self):
self.assert_running_info_transform(
self.fixture_running_state_info(),
self.fixture_running_report(severities.INFO),
expected_running=True,
)
def test_report_error_running(self):
self.assert_running_info_transform(
self.fixture_running_state_info(),
self.fixture_running_report(severities.ERROR),
expected_running=False,
)
def test_report_error_not_running(self):
self.assert_running_info_transform(
[],
self.fixture_not_running_report(severities.ERROR),
expected_running=True,
)
def test_report_info_not_running(self):
self.assert_running_info_transform(
[],
self.fixture_not_running_report(severities.INFO),
expected_running=False,
)
