def Setup(tc):
if api.IsDryrun(): return api.types.status.SUCCESS
tc.nodes = api.GetWorkloadNodeHostnames()
tc.node_intfs = {}
srv,cli = _get_workloads(tc)
tc.workloads = [srv, cli]
if getattr(tc.args, 'restart', False):
ret = api.RestartNodes(tc.nodes)
if ret != api.types.status.SUCCESS:
api.Logger.error("Node restart failed")
return api.types.status.FAILURE
api.Logger.info("Setting driver features")
if common.setup_features(tc) != api.types.status.SUCCESS:
api.Logger.info("Setting driver features :Failed")
return api.types.status.FAILURE
api.Logger.info("Setting driver features : Success")
if getattr(tc.args, 'capture_pcap', False):
if common.start_pcap_capture(tc) != api.types.status.SUCCESS:
return api.types.status.FAILURE
if getattr(tc.args, 'capture_single_pcap', False):
if common.start_single_pcap_capture(tc) != api.types.status.SUCCESS:
return api.types.status.FAILURE
return api.types.status.SUCCESS
def debug_dump_all_nodes():
api.Logger.verbose("debug_dump_all_nodes : START")
nodes = api.GetWorkloadNodeHostnames()
for node in nodes:
debug_dump_node_info(node)
api.Logger.verbose("debug_dump_all_nodes : END")
return
def Setup(tc):
if api.IsDryrun():
return api.types.status.SUCCESS
tc.nodes = api.GetWorkloadNodeHostnames()
tc.workload_pairs = getRemoteWorkloadPairs(tc)
if len(tc.workload_pairs) == 0:
api.Logger.error("Skipping Testcase due to no workload pairs.")
tc.skip = True
return api.types.status.FAILURE
for pair in tc.workload_pairs:
srv = pair[0]
cli = pair[1]
tc.workloads = [srv, cli]
api.Logger.info("Setting up interfaces %s(%s) --> %s(%s)" %
(srv.workload_name, srv.ip_address, cli.workload_name,
cli.ip_address))
if common.setup_features(tc) != api.types.status.SUCCESS:
api.Logger.info("Setting driver features :Failed")
return api.types.status.FAILURE
return api.types.status.SUCCESS
def ServerCmd(port = None, time=None, run_core=None, jsonOut=False, naples=False,
server_ip=None):
assert(port)
nodes = api.GetWorkloadNodeHostnames()
for node in nodes:
os = api.GetNodeOs(node)
break
if os == "windows" and not naples:
cmd = [api.WINDOWS_POWERSHELL_CMD + " \"iperf3.exe", "-s", "-p", str(port)]
else:
cmd = ["iperf3", "-s", "-p", str(port)]
if naples:
cmd = iper3_env + cmd
if run_core:
cmd.extend(["-A", str(run_core)])
if time:
cmd.extend(["-t", str(time)])
if jsonOut:
cmd.append("-J")
# no periodic output
cmd.extend(["-i", "0"])
if os != "windows" or naples:
return " ".join(cmd)
else:
return " ".join(cmd) + "\""
if server_ip:
cmd.extend(["-B", server_ip])
return " ".join(cmd)
def Setup(tc):
tc.Nodes = api.GetNaplesHostnames()
tc.AllNodes = api.GetWorkloadNodeHostnames()
tc.uuidMap = api.GetNaplesNodeUuidMap()
tc.new_node = None
tc.old_node = None
tc.vm_non_dsc_to_dsc = False
tc.vm_dsc_to_dsc = False
tc.move_info = []
if tc.args.vm_type == 'non_dsc_to_dsc':
tc.vm_non_dsc_to_dsc = True
else:
tc.vm_dsc_to_dsc = True
tc.num_moves = int(getattr(tc.args, "num_moves", 1))
getNonNaplesNodes(tc)
if arping.ArPing(tc) != api.types.status.SUCCESS:
api.Logger.info("arping failed on setup")
if ping.TestPing(tc, 'local_only', 'ipv4',
64) != api.types.status.SUCCESS or ping.TestPing(
tc, 'remote_only', 'ipv4',
64) != api.types.status.SUCCESS:
api.Logger.info("ping test failed on setup")
return api.types.status.FAILURE
#Start Fuz
ret = start_fuz(tc)
if ret != api.types.status.SUCCESS:
api.Logger.error("Fuz start failed")
return api.types.status.FAILURE
return api.types.status.SUCCESS
def getNativeWorkloads():
# Get all available host interfaces
lst_nodes = api.GetWorkloadNodeHostnames()
lst_native_if = {}
mgmt_intf = {}
# Get host interfaces on all nodes
for node in lst_nodes:
lst_native_if[node] = list(api.GetWorkloadNodeHostInterfaces(node))
# Exclude host side management interface from this test case on naples
if api.IsNaplesNode(node):
mgmt_intf[node] = list(
naples_utils.GetHostInternalMgmtInterfaces(node))
for node, infs in mgmt_intf.items():
for inf in infs:
if inf in lst_native_if[node]:
lst_native_if[node].remove(inf)
# Get workloads corresponding to host interfaces
total_workloads = api.GetWorkloads()
native_workloads = []
for w1 in total_workloads:
for node, infs in lst_native_if.items():
if w1.interface in infs and w1.node_name == node:
native_workloads.append(w1)
return native_workloads
def start_single_pcap_capture(tc):
try:
req = api.Trigger_CreateExecuteCommandsRequest(serial=True)
nodes = api.GetWorkloadNodeHostnames()
tc.pcap_cmds = []
intf = api.GetRemoteWorkloadPairs()[0][0].interface
tc.pcap_filename = pcap_file_name(intf)
cmd = cmd_builder.tcpdump_cmd(intf, tc.pcap_filename)
api.Trigger_AddHostCommand(req, n, cmd, background=True)
resp = api.Trigger(req)
for cmd in resp.commands:
if cmd.handle == None or len(cmd.handle) == 0:
api.Logger.error("Error starting pcap : %s " % cmd.command)
api.Logger.error("Std Output : %s " % cmd.stdout)
api.Logger.error("Std Err : %s " % cmd.stdout)
return api.types.status.FAILURE
api.Logger.info("Success running cmd : %s" % cmd.command)
tc.pcap_trigger = resp
return api.types.status.SUCCESS
except:
api.Logger.info("failed to start single pcap capture")
api.Logger.debug(
"failed to start single pcap capture. error was: {0}".format(
traceback.format_exc()))
return api.types.status.SUCCESS
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 Setup(tc):
tc.skip = False
nodes = api.GetWorkloadNodeHostnames()
tc.naples_node0 = nodes[0]
tc.naples_node1 = nodes[1]
return api.types.status.SUCCESS
def __get_role(workload_peers):
'''
Gets client or server role for input workload
'''
role = ['client', 'server']
naples_nodes = api.GetWorkloadNodeHostnames()
for w in workload_peers.keys():
idx = naples_nodes.index(w.node_name)
w.role = role[idx % 2]
def stop_single_pcap_capture(tc):
if not getattr(tc, "pcap_trigger", None):
return api.types.status.SUCCESS
api.Trigger_TerminateAllCommands(tc.pcap_trigger)
nodes = api.GetWorkloadNodeHostnames()
tc_dir = tc.GetLogsDir()
resp = api.CopyFromHost(n, [tc.pcap_filename], tc_dir)
if resp == None or resp.api_response.api_status != types_pb2.API_STATUS_OK:
api.Logger.error("Failed to copy from to Node: %s" % n)
return api.types.status.FAILURE
return api.types.status.SUCCESS
def Setup(tc):
tc.nodes = api.GetWorkloadNodeHostnames()
tc.node_intfs = {}
for node in tc.nodes:
#return api.types.status.SUCCESS if api.GetNodeOs(node) in ["esx"] else api.types.status.FAILURE
tc.node_intfs[node] = naples_workload_api.GetNodeInterface(node)
ret = interface.ConfigureInterfaces(tc)
if ret != api.types.status.SUCCESS:
api.Logger.error("Error in setting up interfaces")
return api.types.status.FAILURE
return api.types.status.SUCCESS
def getNativeWorkloadIntfs(tc):
tc.host_nodes = api.GetWorkloadNodeHostnames()
tmp_native_intf_list = {}
tc.native_intf_list = {}
tc.mgmt_intf_list = {}
# Get host interfaces on all nodes
for node in tc.host_nodes:
tmp_native_intf_list[node] = list(api.GetWorkloadNodeHostInterfaces(node))
if api.IsNaplesNode(node):
tc.mgmt_intf_list[node] = list(naples_host_utils.GetHostInternalMgmtInterfaces(node))
for node in tc.mgmt_intf_list:
tc.native_intf_list[node] = list(set(tmp_native_intf_list.get(node))-set(tc.mgmt_intf_list.get(node)))
return api.types.status.SUCCESS
def stop_pcap_capture(tc):
api.Trigger_TerminateAllCommands(tc.pcap_trigger)
nodes = api.GetWorkloadNodeHostnames()
tc_dir = tc.GetLogsDir()
for n, host_intfs in tc.host_intfs.items():
if len(host_intfs) == 0:
api.Logger.error("No host interfaces for node :%s" % n)
return api.types.status.FAILURE
for intfObj in host_intfs:
intf = intfObj.Name()
resp = api.CopyFromHost(n, [pcap_file_name(intf)], tc_dir)
if resp == None or resp.api_response.api_status != types_pb2.API_STATUS_OK:
api.Logger.error("Failed to copy from to Node: %s" % n)
return api.types.status.FAILURE
return api.types.status.SUCCESS
def Setup(tc):
tc.skip = False
node_names = api.GetWorkloadNodeHostnames()
if api.IsNaplesNode(node_names[0]):
tc.naples_node = node_names[0]
tc.peer_node = node_names[1]
elif api.IsNaplesNode(node_names[1]):
tc.naples_node = node_names[1]
tc.peer_node = node_names[0]
else:
api.Logger.verbose("Skipping as there are no Naples nodes")
tc.skip = True
return api.types.status.IGNORED
tc.on_host = {}
tc.host_intfs = list(api.GetNaplesHostInterfaces(tc.naples_node))
for intf in tc.host_intfs:
tc.on_host[intf] = True
# Mgmt interface on host for network connection to Naples over PCIE
tc.host_int_intfs = naples_host_utils.GetHostInternalMgmtInterfaces(
tc.naples_node)
for intf in tc.host_int_intfs:
tc.on_host[intf] = True
tc.inband_intfs = naples_host_utils.GetNaplesInbandInterfaces(
tc.naples_node)
for intf in tc.inband_intfs:
tc.on_host[intf] = False
tc.naples_int_mgmt_intfs = naples_host_utils.GetNaplesInternalMgmtInterfaces(
tc.naples_node)
for intf in tc.naples_int_mgmt_intfs:
tc.on_host[intf] = False
tc.naples_oob_mgmt_intfs = naples_host_utils.GetNaplesOobInterfaces(
tc.naples_node)
for intf in tc.naples_oob_mgmt_intfs:
tc.on_host[intf] = False
tc.all_intfs = tc.host_intfs + tc.host_int_intfs + tc.inband_intfs + tc.naples_int_mgmt_intfs + tc.naples_oob_mgmt_intfs
api.Logger.debug("Promiscuous test interfaces: ", tc.all_intfs)
return api.types.status.SUCCESS
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 Setup(tc):
vm_threads = []
node_list = []
node = getattr(tc.args, "node", None)
if node:
node_list.append(node)
else:
'''
add all nodes in the topo
'''
nodes = api.GetNodes()
for node in nodes:
node_list.append(node.Name())
tc.Nodes = api.GetNaplesHostnames()
tc.AllNodes = api.GetWorkloadNodeHostnames()
tc.uuidMap = api.GetNaplesNodeUuidMap()
tc.move_info = []
tc.vm_dsc_to_dsc = True
tc.num_moves = 0
if hasattr(tc.args, "conntrack"):
tc.detailed = True
else:
tc.detailed = False
getNonNaplesNodes(tc)
if arping.ArPing(tc) != api.types.status.SUCCESS:
api.Logger.info("arping failed on setup")
if ping.TestPing(tc, 'local_only', 'ipv4', 64) != api.types.status.SUCCESS or ping.TestPing(tc, 'remote_only', 'ipv4', 64) != api.types.status.SUCCESS:
api.Logger.info("ping test failed on setup")
return api.types.status.FAILURE
for node in node_list:
(wls,new_node) = getWorkloadsToRemove(tc, node)
tc.num_moves = len(wls)
vm_utils.update_move_info(tc, wls, False, new_node)
#Start Fuz
ret = vm_utils.start_fuz(tc)
if ret != api.types.status.SUCCESS:
api.Logger.error("Fuz start failed")
return api.types.status.FAILURE
return api.types.status.SUCCESS
def __mk_testcase_directory(self, newdir):
Logger.debug("Creating Testcase directory: %s" % newdir)
command = "mkdir -p %s && chmod 777 %s" % (newdir, newdir)
req = api.Trigger_CreateAllParallelCommandsRequest()
for nodename in api.GetWorkloadNodeHostnames():
api.Trigger_AddHostCommand(req, nodename, command)
for wl in api.GetWorkloads():
if api.IsWorkloadRunning(wl.workload_name):
api.Trigger_AddCommand(req,
wl.node_name,
wl.workload_name,
command,
timeout=60)
resp = api.Trigger(req)
if not api.Trigger_IsSuccess(resp):
Logger.error("Failed to create destination directory %s" % newdir)
return types.status.FAILURE
return types.status.SUCCESS
def Setup(tc):
tc.Nodes = api.GetNaplesHostnames()
tc.AllNodes = api.GetWorkloadNodeHostnames()
tc.uuidMap = api.GetNaplesNodeUuidMap()
tc.new_node = None
tc.old_node = None
tc.vm_non_dsc_to_dsc = False
tc.vm_dsc_to_dsc = False
tc.move_info = []
if tc.args.vm_type == 'non_dsc_to_dsc':
tc.vm_non_dsc_to_dsc = True
else:
tc.vm_dsc_to_dsc = True
tc.num_moves = int(getattr(tc.args, "num_moves", 1))
tc.trigger = None
tc.trigger = getattr(tc.args, "trigger_type", None)
tc.trigger_on = getattr(tc.args, "trigger_on", 'new')
'''
if tc.args.trigger_type == 'port_flap':
tc.trigger = 'port_flap'
elif tc.args.trigger_type == 'mgmt_down':
tc.trigger = 'mgmt_down'
elif tc.args.trigger_type == 'delete_ep':
tc.trigger = 'delete_ep'
'''
getNonNaplesNodes(tc)
#Start Fuz
if arping.ArPing(tc) != api.types.status.SUCCESS:
api.Logger.info("arping failed on setup")
tc1 = ping.TestPing(tc, 'local_only', 'ipv4', 64)
tc2 = ping.TestPing(tc, 'remote_only', 'ipv4', 64)
if tc1 != api.types.status.SUCCESS or tc2 != api.types.status.SUCCESS:
api.Logger.info("ping test failed on setup")
return api.types.status.FAILURE
ret = start_fuz(tc, "20s", "20")
if ret != api.types.status.SUCCESS:
api.Logger.error("Fuz start failed")
return api.types.status.FAILURE
stop_fuz(tc)
return api.types.status.SUCCESS
def Main(step):
nodes = api.GetWorkloadNodeHostnames()
req = api.Trigger_CreateExecuteCommandsRequest(serial=False)
for n in nodes:
intfs = api.GetNaplesHostInterfaces(n)
for i in intfs:
api.Logger.info("Enable l2-fwd-offload on intf %s" % i)
api.Trigger_AddHostCommand(req, n,
"ethtool -K %s l2-fwd-offload on" % i)
resp = api.Trigger(req)
if resp == None:
return api.types.status.FAILURE
else:
for cmd in resp.commands:
if cmd.exit_code != 0:
api.Logger.info("Enable l2-fwd-offload FAILED!")
api.Logger.info(cmd.stderr)
return api.types.status.FAILURE
return api.types.status.SUCCESS
def Setup(tc):
api.Logger.verbose("MTU filter : Setup")
tc.skip = False
result = api.types.status.SUCCESS
global __OS_TYPE
global __MIN_MTU
global __MAX_MTU
tc.naples_node, res = naples_host_utils.GetNaplesNodeName()
if res is False:
tc.skip = True
if tc.skip:
api.Logger.error("MTU filter : Setup -> No Naples Topology - So skipping the TC")
return api.types.status.IGNORED
if getNativeWorkloadIntfs(tc) != api.types.status.SUCCESS:
api.Logger.error("MTU filter : Setup -> Failure in retrieving Native Workload interfaces")
return api.types.status.FAILURE
"""
# In Intel cards, post MTU change, need to wait for few sec before pinging
# instead, set max MTU on peer node
"""
result = initPeerNode(tc, tc.naples_node)
nodes = api.GetWorkloadNodeHostnames()
for node in nodes:
__OS_TYPE = api.GetNodeOs(node)
if __OS_TYPE == "freebsd":
__MIN_MTU = __MIN_MTU_FREEBSD
elif __OS_TYPE == "windows":
__MIN_MTU = __MIN_MTU_WINDOWS_IPv4
__MAX_MTU = __MAX_MTU_WINDOWS
break
tc.new_mtu = getMTUconfigs(tc)
api.Logger.info("MTU filter : new MTU - ", tc.new_mtu)
api.Logger.info("MTU filter : Setup final result - ", result)
debug_utils.collect_showtech(result)
return result
def Main(tc):
nodes = api.GetWorkloadNodeHostnames()
for node in nodes:
if api.GetNodeOs(node) == "esx":
continue
for device in api.GetDeviceNames(node):
api.Logger.debug("Creating NodeInterface for node: %s device: %s" %
(node, device))
node_if_info = GetNodeInterface(node, device)
api.Logger.debug("Adding MgmtWorkloads for node: %s device: %s" %
(node, device))
ret = AddMgmtWorkloads(node_if_info)
if ret != api.types.status.SUCCESS:
api.Logger.debug("Failed to add MgmtWorkloads for node: %s" %
node)
return api.types.status.FAILURE
if api.IsNaplesNode(node):
api.Logger.debug("Adding NaplesWorkloads for node: %s" % node)
AddNaplesWorkloads(node_if_info)
return api.types.status.SUCCESS
def Setup(tc):
api.SetTestsuiteAttr("driver_path", api.GetHostToolsDir() + '/')
tc.iota_path = api.GetTestsuiteAttr("driver_path")
tc.nodes = api.GetNaplesHostnames()
tc.other_nodes = api.GetWorkloadNodeHostnames()
tc.os = api.GetNodeOs(tc.nodes[0])
platform_gendir = api.GetTopDir()+'/platform/gen/'
if tc.os == host.OS_TYPE_LINUX:
tc.pkgname = 'drivers-linux.tar.xz'
tc.showgid = 'drivers-linux/show_gid'
else:
tc.pkgname = 'drivers-freebsd.tar.xz'
tc.showgid = 'drivers-freebsd/show_gid'
# Copy RDMA driver to naples nodes
for n in tc.nodes:
api.Logger.info("Copying {pkg} to {node}"
.format(pkg=tc.pkgname, node=n))
resp = api.CopyToHost(n, [platform_gendir + tc.pkgname])
if not api.IsApiResponseOk(resp):
api.Logger.error("Failed to copy {pkg} to {node}: {resp}"
.format(pkg=tc.pkgname, node=n, resp=resp))
return api.types.status.FAILURE
# Copy show_gid to other nodes
for n in tc.other_nodes:
if n in tc.nodes:
continue
api.Logger.info("Copying show_gid to {node}"
.format(node=n))
resp = api.CopyToHost(n, [platform_gendir + tc.showgid])
if not api.IsApiResponseOk(resp):
api.Logger.error("Failed to copy show_gid to {node}: {resp}"
.format(node=n, resp=resp))
return api.types.status.FAILURE
return api.types.status.SUCCESS
def Trigger(tc):
print(
"\t\t\t########################################################################"
)
print(
"\t\t\t# TRANSPARENT, ENFORCE => INSERTION, ENFORCE #"
)
print(
"\t\t\t########################################################################"
)
# Delete workloads
wl_api.DeleteWorkloads()
# Reset the config object store
netagent_api.ResetConfigs()
# Change mode from unified => hostpin
api.SetConfigNicMode("hostpin")
for node_name in api.GetWorkloadNodeHostnames():
api.SetTestbedNicMode("hostpin", node_name=node_name)
# Change mode from TRANSPARENT, ENFORCED => INSERTION, ENFORCE
ret = netagent_api.switch_profile(fwd_mode="INSERTION",
policy_mode="ENFORCED")
if ret != api.types.status.SUCCESS:
api.Logger.error("Failed to switch profile")
return ret
# HW push
ret = wl_api.Main(None)
if ret != api.types.status.SUCCESS:
api.Logger.error("Failed to push hw config")
return ret
api.Logger.info(
"Successfully changed the mode TRANSPARENT, ENFORCED => INSERTION, ENFORCE"
)
return api.types.status.SUCCESS
def start_pcap_capture(tc):
req = api.Trigger_CreateExecuteCommandsRequest(serial=True)
nodes = api.GetWorkloadNodeHostnames()
tc.pcap_cmds = []
for n, host_intfs in tc.host_intfs.items():
if len(host_intfs) == 0:
api.Logger.error("No host interfaces for node :%s" % n)
return api.types.status.FAILURE
for intfObj in host_intfs:
intf = intfObj.Name()
cmd = cmd_builder.tcpdump_cmd(intf, pcap_file_name(intf))
api.Trigger_AddHostCommand(req, n, cmd, background=True)
resp = api.Trigger(req)
for cmd in resp.commands:
if cmd.handle == None or len(cmd.handle) == 0:
api.Logger.error("Error starting pcap : %s " % cmd.command)
api.Logger.error("Std Output : %s " % cmd.stdout)
api.Logger.error("Std Err : %s " % cmd.stdout)
return api.types.status.FAILURE
api.Logger.info("Success running cmd : %s" % cmd.command)
tc.pcap_trigger = resp
return api.types.status.SUCCESS
def Setup(tc):
host1 = None
host2 = None
api.Logger.info("Nodes: %s" % api.GetWorkloadNodeHostnames())
for _node in api.GetWorkloadNodeHostnames():
if not host1 and api.IsNaplesNode(_node) and api.GetNodeOs(
_node) == "linux":
host1 = _node
else:
host2 = _node
if not host1:
api.Logger.error("Unable to find a Naples node with linux os")
return api.types.status.ERROR
if not host2:
api.Logger.error("Unable to find a node with linux os")
return api.types.status.ERROR
tc.host1 = host1
tc.host2 = host2
tc.pf_1 = api.GetWorkloadNodeHostInterfaces(tc.host1)[0]
tc.pf_2 = api.GetWorkloadNodeHostInterfaces(tc.host2)[0]
api.Logger.info("Host interface pair[%s, %s]" % (tc.pf_1, tc.pf_2))
tc.num_vfs = GetSupportedVFs(tc.host1, tc.pf_1)
api.Logger.info("Host %s PF %s supports %d VFs" %
(tc.host1, tc.pf_1, tc.num_vfs))
if tc.num_vfs == 0:
api.Logger.warn(
"Max supported VFs on host %s is 0, expected non-zero" % host)
return api.types.status.ERROR
if CreateVFs(tc.host1, tc.pf_1, tc.num_vfs) != api.types.status.SUCCESS:
return api.types.status.ERROR
tc.vfid = 0
tc.vf_intf = GetVFName(tc.host1, tc.pf_1, tc.vfid)
tc.remote_intf = tc.pf_2
# Set trust on to set the mac addr
if SetVFTrust(tc.host1, tc.pf_1, tc.vfid,
"on") != api.types.status.SUCCESS:
return api.types.status.FAILURE
# Assign mac addr to VF
if SetVFNdevMac(host1, tc.pf_1, tc.vfid,
"00:22:44:66:88:a1") != api.types.status.SUCCESS:
return api.types.status.ERROR
# Assign Ips to the vf interface and corresponding PF on the remote node.
tc.vf_ip = "30.0.0.1"
tc.remote_ip = "30.0.0.2"
if SetIp(host1, tc.vf_intf, tc.vf_ip, 24) != api.types.status.SUCCESS:
return api.types.status.ERROR
if SetIp(host2, tc.remote_intf, tc.remote_ip,
24) != api.types.status.SUCCESS:
return api.types.status.ERROR
if SetVFNdevState(tc.host1, tc.pf_1, tc.vfid,
"up") != api.types.status.SUCCESS:
return api.types.status.ERROR
if ping_check(tc.host1, tc.vf_intf, tc.remote_ip,
retries=5) != api.types.status.SUCCESS:
api.Logger.error("Unable to ping the remote interface")
return api.types.status.ERROR
return api.types.status.SUCCESS
def Setup(tc):
tc.skip = False
node_names = api.GetWorkloadNodeHostnames()
if api.IsNaplesNode(node_names[0]):
tc.naples_node = node_names[0]
tc.peer_node = node_names[1]
elif api.IsNaplesNode(node_names[1]):
tc.naples_node = node_names[1]
tc.peer_node = node_names[0]
else:
api.Logger.verbose("Skipping as there are no Naples nodes")
tc.skip = True
return api.types.status.IGNORED
tc.expect_pkt = {}
tc.on_host = {}
tc.host_intfs = list(api.GetNaplesHostInterfaces(tc.naples_node))
# UUC Packets from uplink will reach host interface while promiscuous
for intf in tc.host_intfs:
tc.expect_pkt[intf] = True
tc.on_host[intf] = True
# Mgmt interface on host for network connection to Naples over PCIE
tc.host_int_intfs = naples_host_utils.GetHostInternalMgmtInterfaces(
tc.naples_node)
for intf in tc.host_int_intfs:
# Host internal management should not receive packets from uplink regardless of its promiscuity state
tc.expect_pkt[intf] = False
tc.on_host[intf] = True
tc.inband_intfs = naples_host_utils.GetNaplesInbandInterfaces(
tc.naples_node)
# UUC Packets from uplink will reach inabnd interface while promiscuous
for intf in tc.inband_intfs:
tc.expect_pkt[intf] = True
tc.on_host[intf] = False
tc.naples_int_mgmt_intfs = naples_host_utils.GetNaplesInternalMgmtInterfaces(
tc.naples_node)
# Packets from uplink should not reach naples internal managment interfaces [int_mnic0] regardless of its promiscuity state
for intf in tc.naples_int_mgmt_intfs:
tc.expect_pkt[intf] = False
tc.on_host[intf] = False
tc.naples_oob_mgmt_intfs = naples_host_utils.GetNaplesOobInterfaces(
tc.naples_node)
# Packets from uplink should not reach naples oob managment interfaces [oob_mnic0] regardless of its promiscuity state
for intf in tc.naples_oob_mgmt_intfs:
tc.expect_pkt[intf] = False
tc.on_host[intf] = False
tc.all_intfs = tc.host_intfs + tc.host_int_intfs + tc.inband_intfs + tc.naples_int_mgmt_intfs + tc.naples_oob_mgmt_intfs
api.Logger.info("Promiscuous test interfaces: ", tc.all_intfs)
workloads = api.GetWorkloads()
tc.peer_workloads = []
# List of 'default vlan' workloads on peer node
for workload in workloads:
if workload.encap_vlan == 0 and workload.node_name == tc.peer_node:
tc.peer_workloads.append(workload)
# Random IP address within workload[0] IP address domain
tc.target_IP = (ipaddress.ip_address(tc.peer_workloads[0].ip_address) +
2).__str__()
#TODO: Generate a random MAC instead
tc.random_mac = "00:0f:b7:aa:bb:cc"
api.Logger.info("Random_Ip = %s Random_MAC = %s " %
(tc.target_IP, tc.random_mac))
host_utils.DeleteARP(tc.peer_node, tc.peer_workloads[0].interface,
tc.target_IP)
if host_utils.AddStaticARP(tc.peer_node, tc.peer_workloads[0].interface,
tc.target_IP,
tc.random_mac) != api.types.status.SUCCESS:
api.Logger.error("Failed to add Static ARP entry on %s" %
(tc.peer_node))
return api.types.status.FAILURE
return api.types.status.SUCCESS
def Setup(tc):
tc.skip = False
node_names = api.GetWorkloadNodeHostnames()
if api.IsNaplesNode(node_names[0]):
tc.naples_node = node_names[0]
tc.peer_node = node_names[1]
elif api.IsNaplesNode(node_names[1]):
tc.naples_node = node_names[1]
tc.peer_node = node_names[0]
else:
api.Logger.verbose("Skipping as there are no Naples nodes")
tc.skip = True
return api.types.status.IGNORED
if tc.args.mode != "promiscuous" and tc.args.mode != "non-promiscuous":
api.Logger.error("Unknown mode '%s'. Skipping testcase" %
(tc.args.mode))
tc.skip = True
return api.types.status.IGNORED
tc.on_host = {}
tc.host_intfs = list(api.GetNaplesHostInterfaces(tc.naples_node))
for intf in tc.host_intfs:
tc.on_host[intf] = True
# Mgmt interface on host for network connection to Naples over PCIE (Subset of tc.host_intfs)
tc.host_int_intfs = naples_host_utils.GetHostInternalMgmtInterfaces(
tc.naples_node)
for intf in tc.host_int_intfs:
tc.on_host[intf] = True
tc.inband_intfs = naples_host_utils.GetNaplesInbandInterfaces(
tc.naples_node)
for intf in tc.inband_intfs:
tc.on_host[intf] = False
tc.naples_int_mgmt_intfs = naples_host_utils.GetNaplesInternalMgmtInterfaces(
tc.naples_node)
for intf in tc.naples_int_mgmt_intfs:
tc.on_host[intf] = False
tc.naples_oob_mgmt_intfs = naples_host_utils.GetNaplesOobInterfaces(
tc.naples_node)
for intf in tc.naples_oob_mgmt_intfs:
tc.on_host[intf] = False
tc.all_intfs = tc.host_intfs + tc.host_int_intfs + tc.inband_intfs + tc.naples_int_mgmt_intfs + tc.naples_oob_mgmt_intfs
workloads = api.GetWorkloads()
tc.peer_workloads = []
# List of 'default vlan' workloads on peer node
for workload in workloads:
if workload.encap_vlan == 0 and workload.node_name == tc.peer_node:
tc.peer_workloads.append(workload)
# Random IP address within workload[0] IP address domain
tc.target_IP = (ipaddress.ip_address(tc.peer_workloads[0].ip_address) +
4).__str__()
return api.types.status.SUCCESS
def Trigger(tc):
tc.cmd_cookies = []
tc.cmd_cookies1 = []
tc.cmd_cookies2 = []
nodes = api.GetWorkloadNodeHostnames()
push_node_0 = [nodes[0]]
push_node_1 = [nodes[1]]
encrypt_objects = netagent_cfg_api.QueryConfigs(kind='IPSecSAEncrypt')
decrypt_objects = netagent_cfg_api.QueryConfigs(kind='IPSecSADecrypt')
policy_objects = netagent_cfg_api.QueryConfigs(kind='IPSecPolicy')
# Configure IPsec on Node 1
if api.IsNaplesNode(nodes[0]):
if len(encrypt_objects) == 0:
newObjects = netagent_cfg_api.AddOneConfig(
api.GetTopologyDirectory() +
"/ipsec/ipsec_encryption_node1.json")
if len(newObjects) == 0:
api.Logger.error(
"Adding new objects to store failed for ipsec_encryption_node1.json"
)
return api.types.status.FAILURE
ret = netagent_cfg_api.PushConfigObjects(newObjects,
node_names=push_node_0,
ignore_error=True)
if ret != api.types.status.SUCCESS:
api.Logger.error(
"Unable to push ipsec-encryption objects to node %s" %
nodes[0])
return api.types.status.FAILURE
get_config_objects = netagent_cfg_api.GetConfigObjects(newObjects)
if len(get_config_objects) == 0:
api.Logger.error("Unable to fetch newly pushed objects")
return api.types.status.FAILURE
if len(decrypt_objects) == 0:
newObjects = netagent_cfg_api.AddOneConfig(
api.GetTopologyDirectory() +
"/ipsec/ipsec_decryption_node1.json")
if len(newObjects) == 0:
api.Logger.error(
"Adding new objects to store failed for ipsec_decryption_node1.json"
)
return api.types.status.FAILURE
ret = netagent_cfg_api.PushConfigObjects(newObjects,
node_names=push_node_0,
ignore_error=True)
if ret != api.types.status.SUCCESS:
api.Logger.error(
"Unable to push ipsec-encryption objects to node %s" %
nodes[0])
return api.types.status.FAILURE
get_config_objects = netagent_cfg_api.GetConfigObjects(newObjects)
if len(get_config_objects) == 0:
api.Logger.error("Unable to fetch newly pushed objects")
return api.types.status.FAILURE
if len(policy_objects) == 0:
newObjects = netagent_cfg_api.AddOneConfig(
api.GetTopologyDirectory() +
"/ipsec/ipsec_policies_node1.json")
if len(newObjects) == 0:
api.Logger.error(
"Adding new objects to store failed for ipsec_policies_node1.json"
)
return api.types.status.FAILURE
ret = netagent_cfg_api.PushConfigObjects(newObjects,
node_names=push_node_0,
ignore_error=True)
if ret != api.types.status.SUCCESS:
api.Logger.error(
"Unable to push ipsec-policy objects to node %s" %
nodes[0])
return api.types.status.FAILURE
get_config_objects = netagent_cfg_api.GetConfigObjects(newObjects)
if len(get_config_objects) == 0:
api.Logger.error("Unable to fetch newly pushed objects")
return api.types.status.FAILURE
else:
workloads = api.GetWorkloads(nodes[0])
w1 = workloads[0]
req1 = api.Trigger_CreateExecuteCommandsRequest(serial=True)
api.Trigger_AddCommand(req1, w1.node_name, w1.workload_name,
"sudo ip xfrm state flush")
api.Trigger_AddCommand(req1, w1.node_name, w1.workload_name,
"sudo ip xfrm policy flush")
api.Trigger_AddCommand(
req1, w1.node_name, w1.workload_name,
"sudo ip xfrm policy add src 192.168.100.103/32 dst 192.168.100.101/32 proto tcp dport %s dir in tmpl src 192.168.100.103 dst 192.168.100.101 proto esp mode tunnel"
% (tc.iterators.port))
api.Trigger_AddCommand(
req1, w1.node_name, w1.workload_name,
"sudo ip xfrm policy add src 192.168.100.103/32 dst 192.168.100.101/32 proto tcp dport %s dir fwd tmpl src 192.168.100.103 dst 192.168.100.101 proto esp mode tunnel"
% (tc.iterators.port))
api.Trigger_AddCommand(
req1, w1.node_name, w1.workload_name,
"sudo ip xfrm policy add src 192.168.100.101/32 dst 192.168.100.103/32 proto tcp sport %s dir out tmpl src 192.168.100.101 dst 192.168.100.103 proto esp mode tunnel"
% (tc.iterators.port))
api.Trigger_AddCommand(
req1, w1.node_name, w1.workload_name,
"sudo ip xfrm state add src 192.168.100.103 dst 192.168.100.101 proto esp spi 0x01 mode tunnel aead 'rfc4106(gcm(aes))' 0x414141414141414141414141414141414141414141414141414141414141414100000000 128 sel src 192.168.100.103/32 dst 192.168.100.101/32"
)
api.Trigger_AddCommand(
req1, w1.node_name, w1.workload_name,
"sudo ip xfrm state add src 192.168.100.101 dst 192.168.100.103 proto esp spi 0x01 mode tunnel aead 'rfc4106(gcm(aes))' 0x414141414141414141414141414141414141414141414141414141414141414100000000 128 sel src 192.168.100.101/32 dst 192.168.100.103/32"
)
api.Trigger_AddCommand(
req1, w1.node_name, w1.workload_name,
"sudo ip xfrm policy add src 192.168.100.103/32 dst 192.168.100.101/32 proto udp dport %s dir in tmpl src 192.168.100.103 dst 192.168.100.101 proto esp mode tunnel"
% (tc.iterators.port))
api.Trigger_AddCommand(
req1, w1.node_name, w1.workload_name,
"sudo ip xfrm policy add src 192.168.100.103/32 dst 192.168.100.101/32 proto udp dport %s dir fwd tmpl src 192.168.100.103 dst 192.168.100.101 proto esp mode tunnel"
% (tc.iterators.port))
api.Trigger_AddCommand(
req1, w1.node_name, w1.workload_name,
"sudo ip xfrm policy add src 192.168.100.101/32 dst 192.168.100.103/32 proto udp sport %s dir out tmpl src 192.168.100.101 dst 192.168.100.103 proto esp mode tunnel"
% (tc.iterators.port))
api.Trigger_AddCommand(req1, w1.node_name, w1.workload_name,
"sudo ip xfrm state list")
api.Trigger_AddCommand(req1, w1.node_name, w1.workload_name,
"sudo ip xfrm policy list")
trig_resp1 = api.Trigger(req1)
term_resp1 = api.Trigger_TerminateAllCommands(trig_resp1)
# Configure IPsec on Node 2
if api.IsNaplesNode(nodes[1]):
if len(encrypt_objects) == 0:
newObjects = netagent_cfg_api.AddOneConfig(
api.GetTopologyDirectory() +
"/ipsec/ipsec_encryption_node2.json")
if len(newObjects) == 0:
api.Logger.error(
"Adding new objects to store failed for ipsec_encryption_node2.json"
)
return api.types.status.FAILURE
ret = netagent_cfg_api.PushConfigObjects(newObjects,
node_names=push_node_1,
ignore_error=True)
if ret != api.types.status.SUCCESS:
api.Logger.error(
"Unable to push ipsec-encryption objects to node %s" %
nodes[1])
return api.types.status.FAILURE
get_config_objects = netagent_cfg_api.GetConfigObjects(newObjects)
if len(get_config_objects) == 0:
api.Logger.error("Unable to fetch newly pushed objects")
#return api.types.status.FAILURE
if len(decrypt_objects) == 0:
newObjects = netagent_cfg_api.AddOneConfig(
api.GetTopologyDirectory() +
"/ipsec/ipsec_decryption_node2.json")
if len(newObjects) == 0:
api.Logger.error(
"Adding new objects to store failed for ipsec_decryption_node2.json"
)
return api.types.status.FAILURE
ret = netagent_cfg_api.PushConfigObjects(newObjects,
node_names=push_node_1,
ignore_error=True)
if ret != api.types.status.SUCCESS:
api.Logger.error(
"Unable to push ipsec-encryption objects to node %s" %
nodes[1])
return api.types.status.FAILURE
get_config_objects = netagent_cfg_api.GetConfigObjects(newObjects)
if len(get_config_objects) == 0:
api.Logger.error("Unable to fetch newly pushed objects")
#return api.types.status.FAILURE
if len(policy_objects) == 0:
newObjects = netagent_cfg_api.AddOneConfig(
api.GetTopologyDirectory() +
"/ipsec/ipsec_policies_node2.json")
if len(newObjects) == 0:
api.Logger.error(
"Adding new objects to store failed for ipsec_policies_node2.json"
)
return api.types.status.FAILURE
ret = netagent_cfg_api.PushConfigObjects(newObjects,
node_names=push_node_1,
ignore_error=True)
if ret != api.types.status.SUCCESS:
api.Logger.error(
"Unable to push ipsec-encryption objects to node %s" %
nodes[1])
return api.types.status.FAILURE
get_config_objects = netagent_cfg_api.GetConfigObjects(newObjects)
if len(get_config_objects) == 0:
api.Logger.error("Unable to fetch newly pushed objects")
#return api.types.status.FAILURE
else:
workloads = api.GetWorkloads(nodes[1])
w2 = workloads[0]
req2 = api.Trigger_CreateExecuteCommandsRequest(serial=True)
api.Trigger_AddCommand(req2, w2.node_name, w2.workload_name,
"sudo ip xfrm state flush")
api.Trigger_AddCommand(req2, w2.node_name, w2.workload_name,
"sudo ip xfrm policy flush")
api.Trigger_AddCommand(
req2, w2.node_name, w2.workload_name,
"sudo ip xfrm policy add src 192.168.100.101/32 dst 192.168.100.103/32 proto tcp dport %s dir in tmpl src 192.168.100.101 dst 192.168.100.103 proto esp mode tunnel"
% (tc.iterators.port))
api.Trigger_AddCommand(
req2, w2.node_name, w2.workload_name,
"sudo ip xfrm policy add src 192.168.100.101/32 dst 192.168.100.103/32 proto tcp dport %s dir fwd tmpl src 192.168.100.101 dst 192.168.100.103 proto esp mode tunnel"
% (tc.iterators.port))
api.Trigger_AddCommand(
req2, w2.node_name, w2.workload_name,
"sudo ip xfrm policy add src 192.168.100.103/32 dst 192.168.100.101/32 proto tcp sport %s dir out tmpl src 192.168.100.103 dst 192.168.100.101 proto esp mode tunnel"
% (tc.iterators.port))
api.Trigger_AddCommand(
req2, w2.node_name, w2.workload_name,
"sudo ip xfrm state add src 192.168.100.101 dst 192.168.100.103 proto esp spi 0x01 mode tunnel aead 'rfc4106(gcm(aes))' 0x414141414141414141414141414141414141414141414141414141414141414100000000 128 sel src 192.168.100.101/32 dst 192.168.100.103/32"
)
api.Trigger_AddCommand(
req2, w2.node_name, w2.workload_name,
"sudo ip xfrm state add src 192.168.100.103 dst 192.168.100.101 proto esp spi 0x01 mode tunnel aead 'rfc4106(gcm(aes))' 0x414141414141414141414141414141414141414141414141414141414141414100000000 128 sel src 192.168.100.103/32 dst 192.168.100.101/32"
)
api.Trigger_AddCommand(
req2, w2.node_name, w2.workload_name,
"sudo ip xfrm policy add src 192.168.100.101/32 dst 192.168.100.103/32 proto udp dport %s dir in tmpl src 192.168.100.101 dst 192.168.100.103 proto esp mode tunnel"
% (tc.iterators.port))
api.Trigger_AddCommand(
req2, w2.node_name, w2.workload_name,
"sudo ip xfrm policy add src 192.168.100.101/32 dst 192.168.100.103/32 proto udp dport %s dir fwd tmpl src 192.168.100.101 dst 192.168.100.103 proto esp mode tunnel"
% (tc.iterators.port))
api.Trigger_AddCommand(
req2, w2.node_name, w2.workload_name,
"sudo ip xfrm policy add src 192.168.100.103/32 dst 192.168.100.101/32 proto udp sport %s dir out tmpl src 192.168.100.103 dst 192.168.100.101 proto esp mode tunnel"
% (tc.iterators.port))
api.Trigger_AddCommand(req2, w2.node_name, w2.workload_name,
"sudo ip xfrm state list")
api.Trigger_AddCommand(req2, w2.node_name, w2.workload_name,
"sudo ip xfrm policy list")
trig_resp2 = api.Trigger(req2)
term_resp2 = api.Trigger_TerminateAllCommands(trig_resp2)
workloads = api.GetWorkloads(nodes[0])
w1 = workloads[0]
workloads = api.GetWorkloads(nodes[1])
w2 = workloads[0]
bypass_test = 0
if w1.IsNaples() and w2.IsNaples():
api.Logger.info(
"Both workloads are Naples, %s is nc client, %s is nc server, bypassing test"
% (w1.node_name, w2.node_name))
nc_client_wl = w1
nc_server_wl = w2
bypass_test = 1
elif w1.IsNaples():
api.Logger.info("%s is Naples and nc client, %s is nc server" %
(w1.node_name, w2.node_name))
nc_client_wl = w1
nc_server_wl = w2
elif w2.IsNaples():
api.Logger.info("%s is Naples and nc client, %s is nc server" %
(w2.node_name, w1.node_name))
nc_client_wl = w2
nc_server_wl = w1
req = api.Trigger_CreateExecuteCommandsRequest(serial=True)
tc.cmd_descr = "Server: %s(%s) <--> Client: %s(%s) on %s port %s" %\
(nc_server_wl.workload_name, nc_server_wl.ip_address, nc_client_wl.workload_name, nc_client_wl.ip_address, tc.iterators.protocol, tc.iterators.port)
api.Logger.info("Starting NC test over IPSec from %s" % (tc.cmd_descr))
if bypass_test == 0:
cmd_cookie = "Creating test file on %s" % (nc_client_wl.workload_name)
api.Trigger_AddCommand(
req, nc_client_wl.node_name, nc_client_wl.workload_name,
"base64 /dev/urandom | head -1000 > ipsec_client.dat")
tc.cmd_cookies.append(cmd_cookie)
cmd_cookie = "Setting MTU to smaller value on %s" % (
nc_client_wl.workload_name)
api.Trigger_AddCommand(req, nc_client_wl.node_name,
nc_client_wl.workload_name,
"ifconfig %s mtu 1048" % nc_client_wl.interface)
tc.cmd_cookies.append(cmd_cookie)
cmd_cookie = "Running nc server on %s" % (nc_server_wl.workload_name)
if tc.iterators.protocol == "tcp":
api.Trigger_AddCommand(req,
nc_server_wl.node_name,
nc_server_wl.workload_name,
"nc -l %s > ipsec_server.dat" %
(tc.iterators.port),
background=True)
else:
api.Trigger_AddCommand(req,
nc_server_wl.node_name,
nc_server_wl.workload_name,
"nc --udp -l %s > ipsec_server.dat" %
(tc.iterators.port),
background=True)
tc.cmd_cookies.append(cmd_cookie)
cmd_cookie = "Running nc client on %s" % (nc_client_wl.workload_name)
if tc.iterators.protocol == "tcp":
api.Trigger_AddCommand(
req, nc_client_wl.node_name, nc_client_wl.workload_name,
"nc %s %s < ipsec_client.dat" %
(nc_server_wl.ip_address, tc.iterators.port))
else:
api.Trigger_AddCommand(
req, nc_client_wl.node_name, nc_client_wl.workload_name,
"nc --udp %s %s < ipsec_client.dat" %
(nc_server_wl.ip_address, tc.iterators.port))
tc.cmd_cookies.append(cmd_cookie)
else:
cmd_cookie = "Creating dummy file on %s" % (nc_client_wl.workload_name)
api.Trigger_AddCommand(
req, nc_client_wl.node_name, nc_client_wl.workload_name,
"rm -f ipsec_client.dat ; touch ipsec_client.dat")
tc.cmd_cookies.append(cmd_cookie)
cmd_cookie = "Creating dummy file on %s" % (nc_server_wl.workload_name)
api.Trigger_AddCommand(
req, nc_server_wl.node_name, nc_server_wl.workload_name,
"rm -f ipsec_server.dat ; touch ipsec_server.dat")
tc.cmd_cookies.append(cmd_cookie)
if nc_client_wl.IsNaples():
cmd_cookie = "IPSec state on %s AFTER running nc test" % (
nc_client_wl.node_name)
api.Trigger_AddNaplesCommand(
req, nc_client_wl.node_name,
"/nic/bin/halctl show ipsec-global-stats")
tc.cmd_cookies.append(cmd_cookie)
else:
cmd_cookie = "IPSec state on %s AFTER running nc test" % (
nc_client_wl.node_name)
api.Trigger_AddCommand(req, nc_client_wl.node_name,
nc_client_wl.workload_name,
"sudo ip xfrm policy show")
tc.cmd_cookies.append(cmd_cookie)
if nc_server_wl.IsNaples():
cmd_cookie = "IPSec state on %s AFTER running nc test" % (
nc_server_wl.node_name)
api.Trigger_AddNaplesCommand(
req, nc_server_wl.node_name,
"/nic/bin/halctl show ipsec-global-stats")
tc.cmd_cookies.append(cmd_cookie)
else:
cmd_cookie = "IPSec state on %s AFTER running nc test" % (
nc_server_wl.node_name)
api.Trigger_AddCommand(req, nc_server_wl.node_name,
nc_server_wl.workload_name,
"sudo ip xfrm policy show")
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)
resp = api.CopyFromWorkload(nc_client_wl.node_name,
nc_client_wl.workload_name,
['ipsec_client.dat'], tc.GetLogsDir())
if resp is None:
api.Logger.error("Could not find ipsec_client.dat")
return api.types.status.FAILURE
resp = api.CopyFromWorkload(nc_server_wl.node_name,
nc_server_wl.workload_name,
['ipsec_server.dat'], tc.GetLogsDir())
if resp is None:
api.Logger.error("Could not find ipsec_server.dat")
return api.types.status.FAILURE
return api.types.status.SUCCESS
def ClientCmd(server_ip, port = None, time=10, pktsize=None, proto='tcp', run_core=None,
ipproto='v4', bandwidth="100G", num_of_streams = None, jsonOut=False,
connect_timeout=None, client_ip=None, client_port=None, packet_count=None,
naples=False, msssize=None, reverse=False):
assert(port)
nodes = api.GetWorkloadNodeHostnames()
for node in nodes:
os = api.GetNodeOs(node)
break
if os == "windows" and not naples:
cmd = [api.WINDOWS_POWERSHELL_CMD + " \"iperf3.exe", "-c", str(server_ip), "-p", str(port), "-b", str(bandwidth)]
else:
cmd = ["iperf3", "-c", str(server_ip), "-p", str(port), "-b", str(bandwidth)]
if naples:
cmd = iper3_env + cmd
if client_ip:
cmd.extend(["-B", str(client_ip)])
if client_port:
cmd.extend(["--cport", str(client_port)])
if time and packet_count is None:
cmd.extend(["-t", str(time)])
if run_core:
cmd.extend(["-A", str(run_core)])
if proto == 'udp':
cmd.append('-u')
if bandwidth:
cmd.extend(["-b", str(bandwidth)])
#cmd.append("-w10000")
if jsonOut:
cmd.append('-J')
if num_of_streams:
cmd.extend(["-P", str(num_of_streams)])
if connect_timeout:
cmd.extend(["--connect-timeout", str(connect_timeout)])
if pktsize:
cmd.extend(["-l", str(pktsize)])
if msssize:
cmd.extend(["-M", str(msssize)])
if ipproto == 'v6':
cmd.append("-6")
if packet_count:
cmd.extend(["-k", str(packet_count)])
# no periodic output
cmd.extend(["-i", "0"])
if os != "windows" or naples:
return " ".join(cmd)
else:
return " ".join(cmd) + "\""
if reverse:
cmd.append("-R")
return " ".join(cmd)
