class Tester(Crb):
"""
Start the DPDK traffic generator on the machine `target`.
A config file and pcap file must have previously been copied
to this machine.
"""
PORT_INFO_CACHE_KEY = 'tester_port_info'
CORE_LIST_CACHE_KEY = 'tester_core_list'
NUMBER_CORES_CACHE_KEY = 'tester_number_cores'
PCI_DEV_CACHE_KEY = 'tester_pci_dev_info'
def __init__(self, crb, serializer):
self.NAME = 'tester'
super(Tester, self).__init__(crb, serializer, self.NAME)
self.bgProcIsRunning = False
self.duts = None
self.inBg = 0
self.scapyCmds = []
self.bgCmds = []
self.bgItf = ''
self.re_run_time = 0
def init_ext_gen(self):
"""
Initialize tester packet generator object.
"""
if self.it_uses_external_generator():
self.ixia_packet_gen = IxiaPacketGenerator(self)
self.packet_gen = SoftwarePacketGenerator(self)
def set_re_run(self, re_run_time):
"""
set failed case re-run time
"""
self.re_run_time = int(re_run_time)
def get_ip_address(self):
"""
Get ip address of tester CRB.
"""
return self.crb['tester IP']
def get_username(self):
"""
Get login username of tester CRB.
"""
return USERNAME
def get_password(self):
"""
Get tester login password of tester CRB.
"""
return self.crb['tester pass']
def has_external_traffic_generator(self):
"""
Check whether performance test will base on IXIA equipment.
"""
try:
if self.crb[IXIA] is not None:
return True
except Exception as e:
return False
return False
def get_external_traffic_generator(self):
"""
Return IXIA object.
"""
return self.crb[IXIA]
def it_uses_external_generator(self):
"""
Check whether IXIA generator is ready for performance test.
"""
return load_global_setting(
PERF_SETTING) == 'yes' and self.has_external_traffic_generator()
def tester_prerequisites(self):
"""
Prerequest function should be called before execute any test case.
Will call function to scan all lcore's information which on Tester.
Then call pci scan function to collect nic device information.
Then discovery the network topology and save it into cache file.
At last setup DUT' environment for validation.
"""
self.init_core_list()
self.pci_devices_information()
self.restore_interfaces()
self.scan_ports()
def get_local_port(self, remotePort):
"""
Return tester local port connect to specified dut port.
"""
return self.duts[0].ports_map[remotePort]
def get_local_port_type(self, remotePort):
"""
Return tester local port type connect to specified dut port.
"""
return self.ports_info[self.get_local_port(remotePort)]['type']
def get_local_port_bydut(self, remotePort, dutIp):
"""
Return tester local port connect to specified port and specified dut.
"""
for dut in self.duts:
if dut.crb['My IP'] == dutIp:
return dut.ports_map[remotePort]
def get_local_index(self, pci):
"""
Return tester local port index by pci id
"""
index = -1
for port in self.ports_info:
index += 1
if pci == port['pci']:
return index
return -1
def get_pci(self, localPort):
"""
Return tester local port pci id.
"""
if localPort == -1:
raise ParameterInvalidException("local port should not be -1")
return self.ports_info[localPort]['pci']
def get_interface(self, localPort):
"""
Return tester local port interface name.
"""
if localPort == -1:
raise ParameterInvalidException("local port should not be -1")
if 'intf' not in self.ports_info[localPort]:
return 'N/A'
return self.ports_info[localPort]['intf']
def get_mac(self, localPort):
"""
Return tester local port mac address.
"""
if localPort == -1:
raise ParameterInvalidException("local port should not be -1")
if self.ports_info[localPort]['type'] == 'ixia':
return "00:00:00:00:00:01"
else:
return self.ports_info[localPort]['mac']
def get_port_status(self, port):
"""
Return link status of ethernet.
"""
eth = self.ports_info[port]['intf']
out = self.send_expect("ethtool %s" % eth, "# ")
status = re.search(r"Link detected:\s+(yes|no)", out)
if not status:
self.logger.error("ERROR: unexpected output")
if status.group(1) == 'yes':
return 'up'
else:
return 'down'
def restore_interfaces(self):
"""
Restore Linux interfaces.
"""
if self.skip_setup:
return
self.send_expect("modprobe igb", "# ", 20)
self.send_expect("modprobe ixgbe", "# ", 20)
self.send_expect("modprobe e1000e", "# ", 20)
self.send_expect("modprobe e1000", "# ", 20)
try:
for (pci_bus, pci_id) in self.pci_devices_info:
addr_array = pci_bus.split(':')
port = GetNicObj(self, addr_array[0], addr_array[1],
addr_array[2])
itf = port.get_interface_name()
self.enable_ipv6(itf)
self.send_expect("ifconfig %s up" % itf, "# ")
if port.get_interface2_name():
itf = port.get_interface2_name()
self.enable_ipv6(itf)
self.send_expect("ifconfig %s up" % itf, "# ")
except Exception as e:
self.logger.error(" !!! Restore ITF: " + e.message)
sleep(2)
def set_promisc(self):
try:
for (pci_bus, pci_id) in self.pci_devices_info:
addr_array = pci_bus.split(':')
port = GetNicObj(self, addr_array[0], addr_array[1],
addr_array[2])
itf = port.get_interface_name()
self.enable_promisc(itf)
if port.get_interface2_name():
itf = port.get_interface2_name()
self.enable_promisc(itf)
except Exception as e:
pass
def load_serializer_ports(self):
cached_ports_info = self.serializer.load(self.PORT_INFO_CACHE_KEY)
if cached_ports_info is None:
return
# now not save netdev object, will implemented later
self.ports_info = cached_ports_info
def save_serializer_ports(self):
cached_ports_info = []
for port in self.ports_info:
port_info = {}
for key in port.keys():
if type(port[key]) is str:
port_info[key] = port[key]
# need save netdev objects
cached_ports_info.append(port_info)
self.serializer.save(self.PORT_INFO_CACHE_KEY, cached_ports_info)
def scan_ports(self):
"""
Scan all ports on tester and save port's pci/mac/interface.
"""
if self.read_cache:
self.load_serializer_ports()
self.scan_ports_cached()
if not self.read_cache or self.ports_info is None:
self.scan_ports_uncached()
if self.it_uses_external_generator():
self.ports_info.extend(self.ixia_packet_gen.get_ports())
self.save_serializer_ports()
for port_info in self.ports_info:
self.logger.info(port_info)
def scan_ports_cached(self):
if self.ports_info is None:
return
for port_info in self.ports_info:
if port_info['type'] == 'ixia':
continue
addr_array = port_info['pci'].split(':')
domain_id = addr_array[0]
bus_id = addr_array[1]
devfun_id = addr_array[2]
port = GetNicObj(self, domain_id, bus_id, devfun_id)
intf = port.get_interface_name()
self.logger.info("Tester cached: [000:%s %s] %s" %
(port_info['pci'], port_info['type'], intf))
port_info['port'] = port
def scan_ports_uncached(self):
"""
Return tester port pci/mac/interface information.
"""
self.ports_info = []
for (pci_bus, pci_id) in self.pci_devices_info:
# ignore unknown card types
if pci_id not in NICS.values():
self.logger.info("Tester: [%s %s] %s" %
(pci_bus, pci_id, "unknow_nic"))
continue
addr_array = pci_bus.split(':')
domain_id = addr_array[0]
bus_id = addr_array[1]
devfun_id = addr_array[2]
port = GetNicObj(self, domain_id, bus_id, devfun_id)
intf = port.get_interface_name()
if "No such file" in intf:
self.logger.info("Tester: [%s %s] %s" %
(pci_bus, pci_id, "unknow_interface"))
continue
self.logger.info("Tester: [%s %s] %s" % (pci_bus, pci_id, intf))
macaddr = port.get_mac_addr()
ipv6 = port.get_ipv6_addr()
ipv4 = port.get_ipv4_addr()
# store the port info to port mapping
self.ports_info.append({
'port': port,
'pci': pci_bus,
'type': pci_id,
'intf': intf,
'mac': macaddr,
'ipv4': ipv4,
'ipv6': ipv6
})
# return if port is not connect x3
if not port.get_interface2_name():
continue
intf = port.get_interface2_name()
self.logger.info("Tester: [%s %s] %s" % (pci_bus, pci_id, intf))
macaddr = port.get_intf2_mac_addr()
ipv6 = port.get_ipv6_addr()
# store the port info to port mapping
self.ports_info.append({
'port': port,
'pci': pci_bus,
'type': pci_id,
'intf': intf,
'mac': macaddr,
'ipv6': ipv6
})
def send_ping(self, localPort, ipv4, mac):
"""
Send ping6 packet from local port with destination ipv4 address.
"""
if self.ports_info[localPort]['type'] == 'ixia':
return "Not implemented yet"
else:
return self.send_expect(
"ping -w 5 -c 5 -A -I %s %s" %
(self.ports_info[localPort]['intf'], ipv4), "# ", 10)
def send_ping6(self, localPort, ipv6, mac):
"""
Send ping6 packet from local port with destination ipv6 address.
"""
if self.ports_info[localPort]['type'] == 'ixia':
return self.ixia_packet_gen.send_ping6(
self.ports_info[localPort]['pci'], mac, ipv6)
else:
return self.send_expect(
"ping6 -w 5 -c 5 -A %s%%%s" %
(ipv6, self.ports_info[localPort]['intf']), "# ", 10)
def get_port_numa(self, port):
"""
Return tester local port numa.
"""
pci = self.ports_info[port]['pci']
out = self.send_expect("cat /sys/bus/pci/devices/%s/numa_node" % pci,
"#")
return int(out)
def check_port_list(self, portList, ftype='normal'):
"""
Check specified port is IXIA port or normal port.
"""
dtype = None
plist = set()
for txPort, rxPort, _ in portList:
plist.add(txPort)
plist.add(rxPort)
plist = list(plist)
if len(plist) > 0:
dtype = self.ports_info[plist[0]]['type']
for port in plist[1:]:
if dtype != self.ports_info[port]['type']:
return False
if ftype == 'ixia' and dtype != ftype:
return False
return True
def scapy_append(self, cmd):
"""
Append command into scapy command list.
"""
self.scapyCmds.append(cmd)
def scapy_execute(self, timeout=60):
"""
Execute scapy command list.
"""
self.kill_all()
self.send_expect("scapy", ">>> ")
if self.bgProcIsRunning:
self.send_expect(
'subprocess.call("scapy -c sniff.py &", shell=True)', ">>> ")
self.bgProcIsRunning = False
sleep(2)
for cmd in self.scapyCmds:
self.send_expect(cmd, ">>> ", timeout)
sleep(2)
self.scapyCmds = []
self.send_expect("exit()", "# ")
def scapy_background(self):
"""
Configure scapy running in backgroud mode which mainly purpose is
that save RESULT into scapyResult.txt.
"""
self.inBg = True
def scapy_foreground(self):
"""
Running backgroup scapy and convert to foregroup mode.
"""
self.send_expect("echo -n '' > scapyResult.txt", "# ")
if self.inBg:
self.scapyCmds.append('f = open(\'scapyResult.txt\',\'w\')')
self.scapyCmds.append('f.write(RESULT)')
self.scapyCmds.append('f.close()')
self.scapyCmds.append('exit()')
outContents = "import os\n" + \
'conf.color_theme=NoTheme()\n' + 'RESULT=""\n' + \
"\n".join(self.scapyCmds) + "\n"
self.create_file(outContents, 'sniff.py')
self.logger.info('SCAPY Receive setup:\n' + outContents)
self.bgProcIsRunning = True
self.scapyCmds = []
self.inBg = False
def scapy_get_result(self):
"""
Return RESULT which saved in scapyResult.txt.
"""
out = self.send_expect("cat scapyResult.txt", "# ")
self.logger.info('SCAPY Result:\n' + out + '\n\n\n')
return out.rpartition('[')[0]
def traffic_generator_throughput(self,
portList,
rate_percent=100,
delay=5):
"""
Run throughput performance test on specified ports.
"""
if self.check_port_list(portList, 'ixia'):
return self.ixia_packet_gen.throughput(portList, rate_percent,
delay)
if not self.check_port_list(portList):
self.logger.warning("exception by mixed port types")
return None
return self.packet_gen.throughput(portList, rate_percent)
def run_rfc2544(self, portlist, delay=120, permit_loss_rate=0):
"""
test_rate: the line rate we are going to test.
"""
test_rate = float(100)
self.logger.info("test rate: %f " % test_rate)
loss_rate, tx_num, rx_num = self.traffic_generator_loss(
portlist, test_rate, delay)
while loss_rate > permit_loss_rate:
test_rate = float(1 - loss_rate) * test_rate
loss_rate, tx_num, rx_num = self.traffic_generator_loss(
portlist, test_rate, delay)
self.logger.info("zero loss rate is %s" % test_rate)
return test_rate, tx_num, rx_num
def traffic_generator_loss(self, portList, ratePercent, delay=60):
"""
Run loss performance test on specified ports.
"""
if self.check_port_list(portList, 'ixia'):
return self.ixia_packet_gen.loss(portList, ratePercent, delay)
elif not self.check_port_list(portList):
self.logger.warning("exception by mixed port types")
return None
return self.packet_gen.loss(portList, ratePercent, delay)
def traffic_generator_latency(self, portList, ratePercent=100, delay=5):
"""
Run latency performance test on specified ports.
"""
if self.check_port_list(portList, 'ixia'):
return self.ixia_packet_gen.latency(portList, ratePercent, delay)
else:
return None
def parallel_transmit_ptks(self,
send_f=None,
intf='',
pkts=[],
interval=0.01):
"""
Callable function for parallel processes
"""
print GREEN(
"Transmitting and sniffing packets, please wait few minutes...")
send_f(intf=intf, pkts=pkts, interval=interval)
def check_random_pkts(self,
portList,
pktnum=2000,
interval=0.01,
allow_miss=True,
seq_check=False,
params=None):
"""
Send several random packets and check rx packets matched
"""
# load functions in packet module
module = __import__("packet")
pkt_c = getattr(module, "Packet")
send_f = getattr(module, "send_packets")
sniff_f = getattr(module, "sniff_packets")
load_f = getattr(module, "load_sniff_packets")
compare_f = getattr(module, "compare_pktload")
strip_f = getattr(module, "strip_pktload")
save_f = getattr(module, "save_packets")
tx_pkts = {}
rx_inst = {}
# packet type random between tcp/udp/ipv6
random_type = ['TCP', 'UDP', 'IPv6_TCP', 'IPv6_UDP']
pkt_minlen = {'TCP': 64, 'UDP': 64, 'IPv6_TCP': 74, 'IPv6_UDP': 64}
# at least wait 2 seconds
timeout = int(pktnum * (interval + 0.01)) + 2
for txport, rxport in portList:
pkts = []
txIntf = self.get_interface(txport)
rxIntf = self.get_interface(rxport)
print GREEN(
"Preparing transmit packets, please wait few minutes...")
for num in range(pktnum):
# chose random packet
pkt_type = random.choice(random_type)
pkt = pkt_c(pkt_type=pkt_type,
pkt_len=random.randint(pkt_minlen[pkt_type], 1514),
ran_payload=True)
# config packet if has parameters
if params and len(portList) == len(params):
for param in params:
layer, config = param
pkt.config_layer(layer, config)
# hardcode src/dst port for some protocal may cause issue
if "TCP" in pkt_type:
pkt.config_layer('tcp', {'src': 65535, 'dst': 65535})
else:
pkt.config_layer('udp', {'src': 65535, 'dst': 65535})
# sequence saved in layer3 source ip
if "IPv6" in pkt_type:
ip_str = convert_int2ip(num, 6)
pkt.config_layer('ipv6', {'src': ip_str})
else:
ip_str = convert_int2ip(num, 4)
pkt.config_layer('ipv4', {'src': ip_str})
pkts.append(pkt)
tx_pkts[txport] = pkts
# send and sniff packets
save_f(pkts=pkts, filename="/tmp/%s_tx.pcap" % txIntf)
inst = sniff_f(intf=rxIntf, count=pktnum, timeout=timeout)
rx_inst[rxport] = inst
# Transmit packet simultaneously
processes = []
for txport, _ in portList:
txIntf = self.get_interface(txport)
processes.append(
Process(target=self.parallel_transmit_ptks,
args=(send_f, txIntf, tx_pkts[txport], interval)))
for transmit_proc in processes:
transmit_proc.start()
for transmit_proc in processes:
transmit_proc.join()
# Verify all packets
prev_id = -1
for txport, rxport in portList:
recv_pkts = load_f(rx_inst[rxport])
# only report when recevied number not matched
if len(tx_pkts[txport]) > len(recv_pkts):
print ("Pkt number not matched,%d sent and %d received\n" \
% (len(tx_pkts[txport]), len(recv_pkts)))
if allow_miss is False:
return False
# check each received packet content
print GREEN(
"Comparing sniffed packets, please wait few minutes...")
for idx in range(len(recv_pkts)):
try:
l3_type = recv_pkts[idx].strip_element_layer2('type')
sip = recv_pkts[idx].strip_element_layer3('src')
except:
continue
# ipv4 packet
if l3_type == 2048:
t_idx = convert_ip2int(sip, 4)
# ipv6 packet
elif l3_type == 34525:
t_idx = convert_ip2int(sip, 6)
else:
continue
if seq_check:
if t_idx <= prev_id:
print "Packet %d sequence not correct" % t_idx
return False
else:
prev_id = t_idx
if compare_f(tx_pkts[txport][t_idx], recv_pkts[idx],
"L4") is False:
print "Pkt recevied index %d not match original " \
"index %d" % (idx, t_idx)
print "Sent: %s" % strip_f(tx_pkts[txport][t_idx], "L4")
print "Recv: %s" % strip_f(recv_pkts[idx], "L4")
return False
return True
def extend_external_packet_generator(self, clazz, instance):
"""
Update packet generator function, will implement later.
"""
if self.it_uses_external_generator():
self.ixia_packet_gen.__class__ = clazz
current_attrs = instance.__dict__
instance.__dict__ = self.ixia_packet_gen.__dict__
instance.__dict__.update(current_attrs)
def sendpkt_bg(self, localPort, dst_mac):
"""
loop to Send packet in background, should call stop_sendpkt_bg to stop it.
"""
itf = self.get_interface(localPort)
src_mac = self.get_mac(localPort)
script_str = "from scapy.all import *\n" + \
"sendp([Ether(dst='%s', src='%s')/IP(len=46)], iface='%s', loop=1)\n" % (dst_mac, src_mac, itf)
self.send_expect("rm -fr send_pkg_loop.py", "# ")
f = open("send_pkt_loop.py", "w")
f.write(script_str)
f.close()
self.proc = subprocess.Popen(['python', 'send_pkt_loop.py'])
def stop_sendpkt_bg(self):
"""
stop send_pkt_loop in background
"""
if self.proc:
self.proc.kill()
self.proc = None
def kill_all(self, killall=False):
"""
Kill all scapy process or DPDK application on tester.
"""
if not self.has_external_traffic_generator():
self.alt_session.send_expect(
'killall scapy 2>/dev/null; echo tester', '# ', 5)
if killall:
super(Tester, self).kill_all()
def close(self):
"""
Close ssh session and IXIA tcl session.
"""
if self.session:
self.session.close()
self.session = None
if self.alt_session:
self.alt_session.close()
self.alt_session = None
if self.it_uses_external_generator():
self.ixia_packet_gen.close()
def crb_exit(self):
"""
Close all resource before crb exit
"""
self.logger.logger_exit()
self.close()
class Tester(Crb):
"""
Start the DPDK traffic generator on the machine `target`.
A config file and pcap file must have previously been copied
to this machine.
"""
PORT_INFO_CACHE_KEY = 'tester_port_info'
CORE_LIST_CACHE_KEY = 'tester_core_list'
NUMBER_CORES_CACHE_KEY = 'tester_number_cores'
PCI_DEV_CACHE_KEY = 'tester_pci_dev_info'
def __init__(self, crb, serializer):
super(Tester, self).__init__(crb, serializer)
self.NAME = 'tester'
self.logger = getLogger(self.NAME)
self.session = SSHConnection(self.get_ip_address(),
self.NAME, self.get_password())
self.session.init_log(self.logger)
self.alt_session = SSHConnection(self.get_ip_address(),
self.NAME + '_alt', self.get_password())
self.alt_session.init_log(self.logger)
self.bgProcIsRunning = False
self.dut = None
self.inBg = 0
self.scapyCmds = []
self.bgCmds = []
self.bgItf = ''
def init_ext_gen(self):
"""
Initialize tester packet generator object.
"""
if self.it_uses_external_generator():
self.ixia_packet_gen = IxiaPacketGenerator(self)
self.packet_gen = SoftwarePacketGenerator(self)
def get_ip_address(self):
"""
Get ip address of tester CRB.
"""
return self.crb['tester IP']
def get_password(self):
"""
Get tester login password of tester CRB.
"""
return self.crb['tester pass']
def has_external_traffic_generator(self):
"""
Check whether performance test will base on IXIA equipment.
"""
try:
if self.crb[IXIA] is not None:
return True
except Exception as e:
return False
return False
def get_external_traffic_generator(self):
"""
Return IXIA object.
"""
return self.crb[IXIA]
def it_uses_external_generator(self):
"""
Check whether IXIA generator is ready for performance test.
"""
return self.want_perf_tests and self.has_external_traffic_generator()
def tester_prerequisites(self):
"""
Prerequest function should be called before execute any test case.
Will call function to scan all lcore's information which on Tester.
Then call pci scan function to collect nic device information.
Then discovery the network topology and save it into cache file.
At last setup DUT' environment for validation.
"""
self.init_core_list()
self.pci_devices_information()
self.restore_interfaces()
self.scan_ports()
def get_local_port(self, remotePort):
"""
Return tester local port connect to specified dut port.
"""
return self.dut.ports_map[remotePort]
def get_local_port_type(self, remotePort):
"""
Return tester local port type connect to specified dut port.
"""
return self.ports_info[self.get_local_port(remotePort)]['type']
def get_local_index(self, pci):
"""
Return tester local port index by pci id
"""
index = -1
for port in self.ports_info:
index += 1
if pci == port['pci']:
return index
def get_pci(self, localPort):
"""
Return tester local port pci id.
"""
return self.ports_info[localPort]['pci']
def get_interface(self, localPort):
"""
Return tester local port interface name.
"""
return self.ports_info[localPort]['intf']
def get_mac(self, localPort):
"""
Return tester local port mac address.
"""
if self.ports_info[localPort]['type'] == 'ixia':
return "00:00:00:00:00:01"
else:
return self.ports_info[localPort]['mac']
def get_port_status(self, port):
"""
Return link status of ethernet.
"""
eth = self.ports_info[port]['intf']
out = self.send_expect("ethtool %s" % eth, "# ")
status = re.search(r"Link detected:\s+(yes|no)", out)
if not status:
self.logger.error("ERROR: unexpected output")
if status.group(1) == 'yes':
return 'up'
else:
return 'down'
def restore_interfaces(self):
"""
Restore Linux interfaces.
"""
self.send_expect("modprobe igb", "# ", 20)
self.send_expect("modprobe ixgbe", "# ", 20)
self.send_expect("modprobe e1000e", "# ", 20)
self.send_expect("modprobe e1000", "# ", 20)
try:
for (pci_bus, pci_id) in self.pci_devices_info:
addr_array = pci_bus.split(':')
itf = self.get_interface_name(addr_array[0], addr_array[1])
self.send_expect("ifconfig %s up" % itf, "# ")
except Exception as e:
self.logger.error(" !!! Restore ITF: " + e.message)
def scan_ports(self):
"""
Scan all ports on tester and save port's pci/mac/interface.
"""
if self.read_cache:
self.ports_info = self.serializer.load(self.PORT_INFO_CACHE_KEY)
if not self.read_cache or self.ports_info is None:
self.scan_ports_uncached()
if self.it_uses_external_generator():
self.ports_info.extend(self.ixia_packet_gen.get_ports())
self.serializer.save(self.PORT_INFO_CACHE_KEY, self.ports_info)
self.logger.info(self.ports_info)
def scan_ports_uncached(self):
"""
Return tester port pci/mac/interface information.
"""
self.ports_info = []
for (pci_bus, pci_id) in self.pci_devices_info:
# ignore unknown card types
if pci_id not in NICS.values():
self.logger.info("Tester: [000:%s %s] %s" % (pci_bus, pci_id,
"unknow_nic"))
continue
addr_array = pci_bus.split(':')
bus_id = addr_array[0]
devfun_id = addr_array[1]
intf = self.get_interface_name(bus_id, devfun_id)
if "No such file" in intf:
self.logger.info("Tester: [000:%s %s] %s" % (pci_bus, pci_id,
"unknow_interface"))
continue
self.logger.info("Tester: [000:%s %s] %s" % (pci_bus, pci_id, intf))
macaddr = self.get_mac_addr(intf, bus_id, devfun_id)
# store the port info to port mapping
self.ports_info.append({'pci': pci_bus,
'type': pci_id,
'intf': intf,
'mac': macaddr})
def send_ping6(self, localPort, ipv6, mac):
"""
Send ping6 packet from local port with destination ipv6 address.
"""
if self.ports_info[localPort]['type'] == 'ixia':
return self.ixia_packet_gen.send_ping6(self.ports_info[localPort]['pci'], mac, ipv6)
else:
return self.send_expect("ping6 -w 5 -c 5 -A -I %s %s" % (self.ports_info[localPort]['intf'], ipv6), "# ", 10)
def get_port_numa(self, port):
"""
Return tester local port numa.
"""
pci = self.ports_info[port]['pci']
out = self.send_expect("cat /sys/bus/pci/devices/0000:%s/numa_node" % pci, "#")
return int(out)
def check_port_list(self, portList, ftype='normal'):
"""
Check specified port is IXIA port or normal port.
"""
dtype = None
plist = set()
for txPort, rxPort, _ in portList:
plist.add(txPort)
plist.add(rxPort)
plist = list(plist)
if len(plist) > 0:
dtype = self.ports_info[plist[0]]['type']
for port in plist[1:]:
if dtype != self.ports_info[port]['type']:
return False
if ftype == 'ixia' and dtype != ftype:
return False
return True
def scapy_append(self, cmd):
"""
Append command into scapy command list.
"""
self.scapyCmds.append(cmd)
def scapy_execute(self, timeout=60):
"""
Execute scapy command list.
"""
self.kill_all()
self.send_expect("scapy", ">>> ")
if self.bgProcIsRunning:
self.send_expect('subprocess.call("scapy -c sniff.py &", shell=True)', ">>> ")
self.bgProcIsRunning = False
sleep(2)
for cmd in self.scapyCmds:
self.send_expect(cmd, ">>> ", timeout)
sleep(2)
self.scapyCmds = []
self.send_expect("exit()", "# ")
def scapy_background(self):
"""
Configure scapy running in backgroud mode which mainly purpose is
that save RESULT into scapyResult.txt.
"""
self.inBg = True
def scapy_foreground(self):
"""
Running backgroup scapy and convert to foregroup mode.
"""
self.send_expect("echo -n '' > scapyResult.txt", "# ")
if self.inBg:
self.scapyCmds.append('f = open(\'scapyResult.txt\',\'w\')')
self.scapyCmds.append('f.write(RESULT)')
self.scapyCmds.append('f.close()')
self.scapyCmds.append('exit()')
outContents = "import os\n" + \
'conf.color_theme=NoTheme()\n' + 'RESULT=""\n' + \
"\n".join(self.scapyCmds) + "\n"
self.create_file(outContents, 'sniff.py')
self.logger.info('SCAPY Receive setup:\n' + outContents)
self.bgProcIsRunning = True
self.scapyCmds = []
self.inBg = False
def scapy_get_result(self):
"""
Return RESULT which saved in scapyResult.txt.
"""
out = self.send_expect("cat scapyResult.txt", "# ")
self.logger.info('SCAPY Result:\n' + out + '\n\n\n')
return out.rpartition('[')[0]
def traffic_generator_throughput(self, portList, rate_percent=100, delay=5):
"""
Run throughput performance test on specified ports.
"""
if self.check_port_list(portList, 'ixia'):
return self.ixia_packet_gen.throughput(portList, rate_percent, delay)
if not self.check_port_list(portList):
self.logger.warning("exception by mixed port types")
return None
return self.packet_gen.throughput(portList, rate_percent)
def traffic_generator_loss(self, portList, ratePercent):
"""
Run loss performance test on specified ports.
"""
if self.check_port_list(portList, 'ixia'):
return self.ixia_packet_gen.loss(portList, ratePercent)
elif not self.check_port_list(portList):
self.logger.warning("exception by mixed port types")
return None
return self.packet_gen.loss(portList, ratePercent)
def traffic_generator_latency(self, portList, ratePercent=100, delay=5):
"""
Run latency performance test on specified ports.
"""
if self.check_port_list(portList, 'ixia'):
return self.ixia_packet_gen.latency(portList, ratePercent, delay)
else:
return None
def extend_external_packet_generator(self, clazz, instance):
"""
Update packet generator function, will implement later.
"""
if self.it_uses_external_generator():
self.ixia_packet_gen.__class__ = clazz
current_attrs = instance.__dict__
instance.__dict__ = self.ixia_packet_gen.__dict__
instance.__dict__.update(current_attrs)
def kill_all(self, killall=False):
"""
Kill all scapy process or DPDK application on tester.
"""
if not self.has_external_traffic_generator():
self.alt_session.send_expect('killall scapy 2>/dev/null; echo tester', '# ', 5)
if killall:
super(Tester, self).kill_all()
def close(self):
"""
Close ssh session and IXIA tcl session.
"""
super(Tester, self).close()
if self.it_uses_external_generator():
self.ixia_packet_gen.close()