def get_nodes(self):
"""
Get all defined nodes
"""
result = NodeAddressesList()
for nodelist in self.config.get_sections("nodelist"):
for node in nodelist.get_sections("node"):
node_data = {
"ring0_addr": None,
"ring1_addr": None,
"name": None,
"nodeid": None,
}
for attr_name, attr_value in node.get_attributes():
if attr_name in node_data:
node_data[attr_name] = attr_value
result.append(
NodeAddresses(node_data["ring0_addr"],
node_data["ring1_addr"], node_data["name"],
node_data["nodeid"]))
return result
def test_success(self, mock_remote_start, mock_remote_stop):
nodes = ["node1", "node2"]
node_addrs_list = NodeAddressesList(
[NodeAddresses(addr) for addr in nodes])
lib.qdevice_reload_on_nodes(self.mock_communicator, self.mock_reporter,
node_addrs_list)
node_calls = [
mock.call(self.mock_reporter, self.mock_communicator,
node_addrs_list[0]),
mock.call(self.mock_reporter, self.mock_communicator,
node_addrs_list[1]),
]
self.assertEqual(len(node_calls), len(mock_remote_stop.mock_calls))
self.assertEqual(len(node_calls), len(mock_remote_start.mock_calls))
mock_remote_stop.assert_has_calls(node_calls, any_order=True)
mock_remote_start.assert_has_calls(node_calls, any_order=True)
assert_report_item_list_equal(self.mock_reporter.report_item_list, [
(severity.INFO, report_codes.QDEVICE_CLIENT_RELOAD_STARTED, {}),
])
def _share_authkey(env,
current_nodes,
candidate_node_addresses,
skip_offline_nodes=False,
allow_incomplete_distribution=False):
if env.pacemaker.has_authkey:
authkey_content = env.pacemaker.get_authkey_content()
node_addresses_list = NodeAddressesList([candidate_node_addresses])
else:
authkey_content = generate_key()
node_addresses_list = current_nodes + [candidate_node_addresses]
com_cmd = DistributeFiles(
env.report_processor,
node_communication_format.pcmk_authkey_file(authkey_content),
skip_offline_targets=skip_offline_nodes,
allow_fails=allow_incomplete_distribution,
description="remote node configuration files",
)
com_cmd.set_targets(
env.get_node_target_factory().get_target_list(node_addresses_list))
run_and_raise(env.get_node_communicator(), com_cmd)
def test_node_down(self):
nodes = ["node1", "node2"]
node_addrs_list = NodeAddressesList(
[NodeAddresses(addr) for addr in nodes]
)
def side_effect(node, request, data):
if node.ring0 == nodes[1]:
raise NodeAuthenticationException(
nodes[1], "command", "HTTP error: 401"
)
return '{"corosync": false}'
self.mock_communicator.call_node.side_effect = side_effect
assert_raise_library_error(
lambda: lib.check_corosync_offline_on_nodes(
self.mock_communicator,
self.mock_reporter,
node_addrs_list
),
(
severity.ERROR,
report_codes.NODE_COMMUNICATION_ERROR_NOT_AUTHORIZED,
{
"node": nodes[1],
"command": "command",
"reason" : "HTTP error: 401",
},
report_codes.SKIP_OFFLINE_NODES
),
(
severity.ERROR,
report_codes.COROSYNC_NOT_RUNNING_CHECK_NODE_ERROR,
{
"node": nodes[1],
},
report_codes.SKIP_OFFLINE_NODES
)
)
def test_errors_forced(self):
nodes = ["node1", "node2"]
node_addrs_list = NodeAddressesList(
[NodeAddresses(addr) for addr in nodes])
def side_effect(node, request, data):
if node.ring0 == nodes[1]:
raise NodeAuthenticationException(nodes[1], "command",
"HTTP error: 401")
return '{' # invalid json
self.mock_communicator.call_node.side_effect = side_effect
lib.check_corosync_offline_on_nodes(self.mock_communicator,
self.mock_reporter,
node_addrs_list,
skip_offline_nodes=True)
assert_report_item_list_equal(
self.mock_reporter.report_item_list,
[(severity.INFO, report_codes.COROSYNC_NOT_RUNNING_CHECK_STARTED,
{}),
(severity.WARNING,
report_codes.COROSYNC_NOT_RUNNING_CHECK_NODE_ERROR, {
"node": nodes[0],
}),
(severity.WARNING,
report_codes.NODE_COMMUNICATION_ERROR_NOT_AUTHORIZED, {
"node": nodes[1],
"command": "command",
"reason": "HTTP error: 401",
}),
(severity.WARNING,
report_codes.COROSYNC_NOT_RUNNING_CHECK_NODE_ERROR, {
"node": nodes[1],
})])
def setUp(self):
self.mock_communicator = mock.MagicMock(spec_set=NodeCommunicator)
self.mock_reporter = MockLibraryReportProcessor()
self.node_list = NodeAddressesList(
[NodeAddresses("node" + str(i) for i in range(5))])
def test_one_node_down(self, mock_corosync_live):
conf_text = "test conf text"
nodes = ["node1", "node2"]
node_addrs_list = NodeAddressesList(
[NodeAddresses(addr) for addr in nodes])
mock_corosync_live.set_remote_corosync_conf = mock.MagicMock()
def raiser(comm, node, conf):
if node.ring0 == nodes[1]:
raise NodeAuthenticationException(nodes[1], "command",
"HTTP error: 401")
mock_corosync_live.set_remote_corosync_conf.side_effect = raiser
assert_raise_library_error(
lambda: lib.distribute_corosync_conf(
self.mock_communicator, self.mock_reporter, node_addrs_list,
conf_text),
(severity.ERROR,
report_codes.NODE_COMMUNICATION_ERROR_NOT_AUTHORIZED, {
"node": nodes[1],
"command": "command",
"reason": "HTTP error: 401",
}, report_codes.SKIP_OFFLINE_NODES),
(severity.ERROR,
report_codes.COROSYNC_CONFIG_DISTRIBUTION_NODE_ERROR, {
"node": nodes[1],
}, report_codes.SKIP_OFFLINE_NODES))
corosync_live_calls = [
mock.call.set_remote_corosync_conf("mock node communicator",
nodes[0], conf_text),
mock.call.set_remote_corosync_conf("mock node communicator",
nodes[1], conf_text),
]
self.assertEqual(len(corosync_live_calls),
len(mock_corosync_live.mock_calls))
mock_corosync_live.set_remote_corosync_conf.assert_has_calls(
[
mock.call("mock node communicator", node_addrs_list[0],
conf_text),
mock.call("mock node communicator", node_addrs_list[1],
conf_text),
],
any_order=True)
assert_report_item_list_equal(
self.mock_reporter.report_item_list,
[(severity.INFO, report_codes.COROSYNC_CONFIG_DISTRIBUTION_STARTED,
{}),
(severity.INFO, report_codes.COROSYNC_CONFIG_ACCEPTED_BY_NODE, {
"node": nodes[0]
}),
(severity.ERROR,
report_codes.NODE_COMMUNICATION_ERROR_NOT_AUTHORIZED, {
"node": nodes[1],
"command": "command",
"reason": "HTTP error: 401",
}, report_codes.SKIP_OFFLINE_NODES),
(severity.ERROR,
report_codes.COROSYNC_CONFIG_DISTRIBUTION_NODE_ERROR, {
"node": nodes[1],
}, report_codes.SKIP_OFFLINE_NODES)])
def test_fail_doesnt_prevent_start(self, mock_remote_start,
mock_remote_stop):
nodes = ["node1", "node2"]
node_addrs_list = NodeAddressesList(
[NodeAddresses(addr) for addr in nodes])
def raiser(reporter, communicator, node):
if node.ring0 == nodes[1]:
raise NodeAuthenticationException(node.label, "command",
"HTTP error: 401")
mock_remote_start.side_effect = raiser
assert_raise_library_error(
lambda: lib.qdevice_reload_on_nodes(
self.mock_communicator, self.mock_reporter, node_addrs_list),
# why the same error twice?
# 1. Tested piece of code calls a function which puts an error
# into the reporter. The reporter raises an exception. The
# exception is caught in the tested piece of code, stored, and
# later put to reporter again.
# 2. Mock reporter remembers everything that goes through it
# and by the machanism described in 1 the error goes througt it
# twice.
(severity.ERROR,
report_codes.NODE_COMMUNICATION_ERROR_NOT_AUTHORIZED, {
"node": nodes[1],
"command": "command",
"reason": "HTTP error: 401",
}, report_codes.SKIP_OFFLINE_NODES),
(severity.ERROR,
report_codes.NODE_COMMUNICATION_ERROR_NOT_AUTHORIZED, {
"node": nodes[1],
"command": "command",
"reason": "HTTP error: 401",
}, report_codes.SKIP_OFFLINE_NODES))
node_calls = [
mock.call(self.mock_reporter, self.mock_communicator,
node_addrs_list[0]),
mock.call(self.mock_reporter, self.mock_communicator,
node_addrs_list[1]),
]
self.assertEqual(len(node_calls), len(mock_remote_stop.mock_calls))
self.assertEqual(len(node_calls), len(mock_remote_start.mock_calls))
mock_remote_stop.assert_has_calls(node_calls, any_order=True)
mock_remote_start.assert_has_calls(node_calls, any_order=True)
assert_report_item_list_equal(
self.mock_reporter.report_item_list,
[
(severity.INFO, report_codes.QDEVICE_CLIENT_RELOAD_STARTED,
{}),
# why the same error twice?
# 1. Tested piece of code calls a function which puts an error
# into the reporter. The reporter raises an exception. The
# exception is caught in the tested piece of code, stored, and
# later put to reporter again.
# 2. Mock reporter remembers everything that goes through it
# and by the machanism described in 1 the error goes througt it
# twice.
(severity.ERROR,
report_codes.NODE_COMMUNICATION_ERROR_NOT_AUTHORIZED, {
"node": nodes[1],
"command": "command",
"reason": "HTTP error: 401",
}, report_codes.SKIP_OFFLINE_NODES),
(severity.ERROR,
report_codes.NODE_COMMUNICATION_ERROR_NOT_AUTHORIZED, {
"node": nodes[1],
"command": "command",
"reason": "HTTP error: 401",
}, report_codes.SKIP_OFFLINE_NODES),
])
def setUp(self):
self.node_list = NodeAddressesList(
[NodeAddresses("node" + str(i)) for i in range(5)]
)
def get_nodes_guest(tree):
return NodeAddressesList(guest_node.find_node_list(get_root(tree)))
def get_nodes_remote(tree):
return NodeAddressesList(remote_node.find_node_list(get_root(tree)))
def setUp(self):
self.node_list = NodeAddressesList([
NodeAddresses("node1"),
NodeAddresses("node2"),
NodeAddresses("node3"),
])
