1 # Copyright (c) 2016-2017 Intel Corporation
3 # Licensed under the Apache License, Version 2.0 (the "License");
4 # you may not use this file except in compliance with the License.
5 # You may obtain a copy of the License at
7 # http://www.apache.org/licenses/LICENSE-2.0
9 # Unless required by applicable law or agreed to in writing, software
10 # distributed under the License is distributed on an "AS IS" BASIS,
11 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 # See the License for the specific language governing permissions and
13 # limitations under the License.
14 """ Trex Traffic Profile definitions """
16 from __future__ import absolute_import
20 from random import SystemRandom
23 from yardstick.network_services.traffic_profile.base import TrafficProfile
24 from trex_stl_lib.trex_stl_client import STLStream
25 from trex_stl_lib.trex_stl_streams import STLFlowLatencyStats
26 from trex_stl_lib.trex_stl_streams import STLTXCont
27 from trex_stl_lib.trex_stl_streams import STLProfile
28 from trex_stl_lib.trex_stl_packet_builder_scapy import STLVmWrFlowVar
29 from trex_stl_lib.trex_stl_packet_builder_scapy import STLVmFlowVarRepeatableRandom
30 from trex_stl_lib.trex_stl_packet_builder_scapy import STLVmFlowVar
31 from trex_stl_lib.trex_stl_packet_builder_scapy import STLPktBuilder
32 from trex_stl_lib.trex_stl_packet_builder_scapy import STLScVmRaw
33 from trex_stl_lib.trex_stl_packet_builder_scapy import STLVmFixIpv4
34 from trex_stl_lib import api as Pkt
37 class TrexProfile(TrafficProfile):
38 """ This class handles Trex Traffic profile generation and execution """
40 def __init__(self, yaml_data):
41 super(TrexProfile, self).__init__(yaml_data)
47 self.profile_data = []
55 self.ip6_packet = None
56 self.udp_packet = None
59 self.qinq_packet = None
61 self.vm_flow_vars = []
63 self.ether_packet = []
65 def execute(self, traffic_generator):
66 """ Generate the stream and run traffic on the given ports """
69 def _set_ether_fields(self, **kwargs):
70 """ set ethernet protocol fields """
71 if not self.ether_packet:
72 self.ether_packet = Pkt.Ether()
73 for key, value in six.iteritems(kwargs):
74 setattr(self.ether_packet, key, value)
76 def _set_ip_fields(self, **kwargs):
77 """ set l3 ipv4 protocol fields """
79 if not self.ip_packet:
80 self.ip_packet = Pkt.IP()
82 setattr(self.ip_packet, key, kwargs[key])
84 def _set_ip6_fields(self, **kwargs):
85 """ set l3 ipv6 protocol fields """
86 if not self.ip6_packet:
87 self.ip6_packet = Pkt.IPv6()
89 setattr(self.ip6_packet, key, kwargs[key])
91 def _set_udp_fields(self, **kwargs):
92 """ set l4 udp ports fields """
93 if not self.udp_packet:
94 self.udp_packet = Pkt.UDP()
96 setattr(self.udp_packet, key, kwargs[key])
98 def set_src_mac(self, src_mac):
99 """ set source mac address fields """
100 src_macs = src_mac.split('-')
101 min_value = src_macs[0]
102 if len(src_macs) == 1:
104 self._set_ether_fields(src=src_mac)
106 stl_vm_flow_var = STLVmFlowVar(name="mac_src",
112 self.vm_flow_vars.append(stl_vm_flow_var)
113 stl_vm_wr_flow_var = STLVmWrFlowVar(fv_name='mac_src',
114 pkt_offset='Ether.src')
115 self.vm_flow_vars.append(stl_vm_wr_flow_var)
117 def set_dst_mac(self, dst_mac):
118 """ set destination mac address fields """
119 dst_macs = dst_mac.split('-')
120 min_value = dst_macs[0]
121 if len(dst_macs) == 1:
123 self._set_ether_fields(dst=dst_mac)
125 stl_vm_flow_var = STLVmFlowVar(name="mac_dst",
131 self.vm_flow_vars.append(stl_vm_flow_var)
132 stl_vm_wr_flow_var = STLVmWrFlowVar(fv_name='mac_dst',
133 pkt_offset='Ether.dst')
134 self.vm_flow_vars.append(stl_vm_wr_flow_var)
136 def set_src_ip4(self, src_ip4, count=1):
137 """ set source ipv4 address fields """
138 src_ips = src_ip4.split('-')
139 min_value = src_ips[0]
140 max_value = src_ips[1] if len(src_ips) == 2 else src_ips[0]
141 if len(src_ips) == 1:
143 self._set_ip_fields(src=src_ip4)
145 stl_vm_flow_var = STLVmFlowVarRepeatableRandom(name="ip4_src",
151 self.vm_flow_vars.append(stl_vm_flow_var)
152 stl_vm_wr_flow_var = STLVmWrFlowVar(fv_name='ip4_src',
154 self.vm_flow_vars.append(stl_vm_wr_flow_var)
155 stl_vm_fix_ipv4 = STLVmFixIpv4(offset="IP")
156 self.vm_flow_vars.append(stl_vm_fix_ipv4)
158 def set_dst_ip4(self, dst_ip4, count=1):
159 """ set destination ipv4 address fields """
160 dst_ips = dst_ip4.split('-')
161 min_value = dst_ips[0]
162 max_value = dst_ips[1] if len(dst_ips) == 2 else dst_ips[0]
163 if len(dst_ips) == 1:
165 self._set_ip_fields(dst=dst_ip4)
167 stl_vm_flow_var = STLVmFlowVarRepeatableRandom(name="dst_ip4",
173 self.vm_flow_vars.append(stl_vm_flow_var)
174 stl_vm_wr_flow_var = STLVmWrFlowVar(fv_name='dst_ip4',
176 self.vm_flow_vars.append(stl_vm_wr_flow_var)
177 stl_vm_fix_ipv4 = STLVmFixIpv4(offset="IP")
178 self.vm_flow_vars.append(stl_vm_fix_ipv4)
180 def set_src_ip6(self, src_ip6):
181 """ set source ipv6 address fields """
182 src_ips = src_ip6.split('-')
183 min_value = src_ips[0]
184 max_value = src_ips[1] if len(src_ips) == 2 else src_ips[0]
186 self._set_ip6_fields(src=src_ip6)
187 if len(src_ips) == 2:
188 min_value, max_value = \
189 self._get_start_end_ipv6(min_value, max_value)
190 stl_vm_flow_var = STLVmFlowVar(name="ip6_src",
196 self.vm_flow_vars.append(stl_vm_flow_var)
197 stl_vm_wr_flow_var = STLVmWrFlowVar(fv_name='ip6_src',
198 pkt_offset='IPv6.src',
200 self.vm_flow_vars.append(stl_vm_wr_flow_var)
202 def set_dst_ip6(self, dst_ip6):
203 """ set destination ipv6 address fields """
204 dst_ips = dst_ip6.split('-')
205 min_value = dst_ips[0]
206 max_value = dst_ips[1] if len(dst_ips) == 2 else dst_ips[0]
208 self._set_ip6_fields(dst=dst_ip6)
209 if len(dst_ips) == 2:
210 min_value, max_value = \
211 self._get_start_end_ipv6(min_value, max_value)
212 stl_vm_flow_var = STLVmFlowVar(name="dst_ip6",
218 self.vm_flow_vars.append(stl_vm_flow_var)
219 stl_vm_wr_flow_var = STLVmWrFlowVar(fv_name='dst_ip6',
220 pkt_offset='IPv6.dst',
222 self.vm_flow_vars.append(stl_vm_wr_flow_var)
224 def set_dscp(self, dscp):
225 """ set dscp for trex """
226 dscps = str(dscp).split('-')
227 min_value = int(dscps[0])
228 max_value = int(dscps[1]) if len(dscps) == 2 else int(dscps[0])
231 self._set_ip_fields(tos=dscp)
233 stl_vm_flow_var = STLVmFlowVar(name="dscp",
239 self.vm_flow_vars.append(stl_vm_flow_var)
240 stl_vm_wr_flow_var = STLVmWrFlowVar(fv_name='dscp',
242 self.vm_flow_vars.append(stl_vm_wr_flow_var)
244 def set_src_port(self, src_port, count=1):
245 """ set packet source port """
246 src_ports = str(src_port).split('-')
247 min_value = int(src_ports[0])
248 if len(src_ports) == 1:
249 max_value = int(src_ports[0])
251 self._set_udp_fields(sport=src_port)
253 max_value = int(src_ports[1])
254 stl_vm_flow_var = STLVmFlowVarRepeatableRandom(name="port_src",
260 self.vm_flow_vars.append(stl_vm_flow_var)
261 stl_vm_wr_flow_var = STLVmWrFlowVar(fv_name='port_src',
262 pkt_offset=self.udp_sport)
263 self.vm_flow_vars.append(stl_vm_wr_flow_var)
265 def set_dst_port(self, dst_port, count=1):
266 """ set packet destnation port """
267 dst_ports = str(dst_port).split('-')
268 min_value = int(dst_ports[0])
269 if len(dst_ports) == 1:
270 max_value = int(dst_ports[0])
272 self._set_udp_fields(dport=dst_port)
274 max_value = int(dst_ports[1])
276 STLVmFlowVarRepeatableRandom(name="port_dst",
282 self.vm_flow_vars.append(stl_vm_flow_var)
283 stl_vm_wr_flow_var = STLVmWrFlowVar(fv_name='port_dst',
284 pkt_offset=self.udp_dport)
285 self.vm_flow_vars.append(stl_vm_wr_flow_var)
287 def set_svlan_cvlan(self, svlan, cvlan):
288 """ set svlan & cvlan """
290 ether_params = {'type': 0x8100}
291 self._set_ether_fields(**ether_params)
292 svlans = str(svlan['id']).split('-')
293 svlan_min = int(svlans[0])
294 svlan_max = int(svlans[1]) if len(svlans) == 2 else int(svlans[0])
296 svlan = self._get_random_value(svlan_min, svlan_max)
299 cvlans = str(cvlan['id']).split('-')
300 cvlan_min = int(cvlans[0])
301 cvlan_max = int(cvlans[1]) if len(cvlans) == 2 else int(cvlans[0])
303 cvlan = self._get_random_value(cvlan_min, cvlan_max)
306 self.qinq_packet = Pkt.Dot1Q(vlan=svlan) / Pkt.Dot1Q(vlan=cvlan)
308 def set_qinq(self, qinq):
309 """ set qinq in packet """
310 self.set_svlan_cvlan(qinq['S-VLAN'], qinq['C-VLAN'])
312 def set_outer_l2_fields(self, outer_l2):
313 """ setup outer l2 fields from traffic profile """
314 ether_params = {'type': 0x800}
315 self._set_ether_fields(**ether_params)
316 if 'srcmac' in outer_l2:
317 self.set_src_mac(outer_l2['srcmac'])
318 if 'dstmac' in outer_l2:
319 self.set_dst_mac(outer_l2['dstmac'])
320 if 'QinQ' in outer_l2:
321 self.set_qinq(outer_l2['QinQ'])
323 def set_outer_l3v4_fields(self, outer_l3v4):
324 """ setup outer l3v4 fields from traffic profile """
326 if 'proto' in outer_l3v4:
327 ip_params['proto'] = outer_l3v4['proto']
328 if outer_l3v4['proto'] == 'tcp':
329 self.udp_packet = Pkt.TCP()
330 self.udp_dport = 'TCP.dport'
331 self.udp_sport = 'TCP.sport'
332 tcp_params = {'flags': '', 'window': 0}
333 self._set_udp_fields(**tcp_params)
334 if 'ttl' in outer_l3v4:
335 ip_params['ttl'] = outer_l3v4['ttl']
336 self._set_ip_fields(**ip_params)
337 if 'dscp' in outer_l3v4:
338 self.set_dscp(outer_l3v4['dscp'])
339 if 'srcip4' in outer_l3v4:
340 self.set_src_ip4(outer_l3v4['srcip4'], outer_l3v4['count'])
341 if 'dstip4' in outer_l3v4:
342 self.set_dst_ip4(outer_l3v4['dstip4'], outer_l3v4['count'])
344 def set_outer_l3v6_fields(self, outer_l3v6):
345 """ setup outer l3v6 fields from traffic profile """
346 ether_params = {'type': 0x86dd}
347 self._set_ether_fields(**ether_params)
349 if 'proto' in outer_l3v6:
350 ip6_params['proto'] = outer_l3v6['proto']
351 if outer_l3v6['proto'] == 'tcp':
352 self.udp_packet = Pkt.TCP()
353 self.udp_dport = 'TCP.dport'
354 self.udp_sport = 'TCP.sport'
355 tcp_params = {'flags': '', 'window': 0}
356 self._set_udp_fields(**tcp_params)
357 if 'ttl' in outer_l3v6:
358 ip6_params['ttl'] = outer_l3v6['ttl']
359 if 'tc' in outer_l3v6:
360 ip6_params['tc'] = outer_l3v6['tc']
361 if 'hlim' in outer_l3v6:
362 ip6_params['hlim'] = outer_l3v6['hlim']
363 self._set_ip6_fields(**ip6_params)
364 if 'srcip6' in outer_l3v6:
365 self.set_src_ip6(outer_l3v6['srcip6'])
366 if 'dstip6' in outer_l3v6:
367 self.set_dst_ip6(outer_l3v6['dstip6'])
369 def set_outer_l4_fields(self, outer_l4):
370 """ setup outer l4 fields from traffic profile """
371 if 'srcport' in outer_l4:
372 self.set_src_port(outer_l4['srcport'], outer_l4['count'])
373 if 'dstport' in outer_l4:
374 self.set_dst_port(outer_l4['dstport'], outer_l4['count'])
376 def generate_imix_data(self, packet_definition):
377 """ generate packet size for a given traffic profile """
380 if not packet_definition:
382 imix = packet_definition.get('framesize')
386 imix_data[int(size[:-1])] = int(data)
387 imix_sum = sum(imix_data.values())
389 raise SystemExit("Error in IMIX data")
391 imix_data[64] = imix_data.get(64, 0) + (100 - imix_sum)
394 for size in imix_data:
395 count = int(imix_data[size])
397 avg_size += round(size * count / 100, 2)
398 pps = round(self.pps * count / 100, 0)
399 imix_count[size] = pps
400 self.rate = round(1342177280 / avg_size, 0) * 2
401 logging.debug("Imax: %s rate: %s", imix_count, self.rate)
404 def get_streams(self, profile_data):
405 """ generate trex stream
410 self.pps = self.params['traffic_profile'].get('frame_rate', 100)
411 for packet_name in profile_data:
412 outer_l2 = profile_data[packet_name].get('outer_l2')
413 imix_data = self.generate_imix_data(outer_l2)
415 imix_data = {64: self.pps}
416 self.generate_vm(profile_data[packet_name])
417 for size in imix_data:
418 self._generate_streams(size, imix_data[size])
419 self._generate_profile()
422 def generate_vm(self, packet_definition):
423 """ generate trex vm with flows setup """
424 self.ether_packet = Pkt.Ether()
425 self.ip_packet = Pkt.IP()
426 self.ip6_packet = None
427 self.udp_packet = Pkt.UDP()
428 self.udp_dport = 'UDP.dport'
429 self.udp_sport = 'UDP.sport'
431 self.vm_flow_vars = []
432 outer_l2 = packet_definition.get('outer_l2', None)
433 outer_l3v4 = packet_definition.get('outer_l3v4', None)
434 outer_l3v6 = packet_definition.get('outer_l3v6', None)
435 outer_l4 = packet_definition.get('outer_l4', None)
437 self.set_outer_l2_fields(outer_l2)
439 self.set_outer_l3v4_fields(outer_l3v4)
441 self.set_outer_l3v6_fields(outer_l3v6)
443 self.set_outer_l4_fields(outer_l4)
444 self.trex_vm = STLScVmRaw(self.vm_flow_vars)
446 def generate_packets(self):
447 """ generate packets from trex TG """
448 base_pkt = self.base_pkt
449 size = self.fsize - 4
450 pad = max(0, size - len(base_pkt)) * 'x'
451 self.packets = [STLPktBuilder(pkt=base_pkt / pad,
452 vm=vm) for vm in self.vms]
454 def _create_single_packet(self, size=64):
456 ether_packet = self.ether_packet
457 ip_packet = self.ip6_packet if self.ip6_packet else self.ip_packet
458 udp_packet = self.udp_packet
460 qinq_packet = self.qinq_packet
461 base_pkt = ether_packet / qinq_packet / ip_packet / udp_packet
463 base_pkt = ether_packet / ip_packet / udp_packet
464 pad = max(0, size - len(base_pkt)) * 'x'
465 packet = STLPktBuilder(pkt=base_pkt / pad, vm=self.trex_vm)
468 def _create_single_stream(self, packet_size, pps, isg=0):
469 packet = self._create_single_packet(packet_size)
472 stl_flow = STLFlowLatencyStats(pg_id=self.pg_id)
473 stream = STLStream(isg=isg, packet=packet, mode=STLTXCont(pps=pps),
476 stream = STLStream(isg=isg, packet=packet, mode=STLTXCont(pps=pps))
479 def _generate_streams(self, packet_size, pps):
480 self.streams.append(self._create_single_stream(packet_size, pps))
482 def _generate_profile(self):
483 self.profile = STLProfile(self.streams)
486 def _get_start_end_ipv6(cls, start_ip, end_ip):
488 ip1 = socket.inet_pton(socket.AF_INET6, start_ip)
489 ip2 = socket.inet_pton(socket.AF_INET6, end_ip)
490 hi1, lo1 = struct.unpack('!QQ', ip1)
491 hi2, lo2 = struct.unpack('!QQ', ip2)
492 if ((hi1 << 64) | lo1) > ((hi2 << 64) | lo2):
493 raise SystemExit("IPv6: start_ip is greater then end_ip")
494 max_p1 = abs(int(lo1) - int(lo2))
496 except Exception as ex_error:
497 raise SystemExit(ex_error)
499 return base_p1, max_p1 + base_p1
502 def _get_random_value(cls, min_port, max_port):
503 cryptogen = SystemRandom()
504 return cryptogen.randrange(min_port, max_port)