def _set_ip_fields(self, **kwargs):
""" set l3 ipv4 protocol fields """
if not self.ip_packet:
self.ip_packet = Pkt.IP()
for key in kwargs:
setattr(self.ip_packet, key, kwargs[key])
def _create_stream(self, src_ip, dst_ip):
base_frame = \
Pkt.Ether() / Pkt.IP(src=src_ip, dst=dst_ip) / Pkt.UDP(dport=12,
sport=1025)
frame_size = self.params["traffic_profile"]["frame_size"]
pad_size = max(0, frame_size - len(base_frame))
frame = base_frame / ("x" * max(0, pad_size))
frame_rate = self.params["traffic_profile"]["frame_rate"]
return STLStream(packet=STLPktBuilder(pkt=frame),
mode=STLTXCont(pps=frame_rate))
def test__create_single_packet(self, mock_pktbuilder):
size = 128
rfc2544_profile = rfc2544.RFC2544Profile(self.TRAFFIC_PROFILE)
rfc2544_profile.ether_packet = Pkt.Eth()
rfc2544_profile.ip_packet = Pkt.IP()
rfc2544_profile.udp_packet = Pkt.UDP()
rfc2544_profile.trex_vm = 'trex_vm'
base_pkt = (rfc2544_profile.ether_packet / rfc2544_profile.ip_packet /
rfc2544_profile.udp_packet)
pad = (size - len(base_pkt)) * 'x'
output = rfc2544_profile._create_single_packet(size=size)
mock_pktbuilder.assert_called_once_with(pkt=base_pkt / pad,
vm='trex_vm')
self.assertEqual(output, 'packet')
def generate_vm(self, packet_definition):
""" generate trex vm with flows setup """
self.ether_packet = Pkt.Ether()
self.ip_packet = Pkt.IP()
self.ip6_packet = None
self.udp_packet = Pkt.UDP()
self.udp[DST_PORT] = 'UDP.dport'
self.udp[SRC_PORT] = 'UDP.sport'
self.qinq = False
self.vm_flow_vars = []
outer_l2 = packet_definition.get('outer_l2', None)
outer_l3v4 = packet_definition.get('outer_l3v4', None)
outer_l3v6 = packet_definition.get('outer_l3v6', None)
outer_l4 = packet_definition.get('outer_l4', None)
if outer_l2:
self._set_outer_l2_fields(outer_l2)
if outer_l3v4:
self._set_outer_l3v4_fields(outer_l3v4)
if outer_l3v6:
self._set_outer_l3v6_fields(outer_l3v6)
if outer_l4:
self._set_outer_l4_fields(outer_l4)
self.trex_vm = STLScVmRaw(self.vm_flow_vars)
def _set_outer_l3v4_fields(self, outer_l3v4):
""" setup outer l3v4 fields from traffic profile """
ip_params = {}
if 'proto' in outer_l3v4:
ip_params['proto'] = outer_l3v4['proto']
self._set_proto_fields(IP, **ip_params)
self.flow = int(outer_l3v4['count'])
src_start_ip, _ = outer_l3v4['srcip4'].split('-')
dst_start_ip, _ = outer_l3v4['dstip4'].split('-')
self.ip_packet = Pkt.IP(src=src_start_ip,
dst=dst_start_ip,
proto=outer_l3v4['proto'])
if self.flow > 1:
dst_start_int = int(ip_address(str(dst_start_ip)))
dst_end_ip_new = ip_address(dst_start_int + self.flow - 1)
# self._set_proto_addr(IP, SRC, outer_l3v4['srcip4'], outer_l3v4['count'])
self._set_proto_addr(
IP, DST,
"{start_ip}-{end_ip}".format(start_ip=dst_start_ip,
end_ip=str(dst_end_ip_new)),
self.flow)
def _create_vm(self, packet_definition):
"""Create the STL Raw instructions"""
self.ether_packet = Pkt.Ether()
self.ip_packet = Pkt.IP()
self.ip6_packet = None
self.udp_packet = Pkt.UDP()
self.udp[DST_PORT] = 'UDP.dport'
self.udp[SRC_PORT] = 'UDP.sport'
self.qinq = False
self.vm_flow_vars = []
outer_l2 = packet_definition.get('outer_l2')
outer_l3v4 = packet_definition.get('outer_l3v4')
outer_l3v6 = packet_definition.get('outer_l3v6')
outer_l4 = packet_definition.get('outer_l4')
if outer_l2:
self._set_outer_l2_fields(outer_l2)
if outer_l3v4:
self._set_outer_l3v4_fields(outer_l3v4)
if outer_l3v6:
self._set_outer_l3v6_fields(outer_l3v6)
if outer_l4:
self._set_outer_l4_fields(outer_l4)
self.trex_vm = trex_stl_packet_builder_scapy.STLScVmRaw(
self.vm_flow_vars)
def run(self):
sys.path.insert(0, os.path.join(self._trex_path, self.trex_stl_path))
import trex_stl_lib.api as trex_api
client = trex_api.STLClient(server=self._server_hostname)
client.connect()
try:
client.acquire(ports=self._ports, force=True)
except:
res_data = {}
res_data["msg"] = "Failed to acquire ports"
return self.set_fail(res_data)
try:
client.reset(ports=self._ports)
except:
client.release(ports=self._ports)
res_data = {}
res_data["msg"] = "Failed to reset ports"
return self.set_fail(res_data)
for i, port in enumerate(self._ports):
L2 = trex_api.Ether(src=self._src_macs[i], dst=self._dst_macs[i])
L3 = trex_api.IP(src="192.168.1.%d" % (i * 2 + 1),
dst="192.168.1.%d" % (i * 2 + 2))
L4 = trex_api.UDP()
base_pkt = L2 / L3 / L4
pad = max(0, self._pkt_size - len(base_pkt)) * 'x'
packet = base_pkt / pad
trex_packet = trex_api.STLPktBuilder(pkt=packet)
trex_stream = trex_api.STLStream(
packet=trex_packet, mode=trex_api.STLTXCont(percentage=100))
client.add_streams(trex_stream, ports=[port])
client.set_port_attr(ports=self._ports, promiscuous=True)
results = []
for i in range(self._runs):
client.clear_stats(ports=self._ports)
client.start(ports=self._ports)
sleep(self._duration)
client.stop(ports=self._ports)
results.append(client.get_stats(ports=self._ports))
#wait before starting next run
sleep(self._run_wait)
client.release(ports=self._ports)
results = self._postprocess_results(results)
res_data = {"results": results}
res_data["msg"] = ""
return self.set_pass(res_data)