def test_3_poller_headers(self):
msg = "Description: Verify header data reported on the poller"
if fit_common.VERBOSITY >= 2:
print "\t{0}".format(msg)
errorlist = []
for node in NODELIST:
mondata = fit_common.rackhdapi("/api/2.0/nodes/" + node +
"/pollers")
self.assertIn(
mondata['status'], [200],
"Incorrect HTTP return code, expecting 200, received {}".
format(mondata['status']))
if fit_common.VERBOSITY >= 2:
nodetype = test_api_utils.get_rackhd_nodetype(node)
print "\nNode: {} Type: {}".format(node, nodetype)
poller_dict = test_api_utils.get_supported_pollers(node)
for poller in poller_dict:
poller_id = poller_dict[poller]["poller_id"]
if fit_common.VERBOSITY >= 2:
print "Poller: {} ID: {} ".format(poller, str(poller_id))
poller_data = test_api_utils.get_poller_data_by_id(poller_id)
if poller_data == []:
errorlist.append(
"Error: Node {} Poller ID {}, {} failed to return any data"
.format(node, poller_id, poller))
if fit_common.VERBOSITY >= 3:
print fit_common.json.dumps(poller_data, indent=4)
if errorlist != []:
if fit_common.VERBOSITY >= 2:
print "{}".format(fit_common.json.dumps(errorlist, indent=4))
self.assertEqual(errorlist, [], "Error reported.")
def test_4_redfish_v1_computer_reset_force_restart(self):
# This test will verify the compute node workflow power reset option ForceRestart
# and corresponding task status.
if fit_common.VERBOSITY >= 2:
msg = "Description: Verify Redfish ComputerSystem.reset option \"ForceRestart\" task data"
print("\n\t{}".format(msg))
errorlist = []
tasklist = []
for node in NODELIST:
nodetype = test_api_utils.get_rackhd_nodetype(node)
if fit_common.VERBOSITY >= 2:
print("\n===============================")
print("\nNode: {} {}".format(node, nodetype))
print("\nPower node via ComputerSystem.reset ForceRestart")
# Perform ComputerSystem.reset ForceRestart command
taskid = rackhd_compute_node_power_action(node, "ForceRestart")
if taskid:
tasklist.append(taskid)
# Poll for task end status
tasktype = "Reboot Node"
errorlist = workflow_tasklist_status_poller(tasklist, tasktype)
if errorlist:
print json.dumps(errorlist, indent=4)
self.assertEqual(errorlist, [], "Errors found".format(errorlist))
# allow power action to work a little
time.sleep(20)
def test_get_poller_status_timestamp(self):
if fit_common.VERBOSITY >= 2:
msg = "Description: Display status and timestamp from current poll"
print "\t{0}".format(msg)
for node in NODELIST:
if fit_common.VERBOSITY >= 2:
print "\nNode: ", node
nodetype = test_api_utils.get_rackhd_nodetype(node)
# Run test against managed nodes only
if nodetype != "unknown" and nodetype != "Unmanaged":
poller_dict = test_api_utils.get_supported_pollers(node)
for poller in poller_dict:
poller_id = poller_dict[poller]["poller_id"]
print "\nPoller: " + poller + " ID: " + str(poller_id)
monurl = "/api/2.0/pollers/" + str(
poller_id) + "/data/current"
mondata = fit_common.rackhdapi(url_cmd=monurl)
print "Return status", mondata['status']
if mondata['status'] == 200:
print "Timestamp:", mondata['json'][0]['timestamp']
if fit_common.VERBOSITY >= 2:
print fit_common.json.dumps(mondata['json'][0],
indent=4)
def test_4_redfish_v1_computer_reset_force_restart(self):
# This test will verify the compute node workflow power reset option ForceRestart
# and corresponding task status.
if fit_common.VERBOSITY >= 2:
msg = "Description: Verify Redfish ComputerSystem.reset option \"ForceRestart\" task data"
print("\n\t{}".format(msg))
errorlist = []
tasklist = []
for node in NODELIST:
nodetype = test_api_utils.get_rackhd_nodetype(node)
if fit_common.VERBOSITY >= 2:
print("\n===============================")
print("\nNode: {} {}".format(node, nodetype))
print("\nPower node via ComputerSystem.reset ForceRestart")
# Perform ComputerSystem.reset ForceRestart command
taskid = rackhd_compute_node_power_action(node, "ForceRestart")
if taskid:
tasklist.append(taskid)
# Poll for task end status
tasktype = "Reboot Node"
errorlist = workflow_tasklist_status_poller(tasklist, tasktype)
if errorlist:
print json.dumps(errorlist, indent=4)
self.assertEqual(errorlist, [], "Errors found".format(errorlist))
# allow power action to work a little
time.sleep(20)
def test_6_poller_status_timestamp(self):
msg = "Description: Display status and timestamp from current poll"
if fit_common.VERBOSITY >= 2:
print "\t{0}".format(msg)
errorlist = []
for node in NODELIST:
nodetype = test_api_utils.get_rackhd_nodetype(node)
if fit_common.VERBOSITY >= 2:
print "\nNode: {} Type: {}".format(node, nodetype)
poller_dict = test_api_utils.get_supported_pollers(node)
for poller in poller_dict:
poller_id = poller_dict[poller]["poller_id"]
if fit_common.VERBOSITY >= 2:
print "Poller: {} ID: {} ".format(poller, str(poller_id))
monurl = "/api/2.0/pollers/" + str(poller_id) + "/data/current"
mondata = fit_common.rackhdapi(url_cmd=monurl)
if mondata['status'] == 200:
if fit_common.VERBOSITY >= 2:
print "Timestamp: {}".format(
mondata['json'][0]['timestamp'])
else:
errorlist.append(
"Error: Node {} Poller_ID {} Failed to get current poller data, status {}"
.format(node, poller_id, mondata['status']))
if errorlist != []:
if fit_common.VERBOSITY >= 2:
print "{}".format(fit_common.json.dumps(errorlist, indent=4))
self.assertEqual(errorlist, [], "Error reported.")
def workflow_tasklist_status_poller(tasklist, tasktype, timeout=180):
"""
This utility will poll the list of taskids for a change from Running state
It will poll for the specified timeout.
:param taskid: list of task ids to poll
:param timeout: timeout in seconds when polling should fail, default is 600 seconds, 10 minutes
:return:
errorlist of taskids, node, status
"""
count = 0 # loops for timeout
polltime = 3 # sleep 3 seconds
taskid_json = []
task_errorlist = []
# if timeout set too short, make it one above polltime
if timeout < polltime:
timeout = polltime + 1
if fit_common.VERBOSITY >= 2:
print("\n===============================")
print("Polling for power update task completion....")
# spin thru the list of tasks and taskstates
while count < timeout:
for task in tasklist:
taskid_json = get_taskid_data(task)
if taskid_json:
if taskid_json.get("Name") != tasktype:
task_errorlist.append(
"Error: TaskName incorrect, expected {}".format(
tasktype))
taskstate = taskid_json.get("TaskState")
if taskstate in ['Exception', 'Killed']:
node = taskid_json["Oem"]["RackHD"].get('SystemId')
nodetype = test_api_utils.get_rackhd_nodetype(node)
task_errorlist.append(
"Error: Node {} {} Task Failure: {}".format(
node, nodetype, taskid_json))
tasklist.remove(task)
elif taskstate in ['Completed']:
# quit polling the completed tasks, remove from list
tasklist.remove(task)
# break out of loop if all tasks have ended
if not tasklist:
break
time.sleep(polltime)
count += polltime
# if any tasks left in tasklist, add to error list
if tasklist:
task_errorlist.append(
"Error: Timeout on Task Completion: {} ".format(tasklist))
for task in tasklist:
task_errorlist.append("Error Task: {}, {}".format(
task, get_taskid_data(task)))
return task_errorlist
def workflow_tasklist_status_poller(tasklist, tasktype, timeout=180):
"""
This utility will poll the list of taskids for a change from Running state
It will poll for the specified timeout.
:param taskid: list of task ids to poll
:param timeout: timeout in seconds when polling should fail, default is 600 seconds, 10 minutes
:return:
errorlist of taskids, node, status
"""
count = 0 # loops for timeout
polltime = 3 # sleep 3 seconds
taskid_json = []
task_errorlist = []
# if timeout set too short, make it one above polltime
if timeout < polltime:
timeout = polltime + 1
if fit_common.VERBOSITY >= 2:
print("\n===============================")
print("Polling for power update task completion....")
# spin thru the list of tasks and taskstates
while count < timeout:
for task in tasklist:
taskid_json = get_taskid_data(task)
if taskid_json:
if taskid_json.get("Name") != tasktype:
task_errorlist.append("Error: TaskName incorrect, expected {}".format(tasktype))
taskstate = taskid_json.get("TaskState")
if taskstate in ['Exception','Killed']:
node = taskid_json["Oem"]["RackHD"].get('SystemId')
nodetype = test_api_utils.get_rackhd_nodetype(node)
task_errorlist.append("Error: Node {} {} Task Failure: {}".format(node, nodetype, taskid_json))
tasklist.remove(task)
elif taskstate in ['Completed']:
# quit polling the completed tasks, remove from list
tasklist.remove(task)
# break out of loop if all tasks have ended
if not tasklist:
break
time.sleep(polltime)
count += polltime
# if any tasks left in tasklist, add to error list
if tasklist:
task_errorlist.append("Error: Timeout on Task Completion: {} ".format(tasklist))
for task in tasklist:
task_errorlist.append("Error Task: {}, {}".format(task, get_taskid_data(task)))
return task_errorlist
def test_4_poller_default_cache(self):
msg = "Description: Check number of polls being kept for poller ID"
if fit_common.VERBOSITY >= 2:
print "\t{0}".format(msg)
for node in NODELIST:
if fit_common.VERBOSITY >= 2:
nodetype = test_api_utils.get_rackhd_nodetype(node)
print "Node: {} Type: {}".format(node, nodetype)
errorlist = []
for node in NODELIST:
nodetype = test_api_utils.get_rackhd_nodetype(node)
if fit_common.VERBOSITY >= 2:
print "\nNode: {} Type: {}".format(node, nodetype)
poller_dict = test_api_utils.get_supported_pollers(node)
for poller in poller_dict:
poller_id = poller_dict[poller]["poller_id"]
poller_data = test_api_utils.get_poller_data_by_id(poller_id)
poll_len = len(poller_data)
if fit_common.VERBOSITY >= 2:
print "Poller: {} ID: {} ".format(poller, str(poller_id))
print "Number of polls for " + str(poller_id) + ": " + str(
len(poller_data))
if poll_len > 10:
errorlist.append(
'Error: Poller {} ID: {} - Number of cached polls should not exceed 10'
.format(poller_id, poller))
elif poll_len == 0:
errorlist.append(
'Error: Poller {} ID: {} - Pollers not running'.format(
poller_id, poller))
if errorlist != []:
if fit_common.VERBOSITY >= 2:
print "{}".format(fit_common.json.dumps(errorlist, indent=4))
self.assertEqual(errorlist, [], "Error reported.")
def test_2_pollers_by_id(self):
msg = "Description: Display the poller data per node."
if fit_common.VERBOSITY >= 2:
print "\t{0}".format(msg)
errorlist = []
poller_list = [
'driveHealth', 'sel', 'chassis', 'selInformation', 'sdr'
]
for node in NODELIST:
if fit_common.VERBOSITY >= 2:
nodetype = test_api_utils.get_rackhd_nodetype(node)
print "Node: {} Type: {}".format(node, nodetype)
mondata = fit_common.rackhdapi("/api/2.0/nodes/" + node +
"/pollers")
self.assertIn(
mondata['status'], [200],
"Incorrect HTTP return code, expecting 200, received {}".
format(mondata['status']))
# check required fields
for item in mondata['json']:
if item['pollInterval'] == 0:
errorlist.append(
"Node: {} pollInterval field error: {}".format(
node, item['pollInterval']))
for subitem in [
'node', 'config', 'createdAt', 'id', 'name', 'config'
]:
if subitem not in item:
errorlist.append("Node: {} field error: {}".format(
node, subitem))
# display poller data for the node
poller_dict = test_api_utils.get_supported_pollers(node)
for poller in poller_dict:
poller_id = poller_dict[poller]["poller_id"]
if fit_common.VERBOSITY >= 2:
print "Poller: {} ID: {} ".format(poller, str(poller_id))
poll_data = fit_common.rackhdapi("/api/2.0/pollers/" +
poller_id)
if fit_common.VERBOSITY >= 3:
print fit_common.json.dumps(poll_data.get('json', ""),
indent=4)
if errorlist != []:
if fit_common.VERBOSITY >= 2:
print "{}".format(fit_common.json.dumps(errorlist, indent=4))
self.assertEqual(errorlist, [], "Error reported.")
def test_display_raid_controller_firmware(self):
inode = 1
for node in NODELIST:
print "==== Displaying MegaRAID and Controller info ===="
source_set = []
nodetype = test_api_utils.get_rackhd_nodetype(node)
print "\nNode " + str(inode) + ": " + node
print "Type: ", nodetype
if nodetype != "unknown" and nodetype != "Unmanaged":
monurl = "/api/1.1/nodes/" + node + "/catalogs"
mondata = fit_common.rackhdapi(monurl, action="get")
catalog = mondata['json']
result = mondata['status']
if result != 200:
print "ERROR: failed catalog request"
else:
source_set = test_api_utils.get_node_source_id_list(node)
if 'megaraid-controllers' in source_set:
print "Source: megaraid-controllers\n"
raidurl = "/api/1.1/nodes/" + node + "/catalogs/megaraid-controllers"
raiddata = fit_common.rackhdapi(raidurl, action="get")
catalog = raiddata['json']
result = raiddata['status']
print " Basics: ", catalog["data"]["Controllers"][0][
"Command Status"]
print " Version: ",
pprint.pprint(catalog["data"]["Controllers"][0]
["Response Data"]["Version"])
else:
print "Info: monorail catalog did not contain megraid-controllers source"
# display controller data if available, no firmware revs are present in the output
device_ids = redfish_simple_storage_members(node)
for dev_id in device_ids:
devurl = "/redfish/v1/Systems/" + node + "/SimpleStorage/" + dev_id
devdata = fit_common.rackhdapi(url_cmd=devurl)
controller = devdata['json']
result = devdata['status']
if result == 200:
controller = devdata['json']
print "Controller: " + str(
dev_id) + " Name: " + str(
controller.get('Name', ""))
print "Description: ", json.dumps(controller.get(
'Description', ""),
indent=4)
inode += 1
print "========================================================="
def test_display_raid_controller_firmware(self):
# This test displays the MegaRaid controller firmware data from the compute
# node if it exists. It then displays the controller info contained in the
# RackHD redfish managed system data
# No asserts are used in this test, avoiding early exit on errors
inode = 1
for node in NODELIST:
print "==== Displaying MegaRAID and Controller info ===="
source_set = []
nodetype = test_api_utils.get_rackhd_nodetype(node)
print "\nNode " + str(inode) + ": " + node
print "Type: ", nodetype
if nodetype != "unknown" and nodetype != "Unmanaged":
monurl = "/api/2.0/nodes/" + node + "/catalogs"
mondata = fit_common.rackhdapi(monurl, action="get")
catalog = mondata['json']
result = mondata['status']
if result != 200:
print "ERROR: failed catalog request"
else:
source_set = test_api_utils.get_node_source_id_list(node)
if 'megaraid-controllers' in source_set:
print "Source: megaraid-controllers\n"
raidurl = "/api/2.0/nodes/" + node + "/catalogs/megaraid-controllers"
raiddata = fit_common.rackhdapi(raidurl, action="get")
catalog = raiddata['json']
result = raiddata['status']
print " Basics: ", catalog["data"]["Controllers"][0]["Command Status"]
print " Version: ",
pprint.pprint(catalog["data"]["Controllers"][0]["Response Data"]["Version"])
else:
print "Info: monorail catalog did not contain megraid-controllers source"
# display controller data if available, no firmware revs are present in the output
device_ids = redfish_simple_storage_members(node)
for dev_id in device_ids:
devurl = "/redfish/v1/Systems/" + node + "/SimpleStorage/" + dev_id
devdata = fit_common.rackhdapi(url_cmd=devurl)
controller = devdata['json']
result = devdata['status']
if result == 200:
controller = devdata['json']
print "Controller: " + str(dev_id) + " Name: " + str(controller.get('Name', ""))
print "Description: ", json.dumps(controller.get('Description', ""), indent=4)
inode += 1
print "========================================================="
def test_1_verify_pollers(self):
msg = "Description: Check pollers created for node"
if fit_common.VERBOSITY >= 2:
print "\t{0}".format(msg)
errorlist = []
poller_list = [
'driveHealth', 'sel', 'chassis', 'selInformation', 'sdr',
'selEntries'
]
if fit_common.VERBOSITY >= 2:
print "Expected Pollers for a Node: ".format(poller_list)
for node in NODELIST:
if fit_common.VERBOSITY >= 2:
nodetype = test_api_utils.get_rackhd_nodetype(node)
print "\nNode: {} Type: {}".format(node, nodetype)
mondata = fit_common.rackhdapi("/api/2.0/nodes/" + node +
"/pollers")
self.assertIn(
mondata['status'], [200],
"Incorrect HTTP return code, expecting 200, received {}".
format(mondata['status']))
poller_dict = test_api_utils.get_supported_pollers(node)
if set(poller_list) == set(poller_dict):
if fit_common.VERBOSITY >= 2:
print "Expected pollers instantiated on node"
if fit_common.VERBOSITY >= 3:
print "Poller list retreived", poller_dict
else:
if list(set(poller_list) - set(poller_dict)):
errorlist.append(
"Error: Node {} Pollers not running {}".format(
node, list(set(poller_list) - set(poller_dict))))
if list(set(poller_dict) - set(poller_list)):
errorlist.append(
"Error: Node {} Unexpected Pollers running {}".format(
node, list(set(poller_dict) - set(poller_list))))
if errorlist != []:
if fit_common.VERBOSITY >= 2:
print "{}".format(fit_common.json.dumps(errorlist, indent=4))
self.assertEqual(errorlist, [], "Error reported.")
def test_display_bmc_mc_info(self):
# This test displays the BMC MC info from the compute node via
# IPMI call ipmitool mc info
# No asserts are used in this test, avoiding early exit on errors
inode = 1
for node in NODELIST:
print "==== Displaying BMC MC info ===="
nodetype = test_api_utils.get_rackhd_nodetype(node)
print "\nNode " + str(inode) + ": " + node
print "Type: ", nodetype
if nodetype != "unknown" and nodetype != "Unmanaged":
nodeurl = "/api/2.0/nodes/" + node
nodedata = fit_common.rackhdapi(nodeurl, action="get")
nodeinfo = nodedata['json']
result = nodedata['status']
if result != 200:
print "Error on node command" + nodeurl
else:
try:
obmlist = nodeinfo["obmSettings"]
except:
print "ERROR: Node has no OBM settings configured"
else:
if obmlist:
bmc_ip = test_api_utils.get_compute_bmc_ip(node)
if bmc_ip in [1, 2]:
print "No BMC IP found"
elif bmc_ip.startswith('192.168'):
print "ERROR: BAD BMC Value: ", bmc_ip
else:
user_cred = test_api_utils.get_compute_node_username(node)
if user_cred in [1, 2, 3, 4]:
print "Unable to get user credetials for node_id", node
else:
mc_data = test_api_utils.run_ipmi_command(bmc_ip, 'mc info', user_cred)
if mc_data['exitcode'] == 0:
print "MC Data: "
print mc_data['stdout']
else:
print "ERROR: Node has no OBM settings configured"
inode += 1
print "=========================================================\n"
def test_get_current_poller_data(self):
if fit_common.VERBOSITY >= 2:
msg = "Description: Display most current data from poller"
print "\t{0}".format(msg)
for node in NODELIST:
if fit_common.VERBOSITY >= 2:
print "\nNode: ", node
nodetype = test_api_utils.get_rackhd_nodetype(node)
# Run test against managed nodes only
if nodetype != "unknown" and nodetype != "Unmanaged":
poller_dict = test_api_utils.get_supported_pollers(node)
for poller in poller_dict:
poller_id = poller_dict[poller]["poller_id"]
print "\nPoller: " + poller + " ID: " + str(poller_id)
monurl = "/api/2.0/pollers/" + str(poller_id) + "/data/current"
mondata = fit_common.rackhdapi(url_cmd=monurl)
if fit_common.VERBOSITY >= 2:
print fit_common.json.dumps(mondata, indent=4)
def test_verify_poller_data(self):
if fit_common.VERBOSITY >= 2:
msg = "Description: Check number of polls being kept for poller ID"
print "\t{0}".format(msg)
for node in NODELIST:
if fit_common.VERBOSITY >= 2:
print "\nNode: ", node
nodetype = test_api_utils.get_rackhd_nodetype(node)
# Run test against managed nodes only
if nodetype != "unknown" and nodetype != "Unmanaged":
poller_dict = test_api_utils.get_supported_pollers(node)
for poller in poller_dict:
poller_id = poller_dict[poller]["poller_id"]
print "\nPoller: " + poller + " ID: " + str(poller_id)
poller_data = test_api_utils.get_poller_data_by_id(poller_id)
poll_len = len(poller_data)
print "Number of polls for "+ str(poller_id) + ": " + str(len(poller_data))
self.assertLessEqual(poll_len, 10, 'Number of cached polls should not exceed 10')
def test_verify_poller_headers(self):
if fit_common.VERBOSITY >= 2:
msg = "Description: Verify header data reported on the poller"
print "\t{0}".format(msg)
for node in NODELIST:
mon_data = fit_common.rackhdapi("/api/2.0/nodes/" + node + "/pollers")
self.assertIn(mon_data['status'], [200], "Incorrect HTTP return code")
nodetype = test_api_utils.get_rackhd_nodetype(node)
if fit_common.VERBOSITY >= 2:
print "\nNode: {} Type: {}".format(node, nodetype)
# Run test against managed nodes only
if nodetype != "unknown" and nodetype != "Unmanaged":
poller_dict = test_api_utils.get_supported_pollers(node)
for poller in poller_dict:
poller_id = poller_dict[poller]["poller_id"]
print "\nPoller: " + poller + " ID: " + str(poller_id)
poller_data = test_api_utils.get_poller_data_by_id(poller_id)
if fit_common.VERBOSITY >= 3:
print fit_common.json.dumps(poller_data, indent=4)
def test_get_current_poller_data(self):
if fit_common.VERBOSITY >= 2:
msg = "Description: Display most current data from poller"
print "\t{0}".format(msg)
for node in NODELIST:
if fit_common.VERBOSITY >= 2:
print "\nNode: ", node
nodetype = test_api_utils.get_rackhd_nodetype(node)
# Run test against managed nodes only
if nodetype != "unknown" and nodetype != "Unmanaged":
poller_dict = test_api_utils.get_supported_pollers(node)
for poller in poller_dict:
poller_id = poller_dict[poller]["poller_id"]
print "\nPoller: " + poller + " ID: " + str(poller_id)
monurl = "/api/2.0/pollers/" + str(
poller_id) + "/data/current"
mondata = fit_common.rackhdapi(url_cmd=monurl)
if fit_common.VERBOSITY >= 2:
print fit_common.json.dumps(mondata, indent=4)
def test_get_poller_status_timestamp(self):
if fit_common.VERBOSITY >= 2:
msg = "Description: Display status and timestamp from current poll"
print "\t{0}".format(msg)
for node in NODELIST:
if fit_common.VERBOSITY >= 2:
print "\nNode: ", node
nodetype = test_api_utils.get_rackhd_nodetype(node)
# Run test against managed nodes only
if nodetype != "unknown" and nodetype != "Unmanaged":
poller_dict = test_api_utils.get_supported_pollers(node)
for poller in poller_dict:
poller_id = poller_dict[poller]["poller_id"]
print "\nPoller: " + poller + " ID: " + str(poller_id)
monurl = "/api/2.0/pollers/" + str(poller_id) + "/data/current"
mondata = fit_common.rackhdapi(url_cmd=monurl)
print "Return status", mondata['status']
if mondata['status'] == 200:
print "Timestamp:", mondata['json'][0]['timestamp']
if fit_common.VERBOSITY >= 2:
print fit_common.json.dumps(mondata['json'][0], indent=4)
def test_verify_poller_headers(self):
if fit_common.VERBOSITY >= 2:
msg = "Description: Verify header data reported on the poller"
print "\t{0}".format(msg)
for node in NODELIST:
mon_data = fit_common.rackhdapi("/api/2.0/nodes/" + node +
"/pollers")
self.assertIn(mon_data['status'], [200],
"Incorrect HTTP return code")
nodetype = test_api_utils.get_rackhd_nodetype(node)
if fit_common.VERBOSITY >= 2:
print "\nNode: {} Type: {}".format(node, nodetype)
# Run test against managed nodes only
if nodetype != "unknown" and nodetype != "Unmanaged":
poller_dict = test_api_utils.get_supported_pollers(node)
for poller in poller_dict:
poller_id = poller_dict[poller]["poller_id"]
print "\nPoller: " + poller + " ID: " + str(poller_id)
poller_data = test_api_utils.get_poller_data_by_id(
poller_id)
if fit_common.VERBOSITY >= 3:
print fit_common.json.dumps(poller_data, indent=4)
def test_verify_poller_data(self):
if fit_common.VERBOSITY >= 2:
msg = "Description: Check number of polls being kept for poller ID"
print "\t{0}".format(msg)
for node in NODELIST:
if fit_common.VERBOSITY >= 2:
print "\nNode: ", node
nodetype = test_api_utils.get_rackhd_nodetype(node)
# Run test against managed nodes only
if nodetype != "unknown" and nodetype != "Unmanaged":
poller_dict = test_api_utils.get_supported_pollers(node)
for poller in poller_dict:
poller_id = poller_dict[poller]["poller_id"]
print "\nPoller: " + poller + " ID: " + str(poller_id)
poller_data = test_api_utils.get_poller_data_by_id(
poller_id)
poll_len = len(poller_data)
print "Number of polls for " + str(poller_id) + ": " + str(
len(poller_data))
self.assertLessEqual(
poll_len, 10,
'Number of cached polls should not exceed 10')
def test99_display_node_list_discovery_data(self):
# This test displays a list of the nodes along with
# the associated BMC, RMM, and OBM settings for the discovered compute nodes
fit_common.VERBOSITY = 1 # this is needed for suppressing debug messages to make reports readable
mondata = fit_common.rackhdapi("/api/2.0/nodes")
nodes = mondata['json']
result = mondata['status']
if result == 200:
log.info_1(" NODE INVENTORY")
log.info_1(" Number of nodes found: %s", str(len(nodes)))
i = 0
for node in nodes:
i += 1
nn = node["id"]
log.info_1(" ************************")
log.info_1(" Node %s: %s", str(i), nn)
# Check type of node and display info
nodetype = node['type']
if nodetype != "compute":
log.info_1(" Node Type: %s ", nodetype)
if nodetype == "enclosure":
log.info_1(" Node Name: %s", node['name'])
nodelist = test_api_utils.get_relations_for_node(nn)
if nodelist:
log.info_1(" Nodes contained in this enclosure: %s", nodelist)
else:
log.info_1(" No Nodes found in this enclosure")
else:
# If compute node, display BMC, RMM and IP info
nodetype = test_api_utils.get_rackhd_nodetype(nn)
log.info_1(" Compute Node Type: %s", nodetype)
enclosure = test_api_utils.get_relations_for_node(nn)
if enclosure:
log.info_1(" In Enclosure: %s ", enclosure[0])
else:
log.info_1(" Not associated with a monorail enclosure")
# try to get the BMC info from the catalog
monurl = "/api/2.0/nodes/" + nn + "/catalogs/bmc"
mondata = fit_common.rackhdapi(monurl, action="get")
catalog = mondata['json']
bmcresult = mondata['status']
if bmcresult != 200:
log.info_1(" Error on catalog/bmc command")
else:
log.info_1(" BMC Mac: %s", catalog["data"]["MAC Address"])
log.info_1(" BMC IP Addr: %s", catalog["data"]["IP Address"])
log.info_1(" BMC IP Addr Src: %s", catalog["data"]["IP Address Source"])
# Get RMM info from the catalog, if present
rmmurl = "/api/2.0/nodes/" + nn + "/catalogs/rmm"
rmmdata = fit_common.rackhdapi(rmmurl, action="get")
rmmcatalog = rmmdata['json']
rmmresult = rmmdata['status']
if rmmresult != 200:
log.info_1(" No RMM catalog entry.")
else:
log.info_1(" RMM Mac: %s", rmmcatalog["data"].get("MAC Address", " "))
log.info_1(" RMM IP: %s", rmmcatalog["data"].get("IP Address", " "))
log.info_1(" RMM IP Addr source: %s", rmmcatalog["data"].get("IP Address Source", " "))
nodeurl = "/api/2.0/nodes/" + nn
nodedata = fit_common.rackhdapi(nodeurl, action="get")
nodeinfo = nodedata['json']
result = nodedata['status']
if result != 200:
log.info_1(" Error on node commandi %s http response %s", nodeurl, result)
else:
# Check BMC IP vs OBM IP setting
try:
obmlist = nodeinfo["obms"]
except:
log.info_1(" ERROR: Node has no OBM settings configured")
else:
try:
obmurl = obmlist[0]['ref']
obmdata = fit_common.rackhdapi(obmurl, action="get")
except:
log.info_1(" Invalid or empty OBM settings on Node")
else:
log.info_1(" obmhost: %s", obmdata['json']["config"].get("host", "Error: No Host in obmdata"))
log.info_1(" obmuser: %s", obmdata['json']["config"].get("user", "Error: No User defined!"))
else:
log.info_1("Cannot get RackHD nodes from stack, http response code: %s", result)
def test_display_node_list_discovery_data(self):
# This test displays a list of the nodes along with
# the associated BMC, RMM, and OBM settings for the discovered compute nodes
mondata = fit_common.rackhdapi("/api/2.0/nodes")
nodes = mondata['json']
result = mondata['status']
if result == 200:
# print "result" + str(result)
# Display node info
print "\nNumber of nodes found: " + str(len(nodes)) + "\n"
i = 0
for node in nodes:
i += 1
print ""
nn = node["id"]
print "Node {0}: {1}".format(str(i), nn)
# Check type of node and display info
nodetype = node['type']
if nodetype != "compute":
print "Node Type: ", nodetype
if nodetype == "enclosure":
print "Node Name: ", node['name']
nodelist = test_api_utils.get_relations_for_node(nn)
if nodelist:
print "Nodes contained in this enclosure: ", nodelist
else:
print "No Nodes found in this enclosure"
else:
# If compute node, display BMC, RMM and IP info
nodetype = test_api_utils.get_rackhd_nodetype(nn)
print "Compute Node Type: ", nodetype
enclosure = test_api_utils.get_relations_for_node(nn)
if enclosure:
print "In Enclosure: ", enclosure[0]
else:
print "Not associated with a monorail enclosure"
# try to get the BMC info from the catalog
monurl = "/api/2.0/nodes/" + nn + "/catalogs/bmc"
mondata = fit_common.rackhdapi(monurl, action="get")
catalog = mondata['json']
bmcresult = mondata['status']
print "BMC MAC Address",
print "\tBMC IP Address",
print "\tBMC IP Source",
print "\tRMM MAC Address",
print "\tRMM IP Address",
print "\tRMM IP Source",
print "\tOBM Host",
print "\t\tOBM User"
if bmcresult != 200:
print "Error on catalog/bmc command",
else:
print catalog["data"]["MAC Address"],
print "\t" + catalog["data"]["IP Address"],
print "\t" + catalog["data"]["IP Address Source"],
# Get RMM info from the catalog, if present
rmmurl = "/api/2.0/nodes/" + nn + "/catalogs/rmm"
rmmdata = fit_common.rackhdapi(rmmurl, action="get")
rmmcatalog = rmmdata['json']
rmmresult = rmmdata['status']
if rmmresult != 200:
print "\tNo RMM catalog entry.\t\t\t\t\t",
else:
print "\t" + rmmcatalog["data"].get(
"MAC Address", "-"),
print "\t" + rmmcatalog["data"].get("IP Address", "-"),
print "\t" + rmmcatalog["data"].get(
"IP Address Source", "-") + "\t",
nodeurl = "/api/2.0/nodes/" + nn
nodedata = fit_common.rackhdapi(nodeurl, action="get")
nodeinfo = nodedata['json']
result = nodedata['status']
if result != 200:
print "Error on node command" + nodeurl + ", http response: " + result
else:
# Check BMC IP vs OBM IP setting
try:
obmlist = nodeinfo["obmSettings"]
except:
print "ERROR: Node has no OBM settings configured"
else:
try:
obmhost = obmlist[0]["config"]["host"]
except:
print "Invalid or empty OBM setting"
else:
print obmhost,
print "\t" + obmlist[0]["config"].get(
"user", "Error: No User defined!")
else:
print "Cannot get RackHD nodes from stack, http response code: ", result
def test_display_node_list_discovery_data(self):
# This test displays a list of the nodes along with
# the associated BMC, RMM, and OBM settings for the discovered compute nodes
mondata = fit_common.rackhdapi("/api/1.1/nodes")
nodes = mondata['json']
result = mondata['status']
if result == 200:
#print "result" + str(result)
# Display node info
print "\nNumber of nodes found: "+str(len(nodes))+"\n"
i = 0
for node in nodes:
i += 1
print ""
nn = node["id"]
print "Node {0}: {1}".format(str(i), nn)
# Check type of node and display info
nodetype = node['type']
if nodetype != "compute":
print "Node Type: ", nodetype
if nodetype == "enclosure":
print "Node Name: ", node['name']
nodelist = test_api_utils.get_relations_for_node(nn)
if nodelist:
print "Nodes contained in this enclosure: ", nodelist
else:
print "No Nodes found in this enclosure"
else:
# If compute node, display BMC, RMM and IP info
nodetype = test_api_utils.get_rackhd_nodetype(nn)
print "Compute Node Type: ", nodetype
enclosure = test_api_utils.get_relations_for_node(nn)
if enclosure:
print "In Enclosure: ", enclosure[0]
else:
print "Not associated with a monorail enclosure"
# try to get the BMC info from the catalog
monurl = "/api/1.1/nodes/"+nn+"/catalogs/bmc"
mondata = fit_common.rackhdapi(monurl, action="get")
catalog = mondata['json']
bmcresult = mondata['status']
print "BMC MAC Address",
print "\tBMC IP Address",
print "\tBMC IP Source",
print "\tRMM MAC Address",
print "\tRMM IP Address",
print "\tRMM IP Source",
print "\tOBM Host",
print "\t\tOBM User"
if bmcresult != 200:
print "Error on catalog/bmc command",
else:
print catalog["data"]["MAC Address"],
print "\t" + catalog["data"]["IP Address"],
print "\t" + catalog["data"]["IP Address Source"],
# Get RMM info from the catalog, if present
rmmurl = "/api/1.1/nodes/"+nn+"/catalogs/rmm"
rmmdata = fit_common.rackhdapi(rmmurl, action="get")
rmmcatalog = rmmdata['json']
rmmresult = rmmdata['status']
if rmmresult != 200:
print "\tNo RMM catalog entry.\t\t\t\t\t",
else:
print "\t" + rmmcatalog["data"].get("MAC Address", "-"),
print "\t" + rmmcatalog["data"].get("IP Address", "-"),
print "\t" + rmmcatalog["data"].get("IP Address Source", "-") + "\t",
nodeurl = "/api/1.1/nodes/"+nn
nodedata = fit_common.rackhdapi(nodeurl, action="get")
nodeinfo = nodedata['json']
result = nodedata['status']
if result != 200:
print "Error on node command" + nodeurl + ", http response: " + result
else:
# Check BMC IP vs OBM IP setting
try:
obmlist = nodeinfo["obmSettings"]
except:
print "ERROR: Node has no OBM settings configured"
else:
try:
obmhost = obmlist[0]["config"]["host"]
except:
print "Invalid or empty OBM setting"
else:
print obmhost,
print "\t" + obmlist[0]["config"].get("user","Error: No User defined!")
else:
print "Cannot get RackHD nodes from stack, http response code: ", result
