def __installPenCtl(node):
fullpath = api.GetTopDir() + '/' + common.PENCTL_PKG
resp = api.CopyToHost(node, [fullpath], "")
if resp is None:
return api.types.status.FAILURE
if resp.api_response.api_status != types_pb2.API_STATUS_OK:
api.Logger.error("Failed to copy penctl to Node: %s" % node)
return api.types.status.FAILURE
fullpath = api.GetTopDir() + '/' + common.PENCTL_TOKEN_FILE
resp = api.CopyToHost(node, [fullpath], "")
if resp is None:
return api.types.status.FAILURE
if resp.api_response.api_status != types_pb2.API_STATUS_OK:
api.Logger.error("Failed to copy penctl token to Node: %s" % node)
return api.types.status.FAILURE
req = api.Trigger_CreateExecuteCommandsRequest()
api.Trigger_AddHostCommand(req, node, "tar -xvf %s" % os.path.basename(common.PENCTL_PKG) + " && sync",
background = False)
#Create a symlink at top level
execName = __penctl_exec(node)
realPath = "realpath %s/%s " % (common.PENCTL_DEST_DIR, execName)
api.Trigger_AddHostCommand(req, node, realPath, background = False)
resp = api.Trigger(req)
for cmd in resp.commands:
api.PrintCommandResults(cmd)
if cmd.exit_code != 0:
return api.types.status.FAILURE
common.PENCTL_EXEC[node] = resp.commands[1].stdout.split("\n")[0]
req = api.Trigger_CreateExecuteCommandsRequest()
#Create a symlink at top level
realPath = "realpath %s " % (common.PENCTL_TOKEN_FILE_NAME)
api.Trigger_AddHostCommand(req, node, realPath, background = False)
resp = api.Trigger(req)
for cmd in resp.commands:
api.PrintCommandResults(cmd)
if cmd.exit_code != 0:
return api.types.status.FAILURE
common.PENCTL_TOKEN[node] = resp.commands[0].stdout.split("\n")[0]
return api.types.status.SUCCESS
def Main(step):
if GlobalOptions.skip_setup:
return api.types.status.SUCCESS
req = api.Trigger_CreateExecuteCommandsRequest(serial=True)
api.ChangeDirectory("iperf")
for naples_host in api.GetNaplesHostnames():
if api.GetNodeOs(naples_host) == host.OS_TYPE_BSD:
api.CopyToHost(naples_host, [IONIC_STATS_SCRIPT], "")
api.Trigger_AddHostCommand(
req, naples_host, "cp ionic_stats.sh " + api.HOST_NAPLES_DIR)
api.CopyToNaples(naples_host, [IPERF_BINARY],
"",
naples_dir="/usr/bin/")
api.Trigger_AddNaplesCommand(
req, naples_host, "ln -s /usr/bin/iperf3_aarch64 /usr/bin/iperf3")
resp = api.Trigger(req)
for cmd in resp.commands:
api.PrintCommandResults(cmd)
if cmd.exit_code != 0:
result = api.types.status.FAILURE
return api.types.status.SUCCESS
def installBinary(node, img):
fullpath = os.path.join(api.GetTopDir(), img)
api.Logger.info("fullpath for binary: " + fullpath)
resp = api.CopyToHost(node, [fullpath], "")
if resp is None:
return api.types.status.FAILURE
if resp.api_response.api_status != types_pb2.API_STATUS_OK:
api.Logger.error("Failed to copy Drivers to Node: %s" % node)
return api.types.status.FAILURE
resp = api.CopyToNaples(node, [fullpath], "", naples_dir="/update")
if resp.api_response.api_status != types_pb2.API_STATUS_OK:
api.Logger.error("Failed to copy Drivers to Node: %s" % node)
return api.types.status.FAILURE
req = api.Trigger_CreateExecuteCommandsRequest()
api.Trigger_AddNaplesCommand(
req, node, "chmod 777 /update/{}".format(os.path.basename(fullpath)))
resp = api.Trigger(req)
for cmd_resp in resp.commands:
api.PrintCommandResults(cmd_resp)
if cmd_resp.exit_code != 0:
api.Logger.error("failed to change permission %s",
cmd_resp.command)
return api.types.status.FAILURE
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 __installNaplesFwImage(node):
fullpath = api.GetTopDir() + '/' + common.PENCTL_NAPLES_PKG
resp = api.CopyToHost(node, [fullpath], "")
if resp is None:
return api.types.status.FAILURE
if resp.api_response.api_status != types_pb2.API_STATUS_OK:
api.Logger.error("Failed to copy Drivers to Node: %s" % node)
return api.types.status.FAILURE
return api.types.status.SUCCESS
def Trigger(tc):
result = api.types.status.SUCCESS
for node in tc.nodes:
host.UnloadDriver(api.GetNodeOs(node), node, "all")
if api.GetNodeOs(node) != "linux":
api.Logger.error("Expected Linux node")
result = api.types.status.FAILURE
continue
# Copy rpm tar to host
resp = api.CopyToHost(node, [LOCAL_TAR], "")
if resp is None:
api.Logger.error("Failed to copy RPMs")
result = api.types.status.FAILURE
continue
# untar the RPM archive
cmd = f"tar -xvf linux-rpms.tar.xz"
if send_command(tc, cmd, node) is api.types.status.FAILURE:
result = api.types.status.FAILURE
continue
# Copy the script
resp = api.CopyToHost(node, [SCRIPT_PWD], "")
if resp is None:
api.Logger.info("Failed to copy RPMs")
result = api.types.status.FAILURE
continue
# run the test script
cmd = f"sudo ./{SCRIPT}"
if send_command(tc, cmd, node) is api.types.status.FAILURE:
result = api.types.status.FAILURE
continue
return result
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 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 Setup(tc):
tc.nodes = api.GetNaplesHostnames()
tc.files = []
for cfgfile in tc.args.cfg:
tc.files.append("%s/%s/%s" % (api.GetTopDir(), tc.args.dir, cfgfile))
tc.files.append("%s/%s/%s" % (api.GetTopDir(), tc.args.dir, tc.args.test))
for n in tc.nodes:
tc.files.append("%s/iota/test/iris/testcases/storage/pnsotest_%s.py" %
(api.GetTopDir(), api.GetNodeOs(n)))
resp = api.CopyToHost(n, tc.files)
if not api.IsApiResponseOk(resp):
return api.types.status.FAILURE
return api.types.status.SUCCESS
def Setup(tc):
api.Logger.info("Iterators: %s" % tc.iterators.Summary())
pnsoutils.Setup(tc)
# Run it only on first Naples
node_list = api.GetNaplesHostnames()
tc.nodes = [node_list[0]]
for n in tc.nodes:
tc.files.append("%s/pnsotest_%s.py" % (tc.tcdir, api.GetNodeOs(n)))
api.Logger.debug("Copying testyml files to Node:%s" % n)
resp = api.CopyToHost(n, tc.files)
if not api.IsApiResponseOk(resp):
return api.types.status.FAILURE
return api.types.status.SUCCESS
def __load_linux_driver(node, node_os, manifest_file):
image_manifest = parser.JsonParse(manifest_file)
driver_images = list(filter(lambda x: x.OS == node_os, image_manifest.Drivers))[0].Images[0]
if driver_images is None:
api.Logger.error("Unable to load image manifest")
return api.types.status.FAILURE
drImgFile = os.path.join(Gl, driver_images.drivers_pkg)
api.Logger.info("Fullpath for driver image: " + drImgFile)
resp = api.CopyToHost(node, [drImgFile], "")
if not api.IsApiResponseOk(resp):
api.Logger.error("Failed to copy %s" % drImgFile)
return api.types.status.FAILURE
rundir = os.path.basename(driver_images.drivers_pkg).split('.')[0]
req = api.Trigger_CreateExecuteCommandsRequest(serial = True)
api.Trigger_AddHostCommand(req, node, "tar -xf " + os.path.basename(driver_images.drivers_pkg))
api.Trigger_AddHostCommand(req, node, "./build.sh", rundir=rundir)
resp = api.Trigger(req)
if not api.IsApiResponseOk(resp):
api.Logger.error("TriggerCommand for driver build failed")
return api.types.status.FAILURE
for cmd in resp.commands:
if cmd.exit_code != 0 and cmd.command != './build.sh': # Build.sh could fail -ignored (FIXME)
api.Logger.error("Failed to exec cmds to build/load new driver")
return api.types.status.FAILURE
api.Logger.info("New driver image is built on target host. Prepare to load")
if host.UnloadDriver(node_os, node) != api.types.status.SUCCESS:
api.Logger.error("Failed to unload current driver - proceeding")
req = api.Trigger_CreateExecuteCommandsRequest(serial = True)
if node_os == OS_TYPE_LINUX:
api.Trigger_AddHostCommand(req, node, "insmod " +
os.path.join(rundir, "drivers/eth/ionic/ionic.ko"))
elif node_os == OS_TYPE_BSD:
api.Trigger_AddHostCommand(req, node, "kldload " +
os.path.join(rundir, "drivers/eth/ionic/ionic.ko"))
resp = api.Trigger(req)
if not api.Trigger_IsSuccess(resp):
api.Logger.error("TriggerCommand for driver installation failed")
return api.types.status.FAILURE
return api.types.status.SUCCESS
def __node_api_handler(self, url, json_data=None, oper=CfgOper.ADD):
if oper == CfgOper.DELETE:
oper = "DELETE"
elif oper == CfgOper.ADD:
oper = "POST"
elif oper == CfgOper.UPDATE:
oper = "PUT"
elif oper == CfgOper.GET:
oper = "GET"
else:
print(oper)
assert (0)
if GlobalOptions.debug:
api.Logger.info("Url : %s" % url)
cmd = None
if json_data and len(json.dumps(json_data)) > 100000:
filename = "/tmp/temp_config.json"
with open(filename, 'w') as outfile:
json.dump(json_data, outfile)
req = api.Trigger_CreateAllParallelCommandsRequest()
cmd = ["rm", "-rf", "temp_config.json"]
cmd = " ".join(cmd)
api.Trigger_AddHostCommand(req, self.host_name, cmd, timeout=3600)
api.Trigger(req)
resp = api.CopyToHost(self.host_name, [filename], "")
if not api.IsApiResponseOk(resp):
assert (0)
cmd = [
"curl", "-X", oper, "-d", "@temp_config.json", "-k", "-H",
"\"Content-Type:application/json\"", url
]
else:
cmd = [
"curl", "-X", oper, "-k", "-d",
"\'" + json.dumps(json_data) + "\'" if json_data else " ",
"-H", "\"Content-Type:application/json\"", url
]
cmd = " ".join(cmd)
req = api.Trigger_CreateAllParallelCommandsRequest()
api.Trigger_AddHostCommand(req, self.host_name, cmd, timeout=3600)
resp = api.Trigger(req)
if GlobalOptions.debug:
print(" ".join(cmd))
return resp.commands[0].stdout
def Trigger(tc):
if tc.skip: return api.types.status.SUCCESS
store = tc.GetBundleStore()
serverReq = store["server_req"]
if serverReq:
store["server_resp"] = api.Trigger(serverReq)
#If we want to start server combined
server_pcap_info = []
if store.get("server_ctxts", None):
serverReq = api.Trigger_CreateAllParallelCommandsRequest()
for _, server in store["server_ctxts"].items():
jsonInput = {"connections": []}
for serverIPPort in server.GetServers():
jsonInput["connections"].append({
"ServerIPPort": serverIPPort,
"proto": "tcp"
})
outfile = api.GetTestDataDirectory(
) + "/" + server.node_name + "_fuz.json"
with open(outfile, 'w') as fp:
json.dump(jsonInput, fp)
api.CopyToHost(server.node_name, [outfile], "")
serverCmd = fuz_init.FUZ_EXEC[
server.workload_name] + " --jsonInput " + os.path.basename(
outfile) + " --jsonOut"
api.Trigger_AddHostCommand(serverReq,
server.node_name,
serverCmd,
background=True)
for intf in server.interfaces:
server_pcap_info.append(
(server.node_name, intf, intf + ".pcap"))
#Start server
store["combined_server_resp"] = api.Trigger(serverReq)
#Start Pcap just before starting client
store["server_pcap_info"] = server_pcap_info
#Sleep for some time as bg may not have been started.
time.sleep(30)
return api.types.status.SUCCESS
def Setup(tc):
api.Logger.info("Pencap - Techsupport Sysinfo")
tc.nodes = api.GetNaplesHostnames()
tc.os = api.GetNodeOs(tc.nodes[0])
#Copy pencap package to the host
platform_gendir = api.GetTopDir() + '/platform/drivers/pencap/'
listDir = os.listdir(platform_gendir)
api.Logger.info("Content of {dir} : {cnt}".format(dir=platform_gendir,
cnt=listDir))
for n in tc.nodes:
api.Logger.info(
"Copying Pencap package to the host{node}".format(node=n))
resp = api.CopyToHost(n, [platform_gendir + "pencap.tar.gz"])
if not api.IsApiResponseOk(resp):
api.Logger.error("Failed to copy {pkg} to {node}: {resp}".format(
pkg="pencap.tar.gz", node=n, resp=resp))
return api.types.status.FAILURE
return api.types.status.SUCCESS
def Setup(tc):
# Find the name of the target host
names = api.GetNaplesHostnames()
name = names[0]
if api.GetNodeOs(name) != "linux":
return api.types.status.SUCCESS
# Copy the test script to the target host
resp = api.CopyToHost(name, [source_file], "")
if resp is None:
api.Logger.error("None resp on Failed copy %s to Host %s" %
(source_file, name))
return api.types.status.FAILURE
if resp.api_response.api_status != types_pb2.API_STATUS_OK:
api.Logger.error("Failed to copy %s to Host %s" % (source_file, name))
return api.types.status.FAILURE
return api.types.status.SUCCESS
def Setup(tc):
tc.nodes = api.GetNaplesHostnames()
for node in tc.nodes:
if api.GetNodeOs(node) != "linux":
return api.types.status.FAILURE
# Copy the test program to the target host
resp = api.CopyToHost(node, [SOURCE_FILE], "")
if resp is None:
api.Logger.info("Failed to copy PCIMEM")
return api.types.status.FAILURE
# Compile pcimem on the host
cmd = f"gcc -Wall -g ./pcimem.c -o pcimem"
if send_command(tc, cmd, node) is api.types.status.FAILURE:
return api.types.status.FAILURE
return api.types.status.SUCCESS
def installNaplesFwLatestImage(node, img):
fullpath = api.GetTopDir() + '/nic/' + img
api.Logger.info("fullpath for upg image: " + fullpath)
resp = api.CopyToHost(node, [fullpath], "")
if resp is None:
return api.types.status.FAILURE
if resp.api_response.api_status != types_pb2.API_STATUS_OK:
api.Logger.error("Failed to copy Drivers to Node: %s" % node)
return api.types.status.FAILURE
resp = api.CopyToNaples(node, [fullpath], "", naples_dir="/update")
if resp is None:
return api.types.status.FAILURE
if resp.api_response.api_status != types_pb2.API_STATUS_OK:
api.Logger.error("Failed to copy Drivers to Node: %s" % node)
return api.types.status.FAILURE
return api.types.status.SUCCESS
def LoadFwDriver(os_type, node):
req = api.Trigger_CreateExecuteCommandsRequest(serial=True)
if os_type != host.OS_TYPE_BSD:
api.Logger.info("Unknown os_type - %s" % os_type)
return api.types.status.FAILURE
fullpath = api.GetTopDir() + '/nic/naples_fw.tar'
api.Logger.info("Fullpath for firmware image: " + fullpath)
resp = api.CopyToHost(node, [fullpath], "")
if resp is None:
api.Logger.info("Failed to copy naples_fw.tar")
return api.types.status.FAILURE
api.Trigger_AddHostCommand(req, node,
"cp naples_fw.tar " + IONIC_FW_DRV_PATH)
api.Trigger_AddHostCommand(req, node, "make -C " + IONIC_FW_DRV_PATH)
api.Trigger_AddHostCommand(req, node,
"kldload " + IONIC_FW_DRV_PATH + "/ionic_fw.ko")
resp = api.Trigger(req)
if resp is None:
return api.types.status.FAILURE
for cmd in resp.commands:
if cmd.exit_code != 0:
if os_type == host.OS_TYPE_BSD:
if cmd.stdout.find("already loaded") != -1:
api.Logger.info("ionic_fw load failed")
api.PrintCommandResults(cmd)
return api.types.status.FAILURE
else:
api.Logger.info(
"ionic_fw already loaded, reload is expected to fail without unload"
)
else:
api.Logger.info("Unknown os_type - %s" % os_type)
return api.types.status.FAILURE
return api.types.status.SUCCESS
def __copy_sonic_to_all_naples(tc):
for n in tc.nodes:
resp = api.CopyToHost(n, [tc.sonicpkg])
if not api.IsApiResponseOk(resp):
return api.types.status.FAILURE
return api.types.status.SUCCESS
def startTestUpgApp(node, param):
stopTestUpgApp(node, False)
#/data/sysmgr.json
data = [{
"name":
"{}".format(UPGRADE_TEST_APP),
"command":
"/update/{} {}".format(UPGRADE_TEST_APP + ".bin", param),
"dependencies": [{
"kind": "service",
"service-name": "delphi"
}, {
"kind": "service",
"service-name": "hal"
}],
"flags": ["save_stdout_on_crash"],
"timeout":
3000.0
}]
# Write JSON file
with open("sysmgr.json", "w") as write_file:
json.dump(data, write_file)
# Read JSON file
with open('sysmgr.json') as data_file:
data_loaded = json.load(data_file)
print(data == data_loaded)
fullpath = api.GetTopDir() + '/iota/sysmgr.json'
api.Logger.info("fullpath for binary: " + fullpath)
resp = api.CopyToHost(node, [fullpath], "")
if resp is None:
return api.types.status.FAILURE
if resp.api_response.api_status != types_pb2.API_STATUS_OK:
api.Logger.error("Failed to copy Drivers to Node: %s" % node)
return api.types.status.FAILURE
resp = api.CopyToNaples(node, [fullpath], "", naples_dir="/data/")
if resp is None:
return api.types.status.FAILURE
if resp.api_response.api_status != types_pb2.API_STATUS_OK:
api.Logger.error("Failed to copy Drivers to Node: %s" % node)
return api.types.status.FAILURE
req = api.Trigger_CreateExecuteCommandsRequest()
api.Trigger_AddNaplesCommand(
req,
node,
"LD_LIBRARY_PATH=/platform/lib:/nic/lib /update/{} {}".format(
UPGRADE_TEST_APP + ".bin", param),
background=True)
resp = api.Trigger(req)
for cmd_resp in resp.commands:
api.PrintCommandResults(cmd_resp)
if cmd_resp.exit_code != 0:
api.Logger.error("Creating core failed {}".format(
cmd_resp.command))
return api.types.status.FAILURE
return api.types.status.SUCCESS
def Setup(tc):
# parse iterator args
# parse_args(tc)
# skip some iterator cases
if skip_curr_test(tc):
return api.types.status.SUCCESS
# node init
tc.tester_node = None
tc.tester_node_name = None
tc.dut_node = None
# init response list
tc.resp = []
workloads = api.GetWorkloads()
if len(workloads) == 0:
api.Logger.error('No workloads available')
return api.types.status.FAILURE
# initialize tester-node and dut-node.
tc.nodes = api.GetNodes()
for node in tc.nodes:
if api.GetNicType(node.Name()) == 'intel':
tc.tester_node = node
tc.tester_node_name = node.Name()
tc.tester_node_mgmt_ip = api.GetMgmtIPAddress(node.Name())
api.Logger.info('tester node: %s mgmt IP: %s' %
(node.Name(), tc.tester_node_mgmt_ip))
else:
tc.dut_node = node
tc.dut_node_mgmt_ip = api.GetMgmtIPAddress(node.Name())
api.Logger.info('dut node: %s mgmt IP: %s' %
(node.Name(), tc.dut_node_mgmt_ip))
# create tar.gz file of dpdk and dpdk-test
sdk_fullpath = api.GetTopDir() + SDK_SRC_PATH
dpdk_tar_path = api.GetTopDir() + DPDK_TAR_FILE
tar = tarfile.open(dpdk_tar_path, "w:gz")
os.chdir(sdk_fullpath)
tar.add("dpdk")
os.chdir("dpdk-test")
for name in os.listdir("."):
tar.add(name)
tar.close()
api.Logger.info("dpdk-test tarfile location is: " + dpdk_tar_path)
api.Logger.info("Configuring DTS on " + tc.tester_node_mgmt_ip)
# copy dpdk-test.tar.gz to tester node.
api.CopyToHost(tc.tester_node.Name(), [dpdk_tar_path], "")
# untar dpdk-test.tar.gz and configure tester to run DTS
req = api.Trigger_CreateExecuteCommandsRequest()
trig_cmd1 = "tar -xzvf dpdk-test.tar.gz"
trig_cmd2 = "scripts/config_tester.sh %s %s" % (tc.dut_node_mgmt_ip,
tc.tester_node_mgmt_ip)
api.Trigger_AddHostCommand(req,
tc.tester_node.Name(),
trig_cmd1,
timeout=60)
api.Trigger_AddHostCommand(req,
tc.tester_node.Name(),
trig_cmd2,
timeout=60)
trig_resp = api.Trigger(req)
tc.resp.append(trig_resp)
# disable internal mnic
cmd = "ifconfig inb_mnic0 down && ifconfig inb_mnic1 down"
resp = api.RunNaplesConsoleCmd(tc.dut_node.Name(), cmd)
return api.types.status.SUCCESS
def Setup(tc):
tc.bitw_node_name = api.GetTestsuiteAttr("bitw_node_name")
tc.intfs = api.GetTestsuiteAttr("inb_mnic_intfs")
tc.nodes = api.GetNaplesHostnames()
# copy device.json to naples
device_json_fname = api.GetTopDir() + '/nic/conf/athena/device.json'
api.CopyToNaples(tc.bitw_node_name, [device_json_fname], "")
# copy plugctl.sh to host
plugctl_fname = api.GetTopDir(
) + '/iota/test/athena/testcases/networking/scripts/plugctl.sh'
api.CopyToHost(tc.bitw_node_name, [plugctl_fname], "")
# get the IP address of int_mnic and store it
req = api.Trigger_CreateExecuteCommandsRequest(serial=True)
tc.int_mnic_ip = None
cmd = "ifconfig int_mnic0 | grep inet | cut -d ':' -f 2 | cut -d ' ' -f 1"
api.Trigger_AddNaplesCommand(req, tc.bitw_node_name, cmd)
resp = api.Trigger(req)
cmd = resp.commands[0]
api.PrintCommandResults(cmd)
if cmd.exit_code != 0:
api.Logger.error("Failed to get int_mnic0 IP on node %s" % \
tc.bitw_node_name)
return api.types.status.FAILURE
else:
tc.int_mnic_ip = str(cmd.stdout)
# delete pensando_pre_init.sh
req = api.Trigger_CreateExecuteCommandsRequest(serial=True)
cmd = "cd /sysconfig/config0 && touch pensando_pre_init.sh && rm pensando_pre_init.sh"
api.Trigger_AddNaplesCommand(req, tc.bitw_node_name, cmd)
# bring down linux interfaces
for intf in tc.intfs:
# unconfigure inb_mnic0 and inb_mnic1
ip_addr = str(ip_address(intf['ip']) + 1)
utils.configureNaplesIntf(req,
tc.bitw_node_name,
intf['name'],
ip_addr,
'24',
vlan=intf['vlan'],
unconfig=True)
resp = api.Trigger(req)
for cmd in resp.commands:
api.PrintCommandResults(cmd)
if cmd.exit_code != 0:
api.Logger.error("Failed to bring down linux interfaces on node %s" % \
tc.bitw_node_name)
return api.types.status.FAILURE
# unconfigure int_mnic0
cmd = "ifconfig int_mnic0 down && ip addr del " + tc.int_mnic_ip
resp = api.RunNaplesConsoleCmd(tc.nodes[0], cmd)
# unload drivers
cmd = "rmmod mnet && rmmod mnet_uio_pdrv_genirq && rmmod ionic_mnic"
resp = api.RunNaplesConsoleCmd(tc.nodes[0], cmd)
# run plugctl to gracefully bring down the PCI device on host
req = api.Trigger_CreateExecuteCommandsRequest(serial=True)
cmd = "./plugctl.sh out"
api.Trigger_AddHostCommand(req, tc.bitw_node_name, cmd)
resp = api.Trigger(req)
cmd = resp.commands[0]
api.PrintCommandResults(cmd)
if cmd.exit_code != 0:
api.Logger.error("Failed to gracefully bring down the PCI device on host %s" % \
tc.bitw_node_name)
return api.types.status.FAILURE
# kill athena primary app
cmd = "pkill athena_app"
resp = api.RunNaplesConsoleCmd(tc.nodes[0], cmd)
return api.types.status.SUCCESS
def Setup(tc):
# parse iterator args
parse_args(tc)
# setup policy.json obj
tc.plcy_obj = None
# read from policy.json
with open(api.GetTestsuiteAttr("dp_policy_json_path")) as fd:
tc.plcy_obj = json.load(fd)
# get vnic
tc.vnic = utils.get_vnic(tc.plcy_obj, tc.vnic_type, tc.nat, _stateful=True)
# get vnic id
tc.vnic_id = utils.get_vnic_id(tc.plcy_obj,
tc.vnic_type,
tc.nat,
_stateful=True)
api.Logger.info('vnic id: {}'.format(tc.vnic_id))
# get node info
tc.bitw_node_name = api.GetTestsuiteAttr("bitw_node_name")
tc.wl_node_name = api.GetTestsuiteAttr("wl_node_name")
tc.wl_node = api.GetTestsuiteAttr("wl_node")
tc.nodes = api.GetNodes()
host_intfs = api.GetNaplesHostInterfaces(tc.wl_node_name)
# Assuming single nic per host
if len(host_intfs) != 2:
api.Logger.error('Failed to get host interfaces')
return api.types.status.FAILURE
tc.up0_intf = host_intfs[0]
tc.up1_intf = host_intfs[1]
# get uplink vlans
tc.up0_vlan = tc.vnic['rewrite_underlay']['vlan_id']
tc.up1_vlan = tc.vnic['vlan_id']
# get uplink mac
tc.up0_mac = tc.vnic['rewrite_underlay']['dmac']
tc.up1_mac = tc.vnic['session']['to_switch']['host_mac']
if not tc.up0_mac or not tc.up1_mac:
api.Logger.error('Failed to get workload sub-intf mac addresses')
return api.types.status.FAILURE
if not tc.up0_vlan or not tc.up1_vlan:
api.Logger.error('Failed to get workload sub-intf vlan value')
return api.types.status.FAILURE
api.Logger.info('Workload0: up0_intf %s up0_vlan %s up0_mac %s' %
(tc.up0_intf, tc.up0_vlan, tc.up0_mac))
api.Logger.info('Workload1: up1_intf %s up1_vlan %s up1_mac %s' %
(tc.up1_intf, tc.up1_vlan, tc.up1_mac))
# fetch flows needed for the test
tc.flows = get_flows(tc)
# copy send/recv scripts to node
send_pkt_script_fname = api.GetTestsuiteAttr("send_pkt_path")
recv_pkt_script_fname = api.GetTestsuiteAttr("recv_pkt_path")
for node in tc.nodes:
if node is tc.wl_node:
api.CopyToHost(node.Name(), [send_pkt_script_fname], "")
api.CopyToHost(node.Name(), [recv_pkt_script_fname], "")
# init response list
tc.resp = []
return api.types.status.SUCCESS
def setup_pkt(self):
types = []
dicts = []
logging.debug("encap: {}, dir: {}, Rx: {}".format(
self.encap, self.dir_, self.Rx))
if self.vnic is not None:
# encap info
encap_info = self.vnic['rewrite_underlay']
# only applicable to L3 vnics
if "vnic_type" not in self.vnic:
# rewrite host info
rewrite_host_info = self.vnic['rewrite_host']
if self.encap:
if not encap_info:
raise Exception('vnic config not found encap vlan %s' %
self.vlan)
if self.dir_ == 's2h':
outer_smac = self.smac
outer_dmac = self.dmac
if encap_info['type'] == 'mplsoudp':
if self.dir_ == 'h2s':
outer_smac = encap_info['smac']
outer_dmac = encap_info['dmac']
outer_sip = encap_info['ipv4_sip']
outer_dip = encap_info['ipv4_dip']
mpls_lbl1 = encap_info['mpls_label1']
mpls_lbl2 = encap_info['mpls_label2']
elif encap_info['type'] == 'geneve':
if self.dir_ == 'h2s':
outer_smac = encap_info['smac']
outer_dmac = encap_info['dmac']
outer_sip = encap_info['ipv4_sip']
outer_dip = encap_info['ipv4_dip']
vni = encap_info['vni']
if self.dir_ == 'h2s':
dst_slot_id = encap_info['dst_slot_id']
src_slot_id = self.vnic['slot_id']
elif self.dir_ == 's2h':
src_slot_id = encap_info['dst_slot_id']
dst_slot_id = self.vnic['slot_id']
else:
raise Exception('encap type %s not supported currently' %
encap_info['type'])
types.append("Ether")
ether = {'smac': outer_smac, 'dmac': outer_dmac}
dicts.append(ether)
types.append("Dot1Q")
dot1q = {'vlan': self.vlan}
dicts.append(dot1q)
# append outer IP
types.append("IP")
ttl_ = 255 if encap_info['type'] == 'mplsoudp' else 32
ip = {'sip': outer_sip, 'dip': outer_dip, 'flags': 2, 'ttl': ttl_}
dicts.append(ip)
# append outer UDP
types.append("UDP") # outer is always UDP
dst_port = '6635' if encap_info['type'] == 'mplsoudp' else '6081'
proto = {'sport': '0', 'dport': dst_port}
dicts.append(proto)
if encap_info['type'] == 'mplsoudp':
# append MPLS label 1
types.append("MPLS")
mpls = {'label': mpls_lbl1, 's': 0}
dicts.append(mpls)
# append MPLS label 2
types.append("MPLS")
mpls = {'label': mpls_lbl2, 's': 1}
dicts.append(mpls)
elif encap_info['type'] == 'geneve':
# append GENEVE options
types.append("GENEVE")
# some of these fields are hard-coded for now
option1 = (0x107 <<
(6 * 8)) | (0x21 <<
(5 * 8)) | (0x1 <<
(4 * 8)) | int(src_slot_id)
option2 = (0x107 <<
(6 * 8)) | (0x22 <<
(5 * 8)) | (0x1 <<
(4 * 8)) | int(dst_slot_id)
options = (option1 << (8 * 8)) | option2
geneve = {
'vni': vni,
'options': options.to_bytes(16, byteorder="big")
}
dicts.append(geneve)
types.append("Ether")
if self.dir_ == 'h2s':
ether = {'smac': self.smac, 'dmac': self.dmac}
elif self.dir_ == 's2h':
ether = {'smac': self.smac, 'dmac': self.dmac}
dicts.append(ether)
else:
types.append("Ether")
if self.dir_ == 'h2s':
ether = {'smac': self.smac, 'dmac': self.dmac}
elif self.dir_ == 's2h':
if utils.is_L2_vnic(self.vnic):
ether = {'smac': self.smac, 'dmac': self.dmac}
else:
if not rewrite_host_info:
raise Exception('vnic config not found encap vlan %s' %
self.vlan)
smac = rewrite_host_info['smac']
dmac = rewrite_host_info['dmac']
ether = {'smac': smac, 'dmac': dmac}
dicts.append(ether)
types.append("Dot1Q")
dot1q = {'vlan': self.vlan}
dicts.append(dot1q)
types.append("IP")
ip = {'sip': self.sip, 'dip': self.dip}
if self.nat == 'yes':
nat_sip, nat_dip = self.get_nat_flow_sip_dip(
self.dir_, self.Rx, self.proto, self.flow_id)
ip = {'sip': nat_sip, 'dip': nat_dip}
dicts.append(ip)
types.append(self.proto)
if self.proto == 'UDP' or self.proto == 'TCP':
if self.flags is not None:
dicts.append({
'sport': self.sport,
'dport': self.dport,
'flags': self.flags
})
else:
dicts.append({'sport': self.sport, 'dport': self.dport})
else: # ICMP
dicts.append({
'icmp_type': self.icmp_type,
'icmp_code': self.icmp_code
})
api.Logger.debug(dicts)
pkt = craft_pkt(types, dicts)
pkt = pkt / get_payload(self.pyld_size)
#logging.debug("Crafted pkt: {}".format(pkt.show()))
if self.dir_ == 'h2s':
fname = DEFAULT_H2S_RECV_PKT_FILENAME if self.Rx == True else DEFAULT_H2S_GEN_PKT_FILENAME
elif self.dir_ == 's2h':
fname = DEFAULT_S2H_RECV_PKT_FILENAME if self.Rx == True else DEFAULT_S2H_GEN_PKT_FILENAME
with open(CURR_DIR + '/' + fname, 'w+') as fd:
logging.debug('Writing crafted pkt to pcap file %s' % fd.name)
wrpcap(fd.name, pkt)
pcap_fname = fd.name
# copy the pcap file to the host
api.CopyToHost(self.node.Name(), [pcap_fname], "")
os.remove(pcap_fname)