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.00/scripts/automation/"+\
                   "trex_control_plane/stl/")
from trex_stl_lib.api import *


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)) + 1
        base_p1 = lo1
    except AddressValueError as ex_error:
        print ex_error
        sys.exit(2)

    return base_p1, max_p1


def create_packets(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: list
    :type frame_size: int
    :return: Packet instances.
    :rtype STLPktBuilder
    """

    if frame_size < 64:
        print_error("Packet min. size is 64B")
        sys.exit(1)

    fsize_no_fcs = frame_size - 4 # no FCS

    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']

    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 increment).
    # It splits the generated traffic by "ip_src" variable to cores and fix
    # IPv4 header checksum.
    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")
    # The following code applies raw instructions to packet (IP src increment).
    # It splits the generated traffic by "ip_src" variable to cores and fix
    # IPv4 header checksum.
    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")

    pkt_a = STLPktBuilder(pkt=base_pkt_a/generate_payload(
        fsize_no_fcs-len(base_pkt_a)), vm=vm1)
    pkt_b = STLPktBuilder(pkt=base_pkt_b/generate_payload(
        fsize_no_fcs-len(base_pkt_b)), vm=vm2)

    return(pkt_a, pkt_b)


def create_packets_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 STLPktBuilder
    """

    if frame_size < 78:
        print "Packet min. size is 78B"
        sys.exit(2)

    fsize_no_fcs = frame_size - 4 # no FCS

    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']

    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)

    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 increment).
    # It splits the generated traffic by "ip_src" variable to cores
    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")

    # The following code applies raw instructions to packet (IP src increment).
    # It splits the generated traffic by "ip_src" variable to cores
    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")

    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)

    return(pkt_a, pkt_b)


def simple_burst(pkt_a, pkt_b, duration, rate, warmup_time, async_start):
    """Run the traffic with specific parameters.

    :param pkt_a: Base packet for stream 1.
    :param pkt_b: Base packet for 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.
    :async_start: Start the traffic and exit
    :type pkt_a: STLPktBuilder
    :type pkt_b: STLPktBuilder
    :type duration: int
    :type rate: string
    :type warmup_time: int
    :type async_start: bool
    :return: nothing
    """

    # create client
    client = STLClient()

    total_rcvd = 0
    total_sent = 0
    lost_a = 0
    lost_b = 0

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

        # create two streams
        stream1 = STLStream(packet=pkt_a,
                            mode=STLTXCont(pps=100))

        # second stream with a phase of 10ns (inter stream gap)
        stream2 = STLStream(packet=pkt_b,
                            isg=10.0,
                            mode=STLTXCont(pps=100))

        # connect to server
        client.connect()

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

        # add both streams to ports
        client.add_streams(stream1, ports=[0])
        client.add_streams(stream2, ports=[1])

        #warmup phase
        if warmup_time > 0:
            client.clear_stats()
            client.start(ports=[0, 1], mult=rate, duration=warmup_time)
            client.wait_on_traffic(ports=[0, 1], timeout=(warmup_time+30))
            stats = client.get_stats()
            print 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()
        total_rcvd = 0
        total_sent = 0
        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))

            # 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"]

            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}"\
                .format(rate, total_rcvd, total_sent, lost_a+lost_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 main():
    """Main function."""

    _traffic_options = {}
    #default L3 profile is IPv4
    _use_ipv6 = False
    #default warmup time is 5 seconds
    _warmup_time = 5
    #default behaviour of this script is sychronous
    _async_call = False

    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, type=int,
                        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",
                        help="Use IPv6 traffic profile instead of IPv4")
    parser.add_argument("--async", action="store_true",
                        help="Non-blocking call of the script")
    parser.add_argument("-w", "--warmup_time", type=int,
                        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", required=True,
                        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",
#                        help="Port 1 destination end IP address")
#    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", required=True,
                        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",
#                        help="Port 2 destination end IP address")

    args = parser.parse_args()

    _duration = args.duration
    _frame_size = args.frame_size
    _rate = args.rate
    _use_ipv6 = args.use_IPv6
    _async_call = args.async

    if args.warmup_time is not None:
        _warmup_time = args.warmup_time

    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:
        pkt_a, pkt_b = create_packets_v6(_traffic_options,
                                         frame_size=_frame_size)
    else:
        pkt_a, pkt_b = create_packets(_traffic_options,
                                      frame_size=_frame_size)

    simple_burst(pkt_a, pkt_b, _duration, _rate, _warmup_time, _async_call)

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