def SanityNICCheck(self, request, context):
"""
Check either NIC PCI ids are Correctly placed or not
"""
if self.tgen_check != 0:
return vsperf_pb2.StatusReply(message="TGen-Host is not Connected [!]" \
"\nMake sure to establish connection with" \
" TGen-Host.")
trex_conf_path = "cat /etc/trex_cfg.yaml | grep interfaces"
trex_conf_read = self.tgen_client.execute(trex_conf_path)[1]
nic_pid_ids_list = [
trex_conf_read.split("\"")[1],
trex_conf_read.split("\"")[3]
]
trex_nic_pic_id_cmd = "lspci | egrep -i --color 'network|ethernet'"
trex_nic_pic_id = str(
self.tgen_client.execute(trex_nic_pic_id_cmd)[1]).split('\n')
acheck = 0
for k in trex_nic_pic_id:
for j in nic_pid_ids_list:
if j in k:
acheck += 1
else:
pass
if acheck == 2:
self.sanity_check_done_list.append(int(3))
return vsperf_pb2.StatusReply(message="Both the NIC PCI Ids are Correctly "\
"configured on TGen-Host..............")
return vsperf_pb2.StatusReply(message="You configured NIC PCI Ids Wrong in "\
"TGen-Host............................[OK]\n")
def VsperfInstall(self, request, context):
"""
Handle VSPERF install command from client
"""
# print("Installing VSPERF")
if self.dut_check != 0:
return vsperf_pb2.StatusReply(message="DUT-Host is not Connected [!]" \
"\nMake sure to establish connection with" \
" DUT-Host.")
vsperf_check_cmd = "source ~/vsperfenv/bin/activate ; cd vswitchperf* && ./vsperf --help"
vsperf_check_cmd_result = str(self.client.execute(vsperf_check_cmd)[1])
vsperf_verify_list = [
'usage',
'positional arguments',
'optional arguments',
'test selection options',
'test behavior options']
for idx, i in enumerate(vsperf_verify_list, start=1):
if str(i) in vsperf_check_cmd_result:
if idx < 5:
continue
elif idx == 5:
return vsperf_pb2.StatusReply(
message="VSPERF is Already Installed on DUT-Host")
self.install_vsperf()
return vsperf_pb2.StatusReply(message="VSPERF Successfully Installed DUT-Host")
def SanityVSPERFCheck(self, request, context):
"""
We have to make sure that VSPERF install correctly
"""
if self.dut_check != 0:
return vsperf_pb2.StatusReply(message="DUT-Host is not Connected [!]" \
"\nMake sure to establish connection with" \
" DUT-Host.")
vsperf_check_command = "source ~/vsperfenv/bin/activate ; cd vswitchperf* && "
vsperf_check_command += "./vsperf --help"
vsperf_check_cmd_result = str(
self.client.execute(vsperf_check_command)[1])
vsperf_verify_list = [
'usage', 'positional arguments', 'optional arguments',
'test selection options', 'test behavior options'
]
for idx, i in enumerate(vsperf_verify_list, start=1):
if str(i) in vsperf_check_cmd_result:
if idx < 5:
continue
elif idx == 5:
self.sanity_check_done_list.append(int(1))
return vsperf_pb2.StatusReply(
message="VSPERF Installed Correctly and Working fine")
return vsperf_pb2.StatusReply(message="VSPERF Does Not Installed Correctly ," \
"INSTALL IT AGAIN..............[Critical]")
return vsperf_pb2.StatusReply(message="VSPERF Does Not Installed Correctly ," \
"INSTALL IT AGAIN..............[Critical]")
def SanityVNFpath(self, request, context):
"""
Check if VNF image available on the mention path in Test Config File
"""
# fetch the VNF path we placed in vsperf.conf file
if self.dut_check != 0:
return vsperf_pb2.StatusReply(message="DUT-Host is not Connected [!]" \
"\nMake sure to establish connection with" \
" DUT-Host.")
if self.test_upload_check == 0:
return vsperf_pb2.StatusReply(message="Test File is not uploaded yet [!] " \
"\nUpload Test Configuration File.")
vsperf_conf_path = 'cat ~/{} | grep "GUEST_IMAGE"'.format(
self.conffile)
vsperf_conf_read = self.client.execute(vsperf_conf_path)[1]
vnf_image_path = vsperf_conf_read.split("'")[1]
vnf_path_check_cmd = "find {}".format(vnf_image_path)
vfn_path_check_result = str(self.client.execute(vnf_path_check_cmd)[1])
if vnf_image_path in vfn_path_check_result:
self.sanity_check_done_list.append(int(2))
return vsperf_pb2.StatusReply(message="Test Configratuion file has Correct "\
"VNF path information on DUT-Host.....[OK]")
return vsperf_pb2.StatusReply(message='Test Configuration file has wrongly placed VNF '\
'path information \n'\
'VNF is not available on DUT-Host................................[Failed]\n ')
def SanityCollectdCheck(self, request, context):
"""
Check and verify collectd is able to run and start properly
"""
if self.dut_check != 0:
return vsperf_pb2.StatusReply(message="DUT-Host is not Connected [!]" \
"\nMake sure to establish connection with" \
" DUT-Host.")
check_collectd_cmd = "find /opt -maxdepth 1 -name 'collectd'"
check_test_result = str(self.client.execute(check_collectd_cmd)[1])
if "collectd" in check_test_result:
check_collectd_run_cmd = "echo {} | sudo -S service collectd start".format(
self.pwd)
self.client.run(check_collectd_run_cmd, pty=True)
check_collectd_status_cmd = "ps aux | grep collectd"
check_collectd_status = str(
self.client.execute(check_collectd_status_cmd)[1])
if "/sbin/collectd" in check_collectd_status:
self.sanity_check_done_list.append(int(5))
return vsperf_pb2.StatusReply(
message="Collectd is working Fine")
return vsperf_pb2.StatusReply(message="Collectd Fail to Start, \
Install correctly before running Test"
)
return vsperf_pb2.StatusReply(message="Collectd is not installed yet.")
def RemoveVsperf(self, request, context):
"""
Handle VSPERF removal command from client
"""
if self.dut_check != 0:
return vsperf_pb2.StatusReply(message="DUT-Host is not Connected [!]" \
"\nMake sure to establish connection with" \
" DUT-Host.")
self.vsperf_remove()
return vsperf_pb2.StatusReply(message="Successfully VSPERF Removed")
def CollectdInstall(self, request, context):
"""
Install Collectd on DUT
"""
if self.dut_check != 0:
return vsperf_pb2.StatusReply(message="DUT-Host is not Connected [!]" \
"\nMake sure to establish connection with" \
" DUT-Host.")
self.install_collectd()
return vsperf_pb2.StatusReply(
message="Collectd Successfully Installed on DUT-Host")
def RemoveCollectd(self, request, context):
"""
Handle collectd removal command from client
"""
if self.dut_check != 0:
return vsperf_pb2.StatusReply(message="DUT-Host is not Connected [!]" \
"\nMake sure to establish connection with" \
" DUT-Host.")
self.collectd_remove()
return vsperf_pb2.StatusReply(
message="Successfully Collectd Removed From DUT-Host")
def cpu_allocation_check(self, list1, list2):
"""compare to cpu_map list"""
if len(list1) >= len(list2):
if all(elem in list1 for elem in list2):
self.sanity_check_done_list.append(int(4))
return vsperf_pb2.StatusReply(message="CPU allocation properly done on" \
" DUT-Host.................[OK]")
return vsperf_pb2.StatusReply(message="CPU allocation not done properly on " \
"DUT-Host............[Failed]")
return vsperf_pb2.StatusReply(message="CPU allocation not done properly on" \
" DUT-Host............[Failed]")
def StartBeats(self, request, context):
"""
Start fileBeats on DUT
"""
if self.dut_check != 0:
return vsperf_pb2.StatusReply(message="DUT-Host is not Connected [!]" \
"\nMake sure to establish connection with" \
" DUT-Host.")
run_cmd = "echo '{}' | sudo -S service filebeat start".format(self.pwd)
#run_cmd = "sudo service filebeat start"
self.client.run(run_cmd, pty=True)
return vsperf_pb2.StatusReply(message="Beats are started on DUT-Host")
def GetVSPERFConffromDUT(self, request, context):
"""
This will extract the vsperf test configuration from DUT-Host
"""
if self.dut_check != 0:
return vsperf_pb2.StatusReply(message="DUT-Host is not Connected [!]" \
"\nMake sure to establish connection with" \
" DUT-Host.")
if self.test_upload_check == 0:
return vsperf_pb2.StatusReply(message="Test File is not uploaded yet [!] " \
"\nUpload Test Configuration File.")
read_cmd = "cat ~/{}".format(self.conffile)
read_cmd_output = str(self.client.execute(read_cmd)[1])
return vsperf_pb2.StatusReply(message="{}".format(read_cmd_output))
def StartTGen(self, request, context):
"""
Handle start-Tgen command from client
"""
if self.tgen_check != 0:
return vsperf_pb2.StatusReply(message="TGen-Host is not Connected [!]" \
"\nMake sure to establish connection with" \
" TGen-Host.")
self.trex_params = request.params
run_cmd = "cd trex_2.37/scripts ; "
run_cmd += "./t-rex-64 "
run_cmd += self.trex_params
self.tgen_client.send_command(run_cmd)
self.tgen_start_check = 1
return vsperf_pb2.StatusReply(message="T-Rex Successfully running...")
def TestStatus(self, request, context):
"""
Chechk for the test status after performing test
"""
if self.dut_check != 0:
return vsperf_pb2.StatusReply(message="DUT-Host is not Connected [!]" \
"\nMake sure to establish connection with" \
" DUT-Host.")
if self.tests_run_check != 1:
return vsperf_pb2.StatusReply(message="No test have ran yet. [!]")
testtype_list = request.testtype.split(",")
test_success = []
test_failed = []
testtype_list_len = len(testtype_list)
for test in testtype_list:
#latest_result_cmd = "find /tmp -mindepth 1 -type d -cmin -5 -printf '%f'"
test_result_dir = str((self.client.\
execute("find /tmp -mindepth 1 -type d -cmin -5 -printf '%f'")[1]).\
split('find')[0])
#test_date_cmd = "date +%F"
test_date = str(self.client.execute("date +%F")[1]).replace(
"\n", "")
if test_date in test_result_dir:
testcase_check_cmd = "cd /tmp && cd `ls -t | grep results | head -{} | tail -1`".\
format(testtype_list_len)
testcase_check_cmd += " && find . -maxdepth 1 -name '*{}*'".\
format(test)
testcase_check_output = str(self.client.execute(testcase_check_cmd)[1]).\
split('\n', 2)
check = 0
for i in testcase_check_output:
if (".csv" in i) or (".md" in i) or (".rst" in i):
check += 1
if check == 3:
test_success.append(test)
else:
test_failed.append(test)
testtype_list_len -= 1
if len(testtype_list) == len(test_success):
return vsperf_pb2.StatusReply(message="All Test Successfully Completed on DUT-Host" \
"\nResults... [OK]")
if not test_success:
return vsperf_pb2.StatusReply(
message="All Test Failed on DUT-Host \nResults... [Failed]")
return vsperf_pb2.StatusReply(message="Only {} Test failed Results ... [Failed]\n"\
"All other Test Successfully Completed on DUT-Host Results... [OK] ".\
format(test_failed))
def DUTvsperfTestAvailability(self, request, context):
"""
Before running test we have to make sure there is no other test running
"""
if self.dut_check != 0:
return vsperf_pb2.StatusReply(message="DUT-Host is not Connected [!]" \
"\nMake sure to establish connection with" \
" DUT-Host.")
vsperf_ava_cmd = "ps -ef | grep -v grep | grep ./vsperf | awk '{print $2}'"
vsperf_ava_result = len(
(self.client.execute(vsperf_ava_cmd)[1]).split("\n"))
if vsperf_ava_result == 1:
return vsperf_pb2.StatusReply(message="DUT-Host is available for performing" \
" VSPERF Test\nYou can perform Test!")
return vsperf_pb2.StatusReply(
message="DUT-Host is busy right now, Wait for some time\n\
Always Check availability before Running Test!")
def RemoveUploadedConfig(self, request, context):
"""
Handle all configuration file removal command from client
"""
if self.dut_check != 0:
return vsperf_pb2.StatusReply(message="DUT-Host is not Connected [!]" \
"\nMake sure to establish connection with" \
" DUT-Host.")
if self.tgen_check != 0:
return vsperf_pb2.StatusReply(message="TGen-Host is not Connected [!]" \
"\nMake sure to establish connection with" \
" TGen-Host.")
if self.test_upload_check == 0:
return vsperf_pb2.StatusReply(message="Test File is not uploaded yet [!] " \
"\nUpload Test Configuration File.")
self.remove_uploaded_config()
return vsperf_pb2.StatusReply(
message="Successfully All Uploaded Config Files Removed")
def RemoveEverything(self, request, context):
"""
Handle of removing everything from DUT command from client
"""
if self.dut_check != 0:
return vsperf_pb2.StatusReply(message="DUT-Host is not Connected [!]" \
"\nMake sure to establish connection with" \
" DUT-Host.")
if self.tgen_check != 0:
return vsperf_pb2.StatusReply(message="TGen-Host is not Connected [!]" \
"\nMake sure to establish connection with" \
" TGen-Host.")
self.vsperf_remove()
self.result_folder_remove()
self.remove_uploaded_config()
self.collectd_remove()
return vsperf_pb2.StatusReply(
message="Successfully Everything Removed From DUT-Host")
def SanityCPUAllocationCheck(self, request, context):
"""
check for cpu-allocation on DUT-Host
"""
if self.dut_check != 0:
return vsperf_pb2.StatusReply(message="DUT-Host is not Connected [!]" \
"\nMake sure to establish connection with" \
" DUT-Host.")
if self.test_upload_check == 0:
return vsperf_pb2.StatusReply(message="Test File is not uploaded yet [!] " \
"\nUpload Test Configuration File.")
read_setting_cmd = "source vsperfenv/bin/activate ; cd vswitchperf* && "
read_setting_cmd += './vsperf --list-settings'
default_vsperf_settings = ast.literal_eval(
str(self.client.execute(read_setting_cmd)[1]))
default_cpu_map = default_vsperf_settings["VSWITCH_VHOST_CPU_MAP"]
default_vswitch_pmd_cpu_mask = str(
default_vsperf_settings["VSWITCH_PMD_CPU_MASK"])
default_vswitch_vhost_cpu_map = [str(x) for x in default_cpu_map]
vswitch_pmd_cpu_mask = self.variable_from_test_config(
"VSWITCH_PMD_CPU_MASK")
vswitch_cpu_map = (
self.variable_from_test_config("VSWITCH_VHOST_CPU_MAP"))
vswitch_vhost_cpu_map = 0
if vswitch_cpu_map != 0:
vswitch_vhost_cpu_map = [
str(x) for x in ast.literal_eval(vswitch_cpu_map)
]
if vswitch_pmd_cpu_mask == 0 and vswitch_vhost_cpu_map == 0:
self.sanity_check_done_list.append(int(4))
return vsperf_pb2.StatusReply(message="CPU allocation Check Done,"\
"\nNo vswitch_pmd_cpu_mask or vswitch_vhost_cpu_map assign in test " \
"configuration file.\nUsing Default Settings..[OK]\n")
if vswitch_pmd_cpu_mask != 0 and vswitch_vhost_cpu_map == 0:
core_id = self.cpumask2coreids(vswitch_pmd_cpu_mask)
return self.cpu_allocation_check(default_vswitch_vhost_cpu_map,
core_id)
if vswitch_pmd_cpu_mask == 0 and vswitch_vhost_cpu_map != 0:
core_id_1 = self.cpumask2coreids(default_vswitch_pmd_cpu_mask)
return self.cpu_allocation_check(vswitch_vhost_cpu_map, core_id_1)
core_id_2 = self.cpumask2coreids(vswitch_pmd_cpu_mask)
return self.cpu_allocation_check(vswitch_vhost_cpu_map, core_id_2)
def TerminateVsperf(self, request, context):
"""
Terminate the VSPERF and kill processes
"""
if self.dut_check != 0:
return vsperf_pb2.StatusReply(message="DUT-Host is not Connected [!]" \
"\nMake sure to establish connection with" \
" DUT-Host.")
stress_kill_cmd = "pkill stress"
python3_kill_cmd = "pkill python3"
qemu_kill_cmd = "killall -9 qemu-system-x86_64"
self.client.send_command(stress_kill_cmd)
self.client.send_command(python3_kill_cmd)
self.client.send_command(qemu_kill_cmd)
# sometimes qemu resists to terminate, so wait a bit and kill it again
qemu_check_cmd = "pgrep qemu-system-x86_64"
qemu_cmd_response = self.client.execute(qemu_check_cmd)[1]
if qemu_cmd_response != '':
time.sleep(5)
self.client.send_command(qemu_kill_cmds)
time.sleep(5)
ovs_kill_cmd = "pkill ovs-vswitchd"
ovsdb_kill_cmd = "pkill ovsdb-server"
vppctl_kill_cmd = "pkill vppctl"
vpp_kill_cmd = "pkill vpp"
vpp_cmd = "pkill -9".format(self.pwd)
self.client.send_command(ovs_kill_cmd)
time.sleep(1)
self.client.send_command(ovsdb_kill_cmd)
time.sleep(1)
self.client.send_command(vppctl_kill_cmd)
time.sleep(1)
self.client.send_command(vpp_kill_cmd)
time.sleep(1)
self.client.send_command(vpp_cmd)
time.sleep(1)
return vsperf_pb2.StatusReply(
message="All the VSPERF related process terminated successfully")
def TGenHostConnect(self, request, context):
"""
Connect to TGen-Node
"""
self.tgen = request.ip
self.tgen_user = request.uname
self.tgenpwd = request.pwd
self.tgen_setup()
check_tgen_cmd = "ls"
self.tgen_check = int(self.tgen_client.execute(check_tgen_cmd)[0])
return vsperf_pb2.StatusReply(message="Successfully Connected")
def HostConnect(self, request, context):
"""
Handle host connectivity command from client
"""
self.dut = request.ip
self.user = request.uname
self.pwd = request.pwd
self.setup()
check_cmd = "ls -l"
self.dut_check = int(self.client.execute(check_cmd)[0])
return vsperf_pb2.StatusReply(message="Successfully Connected")
def CheckDependecies(self, request, context):
"""
Check and Install required packages on DUT
"""
if self.dut_check != 0:
return vsperf_pb2.StatusReply(message="DUT-Host is not Connected [!]" \
"\nMake sure to establish connection with" \
" DUT-Host.")
packages = ['python34-tkinter', 'sysstat', 'bc']
for pkg in packages:
# pkg_check_cmd = "dpkg -s {}".format(pkg) for ubuntu
pkg_check_cmd = "rpm -q {}".format(pkg)
pkg_cmd_response = self.client.execute(pkg_check_cmd)[0]
if pkg_cmd_response == 1:
install_pkg_cmd = "echo '{}' | sudo -S yum install -y {}".format(
self.pwd, pkg)
#install_pkg_cmd = "echo '{}' | sudo -S apt-get install -y {}".format(self.pwd,pkg)
self.client.run(install_pkg_cmd, pty=True)
return vsperf_pb2.StatusReply(message="Python34-tkinter, sysstat and bc Packages"\
"are now Installed")
def StartTest(self, request, context):
"""
Handle start-test command from client
"""
if self.dut_check != 0:
return vsperf_pb2.StatusReply(message="DUT-Host is not Connected [!]" \
"\nMake sure to establish connection with" \
" DUT-Host.")
sanity_dict = {
1: "Check installed VSPERF",
2: "Check Test Config's VNF path is available on DUT-Host",
3: "Check NIC PCIs is available on Traffic Generator",
4: "Check CPU allocation on DUT-Host",
5: "Check installed Collectd",
6: "Check Connection between DUT-Host and Traffic Generator Host"
}
sanity_dict_option_list = list(sanity_dict.keys())
remaining_sanity = [item for item in sanity_dict_option_list if item not in \
self.sanity_check_done_list]
if remaining_sanity:
sanity_return_msg = ""
for i_sanity in remaining_sanity:
sanity_return_msg += sanity_dict[i_sanity] + "\n"
return vsperf_pb2.StatusReply(message="The following sanity checks are either not"\
" performed yet or Does not satisfy test requirements" \
"\n{}".format(sanity_return_msg))
if self.test_upload_check == 0:
return vsperf_pb2.StatusReply(message="Test File is not uploaded yet [!] " \
"\nUpload Test Configuration File.")
if self.tgen_start_check != 1:
return vsperf_pb2.StatusReply(
message="Traffic Generator has not started yet [!]")
self.vsperf_conf = request.conffile
self.testtype = request.testtype
testtype_list = self.testtype.split(",")
self.tests_run_check = 1
for test in testtype_list:
self.scenario = test
self.run_test()
return vsperf_pb2.StatusReply(message="Test Successfully Completed")
def CollectdUploadConfig(self, request, context):
"""
Upload collectd config-file on DUT
"""
if self.dut_check != 0:
return vsperf_pb2.StatusReply(message="DUT-Host is not Connected [!]" \
"\nMake sure to establish connection with" \
" DUT-Host.")
filename = self.collectd_conffile
self.save_chunks_to_file(request, filename)
self.upload_collectd_config()
return vsperf_pb2.UploadStatus(
Message="Successfully Collectd Configuration Uploaded", Code=1)
def DutHugepageConfig(self, request, context):
"""
Configure the DUT system hugepage parameter from client
"""
if self.dut_check != 0:
return vsperf_pb2.StatusReply(message="DUT-Host is not Connected [!]" \
"\nMake sure to establish connection with" \
" DUT-Host.")
self.hpmax = int(request.hpmax)
self.hprequested = int(request.hprequested)
hugepage_cmd = "echo '{}' | sudo -S mkdir -p /mnt/huge ; ".format(
self.pwd)
hugepage_cmd += "echo '{}' | sudo -S mount -t hugetlbfs nodev /mnt/huge".format(
self.pwd)
self.client.run(hugepage_cmd, pty=True)
hp_nr_cmd = "cat /sys/devices/system/node/node0/hugepages/hugepages-2048kB/nr_hugepages"
hp_free_cmd = "cat /sys/devices/system/node/node0/hugepages/hugepages-2048kB/free_hugepages"
hp_nr = int(self.client.execute(hp_nr_cmd)[1])
hp_free = int(self.client.execute(hp_free_cmd)[1])
if hp_free <= self.hprequested:
hp_nr_new = hp_nr + (self.hprequested - hp_free)
if hp_nr_new > self.hpmax:
hp_nr_new = self.hpmax
nr_hugepage_cmd = "echo '{}' | sudo -S bash -c \"echo 'vm.nr_hugepages={}' >>".\
format(self.pwd, hp_nr_new)
nr_hugepage_cmd += " /etc/sysctl.conf\""
self.client.run(nr_hugepage_cmd, pty=True)
dict_cmd = "cat /sys/devices/system/node/node1/hugepages/hugepages-2048kB/nr_hugepages"
dict_check = int(self.client.execute(dict_cmd)[0])
if dict_check == 0:
node1_hugepage_cmd = "echo '{}' | sudo -s bash -c \"echo 0 >".format(self.pwd)
node1_hugepage_cmd += " /sys/devices/system/node/node1/"
node1_hugepage_cmd += "hugepages/hugepages-2048kB/nr_hugepages\""
return vsperf_pb2.StatusReply(
message="DUT-Host system configured with {} No of Hugepages".format(hp_nr_new))
def SanityTgenConnDUTCheck(self, request, context):
"""
We should confirm the DUT connectivity with the Tgen and Traffic Generator is working or not
"""
if self.dut_check != 0:
return vsperf_pb2.StatusReply(message="DUT-Host is not Connected [!]" \
"\nMake sure to establish connection with" \
" DUT-Host.")
self.tgen_ip_address = request.ip
tgen_connectivity_check_cmd = "ping {} -c 1".format(
self.tgen_ip_address)
tgen_connectivity_check_result = int(
self.client.execute(tgen_connectivity_check_cmd)[0])
if tgen_connectivity_check_result == 0:
self.sanity_check_done_list.append(int(6))
return vsperf_pb2.StatusReply(
message=
"DUT-Host is successfully reachable to Traffic Generator......"
)
return vsperf_pb2.StatusReply(
message="DUT-Host is unsuccessful to reach the \
Traffic Generator \nMake sure to establish connection \
between DUT-Host and TGen-Host before running Test\
............... ")
def TGenInstall(self, request, context):
"""
Install Traffic generator on the node.
"""
if self.tgen_check != 0:
return vsperf_pb2.StatusReply(message="TGen-Host is not Connected [!]" \
"\nMake sure to establish connection with" \
" TGen-Host.")
kill_cmd = "pkill -f t-rex"
self.tgen_client.send_command(kill_cmd)
tgen_start_cmd = "cd trex_2.37/scripts && ./t-rex-64 -f cap2/dns.yaml -d 100 -m 1 --nc"
tgen_start_cmd_result = int(self.tgen_client.execute(tgen_start_cmd)[0])
kill_cmd = "pkill -f t-rex"
self.tgen_client.send_command(kill_cmd)
if tgen_start_cmd_result == 0:
return vsperf_pb2.StatusReply(
message="Traffic Generetor has T-rex Installed")
download_cmd = "git clone https://github.com/cisco-system-traffic-generator/trex-core"
self.tgen_client.run(download_cmd)
install_cmd = "cd trex-core/linux_dpdk ; ./b configure ; ./b build"
self.tgen_client.run(install_cmd)
# before you setup your trex_cfg.yml make sure to do sanity check
# NIC PICs and establish route between your DUT and Test Device.
return vsperf_pb2.StatusReply(message="Traffic Generetor has now T-rex Installed")
def TGenUploadConfigFile(self, request, context):
"""
Handle upload config-file command from client
"""
if self.tgen_check != 0:
return vsperf_pb2.StatusReply(message="TGen-Host is not Connected [!]" \
"\nMake sure to establish connection with" \
" TGen-Host.")
filename = self.trex_conffile
self.save_chunks_to_file(request, filename)
check_trex_config_cmd = "echo {} | sudo -S find /etc -maxdepth 1 -name trex_cfg.yaml".\
format(self.tgenpwd)
check_test_result = str(
self.tgen_client.execute(check_trex_config_cmd)[1])
if "trex_cfg.yaml" in check_test_result:
self.tgen_client.run("rm -f /etc/trex_cfg.yaml")
self.upload_tgen_config()
self.tgen_client.run(
"echo {} | sudo -S mv ~/trex_cfg.yaml /etc/".format(self.tgenpwd), pty=True)
return vsperf_pb2.UploadStatus(Message="Successfully Uploaded",
Code=1)
def UploadConfigFile(self, request, context):
"""
Handle upload config-file command from client
"""
if self.dut_check != 0:
return vsperf_pb2.StatusReply(message="DUT-Host is not Connected [!]" \
"\nMake sure to establish connection with" \
" DUT-Host.")
chunks = request.Content
filename = request.Filename
self.conffile = filename
self.save_chunks_to_file(chunks, filename)
# This is chechking if vsperf.conf already exist first remove that and
# then upload the new file.
check_test_config_cmd = "find ~/ -maxdepth 1 -name {}".format(filename)
check_test_result = str(self.client.execute(check_test_config_cmd)[1])
if "{}".format(filename) in check_test_result:
self.client.run("rm -f {}".format(filename))
self.upload_config()
self.test_upload_check = 1
print("Hello")
return vsperf_pb2.UploadStatus(Message="Successfully Uploaded", Code=1)
