def test_refuse_invalid_document(self):
self.covered_status.append_to_first_tag_name(
'nodes', '<node without="required attributes" />')
assert_raise_library_error(
lambda: ClusterState(str(self.covered_status)),
(severities.ERROR, report_codes.BAD_CLUSTER_STATE_FORMAT, {}))
def resource_cleanup(runner, resource=None, node=None, force=False):
if not force and not node and not resource:
summary = ClusterState(get_cluster_status_xml(runner)).summary
operations = summary.nodes.attrs.count * summary.resources.attrs.count
if operations > __RESOURCE_CLEANUP_OPERATION_COUNT_THRESHOLD:
raise LibraryError(
reports.resource_cleanup_too_time_consuming(
__RESOURCE_CLEANUP_OPERATION_COUNT_THRESHOLD
)
)
cmd = [__exec("crm_resource"), "--cleanup"]
if resource:
cmd.extend(["--resource", resource])
if node:
cmd.extend(["--node", node])
stdout, stderr, retval = runner.run(cmd)
if retval != 0:
raise LibraryError(
reports.resource_cleanup_error(
join_multilines([stderr, stdout]),
resource,
node
)
)
# usefull output (what has been done) goes to stderr
return join_multilines([stdout, stderr])
def get_local_node_status(runner):
try:
cluster_status = ClusterState(get_cluster_status_xml(runner))
except CrmMonErrorException:
return {"offline": True}
node_name = __get_local_node_name(runner)
for node_status in cluster_status.node_section.nodes:
if node_status.attrs.name == node_name:
result = {
"offline": False,
}
for attr in (
'id',
'name',
'type',
'online',
'standby',
'standby_onfail',
'maintenance',
'pending',
'unclean',
'shutdown',
'expected_up',
'is_dc',
'resources_running',
):
result[attr] = getattr(node_status.attrs, attr)
return result
raise LibraryError(reports.node_not_found(node_name))
def test_can_get_node_names(self):
self.covered_status.append_to_first_tag_name(
'nodes',
self.fixture_node_string(name='node1', id='1'),
self.fixture_node_string(name='node2', id='2'),
)
xml = str(self.covered_status)
self.assertEqual(
['node1', 'node2'],
[node.attrs.name for node in ClusterState(xml).node_section.nodes])
def test_can_filter_out_remote_nodes(self):
self.covered_status.append_to_first_tag_name(
'nodes',
self.fixture_node_string(name='node1', id='1'),
self.fixture_node_string(name='node2', type='remote', id='2'),
)
xml = str(self.covered_status)
self.assertEqual(['node1'], [
node.attrs.name for node in ClusterState(xml).node_section.nodes
if node.attrs.type != 'remote'
])
def __nodes_standby_unstandby(
runner, standby=True, node_list=None, all_nodes=False
):
if node_list or all_nodes:
# TODO once we switch to editing CIB instead of running crm_stanby, we
# cannot always relly on getClusterState. If we're not editing a CIB
# from a live cluster, there is no status.
state = ClusterState(get_cluster_status_xml(runner)).node_section.nodes
known_nodes = [node.attrs.name for node in state]
if all_nodes:
node_list = known_nodes
elif node_list:
report = []
for node in node_list:
if node not in known_nodes:
report.append(reports.node_not_found(node))
if report:
raise LibraryError(*report)
# TODO Edit CIB directly instead of running commands for each node; be aware
# remote nodes might not be in the CIB yet so we need to put them there.
cmd_template = [__exec("crm_standby")]
cmd_template.extend(["-v", "on"] if standby else ["-D"])
cmd_list = []
if node_list:
for node in node_list:
cmd_list.append(cmd_template + ["-N", node])
else:
cmd_list.append(cmd_template)
report = []
for cmd in cmd_list:
stdout, stderr, retval = runner.run(cmd)
if retval != 0:
report.append(
reports.common_error(join_multilines([stderr, stdout]))
)
if report:
raise LibraryError(*report)
def test_refuse_invalid_xml(self):
assert_raise_library_error(
lambda: ClusterState('invalid xml'),
(severities.ERROR, report_codes.BAD_CLUSTER_STATE_FORMAT, {}))
def test_minimal_crm_mon_is_valid(self):
ClusterState(str(self.covered_status))
def test_resources_count(self):
xml = str(self.covered_status)
self.assertEqual(0, ClusterState(xml).summary.resources.attrs.count)
def nodes_status(argv):
if len(argv) == 1 and argv[0] == "pacemaker-id":
for node_id, node_name in utils.getPacemakerNodesID().items():
print("{0} {1}".format(node_id, node_name))
return
if len(argv) == 1 and argv[0] == "corosync-id":
for node_id, node_name in utils.getCorosyncNodesID().items():
print("{0} {1}".format(node_id, node_name))
return
if len(argv) == 1 and (argv[0] == "config"):
if utils.hasCorosyncConf():
corosync_nodes = utils.getNodesFromCorosyncConf()
else:
corosync_nodes = []
try:
pacemaker_nodes = sorted([
node.attrs.name for node in ClusterState(
utils.getClusterStateXml()).node_section.nodes
if node.attrs.type != 'remote'
])
except LibraryError as e:
utils.process_library_reports(e.args)
print("Corosync Nodes:")
if corosync_nodes:
print(" " + " ".join(corosync_nodes))
print("Pacemaker Nodes:")
if pacemaker_nodes:
print(" " + " ".join(pacemaker_nodes))
return
if len(argv) == 1 and (argv[0] == "corosync" or argv[0] == "both"):
all_nodes = utils.getNodesFromCorosyncConf()
online_nodes = utils.getCorosyncActiveNodes()
offline_nodes = []
for node in all_nodes:
if node not in online_nodes:
offline_nodes.append(node)
online_nodes.sort()
offline_nodes.sort()
print("Corosync Nodes:")
print(" ".join([" Online:"] + online_nodes))
print(" ".join([" Offline:"] + offline_nodes))
if argv[0] != "both":
sys.exit(0)
info_dom = utils.getClusterState()
nodes = info_dom.getElementsByTagName("nodes")
if nodes.length == 0:
utils.err("No nodes section found")
onlinenodes = []
offlinenodes = []
standbynodes = []
maintenancenodes = []
remote_onlinenodes = []
remote_offlinenodes = []
remote_standbynodes = []
remote_maintenancenodes = []
for node in nodes[0].getElementsByTagName("node"):
node_name = node.getAttribute("name")
node_remote = node.getAttribute("type") == "remote"
if node.getAttribute("online") == "true":
if node.getAttribute("standby") == "true":
if node_remote:
remote_standbynodes.append(node_name)
else:
standbynodes.append(node_name)
elif node.getAttribute("maintenance") == "true":
if node_remote:
remote_maintenancenodes.append(node_name)
else:
maintenancenodes.append(node_name)
else:
if node_remote:
remote_onlinenodes.append(node_name)
else:
onlinenodes.append(node_name)
else:
if node_remote:
remote_offlinenodes.append(node_name)
else:
offlinenodes.append(node_name)
print("Pacemaker Nodes:")
print(" ".join([" Online:"] + onlinenodes))
print(" ".join([" Standby:"] + standbynodes))
print(" ".join([" Maintenance:"] + maintenancenodes))
print(" ".join([" Offline:"] + offlinenodes))
print("Pacemaker Remote Nodes:")
print(" ".join([" Online:"] + remote_onlinenodes))
print(" ".join([" Standby:"] + remote_standbynodes))
print(" ".join([" Maintenance:"] + remote_maintenancenodes))
print(" ".join([" Offline:"] + remote_offlinenodes))