def push_corosync_conf(
self, corosync_conf_facade, skip_offline_nodes=False
):
corosync_conf_data = corosync_conf_facade.config.export()
if self.is_corosync_conf_live:
node_list = corosync_conf_facade.get_nodes()
if corosync_conf_facade.need_stopped_cluster:
check_corosync_offline_on_nodes(
self.node_communicator(),
self.report_processor,
node_list,
skip_offline_nodes
)
distribute_corosync_conf(
self.node_communicator(),
self.report_processor,
node_list,
corosync_conf_data,
skip_offline_nodes
)
if is_service_running(self.cmd_runner(), "corosync"):
reload_corosync_config(self.cmd_runner())
self.report_processor.process(
reports.corosync_config_reloaded()
)
if corosync_conf_facade.need_qdevice_reload:
qdevice_reload_on_nodes(
self.node_communicator(),
self.report_processor,
node_list,
skip_offline_nodes
)
else:
self._corosync_conf_data = corosync_conf_data
def test_success(self):
nodes = ["node1", "node2"]
node_addrs_list = NodeAddressesList(
[NodeAddresses(addr) for addr in nodes]
)
self.mock_communicator.call_node.return_value = '{"corosync": false}'
lib.check_corosync_offline_on_nodes(
self.mock_communicator,
self.mock_reporter,
node_addrs_list
)
assert_report_item_list_equal(
self.mock_reporter.report_item_list,
[
(
severity.INFO,
report_codes.COROSYNC_NOT_RUNNING_CHECK_STARTED,
{}
),
(
severity.INFO,
report_codes.COROSYNC_NOT_RUNNING_ON_NODE,
{"node": nodes[0]}
),
(
severity.INFO,
report_codes.COROSYNC_NOT_RUNNING_ON_NODE,
{"node": nodes[1]}
),
]
)
def disable_sbd(lib_env, ignore_offline_nodes=False):
"""
Disable SBD on all nodes in cluster.
lib_env -- LibraryEnvironment
ignore_offline_nodes -- if True, omit offline nodes
"""
node_list = _get_online_nodes(lib_env, _get_cluster_nodes(lib_env),
ignore_offline_nodes)
if lib_env.is_cman_cluster:
nodes_task.check_corosync_offline_on_nodes(lib_env.node_communicator(),
lib_env.report_processor,
node_list,
ignore_offline_nodes)
sbd.set_stonith_watchdog_timeout_to_zero_on_all_nodes(
lib_env.node_communicator(), node_list)
sbd.disable_sbd_service_on_all_nodes(lib_env.report_processor,
lib_env.node_communicator(),
node_list)
if not lib_env.is_cman_cluster:
lib_env.report_processor.process(
reports.cluster_restart_required_to_apply_changes())
def disable_sbd(lib_env, ignore_offline_nodes=False):
"""
Disable SBD on all nodes in cluster.
lib_env -- LibraryEnvironment
ignore_offline_nodes -- if True, omit offline nodes
"""
node_list = _get_online_nodes(
lib_env, _get_cluster_nodes(lib_env), ignore_offline_nodes
)
if lib_env.is_cman_cluster:
nodes_task.check_corosync_offline_on_nodes(
lib_env.node_communicator(),
lib_env.report_processor,
node_list,
ignore_offline_nodes
)
sbd.set_stonith_watchdog_timeout_to_zero_on_all_nodes(
lib_env.node_communicator(), node_list
)
sbd.disable_sbd_service_on_all_nodes(
lib_env.report_processor,
lib_env.node_communicator(),
node_list
)
if not lib_env.is_cman_cluster:
lib_env.report_processor.process(
reports.cluster_restart_required_to_apply_changes()
)
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 push_corosync_conf(
self, corosync_conf_facade, skip_offline_nodes=False
):
corosync_conf_data = corosync_conf_facade.config.export()
if self.is_corosync_conf_live:
node_list = corosync_conf_facade.get_nodes()
if corosync_conf_facade.need_stopped_cluster:
check_corosync_offline_on_nodes(
self.node_communicator(),
self.report_processor,
node_list,
skip_offline_nodes
)
distribute_corosync_conf(
self.node_communicator(),
self.report_processor,
node_list,
corosync_conf_data,
skip_offline_nodes
)
if is_service_running(self.cmd_runner(), "corosync"):
reload_corosync_config(self.cmd_runner())
self.report_processor.process(
reports.corosync_config_reloaded()
)
if corosync_conf_facade.need_qdevice_reload:
qdevice_reload_on_nodes(
self.node_communicator(),
self.report_processor,
node_list,
skip_offline_nodes
)
else:
self._corosync_conf_data = corosync_conf_data
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_json_error(self):
nodes = ["node1", "node2"]
node_addrs_list = NodeAddressesList(
[NodeAddresses(addr) for addr in nodes]
)
self.mock_communicator.call_node.side_effect = [
'{}', # missing key
'{', # not valid json
]
assert_raise_library_error(
lambda: lib.check_corosync_offline_on_nodes(
self.mock_communicator,
self.mock_reporter,
node_addrs_list
),
(
severity.ERROR,
report_codes.COROSYNC_NOT_RUNNING_CHECK_NODE_ERROR,
{
"node": nodes[0],
},
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_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_one_node_running(self):
node_responses = {
"node1": '{"corosync": false}',
"node2": '{"corosync": true}',
}
node_addrs_list = NodeAddressesList(
[NodeAddresses(addr) for addr in node_responses.keys()]
)
self.mock_communicator.call_node.side_effect = (
lambda node, request, data: node_responses[node.label]
)
assert_raise_library_error(
lambda: lib.check_corosync_offline_on_nodes(
self.mock_communicator,
self.mock_reporter,
node_addrs_list
),
(
severity.ERROR,
report_codes.COROSYNC_RUNNING_ON_NODE,
{
"node": "node2",
}
)
)
def test_one_node_running(self):
nodes = ["node1", "node2"]
node_addrs_list = NodeAddressesList([NodeAddresses(addr) for addr in nodes])
self.mock_communicator.call_node.side_effect = ['{"corosync": false}', '{"corosync": true}']
assert_raise_library_error(
lambda: lib.check_corosync_offline_on_nodes(self.mock_communicator, self.mock_reporter, node_addrs_list),
(severity.ERROR, report_codes.COROSYNC_RUNNING_ON_NODE, {"node": nodes[1]}),
)
def test_success(self):
nodes = ["node1", "node2"]
node_addrs_list = NodeAddressesList(
[NodeAddresses(addr) for addr in nodes])
self.mock_communicator.call_node.return_value = '{"corosync": false}'
lib.check_corosync_offline_on_nodes(self.mock_communicator,
self.mock_reporter,
node_addrs_list)
assert_report_item_list_equal(self.mock_reporter.report_item_list, [
(severity.INFO, report_codes.COROSYNC_NOT_RUNNING_CHECK_STARTED,
{}),
(severity.INFO, report_codes.COROSYNC_NOT_RUNNING_ON_NODE, {
"node": nodes[0]
}),
(severity.INFO, report_codes.COROSYNC_NOT_RUNNING_ON_NODE, {
"node": nodes[1]
}),
])
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 test_one_node_running(self):
nodes = ["node1", "node2"]
node_addrs_list = NodeAddressesList(
[NodeAddresses(addr) for addr in nodes])
self.mock_communicator.call_node.side_effect = [
'{"corosync": false}',
'{"corosync": true}',
]
assert_raise_library_error(
lambda: lib.check_corosync_offline_on_nodes(
self.mock_communicator, self.mock_reporter, node_addrs_list),
(severity.ERROR, report_codes.COROSYNC_RUNNING_ON_NODE, {
"node": nodes[1],
}))
def test_one_node_running(self):
node_responses = {
"node1": '{"corosync": false}',
"node2": '{"corosync": true}',
}
node_addrs_list = NodeAddressesList(
[NodeAddresses(addr) for addr in node_responses.keys()])
self.mock_communicator.call_node.side_effect = (
lambda node, request, data: node_responses[node.label])
assert_raise_library_error(
lambda: lib.check_corosync_offline_on_nodes(
self.mock_communicator, self.mock_reporter, node_addrs_list),
(severity.ERROR, report_codes.COROSYNC_RUNNING_ON_NODE, {
"node": "node2",
}))
def test_json_error(self):
nodes = ["node1", "node2"]
node_addrs_list = NodeAddressesList(
[NodeAddresses(addr) for addr in nodes])
self.mock_communicator.call_node.side_effect = [
'{}', # missing key
'{', # not valid json
]
assert_raise_library_error(
lambda: lib.check_corosync_offline_on_nodes(
self.mock_communicator, self.mock_reporter, node_addrs_list),
(severity.ERROR,
report_codes.COROSYNC_NOT_RUNNING_CHECK_NODE_ERROR, {
"node": nodes[0],
}, report_codes.SKIP_OFFLINE_NODES),
(severity.ERROR,
report_codes.COROSYNC_NOT_RUNNING_CHECK_NODE_ERROR, {
"node": nodes[1],
}, report_codes.SKIP_OFFLINE_NODES))
