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
