path: root/resources/tools/t-rex/t-rex-stateless.py

#!/usr/bin/python

# Copyright (c) 2016 Cisco and/or its affiliates.
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at:
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

"""This script uses T-REX stateless API to drive t-rex instance.

Requirements:
- T-REX: https://github.com/cisco-system-traffic-generator/trex-core
 - compiled and running T-REX process (eg. ./t-rex-64 -i -c 4)
 - trex_stl_lib.api library
- Script must be executed on a node with T-REX instance
- 2 interfaces must be configured in configuretion file /etc/trex_cfg.yaml

##################### Example of /etc/trex_cfg.yaml ##########################
- port_limit      : 2 # numbers of ports to use
  version         : 2
  interfaces      : ["84:00.0","84:00.1"] # PCI address of interfaces
  port_info       :  # set eth mac addr
          - dest_mac        :   [0x90,0xe2,0xba,0x1f,0x97,0xd5]  # port 0
            src_mac         :   [0x90,0xe2,0xba,0x1f,0x97,0xd4]
          - dest_mac        :   [0x90,0xe2,0xba,0x1f,0x97,0xd4]  # port 1
            src_mac         :   [0x90,0xe2,0xba,0x1f,0x97,0xd5]
##############################################################################

Functionality:
1. Configure traffic on running T-REX instance
2. Clear statistics on all ports
3. Ctart traffic with specified duration
4. Print statistics to stdout

"""

import argparse
import json
import socket
import string
import struct
import sys

sys.path.insert(0, "/opt/trex-core-2.22/scripts/automation/"+\
                   "trex_control_plane/stl/")
from trex_stl_lib.api import *

stream_table = {'IMIX_v4_1': [{'size': 64, 'pps': 28, 'isg':0},
                              {'size': 570, 'pps': 16, 'isg':0.1},
                              {'size': 1518, 'pps': 4, 'isg':0.2}]
               }

def generate_payload(length):
    """Generate payload.

    :param length: Length of payload.
    :type length: int
    :return: Payload filled with chars.
    :rtype string
    """

    word = ''
    alphabet_size = len(string.letters)
    for i in range(length):
        word += string.letters[(i % alphabet_size)]

    return word


def get_start_end_ipv6(start_ip, end_ip):
    """Get start and end host from IPv6 as integer.

    :param start_ip: Start IPv6.
    :param end_ip: End IPv6.
    :type start_ip: string
    :type end_ip: string
    :return: Start host, end host.
    :rtype int
    """

    try:
        ip1 = socket.inet_pton(socket.AF_INET6, start_ip)
        ip2 = socket.inet_pton(socket.AF_INET6, end_ip)

        hi1, lo1 = struct.unpack('!QQ', ip1)
        hi2, lo2 = struct.unpack('!QQ', ip2)

        if ((hi1 << 64) | lo1) > ((hi2 << 64) | lo2):
            print "IPv6: start_ip is greater then end_ip"
            sys.exit(2)

        max_p1 = abs(int(lo1) - int(lo2))
        base_p1 = lo1
    except AddressValueError as ex_error:
        print ex_error
        sys.exit(2)

    return base_p1, max_p1

def create_streams_v46(base_pkt_a, base_pkt_b, vm1, vm2, frame_size):
    """Create STLStream streams

    :param base_pkt_a: Base packet a for stream_a
    :param base_pkt_b: Base packet b for stream_b
    :param vm1: vm for stream_a
    :param vm2: vm for stream_b
    :param frame_size: frame size or name of traffic profile
    :type base_pkt_a: Eth (scapy)
    :type base_pkt_b: Eth (scapy)
    :type vm1: STLScVmRaw
    :type vm2: STLScVmRaw
    :frame_size: int or string
    :return: stream_a, stream_b, stream_a_latency, stream_b_latency
    :rtype: STLStream, STLStream, STLStream, STLStream
    """

    if type(frame_size) is int:

        fsize_no_fcs = frame_size - 4 # no FCS
        pkt_a = STLPktBuilder(pkt=base_pkt_a/generate_payload(
            max(0, fsize_no_fcs-len(base_pkt_a))), vm=vm1)
        pkt_b = STLPktBuilder(pkt=base_pkt_b/generate_payload(
            max(0, fsize_no_fcs-len(base_pkt_b))), vm=vm2)
        pkt_lat_a = STLPktBuilder(pkt=base_pkt_a/generate_payload(
            max(0, fsize_no_fcs-len(base_pkt_a))))
        pkt_lat_b = STLPktBuilder(pkt=base_pkt_b/generate_payload(
            max(0, fsize_no_fcs-len(base_pkt_b))))
        lat_stream1 = STLStream(packet=pkt_lat_a,
                                flow_stats=STLFlowLatencyStats(pg_id=0),
                                mode=STLTXCont(pps=9000))
        # second traffic stream with a phase of 10ns (inter stream gap)
        lat_stream2 = STLStream(packet=pkt_lat_b,
                                isg=10.0,
                                flow_stats=STLFlowLatencyStats(pg_id=1),
                                mode=STLTXCont(pps=9000))

        stream1 = STLStream(packet=pkt_a,
                            mode=STLTXCont(pps=9000))
        # second traffic stream with a phase of 10ns (inter stream gap)
        stream2 = STLStream(packet=pkt_b,
                            isg=10.0,
                            mode=STLTXCont(pps=9000))
    elif type(frame_size) is str:
        lat_stream1 = []
        lat_stream2 = []
        stream1 = []
        stream2 = []

        for x in stream_table[frame_size]:
            fsize_no_fcs = x['size'] - 4 # no FCS
            pkt_a = STLPktBuilder(pkt=base_pkt_a/generate_payload(
                max(0, fsize_no_fcs-len(base_pkt_a))), vm=vm1)
            pkt_b = STLPktBuilder(pkt=base_pkt_b/generate_payload(
                max(0, fsize_no_fcs-len(base_pkt_b))), vm=vm2)

            stream1.append(STLStream(packet=pkt_a,
                               isg=x['isg'],
                               mode=STLTXCont(pps=x['pps'])))
            stream2.append(STLStream(packet=pkt_b,
                               isg=x['isg'],
                               mode=STLTXCont(pps=x['pps'])))

    else:
        raise ValueError("Unknown frame_size type")

    return (stream1, stream2, lat_stream1, lat_stream2)


def create_streams(traffic_options, frame_size=64):
    """Create two IP packets to be used in stream.

    :param traffic_options: Parameters for packets.
    :param frame_size: Size of L2 frame.
    :type traffic_options: dict
    :type frame_size: int
    :return: Packet instances.
    :rtype: Tuple of STLPktBuilder
    """

    if type(frame_size) is int and frame_size < 64:
        print_error("Frame min. size is 64B")
        sys.exit(1)

    p1_src_start_ip = traffic_options['p1_src_start_ip']
    p1_src_end_ip = traffic_options['p1_src_end_ip']
    p1_dst_start_ip = traffic_options['p1_dst_start_ip']
    p2_src_start_ip = traffic_options['p2_src_start_ip']
    p2_src_end_ip = traffic_options['p2_src_end_ip']
    p2_dst_start_ip = traffic_options['p2_dst_start_ip']

    p1_dst_end_ip = traffic_options['p1_dst_end_ip']
    p2_dst_end_ip = traffic_options['p2_dst_end_ip']

    try:
        p1_src_start_udp_port = traffic_options['p1_src_start_udp_port']
        p1_src_end_udp_port = traffic_options['p1_src_end_udp_port']
        p1_dst_start_udp_port = traffic_options['p1_dst_start_udp_port']
        p2_src_start_udp_port = traffic_options['p2_src_start_udp_port']
        p2_dst_start_udp_port = traffic_options['p2_dst_start_udp_port']
        p2_dst_end_udp_port = traffic_options['p2_dst_end_udp_port']
        ports_defined = True
    except KeyError:
        ports_defined = False

    if ports_defined:
        base_pkt_a = (Ether() /
                      IP(src=p1_src_start_ip, dst=p1_dst_start_ip, proto=17) /
                      UDP(sport=int(p1_src_start_udp_port),
                          dport=int(p1_dst_start_udp_port)))
        base_pkt_b = (Ether() /
                      IP(src=p2_src_start_ip, dst=p2_dst_start_ip, proto=17) /
                      UDP(sport=int(p2_src_start_udp_port),
                          dport=int(p2_dst_start_udp_port)))
    else:
        base_pkt_a = Ether() / IP(src=p1_src_start_ip, dst=p1_dst_start_ip,
                                  proto=61)
        base_pkt_b = Ether() / IP(src=p2_src_start_ip, dst=p2_dst_start_ip,
                                  proto=61)

    # The following code applies raw instructions to packet (IP src/dst
    # increment). It splits the generated traffic by "ip_src"/"ip_dst" variable
    # to cores and fix IPv4 header checksum.
    if ports_defined:
        if p1_src_start_udp_port != p1_src_end_udp_port and \
                        p1_src_start_ip != p1_src_end_ip:
            vm1 = STLScVmRaw([
                STLVmTupleGen(ip_min=p1_src_start_ip,
                              ip_max=p1_src_end_ip,
                              port_min=int(p1_src_start_udp_port),
                              port_max=int(p1_src_end_udp_port),
                              name="tuple"),
                STLVmWrFlowVar(fv_name="tuple.ip", pkt_offset="IP.src"),
                STLVmFixIpv4(offset="IP"),
                STLVmWrFlowVar(fv_name="tuple.port", pkt_offset="UDP.sport")
            ])
            vm2 = STLScVmRaw([
                STLVmTupleGen(ip_min=p2_dst_start_ip,
                              ip_max=p2_dst_start_ip,
                              port_min=int(p2_dst_start_udp_port),
                              port_max=int(p2_dst_end_udp_port),
                              name="tuple"),
                STLVmWrFlowVar(fv_name="tuple.ip", pkt_offset="IP.dst"),
                STLVmFixIpv4(offset="IP"),
                STLVmWrFlowVar(fv_name="tuple.port", pkt_offset="UDP.dport")
            ])
        elif p1_src_start_udp_port != p1_src_end_udp_port:
            vm1 = STLScVmRaw([
                STLVmFlowVar(name="sport",
                             min_value=int(p1_src_start_udp_port),
                             max_value=int(p1_src_end_udp_port),
                             size=2, op="inc"),
                STLVmWrFlowVar(fv_name="sport", pkt_offset="UDP.sport")
                ])
            vm2 = STLScVmRaw([
                STLVmFlowVar(name="dport",
                             min_value=int(p2_dst_start_udp_port),
                             max_value=int(p2_dst_end_udp_port),
                             size=2, op="inc"),
                STLVmWrFlowVar(fv_name="dport", pkt_offset="UDP.dport")
            ])
        elif p1_src_start_udp_port == p1_src_end_udp_port:
            vm1 = STLScVmRaw([STLVmFlowVar(name="src",
                                           min_value=p1_src_start_ip,
                                           max_value=p1_src_end_ip,
                                           size=4, op="inc"),
                              STLVmWrFlowVar(fv_name="src",
                                             pkt_offset="IP.src"),
                              STLVmFixIpv4(offset="IP"),
                              ], split_by_field="src")
            vm2 = STLScVmRaw([STLVmFlowVar(name="src",
                                           min_value=p2_src_start_ip,
                                           max_value=p2_src_end_ip,
                                           size=4, op="inc"),
                              STLVmWrFlowVar(fv_name="src",
                                             pkt_offset="IP.src"),
                              STLVmFixIpv4(offset="IP"),
                              ], split_by_field="src")
    elif p1_dst_end_ip and p2_dst_end_ip:
        vm1 = STLScVmRaw([STLVmFlowVar(name="dst",
                                       min_value=p1_dst_start_ip,
                                       max_value=p1_dst_end_ip,
                                       size=4, op="inc"),
                          STLVmWrFlowVar(fv_name="dst", pkt_offset="IP.dst"),
                          STLVmFixIpv4(offset="IP"),
                         ], split_by_field="dst")
        vm2 = STLScVmRaw([STLVmFlowVar(name="dst",
                                       min_value=p2_dst_start_ip,
                                       max_value=p2_dst_end_ip,
                                       size=4, op="inc"),
                          STLVmWrFlowVar(fv_name="dst", pkt_offset="IP.dst"),
                          STLVmFixIpv4(offset="IP"),
                         ], split_by_field="dst")
    else:
        vm1 = STLScVmRaw([STLVmFlowVar(name="src",
                                       min_value=p1_src_start_ip,
                                       max_value=p1_src_end_ip,
                                       size=4, op="inc"),
                          STLVmWrFlowVar(fv_name="src", pkt_offset="IP.src"),
                          STLVmFixIpv4(offset="IP"),
                         ], split_by_field="src")
        vm2 = STLScVmRaw([STLVmFlowVar(name="src",
                                       min_value=p2_src_start_ip,
                                       max_value=p2_src_end_ip,
                                       size=4, op="inc"),
                          STLVmWrFlowVar(fv_name="src", pkt_offset="IP.src"),
                          STLVmFixIpv4(offset="IP"),
                         ], split_by_field="src")

    return create_streams_v46(base_pkt_a, base_pkt_b, vm1, vm2, frame_size)


def create_streams_v6(traffic_options, frame_size=78):
    """Create two IPv6 packets to be used in stream.

    :param traffic_options: Parameters for packets.
    :param frame_size: Size of L2 frame.
    :type traffic_options: List
    :type frame_size: int
    :return: Packet instances.
    :rtype: Tuple of STLPktBuilder
    """

    if type(frame_size) is int and frame_size < 78:
        print_error("Frame min. size is 78B")
        sys.exit(2)

    p1_src_start_ip = traffic_options['p1_src_start_ip']
    p1_src_end_ip = traffic_options['p1_src_end_ip']
    p1_dst_start_ip = traffic_options['p1_dst_start_ip']
    p2_src_start_ip = traffic_options['p2_src_start_ip']
    p2_src_end_ip = traffic_options['p2_src_end_ip']
    p2_dst_start_ip = traffic_options['p2_dst_start_ip']

    p1_dst_end_ip = traffic_options['p1_dst_end_ip']
    p2_dst_end_ip = traffic_options['p2_dst_end_ip']

    base_pkt_a = Ether()/IPv6(src=p1_src_start_ip, dst=p1_dst_start_ip)
    base_pkt_b = Ether()/IPv6(src=p2_src_start_ip, dst=p2_dst_start_ip)

    # The following code applies raw instructions to packet (IP src/dst
    # increment). It splits the generated traffic by "ip_src"/"ip_dst" variable
    # to cores.
    if p1_dst_end_ip and p2_dst_end_ip:
        base_p1, max_p1 = get_start_end_ipv6(p1_dst_start_ip, p1_dst_end_ip)
        base_p2, max_p2 = get_start_end_ipv6(p2_dst_start_ip, p2_dst_end_ip)

        vm1 = STLScVmRaw([STLVmFlowVar(name="ipv6_dst",
                                       min_value=base_p1,
                                       max_value=max_p1+base_p1,
                                       size=8, op="inc"),
                          STLVmWrFlowVar(fv_name="ipv6_dst",
                                         pkt_offset="IPv6.dst",
                                         offset_fixup=8)
                         ]
                         , split_by_field="ipv6_dst")
        vm2 = STLScVmRaw([STLVmFlowVar(name="ipv6_dst",
                                       min_value=base_p2,
                                       max_value=max_p2+base_p2,
                                       size=8, op="inc"),
                          STLVmWrFlowVar(fv_name="ipv6_dst",
                                         pkt_offset="IPv6.dst",
                                         offset_fixup=8)
                         ]
                         , split_by_field="ipv6_dst")
    else:
        base_p1, max_p1 = get_start_end_ipv6(p1_src_start_ip, p1_src_end_ip)
        base_p2, max_p2 = get_start_end_ipv6(p2_src_start_ip, p2_src_end_ip)

        vm1 = STLScVmRaw([STLVmFlowVar(name="ipv6_src",
                                       min_value=base_p1,
                                       max_value=max_p1+base_p1,
                                       size=8, op="inc"),
                          STLVmWrFlowVar(fv_name="ipv6_src",
                                         pkt_offset="IPv6.src",
                                         offset_fixup=8)
                         ]
                         , split_by_field="ipv6_src")
        vm2 = STLScVmRaw([STLVmFlowVar(name="ipv6_src",
                                       min_value=base_p2,
                                       max_value=max_p2+base_p2,
                                       size=8, op="inc"),
                          STLVmWrFlowVar(fv_name="ipv6_src",
                                         pkt_offset="IPv6.src",
                                         offset_fixup=8)
                         ]
                         , split_by_field="ipv6_src")

    return create_streams_v46(base_pkt_a, base_pkt_b, vm1, vm2, frame_size)

def fmt_latency(lat_min, lat_avg, lat_max):
    """ Return formatted, rounded latency

    :param lat_min: Min latency
    :param lat_avg: Average latency
    :param lat_max: Max latency
    :type lat_min: string
    :type lat_avg: string
    :type lat_max: string
    :return: Formatted and rounded output "min/avg/max"
    :rtype: string
    """

    try:
        t_min = int(round(float(lat_min)))
    except ValueError:
        t_min = int(-1)
    try:
        t_avg = int(round(float(lat_avg)))
    except ValueError:
        t_avg = int(-1)
    try:
        t_max = int(round(float(lat_max)))
    except ValueError:
        t_max = int(-1)

    return "/".join(str(tmp) for tmp in (t_min, t_avg, t_max))

def simple_burst(stream_a, stream_b, stream_lat_a, stream_lat_b, duration, rate,
                 warmup_time, async_start, latency):
    """Run the traffic with specific parameters.

    :param pkt_a: Base packet for stream 1.
    :param pkt_b: Base packet for stream 2.
    :param pkt_lat_a: Base packet for latency stream 1.
    :param pkt_lat_b: Base packet for latency stream 2.
    :param duration: Duration of traffic run in seconds (-1=infinite).
    :param rate: Rate of traffic run [percentage, pps, bps].
    :param warmup_time: Warm up duration.
    :param async_start: Start the traffic and exit.
    :param latency: With latency stats.
    :type pkt_a: STLPktBuilder
    :type pkt_b: STLPktBuilder
    :type pkt_lat_a: STLPktBuilder
    :type pkt_lat_b: STLPktBuilder
    :type duration: int
    :type rate: string
    :type warmup_time: int
    :type async_start: bool
    :type latency: bool
    :return: nothing
    """

    # create client
    client = STLClient()

    total_rcvd = 0
    total_sent = 0
    lost_a = 0
    lost_b = 0
    lat_a = "-1/-1/-1"
    lat_b = "-1/-1/-1"

    try:
        # turn this off if too many logs
        #client.set_verbose("high")

        # connect to server
        client.connect()

        # prepare our ports (my machine has 0 <--> 1 with static route)
        client.reset(ports=[0, 1])

        client.add_streams(stream_a, ports=[0])
        client.add_streams(stream_b, ports=[1])

        if latency:
            try:
                client.add_streams(stream_lat_a, ports=[0])
                client.add_streams(stream_lat_b, ports=[1])
            except:
                #Disable latency if NIC does not support requested stream type
                print "##### FAILED to add latency streams #####"
                latency = False

        #warmup phase
        if warmup_time > 0:
            # clear the stats before injecting
            client.clear_stats()

            # choose rate and start traffic
            client.start(ports=[0, 1], mult=rate, duration=warmup_time)

            # block until done
            client.wait_on_traffic(ports=[0, 1], timeout=(warmup_time+30))

            if client.get_warnings():
                for warning in client.get_warnings():
                    print(warning)

            # read the stats after the test
            stats = client.get_stats()

            print "#####warmup statistics#####"
            print json.dumps(stats, indent=4,
                             separators=(',', ': '), sort_keys=True)
            lost_a = stats[0]["opackets"] - stats[1]["ipackets"]
            lost_b = stats[1]["opackets"] - stats[0]["ipackets"]

            print "\npackets lost from 0 --> 1:   {0} pkts".format(lost_a)
            print "packets lost from 1 --> 0:   {0} pkts".format(lost_b)

        # clear the stats before injecting
        client.clear_stats()
        lost_a = 0
        lost_b = 0

        # choose rate and start traffic
        client.start(ports=[0, 1], mult=rate, duration=duration)

        if not async_start:
            # block until done
            client.wait_on_traffic(ports=[0, 1], timeout=(duration+30))

            if client.get_warnings():
                for warning in client.get_warnings():
                    print(warning)

            # read the stats after the test
            stats = client.get_stats()

            print "#####statistics#####"
            print json.dumps(stats, indent=4,
                             separators=(',', ': '), sort_keys=True)
            lost_a = stats[0]["opackets"] - stats[1]["ipackets"]
            lost_b = stats[1]["opackets"] - stats[0]["ipackets"]

            if latency:
                lat_a = fmt_latency(\
                    str(stats["latency"][0]["latency"]["total_min"]),\
                    str(stats["latency"][0]["latency"]["average"]),\
                    str(stats["latency"][0]["latency"]["total_max"]))
                lat_b = fmt_latency(\
                    str(stats["latency"][1]["latency"]["total_min"]),\
                    str(stats["latency"][1]["latency"]["average"]),\
                    str(stats["latency"][1]["latency"]["total_max"]))

            total_sent = stats[0]["opackets"] + stats[1]["opackets"]
            total_rcvd = stats[0]["ipackets"] + stats[1]["ipackets"]

            print "\npackets lost from 0 --> 1:   {0} pkts".format(lost_a)
            print "packets lost from 1 --> 0:   {0} pkts".format(lost_b)

    except STLError as ex_error:
        print_error(str(ex_error))
        sys.exit(1)

    finally:
        if async_start:
            client.disconnect(stop_traffic=False, release_ports=True)
        else:
            client.disconnect()
            print "rate={0}, totalReceived={1}, totalSent={2}, "\
                "frameLoss={3}, latencyStream0(usec)={4}, "\
                "latencyStream1(usec)={5}".format(rate, total_rcvd,\
                total_sent, lost_a+lost_b, lat_a, lat_b)


def print_error(msg):
    """Print error message on stderr.

    :param msg: Error message to print.
    :type msg: string
    :return: nothing
    """

    sys.stderr.write(msg+'\n')


def parse_args():
    """Parse arguments from cmd line.

    :return: Parsed arguments.
    :rtype ArgumentParser
    """

    parser = argparse.ArgumentParser()
    parser.add_argument("-d", "--duration", required=True, type=int,
                        help="Duration of traffic run")
    parser.add_argument("-s", "--frame_size", required=True,
                        help="Size of a Frame without padding and IPG")
    parser.add_argument("-r", "--rate", required=True,
                        help="Traffic rate with included units (%, pps)")
    parser.add_argument("-6", "--use_IPv6", action="store_true",
                        default=False,
                        help="Use IPv6 traffic profile instead of IPv4")
    parser.add_argument("--async", action="store_true",
                        default=False,
                        help="Non-blocking call of the script")
    parser.add_argument("--latency", action="store_true",
                        default=False,
                        help="Add latency stream")
    parser.add_argument("-w", "--warmup_time", type=int,
                        default=5,
                        help="Traffic warmup time in seconds, 0 = disable")
#    parser.add_argument("--p1_src_mac",
#                        help="Port 1 source MAC address")
#    parser.add_argument("--p1_dst_mac",
#                        help="Port 1 destination MAC address")

    parser.add_argument("--p1_src_start_ip", required=True,
                        help="Port 1 source start IP address")
    parser.add_argument("--p1_src_end_ip",
                        default=False,
                        help="Port 1 source end IP address")
    parser.add_argument("--p1_dst_start_ip", required=True,
                        help="Port 1 destination start IP address")
    parser.add_argument("--p1_dst_end_ip",
                        default=False,
                        help="Port 1 destination end IP address")

    parser.add_argument("--p1_src_start_udp_port",
                        default=None,
                        help="Port 1 source start UDP port.")
    parser.add_argument("--p1_src_end_udp_port",
                        default=None,
                        help="Port 1 source end UDP port.")

    parser.add_argument("--p1_dst_start_udp_port",
                        default=None,
                        help="Port 1 destination start UDP port.")
    parser.add_argument("--p1_dst_end_udp_port",
                        default=None,
                        help="Port 1 destination end UDP port.")

#    parser.add_argument("--p2_src_mac",
#                        help="Port 2 source MAC address")
#    parser.add_argument("--p2_dst_mac",
#                        help="Port 2 destination MAC address")

    parser.add_argument("--p2_src_start_ip", required=True,
                        help="Port 2 source start IP address")
    parser.add_argument("--p2_src_end_ip",
                        default=False,
                        help="Port 2 source end IP address")
    parser.add_argument("--p2_dst_start_ip", required=True,
                        help="Port 2 destination start IP address")
    parser.add_argument("--p2_dst_end_ip",
                        default=False,
                        help="Port 2 destination end IP address")

    parser.add_argument("--p2_src_start_udp_port",
                        default=None,
                        help="Port 2 source start UDP port.")
    parser.add_argument("--p2_src_end_udp_port",
                        default=None,
                        help="Port 2 source end UDP port.")

    parser.add_argument("--p2_dst_start_udp_port",
                        default=None,
                        help="Port 2 destination start UDP port.")
    parser.add_argument("--p2_dst_end_udp_port",
                        default=None,
                        help="Port 2 destination end UDP port.")

    return parser.parse_args()


def main():
    """Main function."""

    args = parse_args()

    _duration = args.duration
    _latency = args.latency
    if args.frame_size.isdigit():
        _frame_size = int(args.frame_size)
    else:
        _frame_size = args.frame_size
        _latency = False
    _rate = args.rate
    _use_ipv6 = args.use_IPv6
    _async_call = args.async
    _warmup_time = args.warmup_time

    _traffic_options = {}
    for attr in [a for a in dir(args) if a.startswith('p')]:
        if getattr(args, attr) is not None:
            _traffic_options[attr] = getattr(args, attr)

    if _use_ipv6:
        stream_a, stream_b, stream_lat_a, stream_lat_b = create_streams_v6(
            _traffic_options, frame_size=_frame_size)
    else:
        stream_a, stream_b, stream_lat_a, stream_lat_b = create_streams(
            _traffic_options, frame_size=_frame_size)

    simple_burst(stream_a, stream_b, stream_lat_a, stream_lat_b,
                 _duration, _rate, _warmup_time, _async_call, _latency)

if __name__ == "__main__":
    sys.exit(main())