def Trigger(tc): api.Logger.info("Trigger.") if tc.skip: return api.types.status.SUCCESS req = api.Trigger_CreateExecuteCommandsRequest(serial=True) if tc.resp_flow: cmd_cookie = 'tcpdump -nni {} "src host {} and dst host {} and src port 1237"'.format( tc.client.interface, tc.server.ip_address, tc.client.ip_address) print(cmd_cookie) add_command(req, tc, 'tcpdump', tc.client, cmd_cookie, True) new_seq_num = tc.pre_ctrckinf.r_tcpseqnum + tc.pre_ctrckinf.i_tcpwinsz * ( 2**tc.pre_ctrckinf.i_tcpwinscale) #left out of window - retransmit cmd_cookie = "hping3 -c 1 -s 1237 -p 52255 -M {} -L {} --ack {} -d 900 --tcp-timestamp".format( wrap_around(tc.pre_ctrckinf.r_tcpseqnum, 0), tc.pre_ctrckinf.r_tcpacknum, tc.client.ip_address) add_command(req, tc, 'fail ping', tc.server, cmd_cookie) else: cmd_cookie = 'tcpdump -nni {} "src host {} and dst host {} and src port 1237"'.format( tc.client.interface, tc.client.ip_address, tc.server.ip_address) print(cmd_cookie) add_command(req, tc, 'tcpdump', tc.client, cmd_cookie, True) new_seq_num = tc.pre_ctrckinf.i_tcpseqnum + tc.pre_ctrckinf.r_tcpwinsz * ( 2**tc.pre_ctrckinf.r_tcpwinscale) #left out of window - retransmit cmd_cookie = "hping3 -c 1 -s 52255 -p 1237 -M {} -L {} --ack --tcp-timestamp {} -d 10".format( wrap_around(tc.pre_ctrckinf.i_tcpseqnum, 0), tc.pre_ctrckinf.i_tcpacknum, tc.server.ip_address) add_command(req, tc, "fail ping", tc.client, cmd_cookie) cmd_cookie = "sleep 3 && /nic/bin/halctl show session --dstport 1237 --dstip {} --yaml".format( tc.server.ip_address) add_command(req, tc, 'show after', tc.client, cmd_cookie, naples=True) cmd_cookie = "/nic/bin/halctl clear session" add_command(req, tc, 'clear', tc.client, cmd_cookie, naples=True) if tc.server.IsNaples(): cmd_cookie = "/nic/bin/halctl clear session" add_command(req, tc, 'clear', tc.server, cmd_cookie, naples=True) sec_resp = api.Trigger(req) term_first_resp = api.Trigger_TerminateAllCommands(tc.first_resp) term_sec_resp = api.Trigger_TerminateAllCommands(sec_resp) tc.resp = api.Trigger_AggregateCommandsResponse(tc.first_resp, term_first_resp) tc.resp = api.Trigger_AggregateCommandsResponse(sec_resp, term_sec_resp) if getattr(tc.args, 'vmotion_enable', False): vmotion_utils.PrepareWorkloadRestore(tc) return api.types.status.SUCCESS
def Trigger(tc): api.Logger.info("Trigger.") req = api.Trigger_CreateExecuteCommandsRequest(serial=True) tc.pcap_file_name = f"conn_mss_{tc.client.ip_address}.pcap" cmd_cookie = "tcpdump -nnSXi {} ip proto 6 and src host {} and " \ "dst host {} and src port 1237 -U -w {}". \ format(tc.client.interface, tc.server.ip_address, tc.client.ip_address, tc.pcap_file_name) print(cmd_cookie) add_command(req, tc, 'tcpdump', tc.client, cmd_cookie, True) if tc.resp_flow: new_seq_num = tc.pre_ctrckinf.r_tcpseqnum + tc.pre_ctrckinf.i_tcpwinsz * ( 2**tc.pre_ctrckinf.i_tcpwinscale) #left out of window - retransmit tc.test_mss = 900 cmd_cookie = "hping3 -c 1 -s 1237 -p 52255 -M {} -L {} --ack {} -d {}" \ .format(wrap_around(tc.pre_ctrckinf.r_tcpseqnum, 0), tc.pre_ctrckinf.r_tcpacknum, tc.client.ip_address, tc.test_mss) add_command(req, tc, 'fail ping', tc.server, cmd_cookie) else: new_seq_num = tc.pre_ctrckinf.i_tcpseqnum + tc.pre_ctrckinf.r_tcpwinsz * ( 2**tc.pre_ctrckinf.r_tcpwinscale) #left out of window - retransmit tc.test_mss = 10 cmd_cookie = "hping3 -c 1 -s 52255 -p 1237 -M {} -L {} --ack --tcp-timestamp {} -d {}" \ .format(wrap_around(tc.pre_ctrckinf.i_tcpseqnum, 0), tc.pre_ctrckinf.i_tcpacknum, tc.server.ip_address, tc.test_mss) add_command(req, tc, "fail ping", tc.client, cmd_cookie) cmd_cookie = "sleep 3 && /nic/bin/halctl show session --dstport 1237 --dstip {} --yaml".format( tc.server.ip_address) add_command(req, tc, 'show after', tc.client, cmd_cookie, naples=True) cmd_cookie = "/nic/bin/halctl clear session" add_command(req, tc, 'clear', tc.client, cmd_cookie, naples=True) if tc.server.IsNaples(): cmd_cookie = "/nic/bin/halctl clear session" add_command(req, tc, 'clear', tc.server, cmd_cookie, naples=True) sec_resp = api.Trigger(req) term_first_resp = api.Trigger_TerminateAllCommands(tc.first_resp) term_sec_resp = api.Trigger_TerminateAllCommands(sec_resp) tc.resp = api.Trigger_AggregateCommandsResponse(tc.first_resp, term_first_resp) tc.resp = api.Trigger_AggregateCommandsResponse(sec_resp, term_sec_resp) return api.types.status.SUCCESS
def Trigger(tc): if api.IsDryrun(): return api.types.status.SUCCESS req1 = api.Trigger_CreateExecuteCommandsRequest(serial=True) req2 = api.Trigger_CreateExecuteCommandsRequest(serial=False) w1 = tc.workloads[0] w2 = tc.workloads[1] tc.cmd_descr = "Server: %s(%s) <--> Client: %s(%s)" %\ (w1.interface, w1.ip_address, w2.interface, w2.ip_address) api.Logger.info("Starting Iperf test from %s" % (tc.cmd_descr)) proto = getattr(tc.iterators, "proto", 'tcp') number_of_iperf_threads = getattr(tc.args, "iperfthreads", 1) pktsize = getattr(tc.iterators, "pktsize", 512) ipproto = getattr(tc.iterators, "ipproto", 'v4') for i in range(number_of_iperf_threads): if proto == 'tcp': port = api.AllocateTcpPort() else: port = api.AllocateUdpPort() iperf_server_cmd = cmd_builder.iperf_server_cmd(port=port) api.Trigger_AddCommand(req1, w1.node_name, w1.workload_name, iperf_server_cmd, background=True) iperf_client_cmd = cmd_builder.iperf_client_cmd( server_ip=w1.ip_address, port=port, proto=proto, pktsize=pktsize, ipproto=ipproto) api.Trigger_AddCommand(req2, w2.node_name, w2.workload_name, iperf_client_cmd) trig_resp1 = api.Trigger(req1) trig_resp2 = api.Trigger(req2) term_resp1 = api.Trigger_TerminateAllCommands(trig_resp1) response = api.Trigger_AggregateCommandsResponse(trig_resp1, term_resp1) tc.resp = api.Trigger_AggregateCommandsResponse(response, trig_resp2) return api.types.status.SUCCESS
def Trigger(tc): req = api.Trigger_CreateExecuteCommandsRequest(serial=True) catreq = api.Trigger_CreateExecuteCommandsRequest(serial=True) tc.cmd_cookies = [] iter_num = 0 for pair in tc.workload_pairs: w1 = pair[0] w2 = pair[1] cmd_cookie = "%s(%s) --> %s(%s)" %\ (w1.workload_name, w1.ip_address, w2.workload_name, w2.ip_address) api.Logger.info("Starting Ping test from %s" % (cmd_cookie)) tc.cmd_cookies.append(cmd_cookie) api.Trigger_AddCommand(req, w2.node_name, w2.workload_name, "tcpdump -nni %s ether proto arp" % (w2.interface), background=True) api.Trigger_AddCommand(req, w2.node_name, w2.workload_name, "tcpdump -nni %s ip proto gre" % (w2.interface), background=True) api.Trigger_AddCommand( req, w1.node_name, w1.workload_name, "ping -f -c 50 -s %d %s" % (tc.iterators.pktsize, w2.ip_address)) iter_num = iter_num + 1 trig_resp = api.Trigger(req) time.sleep(10) term_resp = api.Trigger_TerminateAllCommands(trig_resp) tc.resp = api.Trigger_AggregateCommandsResponse(trig_resp, term_resp) return api.types.status.SUCCESS
def Trigger(tc): #============================================================== # trigger the commands #============================================================== req = api.Trigger_CreateExecuteCommandsRequest(serial = True) w1 = tc.w[1] w2 = tc.w[0] for w in [w1, w2]: for lif in tc.lifs: cmd = 'export PATH=$PATH:/nic/lib:/platform/lib && export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/nic/lib:/platform/lib && /platform/bin/eth_dbgtool rdma_qstate ' + lif api.Logger.info("Collecting rdma qstate command {} on node_name {}, lif {}"\ .format(cmd, w.node_name, lif)) api.Trigger_AddNaplesCommand(req, w.node_name, cmd) #============================================================== # trigger the request #============================================================== trig_resp = api.Trigger(req) term_resp = api.Trigger_TerminateAllCommands(trig_resp) tc.resp = api.Trigger_AggregateCommandsResponse(trig_resp, term_resp) return api.types.status.SUCCESS
def Trigger(tc): #============================================================== # trigger the commands #============================================================== req = api.Trigger_CreateExecuteCommandsRequest(serial=True) w1 = tc.w[0] w2 = tc.w[1] cmd = 'sysctl dev.ionic.0.qos.classification_type=' + str(tc.class_type) # Trigger Classification type config if w1.IsNaples(): api.Trigger_AddCommand(req, w1.node_name, w1.workload_name, cmd) if w2.IsNaples(): api.Trigger_AddCommand(req, w2.node_name, w2.workload_name, cmd) #============================================================== # trigger the request #============================================================== trig_resp = api.Trigger(req) term_resp = api.Trigger_TerminateAllCommands(trig_resp) tc.resp = api.Trigger_AggregateCommandsResponse(trig_resp, term_resp) return api.types.status.SUCCESS
def trigger_data_update(tc): tc.cmd_cookies = [] req = api.Trigger_CreateExecuteCommandsRequest(serial=True) # make sure a file change in client reflects on server api.Trigger_AddCommand(req, tc.client.node_name, tc.client.workload_name, "mv sunrpcdir/sunrpc_file.txt /home/sunrpcdir/") tc.cmd_cookies.append("Create file") api.Trigger_AddCommand(req, tc.client.node_name, tc.client.workload_name, "ls -al /home/sunrpcdir") tc.cmd_cookies.append("verify file") api.Trigger_AddCommand(req, tc.server.node_name, tc.server.workload_name, "ls -al /home/sunrpcmntdir/") tc.cmd_cookies.append("After rpc") api.Trigger_AddCommand(req, tc.server.node_name, tc.server.workload_name, "sh -c 'cat /home/sunrpcmntdir/sunrpc_file.txt'") tc.cmd_cookies.append("After rpc") # Add Naples command validation api.Trigger_AddNaplesCommand(req, tc.vm_node.node_name, "/nic/bin/halctl show session --alg sun_rpc") tc.cmd_cookies.append("show session") trig_resp = api.Trigger(req) term_resp = api.Trigger_TerminateAllCommands(trig_resp) tc.resp = api.Trigger_AggregateCommandsResponse(trig_resp, term_resp)
def Trigger(tc): pairs = api.GetLocalWorkloadPairs() tc.cmd_cookies = [] server, client = pairs[0] naples = server if not server.IsNaples(): naples = client if not client.IsNaples(): return api.types.status.SUCCESS else: client, server = pairs[0] cmd_cookie = "%s(%s) --> %s(%s)" %\ (server.workload_name, server.ip_address, client.workload_name, client.ip_address) api.Logger.info("Starting clear & show stress test from %s" % (cmd_cookie)) basecmd = 'iperf -p %d ' % api.AllocateTcpPort() proto = 6 timeout = 250 #tc.secprof = sec_profile_obj.gl_securityprofile_json_template #timeout = int(tc.secprof['security-profiles'][0]['spec']['timeouts']['tcp']) + \ # int(tc.secprof['security-profiles'][0]['spec']['timeouts']['tcp-close']) if tc.iterators.proto == 'udp': basecmd = 'iperf -u -p %d ' % api.AllocateUdpPort() proto = 17 timeout = 150 #timeout = tc.security_profile['security-profiles'][0]['spec']['timeouts']['udp'] req = api.Trigger_CreateExecuteCommandsRequest(serial=True) for cnt in range(tc.args.count): cmd_cookie = "iperf -s" api.Trigger_AddCommand(req, server.node_name, server.workload_name, "%s-s -t 300" % basecmd, background=True) tc.cmd_cookies.append(cmd_cookie) cmd_cookie = "iperf -c " api.Trigger_AddCommand( req, client.node_name, client.workload_name, "%s -c %s -P 100" % (basecmd, server.ip_address)) tc.cmd_cookies.append(cmd_cookie) cmd_cookie = "Show session" api.Trigger_AddNaplesCommand(req, naples.node_name, "/nic/bin/halctl show session") tc.cmd_cookies.append(cmd_cookie) cmd_cookie = "Clear session" api.Trigger_AddNaplesCommand(req, naples.node_name, "/nic/bin/halctl clear session") tc.cmd_cookies.append(cmd_cookie) trig_resp = api.Trigger(req) term_resp = api.Trigger_TerminateAllCommands(trig_resp) tc.resp = api.Trigger_AggregateCommandsResponse(trig_resp, term_resp) return api.types.status.SUCCESS
def Trigger(tc): api.Logger.info("Trigger.") req = api.Trigger_CreateExecuteCommandsRequest(serial=True) if tc.resp_flow: new_seq_num = tc.pre_ctrckinf.r_tcpseqnum + tc.pre_ctrckinf.i_tcpwinsz * ( 2**tc.pre_ctrckinf.i_tcpwinscale) cmd_cookie = "hping3 -c 1 -s 1237 -p 52255 -M {} -L {} --rst --ack --tcp-timestamp {}".format( new_seq_num, tc.pre_ctrckinf.r_tcpacknum, tc.client.ip_address) add_command(req, tc, 'fail ping', tc.server, cmd_cookie) else: new_seq_num = tc.pre_ctrckinf.i_tcpseqnum + tc.pre_ctrckinf.r_tcpwinsz * ( 2**tc.pre_ctrckinf.r_tcpwinscale) cmd_cookie = "hping3 -c 1 -s 52255 -p 1237 -M {} -L {} --rst --ack --tcp-timestamp {}".format( new_seq_num, tc.pre_ctrckinf.i_tcpacknum, tc.server.ip_address) add_command(req, tc, 'fail ping', tc.client, cmd_cookie) cmd_cookie = "sleep 3 && /nic/bin/halctl show session --dstport 1237 --dstip {} --yaml".format( tc.server.ip_address) add_command(req, tc, 'show after', tc.client, cmd_cookie, naples=True) cmd_cookie = "/nic/bin/halctl clear session" add_command(req, tc, 'clear', tc.client, cmd_cookie, naples=True) if tc.server.IsNaples(): cmd_cookie = "/nic/bin/halctl clear session" add_command(req, tc, 'clear', tc.server, cmd_cookie, naples=True) trig_resp = api.Trigger(req) term_resp1 = api.Trigger_TerminateAllCommands(tc.setup_cmd_resp) tc.resp = api.Trigger_AggregateCommandsResponse(trig_resp, term_resp1) if getattr(tc.args, 'vmotion_enable', False): vmotion_utils.PrepareWorkloadRestore(tc) return api.types.status.SUCCESS
def triggerBCtraffic(tc): workload_pairs = tc.workloads naples_node = tc.naples_node #Get stats before trigger for device_name in api.GetDeviceNames(naples_node): data = tc.device_data[device_name] GetBCFramesTxRxStats(naples_node, device_name, data.preStatsCount, data.intfName2lifId_dict) #trigger tc.req = api.Trigger_CreateExecuteCommandsRequest(serial=False) tc.cmd_cookies = [] for pairs in workload_pairs: #trigger arping in both directions triggerArping(pairs[0], pairs[1], tc) triggerArping(pairs[1], pairs[0], tc) trig_resp = api.Trigger(tc.req) term_resp = api.Trigger_TerminateAllCommands(trig_resp) tc.resp = api.Trigger_AggregateCommandsResponse(trig_resp, term_resp) #Get stats after trigger for device_name in api.GetDeviceNames(naples_node): data = tc.device_data[device_name] GetBCFramesTxRxStats(naples_node, device_name, data.postStatsCount, data.intfName2lifId_dict) return
def Trigger(tc): api.Logger.info("Trigger.") req = api.Trigger_CreateExecuteCommandsRequest(serial = True) if tc.resp_flow: #right of window overlap iwindo_size= tc.pre_ctrckinf.i_tcpwinsz * (2 ** tc.pre_ctrckinf.i_tcpwinscale) cmd_cookie = "hping3 -c 1 -s {} -p {} -M {} -L {} --rst --ack --tcp-timestamp {}".format(tc.server_port, tc.client_port, wrap_around(tc.pre_ctrckinf.r_tcpseqnum + iwindo_size, -200), tc.pre_ctrckinf.r_tcpacknum, tc.client.ip_address, 500) add_command(req, tc, 'fail ping', tc.client, cmd_cookie) else: rwindo_size= tc.pre_ctrckinf.r_tcpwinsz * (2 ** tc.pre_ctrckinf.r_tcpwinscale) #right of window overlap cmd_cookie = "hping3 -c 1 -s {} -p {} -M {} -L {} --rst --ack --tcp-timestamp {}".format(tc.client_port, tc.server_port, wrap_around(tc.pre_ctrckinf.i_tcpseqnum + rwindo_size, -200), tc.pre_ctrckinf.i_tcpacknum, tc.server.ip_address, 500) add_command(req, tc, 'fail ping', tc.client, cmd_cookie) cmd_cookie = "/nic/bin/halctl show session --dstport {} --dstip {} --yaml".format(tc.server_port, tc.server.ip_address) add_command(req, tc, 'show after', tc.client, cmd_cookie, naples=True) cmd_cookie = "/nic/bin/halctl clear session" add_command(req, tc, 'clear', tc.client, cmd_cookie, naples=True) if tc.server.IsNaples(): cmd_cookie = "/nic/bin/halctl clear session" add_command(req, tc, 'clear', tc.server, cmd_cookie, naples=True) trig_resp = api.Trigger(req) term_resp1 = api.Trigger_TerminateAllCommands(tc.setup_cmd_resp) tc.resp = api.Trigger_AggregateCommandsResponse(trig_resp, term_resp1) return api.types.status.SUCCESS
def Trigger(tc): tc.contexts = [] ctxt = IperfTestContext() ctxt.req = api.Trigger_CreateAllParallelCommandsRequest() ctxt.cmd_cookies = [] for tunnel in tc.tunnels: w1 = tunnel.ltep w2 = tunnel.rtep cmd_cookie = "Server: %s(%s) <--> Client: %s(%s)" %\ (w1.workload_name, w1.ip_address, w2.workload_name, w2.ip_address) api.Logger.info("Starting Iperf test from %s" % (cmd_cookie)) basecmd = 'iperf -p %d ' % api.AllocateTcpPort() if tc.iterators.proto == 'udp': basecmd = 'iperf -u -p %d ' % api.AllocateUdpPort() api.Trigger_AddCommand(ctxt.req, w1.node_name, w1.workload_name, "%s -s -t 300" % basecmd, background = True) api.Trigger_AddCommand(ctxt.req, w2.node_name, w2.workload_name, "%s -c %s" % (basecmd, w1.ip_address)) ctxt.cmd_cookies.append(cmd_cookie) ctxt.cmd_cookies.append(cmd_cookie) trig_resp = api.Trigger(ctxt.req) term_resp = api.Trigger_TerminateAllCommands(trig_resp) ctxt.resp = api.Trigger_AggregateCommandsResponse(trig_resp, term_resp) tc.context = ctxt return api.types.status.SUCCESS
def pingAllRemoteWloadPairs(workload_pairs, iterators): cmd_cookies = [] req = api.Trigger_CreateExecuteCommandsRequest(serial=False) for pair in workload_pairs: w1 = pair[0] w2 = pair[1] if iterators.ipaf == 'ipv4': cmd_cookie = "ping -c 5 -i 0.2 -W 2000 -s %d -S %s %s" % ( iterators.pktsize, w1.ip_address, w2.ip_address) api.Logger.verbose( "Ping test cmd %s from %s(%s %s) --> %s(%s %s)" % (cmd_cookie, w1.workload_name, w1.ip_address, w1.interface, w2.workload_name, w2.ip_address, w2.interface)) else: cmd_cookie = "ping6 -c 5 -i 0.2 -s %d -S %s -I %s %s" % ( iterators.pktsize, w1.ipv6_address, w1.interface, w2.ipv6_address) api.Logger.verbose( "Ping test cmd %s from %s(%s %s) --> %s(%s %s)" % (cmd_cookie, w1.workload_name, w1.ipv6_address, w1.interface, w2.workload_name, w2.ipv6_address, w2.interface)) api.Trigger_AddCommand(req, w1.node_name, w1.workload_name, cmd_cookie) cmd_cookies.append(cmd_cookie) trig_resp = api.Trigger(req) term_resp = api.Trigger_TerminateAllCommands(trig_resp) resp = api.Trigger_AggregateCommandsResponse(trig_resp, term_resp) return cmd_cookies, resp
def Trigger(tc): #============================================================== # trigger the commands #============================================================== req = api.Trigger_CreateExecuteCommandsRequest(serial=True) server_idx = 0 client_idx = 1 w1 = tc.w[server_idx] w2 = tc.w[client_idx] if not w1.IsNaples() and not w2.IsNaples(): api.Logger.info("No naples - unsupported configuration") return api.types.status.DISABLED if tc.os != 'freebsd': api.Logger.info("Not FreeBSD - unsupported configuration") return api.types.status.DISABLED qos.TriggerQoSTeardown(req, tc, w1) qos.TriggerQoSTeardown(req, tc, w2) #============================================================== # trigger the request #============================================================== trig_resp = api.Trigger(req) term_resp = api.Trigger_TerminateAllCommands(trig_resp) tc.resp = api.Trigger_AggregateCommandsResponse(trig_resp, term_resp) return api.types.status.SUCCESS
def Trigger(tc): tc.resp = [] tc.nc_server_cmds = [] tc.nc_client_cmds = [] for sub_wl in tc.sub_wl: req = api.Trigger_CreateExecuteCommandsRequest(serial=True) if tc.traffic_type == 'ping': # ping from host cmd = "ping -c 5 " + tc.mnic_p2p_sub_ip[sub_wl.workload_name] api.Trigger_AddHostCommand(req, tc.wl_node_name, cmd) else: # copy send_data to host tc.send_data = tc.traffic_type + " Hello" send_fname = CURR_DIR + '/' + SEND_FNAME f = open(send_fname, "w") f.write(tc.send_data) f.close() api.CopyToHost(tc.wl_node_name, [send_fname], "") os.remove(send_fname) # netcat on naples # args common to TCP & UDP s_args = ' -l -p 9999 ' # arg specific to UDP if tc.traffic_type == 'UDP': s_args += ' -u ' s_args += '> ' + RECV_FNAME_PREFIX + sub_wl.workload_name tc.nc_server_cmds.append(s_args) netcat.StartNetcat(req, tc.bitw_node_name, 'naples', s_args) # netcat on host c_args = tc.mnic_p2p_sub_ip[sub_wl.workload_name] + ' 9999 < ' \ + SEND_FNAME # arg specific to UDP if tc.traffic_type == 'UDP': c_args += ' -u ' tc.nc_client_cmds.append(c_args) netcat.StartNetcat(req, tc.wl_node_name, 'host', c_args) # wait for ping to be done api.Trigger_AddNaplesCommand(req, tc.bitw_node_name, "sleep 5") if tc.traffic_type == 'UDP' or \ tc.traffic_type == 'TCP': api.Trigger_AddNaplesCommand(req, tc.bitw_node_name, "cat " + \ RECV_FNAME_PREFIX + sub_wl.workload_name) trig_resp = api.Trigger(req) term_resp = api.Trigger_TerminateAllCommands(trig_resp) tc.resp.append( api.Trigger_AggregateCommandsResponse(trig_resp, term_resp)) return api.types.status.SUCCESS
def Trigger(tc): #============================================================== # trigger the commands #============================================================== req = api.Trigger_CreateExecuteCommandsRequest(serial=True) server_idx = 0 client_idx = 1 w1 = tc.w[server_idx] w2 = tc.w[client_idx] if not w1.IsNaples() and not w2.IsNaples(): api.Logger.info("No naples - unsupported configuration") return api.types.status.DISABLED if tc.os != 'freebsd': api.Logger.info("Not FreeBSD - unsupported configuration") return api.types.status.DISABLED tc.cmd_descr = "FC Config" if w1.IsNaples(): tc.cmd_descr += " on Server: {}({})".format(w1.workload_name, w1.ip_address) if w2.IsNaples(): tc.cmd_descr += " on Client: {}({})".format(w2.workload_name, w2.ip_address) if tc.os == 'freebsd': cmd = 'sysctl' if hasattr(tc.iterators, 'fc_type'): fc_type = tc.iterators.fc_type if ((fc_type != 0) and (fc_type != 1) and (fc_type != 2)): api.logger.error( "invalid fc_type value passed: {}".format(fc_type)) return api.types.status.FAILURE else: api.Logger.error("mandatory attribute fc_type not passed") return api.types.status.FAILURE #============================================================== # trigger FC config test #============================================================== qos.TriggerFcConfigTest(req, tc, w1, w2, fc_type) #============================================================== # trigger the request #============================================================== trig_resp = api.Trigger(req) term_resp = api.Trigger_TerminateAllCommands(trig_resp) tc.resp = api.Trigger_AggregateCommandsResponse(trig_resp, term_resp) return api.types.status.SUCCESS
def Trigger(tc): pairs = api.GetLocalWorkloadPairs() server = pairs[0][0] client = pairs[0][1] tc.cmd_cookies = [] naples = server if not server.IsNaples(): naples = client if not client.IsNaples(): return api.types.status.SUCCESS req = api.Trigger_CreateExecuteCommandsRequest(serial = True) tc.cmd_descr = "Server: %s(%s) <--> Client: %s(%s)" %\ (server.workload_name, server.ip_address, client.workload_name, client.ip_address) api.Logger.info("Starting RTSP test from %s" % (tc.cmd_descr)) dir_path = os.path.dirname(os.path.realpath(__file__)) fullpath = dir_path + '/' + "small.vob" api.Logger.info("fullpath %s" % (fullpath)) resp = api.CopyToWorkload(server.node_name, server.workload_name, [fullpath], 'rtspdir') if resp is None: return api.types.status.FAILURE api.Trigger_AddCommand(req, client.node_name, client.workload_name, "ls -al | grep video") tc.cmd_cookies.append("Before RTSP") server_cmd = "cd rtspdir && live555MediaServer" api.Trigger_AddCommand(req, server.node_name, server.workload_name, server_cmd, background = True) tc.cmd_cookies.append("Run RTSP server") api.Trigger_AddCommand(req, client.node_name, client.workload_name, "openRTSP rtsp://%s/small.vob" % server.ip_address) tc.cmd_cookies.append("Run RTSP client") ## Add Naples command validation api.Trigger_AddNaplesCommand(req, naples.node_name, "/nic/bin/halctl show session --alg rtsp --yaml") tc.cmd_cookies.append("show session RTSP established") api.Trigger_AddNaplesCommand(req, naples.node_name, "/nic/bin/halctl show nwsec flow-gate | grep RTSP") tc.cmd_cookies.append("show flow-gate") api.Trigger_AddCommand(req, client.node_name, client.workload_name, "ls -al | grep video") tc.cmd_cookies.append("After RTSP") trig_resp = api.Trigger(req) term_resp = api.Trigger_TerminateAllCommands(trig_resp) tc.resp = api.Trigger_AggregateCommandsResponse(trig_resp, term_resp) return api.types.status.SUCCESS
def ForceReleasePort(port, node): req = api.Trigger_CreateExecuteCommandsRequest(serial=True) api.Trigger_AddCommand(req, node.node_name, node.workload_name, "sudo fuser -k %s" % (port)) trig_resp = api.Trigger(req) term_resp = api.Trigger_TerminateAllCommands(trig_resp) resp = api.Trigger_AggregateCommandsResponse(trig_resp, term_resp) for cmd in trig_resp.commands: api.PrintCommandResults(cmd) return api.types.status.SUCCESS
def Trigger(tc): #Run all commands in serial req = api.Trigger_CreateExecuteCommandsRequest(serial=True) tc.cmd_cookies = [] count = 0 for tunnel in tc.tunnels: w1 = tunnel.ltep w2 = tunnel.rtep cmd_cookie = "%s(%s) --> %s(%s)" %\ (w1.workload_name, w1.ip_address, w2.workload_name, w2.ip_address) if count % 2 == 0: # TCP test api.Trigger_AddCommand(req, w2.node_name, w2.workload_name, "nc -l %s 2000" % w2.ip_address, background=True) api.Logger.info("Listen on IP %s and TCP port 2000" % w2.ip_address) api.Trigger_AddCommand( req, w1.node_name, w1.workload_name, "echo \"Pensando Systems\" | nc %s 2000" % w2.ip_address) api.Logger.info("Send TCP traffic from %s" % (cmd_cookie)) tc.cmd_cookies.append("TCP test " + cmd_cookie) if count % 2 == 1: # UDP test api.Trigger_AddCommand(req, w2.node_name, w2.workload_name, "nc -l -u %s 2000" % w2.ip_address, background=True) api.Logger.info("Listen on IP %s and UDP port 2000" % w2.ip_address) api.Trigger_AddCommand( req, w1.node_name, w1.workload_name, "echo \"Pensando Systems\" | nc -u %s 2000" % w2.ip_address) api.Logger.info("Send UDP traffic from %s" % (cmd_cookie)) tc.cmd_cookies.append("UDP test " + cmd_cookie) count += 1 if count == 16: break trig_resp = api.Trigger(req) time.sleep(10) term_resp = api.Trigger_TerminateAllCommands(trig_resp) tc.resp = api.Trigger_AggregateCommandsResponse(trig_resp, term_resp) return api.types.status.SUCCESS
def send_pkt_h2s(tc, node, flow, pkt_gen): # Send and Receive packets in H2S direction pkt_gen.set_dir_('h2s') pkt_gen.set_sip(flow.sip) pkt_gen.set_dip(flow.dip) if flow.proto == 'UDP' or flow.proto == 'TCP': pkt_gen.set_sport(flow.sport) pkt_gen.set_dport(flow.dport) h2s_req = api.Trigger_CreateExecuteCommandsRequest(serial=False) # ========== # Rx Packet # ========== pkt_gen.set_encap(True) pkt_gen.set_Rx(True) pkt_gen.set_vlan(tc.up0_vlan) pkt_gen.set_smac(tc.up1_mac) pkt_gen.set_dmac(tc.up0_mac) pkt_gen.setup_pkt() recv_cmd = "./recv_pkt.py --intf_name %s --pcap_fname %s "\ "--timeout %s --pkt_cnt %d" % (tc.up0_intf, pktgen.DEFAULT_H2S_RECV_PKT_FILENAME, str(SNIFF_TIMEOUT), tc.pkt_cnt) api.Trigger_AddHostCommand(h2s_req, node.Name(), recv_cmd, background=True) # ========== # Tx Packet # ========== pkt_gen.set_encap(False) pkt_gen.set_Rx(False) pkt_gen.set_smac(tc.up1_mac) pkt_gen.set_dmac(tc.up0_mac) pkt_gen.set_vlan(tc.up1_vlan) pkt_gen.setup_pkt() send_cmd = "./send_pkt.py --intf_name %s --pcap_fname %s "\ "--pkt_cnt %d" % (tc.up1_intf, pktgen.DEFAULT_H2S_GEN_PKT_FILENAME, tc.pkt_cnt) api.Trigger_AddHostCommand(h2s_req, node.Name(), 'sleep 0.5') api.Trigger_AddHostCommand(h2s_req, node.Name(), send_cmd) trig_resp = api.Trigger(h2s_req) time.sleep(SNIFF_TIMEOUT) term_resp = api.Trigger_TerminateAllCommands(trig_resp) h2s_resp = api.Trigger_AggregateCommandsResponse(trig_resp, term_resp) tc.resp.append(h2s_resp)
def Trigger(tc): #============================================================== # trigger the commands #============================================================== req = api.Trigger_CreateExecuteCommandsRequest(serial=True) if getattr(tc.iterators, 'server', None) == 'yes': i = 0 k = 1 else: i = 1 k = 2 while ((i < 2) and (i < k)): j = (i + 1) % 2 w1 = tc.w[i] w2 = tc.w[j] tc.cmd_descr = "Server: %s(%s) <--> Client: %s(%s)" %\ (w1.workload_name, w1.ip_address, w2.workload_name, w2.ip_address) api.Logger.info("Starting rping test from %s" % (tc.cmd_descr)) # cmd for server cmd = "rping -s -a %s -C 10 -S %d " % (w1.ip_address, tc.iterators.pktsize) api.Trigger_AddCommand(req, w1.node_name, w1.workload_name, tc.ib_prefix[i] + cmd, background=True) # On Naples-Mellanox setups, with Mellanox as server, it takes a few seconds before the server # starts listening. So sleep for a few seconds before trying to start the client cmd = 'sleep 2' api.Trigger_AddCommand(req, w1.node_name, w1.workload_name, cmd) # cmd for client cmd = "rping -c -a %s -C 10 -S %d " % (w1.ip_address, tc.iterators.pktsize) api.Trigger_AddCommand(req, w2.node_name, w2.workload_name, tc.ib_prefix[j] + cmd) i = i + 1 #end while # trigger the request trig_resp = api.Trigger(req) term_resp = api.Trigger_TerminateAllCommands(trig_resp) tc.resp = api.Trigger_AggregateCommandsResponse(trig_resp, term_resp) return api.types.status.SUCCESS
def Trigger(tc): req = api.Trigger_CreateExecuteCommandsRequest(serial=True) for intf in tc.intfs: ip_addr = str(ip_address(intf['sub_ip']) + 1) if tc.traffic_type == 'ping': # ping from host cmd = "ping -c 5 " + ip_addr api.Trigger_AddHostCommand(req, tc.wl_node_name, cmd) else: # copy send_data to host tc.send_data = tc.traffic_type + " Hello" send_fname = CURR_DIR + '/' + SEND_FNAME f = open(send_fname, "w") f.write(tc.send_data) f.close() api.CopyToHost(tc.wl_node_name, [send_fname], "") os.remove(send_fname) # netcat on naples # args common to TCP & UDP s_args = ' -l -p 9999 ' # arg specific to UDP if tc.traffic_type == 'UDP': s_args += ' -u ' s_args += '> ' + RECV_FNAME netcat.StartNetcat(req, tc.bitw_node_name, 'naples', s_args) # netcat on host c_args = ip_addr + ' 9999 < ' + SEND_FNAME # arg specific to UDP if tc.traffic_type == 'UDP': c_args += ' -u ' netcat.StartNetcat(req, tc.wl_node_name, 'host', c_args) # wait for ping to be done api.Trigger_AddNaplesCommand(req, tc.bitw_node_name, "sleep 5") if tc.traffic_type == 'UDP' or \ tc.traffic_type == 'TCP': api.Trigger_AddNaplesCommand(req, tc.bitw_node_name, "cat " + RECV_FNAME) trig_resp = api.Trigger(req) term_resp = api.Trigger_TerminateAllCommands(trig_resp) tc.resp = api.Trigger_AggregateCommandsResponse(trig_resp, term_resp) return api.types.status.SUCCESS
def Trigger(tc): pairs = api.GetLocalWorkloadPairs() server = pairs[0][0] client = pairs[0][1] tc.cmd_cookies = [] naples = server if not server.IsNaples(): naples = client if not client.IsNaples(): return api.types.status.SUCCESS req = api.Trigger_CreateExecuteCommandsRequest(serial = True) tc.cmd_descr = "Server: %s(%s) <--> Client: %s(%s)" %\ (server.workload_name, server.ip_address, client.workload_name, client.ip_address) api.Logger.info("Starting SUNRPC test from %s" % (tc.cmd_descr)) api.Trigger_AddNaplesCommand(req, naples.node_name, "/nic/bin/halctl clear session") tc.cmd_cookies.append("clear session") api.Trigger_AddCommand(req, server.node_name, server.workload_name, "sudo service rpcbind start") tc.cmd_cookies.append("Start RPC") api.Trigger_AddCommand(req, client.node_name, client.workload_name, "rpcinfo -T udp %s 100000 4"%(server.ip_address)) tc.cmd_cookies.append("RPC Getport") api.Trigger_AddNaplesCommand(req, naples.node_name, "/nic/bin/halctl show session --alg sun_rpc") tc.cmd_cookies.append("show session") api.Trigger_AddNaplesCommand(req, naples.node_name, "/nic/bin/halctl show nwsec flow-gate") tc.cmd_cookies.append("show security flow-gate") # Add Naples command validation api.Trigger_AddNaplesCommand(req, naples.node_name, "sleep 100", timeout=120) tc.cmd_cookies.append("sleep") api.Trigger_AddNaplesCommand(req, naples.node_name, "/nic/bin/halctl show session --alg sun_rpc") tc.cmd_cookies.append("After timeout session") api.Trigger_AddNaplesCommand(req, naples.node_name, "/nic/bin/halctl show nwsec flow-gate") tc.cmd_cookies.append("After timeout flow-gate") trig_resp = api.Trigger(req) term_resp = api.Trigger_TerminateAllCommands(trig_resp) tc.resp = api.Trigger_AggregateCommandsResponse(trig_resp, term_resp) return api.types.status.SUCCESS
def Trigger(tc): #============================================================== # trigger the commands #============================================================== req = api.Trigger_CreateExecuteCommandsRequest(serial=True) if tc.iterators.rdma_cm == 'yes': cm_opt = " -R " else: cm_opt = " " i = 0 j = i + 1 w1 = tc.w[i] w2 = tc.w[j] tc.cmd_descr = "Server: %s(%s) <--> Client: %s(%s)" %\ (w1.workload_name, w1.ip_address, w2.workload_name, w2.ip_address) api.Logger.info("Starting ib_%s_bw test from %s" % (tc.iterators.test, tc.cmd_descr)) # cmd for server cmd = "ib_" + tc.iterators.test + "_bw -d " + tc.devices[ i] + " -n 10 -F -x " + tc.gid[i] + " -s 1024 -b -q " + str( tc.iterators.num_qp) + cm_opt + " --report_gbits" api.Trigger_AddCommand(req, w1.node_name, w1.workload_name, tc.ib_prefix[i] + cmd, background=True) # On Naples-Mellanox setups, with Mellanox as server, it takes a few seconds before the server # starts listening. So sleep for a few seconds before trying to start the client cmd = 'sleep 2' api.Trigger_AddCommand(req, w1.node_name, w1.workload_name, cmd) # cmd for client cmd = "ib_" + tc.iterators.test + "_bw -d " + tc.devices[ j] + " -n 10 -F -x " + tc.gid[j] + " -s 1024 -b -q " + str( tc.iterators.num_qp) + cm_opt + " --report_gbits " + w1.ip_address api.Trigger_AddCommand(req, w2.node_name, w2.workload_name, tc.ib_prefix[j] + cmd) # trigger the request trig_resp = api.Trigger(req) term_resp = api.Trigger_TerminateAllCommands(trig_resp) tc.resp = api.Trigger_AggregateCommandsResponse(trig_resp, term_resp) return api.types.status.SUCCESS
def Trigger(tc): pairs = api.GetRemoteWorkloadPairs() w1 = pairs[0][1] w2 = pairs[0][0] group = "239.1.1.1" maddr = "01:00:5e:01:01:01" req = api.Trigger_CreateExecuteCommandsRequest(serial = True) tc.cmd_descr = "Server: %s(%s) <--> Client: %s(%s)" % \ (w1.workload_name, w1.ip_address, w2.workload_name, w2.ip_address) api.Logger.info("Starting Multicast outbound Iperf test from %s" % (tc.cmd_descr)) basecmd = "ip maddress add %s dev %s" % (maddr, w1.interface) api.Trigger_AddCommand(req, w1.node_name, w1.workload_name, basecmd, background = True) basecmd = "ip maddress add %s dev %s" % (maddr, w2.interface) api.Trigger_AddCommand(req, w2.node_name, w2.workload_name, basecmd, background = True) basecmd = "ip route add %s/32 dev %s" % (group, w1.interface) api.Trigger_AddCommand(req, w1.node_name, w1.workload_name, basecmd, background = True) basecmd = "ip route add %s/32 dev %s" % (group, w2.interface) api.Trigger_AddCommand(req, w2.node_name, w2.workload_name, basecmd, background = True) basecmd = 'iperf -p %d ' % api.AllocateTcpPort() if tc.iterators.proto == 'udp': basecmd = 'iperf -u -p %d ' % api.AllocateUdpPort() api.Trigger_AddCommand(req, w1.node_name, w1.workload_name, "%s -s -t 300 -B %s -i 1" % (basecmd, group), background = True) api.Trigger_AddCommand(req, w2.node_name, w2.workload_name, "%s -c %s -T 32 -t 3 -i 1" % (basecmd, group)) basecmd = "ip maddress del %s dev %s" % (maddr, w1.interface) api.Trigger_AddCommand(req, w1.node_name, w1.workload_name, basecmd, background = True) basecmd = "ip maddress del %s dev %s" % (maddr, w2.interface) api.Trigger_AddCommand(req, w2.node_name, w2.workload_name, basecmd, background = True) basecmd = "ip route del %s/32 dev %s" % (group, w1.interface) api.Trigger_AddCommand(req, w1.node_name, w1.workload_name, basecmd, background = True) basecmd = "ip route del %s/32 dev %s" % (group, w2.interface) api.Trigger_AddCommand(req, w2.node_name, w2.workload_name, basecmd, background = True) trig_resp = api.Trigger(req) term_resp = api.Trigger_TerminateAllCommands(trig_resp) tc.resp = api.Trigger_AggregateCommandsResponse(trig_resp, term_resp) return api.types.status.SUCCESS
def get_dbg_vmotion_stats(tc, node): req = api.Trigger_CreateExecuteCommandsRequest(serial = True) api.Trigger_AddNaplesCommand(req, node, "/nic/bin/halctl show vmotion") trig_resp = api.Trigger(req) term_resp = api.Trigger_TerminateAllCommands(trig_resp) tc.resp = api.Trigger_AggregateCommandsResponse(trig_resp, term_resp) for cmd in tc.resp.commands: api.PrintCommandResults(cmd) if cmd.stdout == '': api.Logger.info("halctl show vmotion returned no info") return None else: ret = vm_process_dbg_stats(cmd.stdout) return ret
def Trigger(tc): #============================================================== # trigger the commands #============================================================== req = api.Trigger_CreateExecuteCommandsRequest(serial=True) i = 0 while (i < 2): j = (i + 1) % 2 w1 = tc.w[i] w2 = tc.w[j] tc.cmd_descr = "Server: %s(%s) <--> Client: %s(%s)" %\ (w1.workload_name, w1.ip_address, w2.workload_name, w2.ip_address) api.Logger.info("Starting ibv_ud_pingpong test from %s" % (tc.cmd_descr)) # cmd for server cmd = "ibv_ud_pingpong -d " + tc.devices[i] + " -g " + tc.gid[ i] + " -s 1024 -r 10 -n 10" api.Trigger_AddCommand(req, w1.node_name, w1.workload_name, tc.ib_prefix[i] + cmd, background=True) # On Naples-Mellanox setups, with Mellanox as server, it takes a few seconds before the server # starts listening. So sleep for a few seconds before trying to start the client cmd = 'sleep 2' api.Trigger_AddCommand(req, w1.node_name, w1.workload_name, cmd) # cmd for client cmd = "ibv_ud_pingpong -d " + tc.devices[j] + " -g " + tc.gid[ j] + " -s 1024 -r 10 -n 10 " + w1.ip_address api.Trigger_AddCommand(req, w2.node_name, w2.workload_name, tc.ib_prefix[j] + cmd) i = i + 1 #end while # trigger the request trig_resp = api.Trigger(req) term_resp = api.Trigger_TerminateAllCommands(trig_resp) tc.resp = api.Trigger_AggregateCommandsResponse(trig_resp, term_resp) return api.types.status.SUCCESS
def Trigger(tc): tc.cmd_cookies = [] tc.event_count_at_start = GetPenctlEventsCount(tc) req = api.Trigger_CreateExecuteCommandsRequest(serial=True) cmd_cookie = "%s(%s) --> %s(%s)" %\ (tc.wc_server.workload_name, tc.wc_server.ip_address, tc.wc_client.workload_name, tc.wc_client.ip_address) api.Logger.info("Starting %s Session test from %s" % (tc.proto, cmd_cookie)) utils.clearNaplesSessions(node_name=tc.wc_server.node_name) metrics = utils.GetDelphiSessionSummaryMetrics(tc.wc_server.node_name) api.Logger.info("Before Session summary metrics for %s => %s" % \ (tc.wc_server.node_name, metrics)) #Step 0: Update the session limit in the config object utils.SetSessionLimit(tc.proto, 100) if tc.proto == 'tcp': cmd_cookie = "iptable drop rule" api.Trigger_AddCommand(req, tc.wc_client.node_name, \ tc.wc_client.workload_name, \ "iptables -A INPUT -p tcp --destination-port 80 -j DROP", \ background = True) tc.cmd_cookies.append(cmd_cookie) SetTrafficGeneratorCommand(tc, req) cmd_cookie = "show sessions" api.Trigger_AddNaplesCommand(req, tc.wc_server.node_name, "/nic/bin/halctl show session") tc.cmd_cookies.append(cmd_cookie) trig_resp = api.Trigger(req) if tc.proto == 'tcp': cmd_cookie = "iptable states" api.Trigger_AddCommand(req, tc.wc_client.node_name, \ tc.wc_client.workload_name, \ "iptables -L -v", background = True) tc.cmd_cookies.append(cmd_cookie) #give some time for the traffic to pass time.sleep(5) term_resp = api.Trigger_TerminateAllCommands(trig_resp) tc.resp = api.Trigger_AggregateCommandsResponse(trig_resp, term_resp) return api.types.status.SUCCESS
def TriggerSWMQoSConfigVerfication(req, tc): api.Logger.info("Running commands to verify SWM QoS Configuration") tc.cmd_descr = "QoS configuration commands" # channel that has RX mode set is the uplink that is configured to receive BMC traffic ncsi_cmd = "/nic/bin/halctl show ncsi channel" api.Trigger_AddNaplesCommand(req, tc.node_name, ncsi_cmd) tc.cmd_cookies.append(ncsi_cmd) # 0 - NONE; 1 - ETHERTYPE; 2 - DA reg_name = 'pb_pbc_hbm_hbm_port_0_cfg_hbm_parser_cam_enable' reg_read_cmd = '/bin/echo \'read ' + reg_name + '\' | LD_LIBRARY_PATH=/nic/lib:/platform/lib:$LD_LIBRARY_PATH /platform/bin/capview' api.Trigger_AddNaplesCommand(req, tc.node_name, reg_read_cmd) tc.cmd_cookies.append(reg_read_cmd) reg_name = 'pb_pbc_hbm_hbm_port_1_cfg_hbm_parser_cam_enable' reg_read_cmd = '/bin/echo \'read ' + reg_name + '\' | LD_LIBRARY_PATH=/nic/lib:/platform/lib:$LD_LIBRARY_PATH /platform/bin/capview' api.Trigger_AddNaplesCommand(req, tc.node_name, reg_read_cmd) tc.cmd_cookies.append(reg_read_cmd) reg_name = 'pb_pbc_hbm_hbm_port_8_cfg_hbm_parser_cam_enable' reg_read_cmd = '/bin/echo \'read ' + reg_name + '\' | LD_LIBRARY_PATH=/nic/lib:/platform/lib:$LD_LIBRARY_PATH /platform/bin/capview' api.Trigger_AddNaplesCommand(req, tc.node_name, reg_read_cmd) tc.cmd_cookies.append(reg_read_cmd) #============================================================== # trigger the request #============================================================== trig_resp = api.Trigger(req) term_resp = api.Trigger_TerminateAllCommands(trig_resp) tc.resp = api.Trigger_AggregateCommandsResponse(trig_resp, term_resp) return api.types.status.SUCCESS
def get_sessions_info(tc, node): tc.cmd_cookies = [] sessions = [] api.Logger.info("showing session info on node %s" % (node)) req = api.Trigger_CreateExecuteCommandsRequest(serial = True) cmd_cookie = "hal show session" api.Trigger_AddNaplesCommand(req, node, "/nic/bin/halctl show session ") tc.cmd_cookies.append(cmd_cookie) trig_resp = api.Trigger(req) term_resp = api.Trigger_TerminateAllCommands(trig_resp) tc.resp = api.Trigger_AggregateCommandsResponse(trig_resp, term_resp) cookie_idx = 0 for cmd in tc.resp.commands: api.Logger.info("Results for %s" % (tc.cmd_cookies[cookie_idx])) api.PrintCommandResults(cmd) return