def Verify(tc):
if tc.resp is None:
return api.types.status.FAILURE
result = api.types.status.SUCCESS
api.Logger.info("Results for %s" % (tc.cmd_descr))
cookie_idx = 0
for cmd in tc.resp.commands:
api.PrintCommandResults(cmd)
if cmd.exit_code != 0 and not api.Trigger_IsBackgroundCommand(cmd):
if (tc.cmd_cookies[cookie_idx].find("Before") != -1 or \
tc.cmd_cookies[cookie_idx].find("After") != -1):
result = api.types.status.SUCCESS
else:
result = api.types.status.FAILURE
if tc.cmd_cookies[cookie_idx].find("show security flow-gate") != -1 and \
cmd.stdout == '':
result = api.types.status.FAILURE
cookie_idx += 1
for cmd in tc.resp2.commands:
api.PrintCommandResults(cmd)
if cmd.exit_code != 0 and not api.Trigger_IsBackgroundCommand(cmd):
if tc.cmd_cookies[cookie_idx].find("Hping") != -1 or \
tc.cmd_cookies[cookie_idx].find("show session reverse direction") != -1:
result = api.types.status.SUCCESS
else:
result = api.types.status.FAILURE
if tc.cmd_cookies[cookie_idx].find("show session different dir") != -1 and \
cmd.stdout != '':
result = api.types.status.FAILURE
cookie_idx += 1
return result
def Verify(tc):
if tc.resp is None:
return api.types.status.FAILURE
result = api.types.status.SUCCESS
cookie_idx = 0
api.Logger.info("Results for %s" % (tc.cmd_descr))
for cmd in tc.resp.commands:
api.PrintCommandResults(cmd)
if cmd.exit_code != 0 and not api.Trigger_IsBackgroundCommand(cmd):
if (tc.cmd_cookies[cookie_idx].find("Run RTSP client") != -1 or \
tc.cmd_cookies[cookie_idx].find("Before RTSP") != -1 or \
tc.cmd_cookies[cookie_idx].find("show flow-gate") != -1):
result = api.types.status.SUCCESS
else:
result = api.types.status.FAILURE
if tc.cmd_cookies[cookie_idx].find("show session RTSP") != -1 and \
cmd.stdout == '':
result = api.types.status.FAILURE
cookie_idx += 1
for cmd in tc.resp2.commands:
api.PrintCommandResults(cmd)
if cmd.exit_code != 0 and not api.Trigger_IsBackgroundCommand(cmd):
if tc.cmd_cookies[cookie_idx].find("Run RTP client") != -1:
result = api.types.status.SUCCESS
else:
result = api.types.status.FAILURE
if tc.cmd_cookies[cookie_idx].find("show session RTP") != -1 and \
cmd.stdout == '':
result = api.types.status.FAILURE
cookie_idx += 1
return result
def Verify(tc):
for cmd in tc.install_cmd_resp.commands:
api.PrintCommandResults(cmd)
if cmd.exit_code != 0 and not api.Trigger_IsBackgroundCommand(cmd):
api.Logger.error("Installation failed on Node %s\n" %
(cmd.node_name))
return api.types.status.FAILURE
for cmd in tc.deploy_cmd_resp.commands:
api.PrintCommandResults(cmd)
if cmd.exit_code != 0 and not api.Trigger_IsBackgroundCommand(cmd):
api.Logger.error("Deploy failed on Node %s\n" % (cmd.node_name))
return api.types.status.FAILURE
for cmd in tc.validate_cmd_resp.commands:
api.PrintCommandResults(cmd)
if cmd.exit_code != 0 and not api.Trigger_IsBackgroundCommand(cmd):
api.Logger.error("Validation procedure failed on Node %s\n" %
(cmd.node_name))
return api.types.status.FAILURE
dir_path = os.path.dirname(os.path.realpath(__file__))
api.Logger.info("Dir Path is: %s\n" % (dir_path))
for n in tc.nodes:
api.Logger.info("Getting data for: %s\n" % (n))
resp = api.CopyFromHost(n,
["pencap/linux/techsupport/techsupport.json"],
dir_path)
if resp == None or resp.api_response.api_status != types_pb2.API_STATUS_OK:
api.Logger.error("Failed to copy client file: %s\n" % (n))
return api.types.status.FAILURE
jdata = {}
try:
with open(dir_path + "/techsupport.json") as f:
jdata = json.load(f)
except:
api.Logger.error("Unable to open local file from node: %s\n" % (n))
return api.types.status.FAILURE
for data in jdata:
array_of_dumps = jdata[data]
for dump in array_of_dumps:
dump_menu_title = ""
for item in dump:
if (isinstance(dump[item], str) == True):
dump_menu_title += dump[item] + "_"
api.Logger.info("Dumped data: %s\n" % (dump_menu_title))
return api.types.status.SUCCESS
def Verify(tc):
if tc.resp is None:
return api.types.status.FAILURE
#if tc.config_update_fail == 1:
# return api.types.status.FAILURE
result = api.types.status.SUCCESS
#Verify Half close timeout & session state
cookie_idx = 0
for cmd in tc.resp.commands:
api.PrintCommandResults(cmd)
if cmd.exit_code != 0 and not api.Trigger_IsBackgroundCommand(cmd):
#This is expected so dont set failure for this case
if (tc.cmd_cookies2[cookie_idx].find("After timeout") != -1) or \
(tc.cmd_cookies2[cookie_idx].find("Send FIN ACK") != -1):
result = api.types.status.SUCCESS
else:
result = api.types.status.FAILURE
elif tc.cmd_cookies2[cookie_idx].find("Before timeout") != -1:
#Session were not established ?
if cmd.stdout.find("FIN_RCVD") == -1:
result = api.types.status.FAILURE
elif tc.cmd_cookies2[cookie_idx].find("After timeout") != -1:
#Check if sessions are aged and new session is not created
if cmd.stdout != '':
result = api.types.status.FAILURE
cookie_idx += 1
#Verify TCP DUMP responses
cookie_idx = 0
for cmd in tc.tcpdump_resp.commands:
api.PrintCommandResults(cmd)
if cmd.exit_code != 0 and not api.Trigger_IsBackgroundCommand(cmd):
if tc.cmd_cookies3[cookie_idx].find("Check FIN Received") != -1:
result = api.types.status.SUCCESS
else:
result = api.types.status.FAILURE
elif tc.cmd_cookies3[cookie_idx].find("Check sent FIN") != -1:
#make sure FIN was sent
if cmd.stdout == -1:
result = api.types.status.FAILURE
elif tc.cmd_cookies3[cookie_idx].find("Check FIN Received") != -1:
#Check if FIN wasnt received on that other side
if cmd.stdout != '':
result = api.types.status.FAILURE
cookie_idx += 1
return result
def Verify(tc):
if tc.resp is None:
return api.types.status.FAILURE
#if tc.config_update_fail == 1:
# return api.types.status.FAILURE
result = api.types.status.SUCCESS
cookie_idx = 0
grep_cmd = "UDP"
for cmd in tc.resp.commands:
api.Logger.info("Results for %s" % (tc.cmd_cookies[cookie_idx]))
api.PrintCommandResults(cmd)
if cmd.exit_code != 0 and not api.Trigger_IsBackgroundCommand(cmd):
#This is expected so dont set failure for this case
if tc.cmd_cookies[cookie_idx].find(
"After aging") != -1 and cmd.stdout == '':
result = api.types.status.SUCCESS
else:
result = api.types.status.FAILURE
if tc.cmd_cookies[cookie_idx].find("clear session") != -1:
if cmd.stdout != '':
result = api.types.status.FAILURE
elif tc.cmd_cookies[cookie_idx].find("Before aging") != -1:
#Session were not established ?
if cmd.stdout.find("") == -1:
result = api.types.status.FAILURE
elif tc.cmd_cookies[cookie_idx].find("After aging") != -1:
#Check if sessions were aged
if cmd.stdout.find(grep_cmd) != -1:
result = api.types.status.FAILURE
cookie_idx += 1
return result
def Verify(tc):
if tc.resp is None:
return api.types.status.FAILURE
result = api.types.status.SUCCESS
f = open('test/iris/testcases/nvme/nvmf_cfg.json')
nvmf_cfg = json.load(f)
api.Logger.info("nvme_id_ns results for the following nodes: {0}".format(
tc.nodes))
for cmd in tc.resp.commands:
api.PrintCommandResults(cmd)
if cmd.exit_code != 0 and not api.Trigger_IsBackgroundCommand(cmd):
result = api.types.status.FAILURE
output = json.loads(cmd.stdout)
if output['nsze'] != (int(nvmf_cfg['block_size']) *
int(nvmf_cfg['num_block']) * 4):
result = api.types.status.FAILURE
if output['nguid'] != "00000000000000000000000000000000":
result = api.types.status.FAILURE
return result
def Verify(tc):
if tc.resp is None:
return api.types.status.FAILURE
if tc.memleak == 1:
for cmd in tc.resp.commands:
api.PrintCommandResults(cmd)
api.Logger.info("MEMORY LEAK DETECTED")
return api.types.status.FAILURE
result = api.types.status.SUCCESS
api.Logger.info("Results for %s" % (tc.cmd_descr))
cookie_idx = 0
for cmd in tc.resp.commands:
api.PrintCommandResults(cmd)
if cmd.exit_code != 0 and not api.Trigger_IsBackgroundCommand(cmd):
if (tc.cmd_cookies[cookie_idx].find("Before") != -1 or \
tc.cmd_cookies[cookie_idx].find("After") != -1 or \
tc.cmd_cookies[cookie_idx].find("After flow-gate ageout") != -1):
result = api.types.status.SUCCESS
else:
result = api.types.status.FAILURE
if tc.cmd_cookies[cookie_idx].find("show session") != -1 and \
cmd.stdout == '':
result = api.types.status.FAILURE
if tc.cmd_cookies[cookie_idx].find("show security flow-gate") != -1 and \
cmd.stdout == '':
result = api.types.status.FAILURE
if tc.cmd_cookies[cookie_idx].find("After flow-gate ageout") != -1 and \
cmd.stdout != '':
result = api.types.status.FAILURE
cookie_idx += 1
return result
def Verify(tc):
if tc.resp is None:
return api.types.status.FAILURE
result = api.types.status.SUCCESS
f = open('test/iris/testcases/nvme/nvmf_cfg.json')
nvmf_cfg = json.load(f)
api.Logger.info("nvme_id_ctrl results for the following nodes: {0}".format(
tc.nodes))
for cmd in tc.resp.commands:
api.PrintCommandResults(cmd)
if cmd.exit_code != 0 and not api.Trigger_IsBackgroundCommand(cmd):
result = api.types.status.FAILURE
output = json.loads(cmd.stdout)
if output['mn'] != nvmf_cfg['ctrl_name']:
result = api.types.status.FAILURE
if output['subnqn'] != nvmf_cfg['nqn']:
result = api.types.status.FAILURE
if output['npss'] != 0: # As per unh compliance doc
result = api.types.status.FAILURE
return result
def Verify(tc):
if tc.resp is None:
return api.types.status.FAILURE
result = api.types.status.SUCCESS
cookie_idx = 0
api.Logger.info("Results for %s" % (tc.cmd_descr))
for cmd in tc.resp.commands:
api.PrintCommandResults(cmd)
if cmd.exit_code != 0 and not api.Trigger_IsBackgroundCommand(cmd):
if tc.cmd_cookies[cookie_idx].find("Before") != -1:
result = api.types.status.SUCCESS
else:
result = api.types.status.FAILURE
if tc.cmd_cookies[cookie_idx].find("show session") != -1 and \
cmd.stdout == '':
result = api.types.status.FAILURE
if tc.cmd_cookies[cookie_idx].find("show session") != -1 and \
cmd.stdout != '':
alginfo = get_alginfo(cmd, APP_SVC_RTSP)
control_seen = 0
data_seen = 0
for info in alginfo:
if info['rtspinfo']['iscontrol'] == True:
control_seen = 1
if info['rtspinfo']['iscontrol'] == False:
data_seen = 1
if control_seen == 0 or data_seen == 0:
result = api.types.status.FAILURE
cookie_idx += 1
return result
def Verify(tc):
if tc.resp is None:
return api.types.status.FAILURE
result = api.types.status.SUCCESS
api.Logger.info("krping results for %s" % (tc.cmd_descr))
for cmd in tc.resp.commands:
api.PrintCommandResults(cmd)
if cmd.exit_code != 0 and not api.Trigger_IsBackgroundCommand(cmd):
result = api.types.status.FAILURE
for cmd in tc.stats_results:
# [...] krping: stats_out 820 ionic_0 0 Sn 64000 4000 Rc 64000 4000 W 128000 2000 R 128000 2000
try:
statline = cmd.stdout.splitlines()[-1]
(idx, dev, rc,
stats) = statline.split('stats_out')[-1].strip().split(' ', 3)
if int(rc) != 0:
api.Logger.info("test failed: '%s'" % (statline))
result = api.types.status.FAILURE
except:
api.Logger.info("unexpected test output: '%s'" % (cmd.stdout))
result = api.types.status.FAILURE
return result
def Verify(tc):
if tc.resp is None:
return api.types.status.FAILURE
#if tc.config_update_fail == 1:
# return api.types.status.FAILURE
result = api.types.status.SUCCESS
#Verify Half close timeout & session state
cookie_idx = 0
for cmd in tc.resp.commands:
api.PrintCommandResults(cmd)
if cmd.exit_code != 0 and not api.Trigger_IsBackgroundCommand(cmd):
#This is expected so dont set failure for this case
if (tc.cmd_cookies2[cookie_idx].find("After timeout") != -1 and cmd.stdout == ''):
result = api.types.status.SUCCESS
else:
result = api.types.status.FAILURE
elif tc.cmd_cookies2[cookie_idx].find("Before timeout") != -1:
#Session were not established ?
if cmd.stdout.find("BIDIR_FIN") == -1:
result = api.types.status.FAILURE
elif tc.cmd_cookies2[cookie_idx].find("After timeout") != -1:
#Check if sessions are aged and new session is not created
if cmd.stdout != '':
result = api.types.status.FAILURE
cookie_idx += 1
return result
def Verify(tc):
if tc.resp is None:
return api.types.status.FAILURE
if tc.controlageout_fail == 1:
api.Logger.info("CONTROLE AGED OUT")
return api.types.status.FAILURE
result = api.types.status.SUCCESS
cookie_idx = 0
api.Logger.info("Results for %s" % (tc.cmd_descr))
for cmd in tc.resp.commands:
api.PrintCommandResults(cmd)
if cmd.exit_code != 0 and not api.Trigger_IsBackgroundCommand(cmd):
if tc.cmd_cookies[cookie_idx].find("Run RTSP client") != -1 or \
tc.cmd_cookies[cookie_idx].find("ip route server") != -1:
result = api.types.status.SUCCESS
else:
result = api.types.status.FAILURE
if (tc.cmd_cookies[cookie_idx].find("show session RTSP") != -1 or \
tc.cmd_cookies[cookie_idx].find("show flow-gate") != -1) and \
cmd.stdout == '':
result = api.types.status.FAILURE
if (tc.cmd_cookies[cookie_idx].find("check age out") != -1 and \
cmd.stdout != ''):
result = api.types.status.FAILURE
cookie_idx += 1
return result
def Verify(tc):
nodes = api.GetWorkloadNodeHostnames()
if api.IsNaplesNode(nodes[0]) and api.IsNaplesNode(nodes[1]):
return api.types.status.DISABLED
if tc.resp is None:
return api.types.status.FAILURE
file1 = tc.GetLogsDir() + '/tcp_proxy_client.dat'
file2 = tc.GetLogsDir() + '/tcp_proxy_server.dat'
if not filecmp.cmp(file1, file2, shallow=False):
api.Logger.error("Client and server files do not match")
return api.types.status.FAILURE
result = api.types.status.SUCCESS
cookie_idx = 0
api.Logger.info("NC Results for %s" % (tc.cmd_descr))
for cmd in tc.resp.commands:
api.Logger.info("%s" % (tc.cmd_cookies[cookie_idx]))
api.PrintCommandResults(cmd)
if cmd.exit_code != 0 and not api.Trigger_IsBackgroundCommand(cmd):
#TOOD nc seems to be stuck sometimes, have to debug this
#result = api.types.status.FAILURE
pass
cookie_idx += 1
return result
def Verify(tc):
if tc.resp is None:
return api.types.status.FAILURE
result = api.types.status.SUCCESS
api.Logger.info("Results for %s" % (tc.cmd_descr))
cookie_idx = 0
for cmd in tc.resp.commands:
api.PrintCommandResults(cmd)
if cmd.exit_code != 0 and not api.Trigger_IsBackgroundCommand(cmd):
if tc.cmd_cookies[cookie_idx].find("Before") != -1 or \
tc.cmd_cookies[cookie_idx].find("show flow-gate timeout") != -1:
result = api.types.status.SUCCESS
else:
result = api.types.status.FAILURE
if (tc.cmd_cookies[cookie_idx].find("show session") != -1 and \
cmd.stdout != ''):
result = api.types.status.FAILURE
if (tc.cmd_cookies[cookie_idx].find("show security flow-gate") != -1 and \
cmd.stdout == ''):
result = api.types.status.FAILURE
#Check if flow-gate timed out
if (tc.cmd_cookies[cookie_idx].find("show flow-gate timeout") != -1 and \
cmd.stdout != ''):
result = api.types.status.FAILURE
if (tc.cmd_cookies[cookie_idx].find("show session after flow-gate timeout") != -1 and \
cmd.stdout != ''):
result = api.types.status.FAILURE
cookie_idx += 1
return result
def Verify(tc):
if tc.resp is None:
api.Logger.error("Empty response")
return api.types.status.FAILURE
result = api.types.status.SUCCESS
cookie_idx = 0
grep_cmd = "TCP"
if tc.iterators.proto == 'udp':
grep_cmd = "UDP"
if tc.config_update_fail == 1:
api.Logger.error("Updating timeout failed.")
return api.types.status.FAILURE
for cmd in tc.resp.commands:
api.Logger.info("Results for %s" % (tc.cmd_cookies[cookie_idx]))
api.PrintCommandResults(cmd)
if cmd.exit_code != 0 and not api.Trigger_IsBackgroundCommand(cmd):
#This is expected so dont set failure for this case
if tc.cmd_cookies[cookie_idx].find("After aging") != -1 or \
tc.cmd_cookies[cookie_idx].find("Before aging") != -1:
result = api.types.status.SUCCESS
else:
result = api.types.status.FAILURE
if tc.cmd_cookies[cookie_idx].find("clear session") != -1:
if cmd.stdout != '':
result = api.types.status.FAILURE
elif tc.cmd_cookies[cookie_idx].find("After aging") != -1:
#Check if sessions were aged
if cmd.stdout.find(grep_cmd) != -1:
result = api.types.status.FAILURE
cookie_idx += 1
return result
def Verify(tc):
if tc.resp is None:
return api.types.status.FAILURE
result = api.types.status.SUCCESS
for cmd in tc.resp.commands:
api.PrintCommandResults(cmd)
if cmd.exit_code != 0 and not api.Trigger_IsBackgroundCommand(cmd):
result = api.types.status.FAILURE
return result
def Verify(tc):
if tc.resp is None:
return api.types.status.FAILURE
result = api.types.status.SUCCESS
api.Logger.info("DPS: Ping Results for %s" % (tc.cmd_descr))
for cmd in tc.resp.commands:
api.PrintCommandResults(cmd)
if cmd.exit_code != 0 and not api.Trigger_IsBackgroundCommand(cmd):
result = api.types.status.FAILURE
return result
def Verify(tc):
if tc.resp is None:
return api.types.status.FAILURE
api.Logger.info("show_gid results")
for cmd in tc.resp.commands:
api.PrintCommandResults(cmd)
if cmd.exit_code != 0 and not api.Trigger_IsBackgroundCommand(cmd):
return api.types.status.FAILURE
#set the path for testcases in this testsuite to use
w = [tc.w1, tc.w2, tc.vlan_w1, tc.vlan_w2]
for i in range(len(w)):
if api.IsDryrun():
api.SetTestsuiteAttr(w[i].ip_address + "_device", '0')
else:
api.SetTestsuiteAttr(
w[i].ip_address + "_device",
rdma.GetWorkloadDevice(tc.resp.commands[i + 1].stdout))
if api.IsDryrun():
api.SetTestsuiteAttr(w[i].ip_address + "_gid", '0')
else:
api.SetTestsuiteAttr(
w[i].ip_address + "_gid",
rdma.GetWorkloadGID(tc.resp.commands[i + 1].stdout))
cookie_idx = 0
for cmd in tc.resp.commands:
if "show drops cmd" in tc.cmd_cookies[cookie_idx]:
cookie_attrs = tc.cmd_cookies[cookie_idx].split()
ip_address = cookie_attrs[-1]
node_name = cookie_attrs[5]
dev = api.GetTestsuiteAttr(ip_address + "_device")[-1]
curr_drops = qos.QosGetDropsForDevFromOutput(cmd.stdout, dev)
qos.QosSetDropsForDev(cmd.stdout, dev, node_name)
if "QoS sysctl get" in tc.cmd_cookies[cookie_idx]:
qos.QosSetTestsuiteAttrs(cmd.stdout)
if "show lif" in tc.cmd_cookies[cookie_idx]:
lif_list = []
lines = cmd.stdout.split('\n')
for line in lines:
api.Logger.info("{}".format(line))
if len(line) == 0:
continue
lif = line.split(' ')[0]
lif_list.append(lif)
api.SetTestsuiteAttr("lifs", lif_list)
cookie_idx += 1
return api.types.status.SUCCESS
def Verify(tc):
if tc.resp is None:
return api.types.status.FAILURE
result = api.types.status.SUCCESS
api.Logger.info("nvme_write results for the following nodes: {0}".format(tc.nodes))
for cmd in tc.resp.commands:
api.PrintCommandResults(cmd)
if cmd.exit_code != 0 and not api.Trigger_IsBackgroundCommand(cmd):
result = api.types.status.FAILURE
return result
def Verify(tc):
if tc.resp is None:
return api.types.status.FAILURE
result = api.types.status.SUCCESS
cookie_idx = 0
api.Logger.info("Multi Iperf Results for %s" % (tc.cmd_descr))
for cmd in tc.resp.commands:
api.Logger.info("%s" % (tc.cmd_cookies[cookie_idx]))
api.PrintCommandResults(cmd)
if cmd.exit_code != 0 and not api.Trigger_IsBackgroundCommand(cmd):
result = api.types.status.FAILURE
cookie_idx += 1
return result
def Verify(tc):
'''
#TODO
1. Check for memleaks, maybe? Can that be made as common verif step?
'''
api.Logger.verbose("BC MAC filter : Verify")
result = api.types.status.SUCCESS
if tc.skip: return api.types.status.IGNORED
# Check if all interfaces have broadcast filter enabled on them
for device_name in api.GetDeviceNames(tc.naples_node):
data = tc.device_data[device_name]
if not filters_utils.verifyPktFilters(data.intf_pktfilter_list,
data.intf_pktfilter_dict, True):
api.Logger.error(
"BC MAC filter : Verify failed for verifyBCPktFilters ",
data.intf_pktfilter_dict)
result = api.types.status.FAILURE
else:
api.Logger.debug(
"BC MAC filter : Verify - verifyBCPktFilters SUCCESS ")
# Check broadcast traffic stats
if not verifyBCTrafficStats(tc):
api.Logger.error(
"BC MAC filter : Verify failed for verifyBCTrafficStats ")
result = api.types.status.FAILURE
else:
api.Logger.debug(
"BC MAC filter : Verify - verifyBCTrafficStats SUCCESS ")
if tc.resp is None:
api.Logger.error("BC MAC filter : Verify failed - no response")
return api.types.status.FAILURE
cookie_idx = 0
for cmd in tc.resp.commands:
#api.Logger.info("BC MAC filter : Results for %s" % (tc.cmd_cookies[cookie_idx]))
#api.PrintCommandResults(cmd)
if cmd.exit_code != 0 and not api.Trigger_IsBackgroundCommand(cmd):
api.Logger.error("BC MAC filter : Verify failed for %s" %
(tc.cmd_cookies[cookie_idx]))
api.PrintCommandResults(cmd)
result = api.types.status.FAILURE
cookie_idx += 1
api.Logger.info("BC MAC filter : Verify final result - ", result)
debug_utils.collect_showtech(result)
return result
def Verify(tc):
if tc.resp_uname is None or tc.resp is None:
return api.types.status.FAILURE
result = api.types.status.SUCCESS
api.Logger.info("build_rdma results for the following nodes: {0}".format(tc.nodes))
unames = []
for cmd in tc.resp_uname.commands:
api.PrintCommandResults(cmd)
if cmd.exit_code != 0 and not api.Trigger_IsBackgroundCommand(cmd):
result = api.types.status.FAILURE
else:
unames.append(cmd.stdout)
api.SetTestsuiteAttr("unames", unames)
for cmd in tc.resp.commands:
api.PrintCommandResults(cmd)
if cmd.exit_code != 0 and not api.Trigger_IsBackgroundCommand(cmd):
result = api.types.status.FAILURE
return result
def Verify(tc):
if tc.resp is None:
return api.types.status.FAILURE
#import pdb; pdb.set_trace()
result = api.types.status.SUCCESS
for cmd in tc.resp.commands:
api.PrintCommandResults(cmd)
if cmd.exit_code != 0 and not api.Trigger_IsBackgroundCommand(cmd):
result = api.types.status.FAILURE
api.Logger.info('Setting API FAILURE for command: ' + cmd.command)
if 'tcpdump' in cmd.command:
# Check stdout first
matchObj = re.search(r'(.*) GREv0, length 158(.*)', cmd.stdout, 0)
if matchObj is None:
result = api.types.status.FAILURE
return result
def Verify(tc):
nodes = api.GetWorkloadNodeHostnames()
if api.IsNaplesNode(nodes[0]) and api.IsNaplesNode(nodes[1]):
return api.types.status.DISABLED
if tc.resp is None:
return api.types.status.FAILURE
result = api.types.status.SUCCESS
cookie_idx = 0
api.Logger.info("Iperf Results for %s" % (tc.cmd_descr))
for cmd in tc.resp.commands:
api.Logger.info("%s" % (tc.cmd_cookies[cookie_idx]))
api.PrintCommandResults(cmd)
if cmd.exit_code != 0 and not api.Trigger_IsBackgroundCommand(cmd):
result = api.types.status.FAILURE
cookie_idx += 1
return result
def Verify(tc):
if tc.resp is None:
return api.types.status.FAILURE
result = api.types.status.SUCCESS
api.Logger.info("nvme_get_ftr results for the following nodes: {0}".format(tc.nodes))
for cmd in tc.resp.commands:
api.PrintCommandResults(cmd)
if cmd.exit_code != 0 and not api.Trigger_IsBackgroundCommand(cmd):
result = api.types.status.FAILURE
# elif cmd.stdout != "0x16?\n":
elif cmd.stdout != "0x7e007e\n": #Temporary, for testing with SPDK
result = api.types.status.FAILURE
return result
def Verify(tc):
if tc.resp is None:
return api.types.status.FAILURE
result = api.types.status.SUCCESS
cookie_idx = 0
for cmd in tc.resp.commands:
api.Logger.info("Results for %s" % (tc.cmd_cookies[cookie_idx]))
api.PrintCommandResults(cmd)
if cmd.exit_code != 0 and not api.Trigger_IsBackgroundCommand(cmd):
if tc.cmd_cookies[cookie_idx].find(
"After aging show session") != -1:
result = api.types.status.SUCCESS
else:
result = api.types.status.FAILURE
cookie_idx += 1
return result
def Verify(tc):
if tc.resp is None:
return api.types.status.FAILURE
result = api.types.status.SUCCESS
api.Logger.info("Results for %s" % (tc.cmd_descr))
cookie_idx = 0
for cmd in tc.resp.commands:
api.PrintCommandResults(cmd)
if cmd.exit_code != 0 and not api.Trigger_IsBackgroundCommand(cmd):
if tc.cmd_cookies[cookie_idx].find(
"Find session") != -1 and cmd.exit_code == 0:
result = api.types.status.SUCCESS
else:
result = api.types.status.FAILURE
#Add a stricter check for session being gone
cookie_idx += 1
return result
def Verify(tc):
if tc.resp is None:
return api.types.status.FAILURE
result = api.types.status.SUCCESS
api.Logger.info("ibv_rc_pingpong results for %s" % (tc.cmd_descr))
for cmd in tc.resp.commands:
api.PrintCommandResults(cmd)
if cmd.exit_code != 0 and not api.Trigger_IsBackgroundCommand(cmd):
result = api.types.status.FAILURE
for cmd_refs in tc.stats_results:
if cmd_refs[0].stdout == cmd_refs[1].stdout:
api.Logger.info("counter value did not change %s -> %s" %
(cmd_refs[0].stdout, cmd_refs[1].stdout))
result = api.types.status.FAILURE
return result
def Verify(tc):
if tc.resp is None:
return api.types.status.FAILURE
file1 = tc.GetLogsDir() + '/ipsec_client.dat'
file2 = tc.GetLogsDir() + '/ipsec_server.dat'
if not filecmp.cmp(file1, file2, shallow=False):
api.Logger.error("Client and server files do not match")
return api.types.status.FAILURE
result = api.types.status.SUCCESS
cookie_idx = 0
api.Logger.info("NC Results for %s" % (tc.cmd_descr))
for cmd in tc.resp.commands:
api.Logger.info("%s" % (tc.cmd_cookies[cookie_idx]))
api.PrintCommandResults(cmd)
if cmd.exit_code != 0 and not api.Trigger_IsBackgroundCommand(cmd):
result = api.types.status.FAILURE
cookie_idx += 1
return result
def checkLinks(tc, node):
result = api.types.status.SUCCESS
all_naples = api.GetDeviceNames(node)
api.Logger.info(f"Working with the following Naples Cards: {all_naples}")
for naples in api.GetDeviceNames(node):
req = api.Trigger_CreateExecuteCommandsRequest(serial=True)
command = "/nic/bin/halctl show port --yaml"
api.Trigger_AddNaplesCommand(req, node, command, naples)
tc.resp = api.Trigger(req)
if tc.resp is None:
return api.types.status.FAILURE
api.Logger.info("Verifying Link State for Uplink Ports:")
for cmd in tc.resp.commands:
if cmd.exit_code != 0 and not api.Trigger_IsBackgroundCommand(cmd):
api.Logger.error(cmd.stderr)
result = api.types.status.FAILURE
#split output of halctl. Each entry will hold information about a port
perPortOutput = cmd.stdout.split("---")
for portInfo in perPortOutput:
testobj = yaml.load(portInfo, Loader=yaml.FullLoader)
#last split is always empty - skip it. Otherwise process it
if bool(testobj):
portId = testobj['spec']['keyorhandle']['keyorhandle'][
'portid']
portStatus = testobj['status']['linkstatus']['operstate']
if portStatus != 1:
api.Logger.error(
f"ERROR:[{cmd.node_name},{naples}] port:{portId} status:{portStatus}"
)
#TODO: return success for now. There is an issue with the port stuck in down state
result = api.types.status.SUCCESS
else:
api.Logger.info(
f" [{cmd.node_name},{naples}] port:{portId} status:{portStatus}"
)
return result
