3 # Copyright (c) 2016 Cisco and/or its affiliates.
4 # Licensed under the Apache License, Version 2.0 (the "License");
5 # you may not use this file except in compliance with the License.
6 # You may obtain a copy of the License at:
8 # http://www.apache.org/licenses/LICENSE-2.0
10 # Unless required by applicable law or agreed to in writing, software
11 # distributed under the License is distributed on an "AS IS" BASIS,
12 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 # See the License for the specific language governing permissions and
14 # limitations under the License.
16 """This script uses T-REX stateless API to drive t-rex instance.
19 - T-REX: https://github.com/cisco-system-traffic-generator/trex-core
20 - compiled and running T-REX process (eg. ./t-rex-64 -i -c 4)
21 - trex_stl_lib.api library
22 - Script must be executed on a node with T-REX instance
23 - 2 interfaces must be configured in configuretion file /etc/trex_cfg.yaml
25 ##################### Example of /etc/trex_cfg.yaml ##########################
26 - port_limit : 2 # numbers of ports to use
28 interfaces : ["84:00.0","84:00.1"] # PCI address of interfaces
29 port_info : # set eth mac addr
30 - dest_mac : [0x90,0xe2,0xba,0x1f,0x97,0xd5] # port 0
31 src_mac : [0x90,0xe2,0xba,0x1f,0x97,0xd4]
32 - dest_mac : [0x90,0xe2,0xba,0x1f,0x97,0xd4] # port 1
33 src_mac : [0x90,0xe2,0xba,0x1f,0x97,0xd5]
34 ##############################################################################
37 1. Configure traffic on running T-REX instance
38 2. Clear statistics on all ports
39 3. Ctart traffic with specified duration
40 4. Print statistics to stdout
51 sys.path.insert(0, "/opt/trex-core-2.22/scripts/automation/"+\
52 "trex_control_plane/stl/")
53 from trex_stl_lib.api import *
55 stream_table = {'IMIX_v4_1': [{'size': 64, 'pps': 28, 'isg':0},
56 {'size': 570, 'pps': 16, 'isg':0.1},
57 {'size': 1518, 'pps': 4, 'isg':0.2}]
60 def generate_payload(length):
63 :param length: Length of payload.
65 :return: Payload filled with chars.
70 alphabet_size = len(string.letters)
71 for i in range(length):
72 word += string.letters[(i % alphabet_size)]
77 def get_start_end_ipv6(start_ip, end_ip):
78 """Get start and end host from IPv6 as integer.
80 :param start_ip: Start IPv6.
81 :param end_ip: End IPv6.
82 :type start_ip: string
84 :return: Start host, end host.
89 ip1 = socket.inet_pton(socket.AF_INET6, start_ip)
90 ip2 = socket.inet_pton(socket.AF_INET6, end_ip)
92 hi1, lo1 = struct.unpack('!QQ', ip1)
93 hi2, lo2 = struct.unpack('!QQ', ip2)
95 if ((hi1 << 64) | lo1) > ((hi2 << 64) | lo2):
96 print "IPv6: start_ip is greater then end_ip"
99 max_p1 = abs(int(lo1) - int(lo2))
101 except AddressValueError as ex_error:
105 return base_p1, max_p1
107 def create_streams_v46(base_pkt_a, base_pkt_b, vm1, vm2, frame_size):
108 """Create STLStream streams
110 :param base_pkt_a: Base packet a for stream_a
111 :param base_pkt_b: Base packet b for stream_b
112 :param vm1: vm for stream_a
113 :param vm2: vm for stream_b
114 :param frame_size: frame size or name of traffic profile
115 :type base_pkt_a: Eth (scapy)
116 :type base_pkt_b: Eth (scapy)
117 :type vm1: STLScVmRaw
118 :type vm2: STLScVmRaw
119 :frame_size: int or string
120 :return: stream_a, stream_b, stream_a_latency, stream_b_latency
121 :rtype: STLStream, STLStream, STLStream, STLStream
124 if type(frame_size) is int:
126 fsize_no_fcs = frame_size - 4 # no FCS
127 pkt_a = STLPktBuilder(pkt=base_pkt_a/generate_payload(
128 max(0, fsize_no_fcs-len(base_pkt_a))), vm=vm1)
129 pkt_b = STLPktBuilder(pkt=base_pkt_b/generate_payload(
130 max(0, fsize_no_fcs-len(base_pkt_b))), vm=vm2)
131 pkt_lat_a = STLPktBuilder(pkt=base_pkt_a/generate_payload(
132 max(0, fsize_no_fcs-len(base_pkt_a))))
133 pkt_lat_b = STLPktBuilder(pkt=base_pkt_b/generate_payload(
134 max(0, fsize_no_fcs-len(base_pkt_b))))
135 lat_stream1 = STLStream(packet=pkt_lat_a,
136 flow_stats=STLFlowLatencyStats(pg_id=0),
137 mode=STLTXCont(pps=9000))
138 # second traffic stream with a phase of 10ns (inter stream gap)
139 lat_stream2 = STLStream(packet=pkt_lat_b,
141 flow_stats=STLFlowLatencyStats(pg_id=1),
142 mode=STLTXCont(pps=9000))
144 stream1 = STLStream(packet=pkt_a,
145 mode=STLTXCont(pps=9000))
146 # second traffic stream with a phase of 10ns (inter stream gap)
147 stream2 = STLStream(packet=pkt_b,
149 mode=STLTXCont(pps=9000))
150 elif type(frame_size) is str:
156 for x in stream_table[frame_size]:
157 fsize_no_fcs = x['size'] - 4 # no FCS
158 pkt_a = STLPktBuilder(pkt=base_pkt_a/generate_payload(
159 max(0, fsize_no_fcs-len(base_pkt_a))), vm=vm1)
160 pkt_b = STLPktBuilder(pkt=base_pkt_b/generate_payload(
161 max(0, fsize_no_fcs-len(base_pkt_b))), vm=vm2)
163 stream1.append(STLStream(packet=pkt_a,
165 mode=STLTXCont(pps=x['pps'])))
166 stream2.append(STLStream(packet=pkt_b,
168 mode=STLTXCont(pps=x['pps'])))
171 raise ValueError("Unknown frame_size type")
173 return (stream1, stream2, lat_stream1, lat_stream2)
176 def create_streams(traffic_options, frame_size=64):
177 """Create two IP packets to be used in stream.
179 :param traffic_options: Parameters for packets.
180 :param frame_size: Size of L2 frame.
181 :type traffic_options: dict
182 :type frame_size: int
183 :return: Packet instances.
184 :rtype: Tuple of STLPktBuilder
187 if type(frame_size) is int and frame_size < 64:
188 print_error("Frame min. size is 64B")
191 p1_src_start_ip = traffic_options['p1_src_start_ip']
192 p1_src_end_ip = traffic_options['p1_src_end_ip']
193 p1_dst_start_ip = traffic_options['p1_dst_start_ip']
194 p2_src_start_ip = traffic_options['p2_src_start_ip']
195 p2_src_end_ip = traffic_options['p2_src_end_ip']
196 p2_dst_start_ip = traffic_options['p2_dst_start_ip']
198 p1_dst_end_ip = traffic_options['p1_dst_end_ip']
199 p2_dst_end_ip = traffic_options['p2_dst_end_ip']
202 p1_src_start_udp_port = traffic_options['p1_src_start_udp_port']
203 p1_src_end_udp_port = traffic_options['p1_src_end_udp_port']
204 p1_dst_start_udp_port = traffic_options['p1_dst_start_udp_port']
205 p2_src_start_udp_port = traffic_options['p2_src_start_udp_port']
206 p2_dst_start_udp_port = traffic_options['p2_dst_start_udp_port']
207 p2_dst_end_udp_port = traffic_options['p2_dst_end_udp_port']
210 ports_defined = False
213 base_pkt_a = (Ether() /
214 IP(src=p1_src_start_ip, dst=p1_dst_start_ip, proto=17) /
215 UDP(sport=int(p1_src_start_udp_port),
216 dport=int(p1_dst_start_udp_port)))
217 base_pkt_b = (Ether() /
218 IP(src=p2_src_start_ip, dst=p2_dst_start_ip, proto=17) /
219 UDP(sport=int(p2_src_start_udp_port),
220 dport=int(p2_dst_start_udp_port)))
222 base_pkt_a = Ether() / IP(src=p1_src_start_ip, dst=p1_dst_start_ip,
224 base_pkt_b = Ether() / IP(src=p2_src_start_ip, dst=p2_dst_start_ip,
227 # The following code applies raw instructions to packet (IP src/dst
228 # increment). It splits the generated traffic by "ip_src"/"ip_dst" variable
229 # to cores and fix IPv4 header checksum.
231 if p1_src_start_udp_port != p1_src_end_udp_port and \
232 p1_src_start_ip != p1_src_end_ip:
234 STLVmTupleGen(ip_min=p1_src_start_ip,
235 ip_max=p1_src_end_ip,
236 port_min=int(p1_src_start_udp_port),
237 port_max=int(p1_src_end_udp_port),
239 STLVmWrFlowVar(fv_name="tuple.ip", pkt_offset="IP.src"),
240 STLVmFixIpv4(offset="IP"),
241 STLVmWrFlowVar(fv_name="tuple.port", pkt_offset="UDP.sport")
244 STLVmTupleGen(ip_min=p2_dst_start_ip,
245 ip_max=p2_dst_start_ip,
246 port_min=int(p2_dst_start_udp_port),
247 port_max=int(p2_dst_end_udp_port),
249 STLVmWrFlowVar(fv_name="tuple.ip", pkt_offset="IP.dst"),
250 STLVmFixIpv4(offset="IP"),
251 STLVmWrFlowVar(fv_name="tuple.port", pkt_offset="UDP.dport")
253 elif p1_src_start_udp_port != p1_src_end_udp_port:
255 STLVmFlowVar(name="sport",
256 min_value=int(p1_src_start_udp_port),
257 max_value=int(p1_src_end_udp_port),
259 STLVmWrFlowVar(fv_name="sport", pkt_offset="UDP.sport")
262 STLVmFlowVar(name="dport",
263 min_value=int(p2_dst_start_udp_port),
264 max_value=int(p2_dst_end_udp_port),
266 STLVmWrFlowVar(fv_name="dport", pkt_offset="UDP.dport")
268 elif p1_src_start_udp_port == p1_src_end_udp_port:
269 vm1 = STLScVmRaw([STLVmFlowVar(name="src",
270 min_value=p1_src_start_ip,
271 max_value=p1_src_end_ip,
273 STLVmWrFlowVar(fv_name="src",
274 pkt_offset="IP.src"),
275 STLVmFixIpv4(offset="IP"),
276 ], split_by_field="src")
277 vm2 = STLScVmRaw([STLVmFlowVar(name="src",
278 min_value=p2_src_start_ip,
279 max_value=p2_src_end_ip,
281 STLVmWrFlowVar(fv_name="src",
282 pkt_offset="IP.src"),
283 STLVmFixIpv4(offset="IP"),
284 ], split_by_field="src")
285 elif p1_dst_end_ip and p2_dst_end_ip:
286 vm1 = STLScVmRaw([STLVmFlowVar(name="dst",
287 min_value=p1_dst_start_ip,
288 max_value=p1_dst_end_ip,
290 STLVmWrFlowVar(fv_name="dst", pkt_offset="IP.dst"),
291 STLVmFixIpv4(offset="IP"),
292 ], split_by_field="dst")
293 vm2 = STLScVmRaw([STLVmFlowVar(name="dst",
294 min_value=p2_dst_start_ip,
295 max_value=p2_dst_end_ip,
297 STLVmWrFlowVar(fv_name="dst", pkt_offset="IP.dst"),
298 STLVmFixIpv4(offset="IP"),
299 ], split_by_field="dst")
301 vm1 = STLScVmRaw([STLVmFlowVar(name="src",
302 min_value=p1_src_start_ip,
303 max_value=p1_src_end_ip,
305 STLVmWrFlowVar(fv_name="src", pkt_offset="IP.src"),
306 STLVmFixIpv4(offset="IP"),
307 ], split_by_field="src")
308 vm2 = STLScVmRaw([STLVmFlowVar(name="src",
309 min_value=p2_src_start_ip,
310 max_value=p2_src_end_ip,
312 STLVmWrFlowVar(fv_name="src", pkt_offset="IP.src"),
313 STLVmFixIpv4(offset="IP"),
314 ], split_by_field="src")
316 return create_streams_v46(base_pkt_a, base_pkt_b, vm1, vm2, frame_size)
319 def create_streams_v6(traffic_options, frame_size=78):
320 """Create two IPv6 packets to be used in stream.
322 :param traffic_options: Parameters for packets.
323 :param frame_size: Size of L2 frame.
324 :type traffic_options: List
325 :type frame_size: int
326 :return: Packet instances.
327 :rtype: Tuple of STLPktBuilder
330 if type(frame_size) is int and frame_size < 78:
331 print_error("Frame min. size is 78B")
334 p1_src_start_ip = traffic_options['p1_src_start_ip']
335 p1_src_end_ip = traffic_options['p1_src_end_ip']
336 p1_dst_start_ip = traffic_options['p1_dst_start_ip']
337 p2_src_start_ip = traffic_options['p2_src_start_ip']
338 p2_src_end_ip = traffic_options['p2_src_end_ip']
339 p2_dst_start_ip = traffic_options['p2_dst_start_ip']
341 p1_dst_end_ip = traffic_options['p1_dst_end_ip']
342 p2_dst_end_ip = traffic_options['p2_dst_end_ip']
344 base_pkt_a = Ether()/IPv6(src=p1_src_start_ip, dst=p1_dst_start_ip)
345 base_pkt_b = Ether()/IPv6(src=p2_src_start_ip, dst=p2_dst_start_ip)
347 # The following code applies raw instructions to packet (IP src/dst
348 # increment). It splits the generated traffic by "ip_src"/"ip_dst" variable
350 if p1_dst_end_ip and p2_dst_end_ip:
351 base_p1, max_p1 = get_start_end_ipv6(p1_dst_start_ip, p1_dst_end_ip)
352 base_p2, max_p2 = get_start_end_ipv6(p2_dst_start_ip, p2_dst_end_ip)
354 vm1 = STLScVmRaw([STLVmFlowVar(name="ipv6_dst",
356 max_value=max_p1+base_p1,
358 STLVmWrFlowVar(fv_name="ipv6_dst",
359 pkt_offset="IPv6.dst",
362 , split_by_field="ipv6_dst")
363 vm2 = STLScVmRaw([STLVmFlowVar(name="ipv6_dst",
365 max_value=max_p2+base_p2,
367 STLVmWrFlowVar(fv_name="ipv6_dst",
368 pkt_offset="IPv6.dst",
371 , split_by_field="ipv6_dst")
373 base_p1, max_p1 = get_start_end_ipv6(p1_src_start_ip, p1_src_end_ip)
374 base_p2, max_p2 = get_start_end_ipv6(p2_src_start_ip, p2_src_end_ip)
376 vm1 = STLScVmRaw([STLVmFlowVar(name="ipv6_src",
378 max_value=max_p1+base_p1,
380 STLVmWrFlowVar(fv_name="ipv6_src",
381 pkt_offset="IPv6.src",
384 , split_by_field="ipv6_src")
385 vm2 = STLScVmRaw([STLVmFlowVar(name="ipv6_src",
387 max_value=max_p2+base_p2,
389 STLVmWrFlowVar(fv_name="ipv6_src",
390 pkt_offset="IPv6.src",
393 , split_by_field="ipv6_src")
395 return create_streams_v46(base_pkt_a, base_pkt_b, vm1, vm2, frame_size)
397 def fmt_latency(lat_min, lat_avg, lat_max):
398 """ Return formatted, rounded latency
400 :param lat_min: Min latency
401 :param lat_avg: Average latency
402 :param lat_max: Max latency
403 :type lat_min: string
404 :type lat_avg: string
405 :type lat_max: string
406 :return: Formatted and rounded output "min/avg/max"
411 t_min = int(round(float(lat_min)))
415 t_avg = int(round(float(lat_avg)))
419 t_max = int(round(float(lat_max)))
423 return "/".join(str(tmp) for tmp in (t_min, t_avg, t_max))
425 def simple_burst(stream_a, stream_b, stream_lat_a, stream_lat_b, duration, rate,
426 warmup_time, async_start, latency):
427 """Run the traffic with specific parameters.
429 :param pkt_a: Base packet for stream 1.
430 :param pkt_b: Base packet for stream 2.
431 :param pkt_lat_a: Base packet for latency stream 1.
432 :param pkt_lat_b: Base packet for latency stream 2.
433 :param duration: Duration of traffic run in seconds (-1=infinite).
434 :param rate: Rate of traffic run [percentage, pps, bps].
435 :param warmup_time: Warm up duration.
436 :param async_start: Start the traffic and exit.
437 :param latency: With latency stats.
438 :type pkt_a: STLPktBuilder
439 :type pkt_b: STLPktBuilder
440 :type pkt_lat_a: STLPktBuilder
441 :type pkt_lat_b: STLPktBuilder
444 :type warmup_time: int
445 :type async_start: bool
461 # turn this off if too many logs
462 #client.set_verbose("high")
467 # prepare our ports (my machine has 0 <--> 1 with static route)
468 client.reset(ports=[0, 1])
470 client.add_streams(stream_a, ports=[0])
471 client.add_streams(stream_b, ports=[1])
475 client.add_streams(stream_lat_a, ports=[0])
476 client.add_streams(stream_lat_b, ports=[1])
478 #Disable latency if NIC does not support requested stream type
479 print "##### FAILED to add latency streams #####"
484 # clear the stats before injecting
487 # choose rate and start traffic
488 client.start(ports=[0, 1], mult=rate, duration=warmup_time)
491 client.wait_on_traffic(ports=[0, 1], timeout=(warmup_time+30))
493 if client.get_warnings():
494 for warning in client.get_warnings():
497 # read the stats after the test
498 stats = client.get_stats()
500 print "#####warmup statistics#####"
501 print json.dumps(stats, indent=4,
502 separators=(',', ': '), sort_keys=True)
503 lost_a = stats[0]["opackets"] - stats[1]["ipackets"]
504 lost_b = stats[1]["opackets"] - stats[0]["ipackets"]
506 print "\npackets lost from 0 --> 1: {0} pkts".format(lost_a)
507 print "packets lost from 1 --> 0: {0} pkts".format(lost_b)
509 # clear the stats before injecting
514 # choose rate and start traffic
515 client.start(ports=[0, 1], mult=rate, duration=duration)
519 client.wait_on_traffic(ports=[0, 1], timeout=(duration+30))
521 if client.get_warnings():
522 for warning in client.get_warnings():
525 # read the stats after the test
526 stats = client.get_stats()
528 print "#####statistics#####"
529 print json.dumps(stats, indent=4,
530 separators=(',', ': '), sort_keys=True)
531 lost_a = stats[0]["opackets"] - stats[1]["ipackets"]
532 lost_b = stats[1]["opackets"] - stats[0]["ipackets"]
535 lat_a = fmt_latency(\
536 str(stats["latency"][0]["latency"]["total_min"]),\
537 str(stats["latency"][0]["latency"]["average"]),\
538 str(stats["latency"][0]["latency"]["total_max"]))
539 lat_b = fmt_latency(\
540 str(stats["latency"][1]["latency"]["total_min"]),\
541 str(stats["latency"][1]["latency"]["average"]),\
542 str(stats["latency"][1]["latency"]["total_max"]))
544 total_sent = stats[0]["opackets"] + stats[1]["opackets"]
545 total_rcvd = stats[0]["ipackets"] + stats[1]["ipackets"]
547 print "\npackets lost from 0 --> 1: {0} pkts".format(lost_a)
548 print "packets lost from 1 --> 0: {0} pkts".format(lost_b)
550 except STLError as ex_error:
551 print_error(str(ex_error))
556 client.disconnect(stop_traffic=False, release_ports=True)
559 print "rate={0}, totalReceived={1}, totalSent={2}, "\
560 "frameLoss={3}, latencyStream0(usec)={4}, "\
561 "latencyStream1(usec)={5}".format(rate, total_rcvd,\
562 total_sent, lost_a+lost_b, lat_a, lat_b)
565 def print_error(msg):
566 """Print error message on stderr.
568 :param msg: Error message to print.
573 sys.stderr.write(msg+'\n')
577 """Parse arguments from cmd line.
579 :return: Parsed arguments.
580 :rtype ArgumentParser
583 parser = argparse.ArgumentParser()
584 parser.add_argument("-d", "--duration", required=True, type=int,
585 help="Duration of traffic run")
586 parser.add_argument("-s", "--frame_size", required=True,
587 help="Size of a Frame without padding and IPG")
588 parser.add_argument("-r", "--rate", required=True,
589 help="Traffic rate with included units (%, pps)")
590 parser.add_argument("-6", "--use_IPv6", action="store_true",
592 help="Use IPv6 traffic profile instead of IPv4")
593 parser.add_argument("--async", action="store_true",
595 help="Non-blocking call of the script")
596 parser.add_argument("--latency", action="store_true",
598 help="Add latency stream")
599 parser.add_argument("-w", "--warmup_time", type=int,
601 help="Traffic warmup time in seconds, 0 = disable")
602 # parser.add_argument("--p1_src_mac",
603 # help="Port 1 source MAC address")
604 # parser.add_argument("--p1_dst_mac",
605 # help="Port 1 destination MAC address")
607 parser.add_argument("--p1_src_start_ip", required=True,
608 help="Port 1 source start IP address")
609 parser.add_argument("--p1_src_end_ip",
611 help="Port 1 source end IP address")
612 parser.add_argument("--p1_dst_start_ip", required=True,
613 help="Port 1 destination start IP address")
614 parser.add_argument("--p1_dst_end_ip",
616 help="Port 1 destination end IP address")
618 parser.add_argument("--p1_src_start_udp_port",
620 help="Port 1 source start UDP port.")
621 parser.add_argument("--p1_src_end_udp_port",
623 help="Port 1 source end UDP port.")
625 parser.add_argument("--p1_dst_start_udp_port",
627 help="Port 1 destination start UDP port.")
628 parser.add_argument("--p1_dst_end_udp_port",
630 help="Port 1 destination end UDP port.")
632 # parser.add_argument("--p2_src_mac",
633 # help="Port 2 source MAC address")
634 # parser.add_argument("--p2_dst_mac",
635 # help="Port 2 destination MAC address")
637 parser.add_argument("--p2_src_start_ip", required=True,
638 help="Port 2 source start IP address")
639 parser.add_argument("--p2_src_end_ip",
641 help="Port 2 source end IP address")
642 parser.add_argument("--p2_dst_start_ip", required=True,
643 help="Port 2 destination start IP address")
644 parser.add_argument("--p2_dst_end_ip",
646 help="Port 2 destination end IP address")
648 parser.add_argument("--p2_src_start_udp_port",
650 help="Port 2 source start UDP port.")
651 parser.add_argument("--p2_src_end_udp_port",
653 help="Port 2 source end UDP port.")
655 parser.add_argument("--p2_dst_start_udp_port",
657 help="Port 2 destination start UDP port.")
658 parser.add_argument("--p2_dst_end_udp_port",
660 help="Port 2 destination end UDP port.")
662 return parser.parse_args()
670 _duration = args.duration
671 _latency = args.latency
672 if args.frame_size.isdigit():
673 _frame_size = int(args.frame_size)
675 _frame_size = args.frame_size
678 _use_ipv6 = args.use_IPv6
679 _async_call = args.async
680 _warmup_time = args.warmup_time
682 _traffic_options = {}
683 for attr in [a for a in dir(args) if a.startswith('p')]:
684 if getattr(args, attr) is not None:
685 _traffic_options[attr] = getattr(args, attr)
688 stream_a, stream_b, stream_lat_a, stream_lat_b = create_streams_v6(
689 _traffic_options, frame_size=_frame_size)
691 stream_a, stream_b, stream_lat_a, stream_lat_b = create_streams(
692 _traffic_options, frame_size=_frame_size)
694 simple_burst(stream_a, stream_b, stream_lat_a, stream_lat_b,
695 _duration, _rate, _warmup_time, _async_call, _latency)
697 if __name__ == "__main__":