TRex Stateless support

from trex_stl_lib.api import *

class STLS1(object):

    def create_stream (self):

        return STLStream(
            packet =
                    STLPktBuilder(
                        pkt = Ether()/IP(src="16.0.0.1",dst="48.0.0.1")/
                                UDP(dport=12,sport=1025)/(10*'x')                   
                    ),
             mode = STLTXCont())                                                    


    def get_streams (self, direction = 0, **kwargs):                                
        # create 1 stream
        return [ self.create_stream() ]


# dynamic load - used for TRex console or simulator
def register():                                                                     
    return STLS1()

[bash]>sudo ./t-rex-64 -i

[bash]>trex-console                                                    #

Connecting to RPC server on localhost:4501                   [SUCCESS]
connecting to publisher server on localhost:4500             [SUCCESS]
Acquiring ports [0, 1, 2, 3]:                                [SUCCESS]

125.69 [ms]

trex>start -f stl/udp_1pkt_simple.py -m 10mbps -a                      #

Removing all streams from port(s) [0, 1, 2, 3]:              [SUCCESS]
Attaching 1 streams to port(s) [0, 1, 2, 3]:                 [SUCCESS]
Starting traffic on port(s) [0, 1, 2, 3]:                    [SUCCESS]

# pause  the traffic on all port
>pause -a                                                              #

# resume  the traffic on all port
>resume -a                                                             #

# stop traffic on all port
>stop -a                                                               #

# show dynamic statistic
>tui

trex>streams -a
Port 0:

    ID |     packet type     |  length  |       mode       |  rate     | next stream
  -----------------------------------------------------------------------------------
    1  | Ethernet:IP:UDP:Raw |       56 |    Continuous    |  1.00 pps |      -1

Port 1:

    ID |     packet type     |  length  |       mode       |  rate     | next stream
  -----------------------------------------------------------------------------------
    1  | Ethernet:IP:UDP:Raw |       56 |    Continuous    |  1.00 pps |      -1

Port 2:

    ID |     packet type     |  length  |       mode       |  rate     | next stream
  -----------------------------------------------------------------------------------
    1  | Ethernet:IP:UDP:Raw |       56 |    Continuous    |  1.00 pps |      -1

Port 3:

    ID |     packet type     |  length  |       mode       |  rate     | next stream
  -----------------------------------------------------------------------------------
    1  | Ethernet:IP:UDP:Raw |       56 |    Continuous    |  1.00 pps |      -1

TRex >tui
Global Statistics

Connection  : localhost, Port 4501
Version     : v1.93, UUID: N/A
Cpu Util    : 0.2%
            :
Total Tx L2 : 40.01 Mb/sec
Total Tx L1 : 52.51 Mb/sec
Total Rx    : 40.01 Mb/sec
Total Pps   : 78.14 Kpkt/sec
            :
Drop Rate   : 0.00 b/sec
Queue Full  : 0 pkts

Port Statistics

   port    |         0          |         1          |
 --------------------------------------------------------
 owner      |             hhaim |             hhaim |
 state      |            ACTIVE |            ACTIVE |
 --         |                   |                   |
 Tx bps L2  |        10.00 Mbps |        10.00 Mbps |
 Tx bps L1  |        13.13 Mbps |        13.13 Mbps |
 Tx pps     |        19.54 Kpps |        19.54 Kpps |
 Line Util. |            0.13 % |            0.13 % |
 ---        |                   |                   |
 Rx bps     |        10.00 Mbps |        10.00 Mbps |
 Rx pps     |        19.54 Kpps |        19.54 Kpps |
 ----       |                   |                   |
 opackets   |           1725794 |           1725794 |
 ipackets   |           1725794 |           1725794 |
 obytes     |         110450816 |         110450816 |
 ibytes     |         110450816 |         110450816 |
 tx-bytes   |         110.45 MB |         110.45 MB |
 rx-bytes   |         110.45 MB |         110.45 MB |
 tx-pkts    |        1.73 Mpkts |        1.73 Mpkts |
 rx-pkts    |        1.73 Mpkts |        1.73 Mpkts |
 -----      |                   |                   |
 oerrors    |                 0 |                 0 |
 ierrors    |                 0 |                 0 |

 status:  /

 browse:     'q' - quit, 'g' - dashboard, '0-3' - port display
 dashboard:  'p' - pause, 'c' - clear, '-' - low 5%, '+' - up 5%,

interface TenGigabitEthernet0/0/0
 mtu 9000
 ip address 1.1.9.1 255.255.255.0
!
interface TenGigabitEthernet0/1/0
 mtu 9000
 ip address 1.1.10.1 255.255.255.0
!

ip route 16.0.0.0 255.0.0.0 1.1.9.2
ip route 48.0.0.0 255.0.0.0 1.1.10.2

 class STLS1(object):

    def create_stream (self):
        return STLStream(
            packet =
                    STLPktBuilder(
                        pkt = Ether()/IP(src="16.0.0.1",dst="48.0.0.1")/
                                UDP(dport=12,sport=1025)/(10*'x')
                    ),
             mode = STLTXCont())

    def get_streams (self, direction = 0, **kwargs):
        # create 1 stream
        if direction==0:                                                        
            src_ip="16.0.0.1"
            dst_ip="48.0.0.1"
        else:
            src_ip="48.0.0.1"
            dst_ip="16.0.0.1"

        pkt   = STLPktBuilder(
                              pkt = Ether()/IP(src=src_ip,dst=dst_ip)/
                              UDP(dport=12,sport=1025)/(10*'x') )

        return [ STLStream( packet = pkt,mode = STLTXCont()) ]

[bash]>sudo ./t-rex-64 -i

[bash]>trex-console -s csi-kiwi-02  #

[tcsh]>setenv PYTHON /bin/python     #tcsh

[bash]>extern PYTHON=/bin/mypython    #bash

    def create_stream (self):

        base_pkt =  Ether(src="00:bb:12:34:56:01")/      
                    IP(src="16.0.0.1",dst="48.0.0.1")/
                    UDP(dport=12,sport=1025)

trex>portattr -a --prom on                                          #
trex>stats --ps                                                     #
Port Status

     port       |          0           |          1           |
  ---------------------------------------------------------------
driver          |    rte_ixgbe_pmd     |    rte_ixgbe_pmd     |
maximum         |       10 Gb/s        |       10 Gb/s        |
status          |         IDLE         |         IDLE         |
promiscuous     |         on           |         on           |     #
  --            |                      |                      |
HW src mac      |  90:e2:ba:36:33:c0   |  90:e2:ba:36:33:c1   |
SW src mac      |  00:00:00:01:00:00   |  00:00:00:01:00:00   |
SW dst mac      |  00:00:00:01:00:00   |  00:00:00:01:00:00   |
  ---           |                      |                      |
PCI Address     |     0000:03:00.0     |     0000:03:00.1     |
NUMA Node       |          0           |          0           |

        c = STLClient(verbose_level ="error")

        c.connect()

        my_ports=[0,1]

        # prepare our ports
        c.reset(ports = my_ports)

        # port info, mac-addr info, speed
        print c.get_port_info(my_ports)                         

        c.set_port_attr(my_ports, promiscuous = True)           

import stl_path                                                         
from trex_stl_lib.api import *                                          

import time
import json

# simple packet creation                                                
def create_pkt (size, direction):

    ip_range = {'src': {'start': "10.0.0.1", 'end': "10.0.0.254"},
                'dst': {'start': "8.0.0.1",  'end': "8.0.0.254"}}

    if (direction == 0):
        src = ip_range['src']
        dst = ip_range['dst']
    else:
        src = ip_range['dst']
        dst = ip_range['src']

    vm = [
        # src                                                            
        STLVmFlowVar(name="src",
                     min_value=src['start'],
                     max_value=src['end'],
                     size=4,op="inc"),
        STLVmWrFlowVar(fv_name="src",pkt_offset= "IP.src"),

        # dst
        STLVmFlowVar(name="dst",
                     min_value=dst['start'],
                     max_value=dst['end'],
                     size=4,op="inc"),
        STLVmWrFlowVar(fv_name="dst",pkt_offset= "IP.dst"),

        # checksum
        STLVmFixIpv4(offset = "IP")
        ]


    base = Ether()/IP()/UDP()
    pad = max(0, len(base)) * 'x'

    return STLPktBuilder(pkt = base/pad,
                         vm  = vm)


def simple_burst ():

    # create client
    c = STLClient()
                    # username/server can be changed those are the default
                    # username = common.get_current_user(),
                    # server = "localhost"
                    # STLClient(server = "my_server",username ="trex_client") for example
    passed = True

    try:
        # turn this on for some information
        #c.set_verbose("high")

        # create two streams
        s1 = STLStream(packet = create_pkt(200, 0),
                       mode = STLTXCont(pps = 100))

        # second stream with a phase of 1ms (inter stream gap)
        s2 = STLStream(packet = create_pkt(200, 1),
                       isg = 1000,
                       mode = STLTXCont(pps = 100))


        # connect to server
        c.connect()                                                                

        # prepare our ports (my machine has 0 <--> 1 with static route)
        c.reset(ports = [0, 1]) #  Acquire port 0,1 for $USER                      

        # add both streams to ports
        c.add_streams(s1, ports = [0])
        c.add_streams(s2, ports = [1])

        # clear the stats before injecting
        c.clear_stats()

        # choose rate and start traffic for 10 seconds on 5 mpps
        print "Running 5 Mpps on ports 0, 1 for 10 seconds..."
        c.start(ports = [0, 1], mult = "5mpps", duration = 10)                     

        # block until done
        c.wait_on_traffic(ports = [0, 1])                                          

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

        print json.dumps(stats[0], indent = 4, separators=(',', ': '), sort_keys = True)
        print json.dumps(stats[1], 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)

        if (lost_a == 0) and (lost_b == 0):
            passed = True
        else:
            passed = False

    except STLError as e:
        passed = False
        print e

    finally:
        c.disconnect()                                                             

    if passed:
        print "\nTest has passed :-)\n"
    else:
        print "\nTest has failed :-(\n"


# run the tests
simple_burst()

import sys
import argparse
import stl_path
from trex_stl_lib.api import *                                          
from trex_stl_lib.trex_stl_hltapi import *                              


if __name__ == "__main__":
    parser = argparse.ArgumentParser(usage="""
    Connect to TRex and send burst of packets

    examples

     hlt_udp_simple.py -s 9000 -d 30

     hlt_udp_simple.py -s 9000 -d 30 -rate_percent 10

     hlt_udp_simple.py -s 300 -d 30 -rate_pps 5000000

     hlt_udp_simple.py -s 800 -d 30 -rate_bps 500000000 --debug

     then run the simulator on the output
       ./stl-sim -f example.py -o a.pcap  ==> a.pcap include the packet

    """,
    description="Example for TRex HLTAPI",
    epilog=" based on hhaim's stl_run_udp_simple example")

    parser.add_argument("--ip",
                        dest="ip",
                        help='Remote trex ip',
                        default="127.0.0.1",
                        type = str)

    parser.add_argument("-s", "--frame-size",
                        dest="frame_size",
                        help='L2 frame size in bytes without FCS',
                        default=60,
                        type = int,)

    parser.add_argument('-d','--duration',
                        dest='duration',
                        help='duration in second ',
                        default=10,
                        type = int,)

    parser.add_argument('--rate-pps',
                        dest='rate_pps',
                        help='speed in pps',
                        default="100")

    parser.add_argument('--src',
                        dest='src_mac',
                        help='src MAC',
                        default='00:50:56:b9:de:75')

    parser.add_argument('--dst',
                        dest='dst_mac',
                        help='dst MAC',
                        default='00:50:56:b9:34:f3')

    args = parser.parse_args()

    hltapi = CTRexHltApi()
    print 'Connecting to TRex'
    res = hltapi.connect(device = args.ip, port_list = [0, 1], reset = True, break_locks = True)
    check_res(res)
    ports = res['port_handle']
    if len(ports) < 2:
        error('Should have at least 2 ports for this test')
    print 'Connected, acquired ports: %s' % ports

    print 'Creating traffic'

    res = hltapi.traffic_config(mode = 'create', bidirectional = True,
                                port_handle = ports[0], port_handle2 = ports[1],
                                frame_size = args.frame_size,
                                mac_src = args.src_mac, mac_dst = args.dst_mac,
                                mac_src2 = args.dst_mac, mac_dst2 = args.src_mac,
                                l3_protocol = 'ipv4',
                                ip_src_addr = '10.0.0.1', ip_src_mode = 'increment', ip_src_count = 254,
                                ip_dst_addr = '8.0.0.1', ip_dst_mode = 'increment', ip_dst_count = 254,
                                l4_protocol = 'udp',
                                udp_dst_port = 12, udp_src_port = 1025,
                                stream_id = 1, # temporary workaround, add_stream does not return stream_id
                                rate_pps = args.rate_pps,
                                )
    check_res(res)

    print 'Starting traffic'
    res = hltapi.traffic_control(action = 'run', port_handle = ports[:2])
    check_res(res)
    wait_with_progress(args.duration)

    print 'Stopping traffic'
    res = hltapi.traffic_control(action = 'stop', port_handle = ports[:2])
    check_res(res)

    res = hltapi.traffic_stats(mode = 'aggregate', port_handle = ports[:2])
    check_res(res)
    print_brief_stats(res)

    res = hltapi.cleanup_session(port_handle = 'all')
    check_res(res)

    print 'Done'

from trex_stl_lib.api import *

class STLS1(object):

    def create_stream (self):

        return STLStream(
            packet =
                    STLPktBuilder(
                        pkt = Ether()/IP(src="16.0.0.1",dst="48.0.0.1")/
                                UDP(dport=12,sport=1025)/(10*'x')                       
                    ),
             mode = STLTXCont())                                                        


    def get_streams (self, direction = 0, **kwargs):
        # create 1 stream
        return [ self.create_stream() ]


# dynamic load - used for TRex console or simulator
def register():                                                                         
    return STLS1()

[bash]>./stl-sim -f stl/udp_1pkt_simple.py -o b.pcap -l 10
  executing command: 'bp-sim-64-debug --pcap --sl --cores 1 --limit 5000 -f /tmp/tmpq94Tfx -o b.pcap'

  General info:
  ------------

  image type:               debug
  I/O output:               b.pcap
  packet limit:             10
  core recording:           merge all

  Configuration info:
  -------------------

  ports:                    2
  cores:                    1

  Port Config:
  ------------

  stream count:             1
  max PPS    :              1.00  pps
  max BPS L1 :              672.00  bps
  max BPS L2 :              512.00  bps
  line util. :              0.00  %


  Starting simulation...


  Simulation summary:
  -------------------

  simulated 10 packets
  written 10 packets to 'b.pcap'

[bash]>./stl-sim -f stl/udp_1pkt_simple.py --json
[
    {
        "id": 1,
        "jsonrpc": "2.0",
        "method": "add_stream",
        "params": {
            "handler": 0,
            "port_id": 0,
            "stream": {
                "action_count": 0,
                "enabled": true,
                "flags": 0,
                "isg": 0.0,
                "mode": {
                    "rate": {
                        "type": "pps",
                        "value": 1.0
                    },
                    "type": "continuous"
                },
                "next_stream_id": -1,
                "packet": {
                    "binary": "AAAAAQAAAAAAAgAACABFAAAmAA",
                    "meta": ""
                },
                "rx_stats": {
                    "enabled": false
                },
                "self_start": true,
                "vm": {
                    "instructions": [],
                    "split_by_var": ""
                }
            },
            "stream_id": 1
        }
    },
    {
        "id": 1,
        "jsonrpc": "2.0",
        "method": "start_traffic",
        "params": {
            "duration": -1,
            "force": true,
            "handler": 0,
            "mul": {
                "op": "abs",
                "type": "raw",
                "value": 1.0
            },
            "port_id": 0
        }
    }
]

$./stl-sim -f stl/udp_1pkt_simple.py --yaml
- stream:
    action_count: 0
    enabled: true
    flags: 0
    isg: 0.0
    mode:
      pps: 1.0
      type: continuous
    packet:
      binary: AAAAAQAAAAAAAgAACABFAAAmAAEAAEARO
      meta: ''
    rx_stats:
      enabled: false
    self_start: true
    vm:
      instructions: []
      split_by_var: ''

[bash]>./stl-sim -f stl/udp_1pkt_simple.py --pkt
 =======================
 Stream 0
 =======================
###[ Ethernet ]###
  dst       = 00:00:00:01:00:00
  src       = 00:00:00:02:00:00
  type      = IPv4
###[ IP ]###
     version   = 4L
     ihl       = 5L
     tos       = 0x0
     len       = 38
     id        = 1
     flags     =
     frag      = 0L
     ttl       = 64
     proto     = udp
     chksum    = 0x3ac5
     src       = 16.0.0.1
     dst       = 48.0.0.1
     \options   \
###[ UDP ]###
        sport     = blackjack
        dport     = 12
        len       = 18
        chksum    = 0x6161
###[ Raw ]###
           load      = 'xxxxxxxxxx'
0000   00 00 00 01 00 00 00 00  00 02 00 00 08 00 45 00   ..............E.
0010   00 26 00 01 00 00 40 11  3A C5 10 00 00 01 30 00   .&....@.:.....0.
0020   00 01 04 01 00 0C 00 12  61 61 78 78 78 78 78 78   ........aaxxxxxx
0030   78 78 78 78                                        xxxx

- name: udp_64B
  stream:
    self_start: True
    packet:
       binary: AAAAAAAAAAAAAAAACABFAAAuBNIAAH8R9usQAAABMAAAAQQBBAEAEgAAAAAAAAAAAAAAAAAAAAAAAAAA
    mode:
      type: continuous
      pps: 100

[bash]>./stl-sim -f my_yaml.yaml --native

# !!! Auto-generated code !!!
from trex_stl_lib.api import *

class STLS1(object):
    def get_streams(self):
        streams = []

        packet = (Ether(src='00:de:01:0a:01:00', dst='00:50:56:80:0d:28', type=2048) /
                  IP(src='101.0.0.1', proto=17, dst='102.0.0.1', chksum=28605, len=46, flags=2L, ihl=5L, id=0) /
                  UDP(dport=2001, sport=2001, len=26, chksum=1176) /
                  Raw(load='\xde\xad\xbe\xef\x00\x01\x06\x07\x08\x09\x0a\x0b\x00\x9b\xe7\xdb\x82M'))
        vm = STLScVmRaw([], split_by_field = '')
        stream = STLStream(packet = CScapyTRexPktBuilder(pkt = packet, vm = vm),
                           name = 'udp_64B',
                           mac_src_override_by_pkt = 0,
                           mac_dst_override_mode = 0,
                           mode = STLTXCont(pps = 100))
        streams.append(stream)

        return streams

def register():
    return STLS1()

trex>service

trex>l2 --help
usage: port [-h] --port PORT --dst DST_MAC

Configures a port in L2 mode

optional arguments:
  -h, --help            show this help message and exit
  --port PORT, -p PORT  source port for the action
  --dst DST_MAC         Configure destination MAC address


trex(service)>l2 -p 0 --dst 6A:A7:B5:3A:4E:FF

Setting port 0 in L2 mode:                                   [SUCCESS]

trex>service --off

  client.set_service_mode(port = 0, enabled = True)

  client.set_l2_mode(port = 0, dst_mac = "6A:A7:B5:3A:4E:FF")

  client.set_service_mode(port = 0, enabled = False)

trex>service


trex(service)>l3 --help
usage: port [-h] --port PORT --src SRC_IPV4 --dst DST_IPV4

Configures a port in L3 mode

optional arguments:
  -h, --help            show this help message and exit
  --port PORT, -p PORT  source port for the action
  --src SRC_IPV4        Configure source IPv4 address
  --dst DST_IPV4        Configure destination IPv4 address

trex(service)>l3 -p 0 --src 1.1.1.2 --dst 1.1.1.1

Setting port 0 in L3 mode:                                   [SUCCESS]


ARP resolving address '1.1.1.1':                             [SUCCESS]

trex>service --off

client.set_service_mode(port = 0, enabled = True)

client.set_l3_mode(port = 0, src_ipv4 = '1.1.1.2', dst_ipv4 = '1.1.1.1')

client.set_service_mode(port = 0, enabled = False)

'arp or icmp'

'udp and dst 53'

'vlan 200 and tcp[tcpflags] == tcp-syn'

Global Statistics

connection   : localhost, Port 4501                  total_tx_L2  : 8.18 Gb/sec
version      : v2.28                                 total_tx_L1  : 10.73 Gb/sec
cpu_util.    : 3.31% @ 14 cores (7 per port)         total_rx     : 8.18 Gb/sec
rx_cpu_util. : 82.0% / 15.72 Mpkt/sec              total_pps    : 15.97 Mpkt/sec
async_util.  : 0.19% / 1.76 KB/sec                   drop_rate    : 0.00 b/sec
                                                     queue_full   : 0 pkts

Global Statistics

connection   : localhost, Port 4501                  total_tx_L2  : 8.21 Gb/sec
version      : v2.28                                 total_tx_L1  : 10.77 Gb/sec
cpu_util.    : 3.37% @ 14 cores (7 per port)         total_rx     : 8.21 Gb/sec
rx_cpu_util. : 86.4% / 15.63 Mpkt/sec              total_pps    : 16.03 Mpkt/sec
async_util.  : 0.21% / 1.64 KB/sec                   drop_rate    : 0.00 b/sec
                                                     queue_full   : 0 pkts

# move port 1 to service mode as we want to capture traffic on it
client.set_service_mode(ports = 1)

# start a capture on port 1 Rx side with a limit, a mode and a *BPF* filter for any UDP with dst port 53
capture = client.start_capture(rx_ports = 1, limit = 100, mode = 'fixed', bpf_filter = 'udp and dst 53')

# execute your code here

# save the packets to a file or to a list (see the Python API docs)
client.stop_capture(capture['id'], '/home/mydir/port_0_rx.pcap')

# exit service mode on port 1
client.set_service_mode(ports = 1, enabled = False)

trex(service)>capture record start --rx 3 --limit 0 -f udp and src 5000

Starting packet capturing up to 0 packets                    [SUCCESS]

*** Capturing ID is set to '14' ***
*** Please call 'capture record stop --id 14 -o <out.pcap>' when done ***

trex(service)>capture

Active Recorders

    ID     |   Status    |  Matched   |    Packets     |   Bytes    |    RX Ports     |   BPF Filter
 -------------------------------------------------------------------------------------------------------
    14     |   ACTIVE    |      0     |     [0/0]      |    0 B     |        3        | udp and src 5000

trex(service)>

import zmq
# Bind our ZeroMQ socket so that the TRex server can connect to it
capture_port = "ipc:///tmp/trex_capture_port"
zmq_context = zmq.Context()
zmq_socket = zmq_context.socket(zmq.PAIR)
zmq_socket.bind(capture_port)

# move port 0 to service mode as we want to start capture port on it
client.set_service_mode(ports = 0)

# start a trex capture port on port 0 with *BPF* filter for any IP packets
client.start_capture_port(port = 0, endpoint = capture_port, bpf_filter = 'ip')

# Send one packet (using scapy here)
zmq_socket.send(bytes(Ether()/IP()/IP()/UDP()))

# Wait until we get an IP packet on TRex port 0 and display it parsed using Scapy
received_packet = zmq_socket.recv()
Ether(received_packet).show2()

# Stop capture port
client.stop_capture_port(port = 0)

# exit service mode on port 0
client.set_service_mode(ports = 0, enabled = False)

trex>service                                                      #

Enabling service mode on port(s) [0, 1]:                     [SUCCESS]

trex(service)>portattr  --port 0

             port       |          0           |
        ------------------------------------------
        driver          |    rte_ixgbe_pmd     |
        description     |  82599EB 10-Gigabit  |
        link status     |          UP          |
        link speed      |       10 Gb/s        |
        port status     |         IDLE         |
        promiscuous     |         off          |
        flow ctrl       |         none         |
        --              |                      |
        src IPv4        |          -           |
        src MAC         |  00:00:00:01:00:00   |
        ---             |                      |
        Destination     |  00:00:00:01:00:00   |
        ARP Resolution  |          -           |
        ----            |                      |
        PCI Address     |     0000:03:00.0     |
        NUMA Node       |          0           |
        -----           |                      |
        RX Filter Mode  |    hardware match    |
        RX Queueing     |         off          |
        RX sniffer      |         off          |
        Grat ARP        |         off          |


trex(service)>l3 -p -s 1.1.1.1 -d 1.1.1.2                         #

trex(service)>arp -p 0 1                                          #

Resolving destination on port(s) [0, 1]:                     [SUCCESS]


Port 0 - Recieved ARP reply from: 1.1.1.1, hw: d0:d0:fd:a8:a1:01
Port 1 - Recieved ARP reply from: 1.1.2.1, hw: d0:d0:fd:a8:a1:02

trex(service)>service --off                                       #

trex>l2 -p 0 --dst 00:00:00:01:00:00       #

trex>portattr  --port 0

             port       |          0           |
        ------------------------------------------
        driver          |    rte_ixgbe_pmd     |
        description     |  82599EB 10-Gigabit  |
        link status     |          UP          |
        link speed      |       10 Gb/s        |
        port status     |         IDLE         |
        promiscuous     |         off          |
        flow ctrl       |         none         |
        --              |                      |
        src IPv4        |          -           |
        src MAC         |  00:00:00:01:00:00   |
        ---             |                      |
        Destination     |  00:00:00:01:00:00   |
        ARP Resolution  |          -           |
        ----            |                      |
        PCI Address     |     0000:03:00.0     |
        NUMA Node       |          0           |
        -----           |                      |
        RX Filter Mode  |    hardware match    |
        RX Queueing     |         off          |
        RX sniffer      |         off          |
        Grat ARP        |         off          |

client.set_service_mode(ports = [0, 1], enabled = True)                  

# configure port 0, 1 to Layer 3 mode
client.set_l3_mode(port = 0, src_ipv4 = '1.1.1.2', dst_ipv4 = '1.1.1.2') 
client.set_l3_mode(port = 1, src_ipv4 = '1.1.2.2', dst_ipv4 = '1.1.2.1')

# ARP resolve ports 0, 1
c.resolve(ports = [0, 1])

client.set_service_mode(ports = [0, 1], enabled = False)                 

trex(service)>ping --help
usage: ping [-h] --port PORT -d PING_IPV4 [-s PKT_SIZE] [-n COUNT]

pings the server / specific IP

optional arguments:
  -h, --help            show this help message and exit
  --port PORT, -p PORT  source port for the action
  -d PING_IPV4          which IPv4 to ping
  -s PKT_SIZE           packet size to use
  -n COUNT, --count COUNT
                        How many times to ping [default is 5]

trex(service)>ping -p 0 -d 1.1.2.2

Pinging 1.1.2.2 from port 0 with 64 bytes of data:
Reply from 1.1.2.2: bytes=64, time=27.72ms, TTL=127
Reply from 1.1.2.2: bytes=64, time=1.40ms, TTL=127
Reply from 1.1.2.2: bytes=64, time=1.31ms, TTL=127
Reply from 1.1.2.2: bytes=64, time=1.78ms, TTL=127
Reply from 1.1.2.2: bytes=64, time=1.95ms, TTL=127

# move to service mode
client.set_service_mode(ports = ports, enabled = True)

# configure port 0, 1 to Layer 3 mode
client.set_l3_mode(port = 0, src_ipv4 = '1.1.1.2', dst_ipv4 = '1.1.1.1')
client.set_l3_mode(port = 1, src_ipv4 = '1.1.2.2', dst_ipv4 = '1.1.2.1')

# ping port 1 from port 0 through the router
client.ping_ip(src_port = 0, dst_ipv4 = '1.1.2.2', pkt_size = 64)        

# disable service mode
client.set_service_mode(enabled = False)

  - version: 2
    interfaces: ['82:00.0', '82:00.1']
    stack: linux_based
...

    def create_stream (self):

        # create a base packet and pad it to size
        size = self.fsize - 4 # no FCS
        base_pkt =  Ether()/IP(src="16.0.0.1",dst="48.0.0.1")/UDP(dport=12,sport=1025)       
        base_pkt1 =  Ether()/IP(src="16.0.0.2",dst="48.0.0.1")/UDP(dport=12,sport=1025)
        base_pkt2 =  Ether()/IP(src="16.0.0.3",dst="48.0.0.1")/UDP(dport=12,sport=1025)
        pad = max(0, size - len(base_pkt)) * 'x'


        return STLProfile( [ STLStream( isg = 0.0,
                                        packet = STLPktBuilder(pkt = base_pkt/pad),
                                        mode = STLTXCont( pps = 10),                         
                                        ),

                             STLStream( isg = 25000.0, #defined in usec, 25 msec
                                        packet  = STLPktBuilder(pkt = base_pkt1/pad),
                                        mode    = STLTXCont( pps = 20),                      
                                        ),

                             STLStream(  isg = 50000.0,#defined in usec, 50 msec
                                         packet = STLPktBuilder(pkt = base_pkt2/pad),
                                         mode    = STLTXCont( pps = 40)                      

                                        )
                            ]).get_streams()

[bash]>./stl-sim -f stl/simple_3pkt.py -o b.pcap -l 200

trex>start -f stl/simple_3pkt.py -m 10mbps

    def create_stream (self):

        # create a base packet and pad it to size
        size = self.fsize - 4 # no FCS
        base_pkt =  Ether()/IP(src="16.0.0.1",dst="48.0.0.1")/UDP(dport=12,sport=1025)
        base_pkt1 =  Ether()/IP(src="16.0.0.2",dst="48.0.0.1")/UDP(dport=12,sport=1025)
        base_pkt2 =  Ether()/IP(src="16.0.0.3",dst="48.0.0.1")/UDP(dport=12,sport=1025)
        pad = max(0, size - len(base_pkt)) * 'x'


        return STLProfile( [ STLStream( isg = 10.0, # star in delay
                                        name    ='S0',
                                        packet = STLPktBuilder(pkt = base_pkt/pad),
                                        mode = STLTXSingleBurst( pps = 10, total_pkts = 10),  
                                        next = 'S1'), # point to next stream

                             STLStream( self_start = False, # stream is  disabled enable trow S0  
                                        name    ='S1',
                                        packet  = STLPktBuilder(pkt = base_pkt1/pad),
                                        mode    = STLTXSingleBurst( pps = 10, total_pkts = 20),
                                        next    = 'S2' ),

                             STLStream(  self_start = False, # stream is  disabled enable trow S0 
                                         name   ='S2',
                                         packet = STLPktBuilder(pkt = base_pkt2/pad),
                                         mode = STLTXSingleBurst( pps = 10, total_pkts = 30 )
                                        )
                            ]).get_streams()

[bash]>./stl-sim -f stl/stl/burst_3pkt_60pkt.py -o b.pcap

TRex>start -f stl/stl/burst_3pkt_60pkt.py --port 0

    def create_stream (self):

        # create a base packet and pad it to size
        size = self.fsize - 4 # no FCS
        base_pkt =  Ether()/IP(src="16.0.0.1",dst="48.0.0.1")/UDP(dport=12,sport=1025)
        base_pkt1 =  Ether()/IP(src="16.0.0.2",dst="48.0.0.1")/UDP(dport=12,sport=1025)
        pad = max(0, size - len(base_pkt)) * 'x'


        return STLProfile( [ STLStream( isg = 10.0, # start in delay                                  
                                        name    ='S0',
                                        packet = STLPktBuilder(pkt = base_pkt/pad),
                                        mode = STLTXSingleBurst( pps = 10, total_pkts = self.burst_size),
                                        next = 'S1'), # point to next stream

                             STLStream( self_start = False, # stream is disabled. Enabled by S0       
                                        name    ='S1',
                                        packet  = STLPktBuilder(pkt = base_pkt1/pad),
                                        mode    = STLTXMultiBurst( pps = 1000,
                                                                   pkts_per_burst = 4,
                                                                   ibg = 1000000.0,
                                                                   count = 5)
                                        )

                            ]).get_streams()

    def create_stream (self):

        # create a base packet and pad it to size
        size = self.fsize - 4 # no FCS
        base_pkt =  Ether()/IP(src="16.0.0.1",dst="48.0.0.1")/UDP(dport=12,sport=1025)
        base_pkt1 =  Ether()/IP(src="16.0.0.2",dst="48.0.0.1")/UDP(dport=12,sport=1025)
        base_pkt2 =  Ether()/IP(src="16.0.0.3",dst="48.0.0.1")/UDP(dport=12,sport=1025)
        pad = max(0, size - len(base_pkt)) * 'x'


        return STLProfile( [ STLStream( isg = 10.0, # start in delay
                                        name    ='S0',
                                        packet = STLPktBuilder(pkt = base_pkt/pad),
                                        mode = STLTXSingleBurst( pps = 10, total_pkts = 1),
                                        next = 'S1'), # point to next stream

                             STLStream( self_start = False, # stream is disabled. Enabled by S0
                                        name    ='S1',
                                        packet  = STLPktBuilder(pkt = base_pkt1/pad),
                                        mode    = STLTXSingleBurst( pps = 10, total_pkts = 2),
                                        next    = 'S2' ),

                             STLStream(  self_start = False, # stream is disabled. Enabled by S1
                                         name   ='S2',
                                         packet = STLPktBuilder(pkt = base_pkt2/pad),
                                         mode = STLTXSingleBurst( pps = 10, total_pkts = 3 ),
                                         action_count = 2, # loop 2 times                       
                                         next    = 'S0' # loop back to S0
                                        )
                            ]).get_streams()

    def __init__ (self):
        # default IP range
        self.ip_range = {'src': {'start': "10.0.0.1", 'end': "10.0.0.254"},
                         'dst': {'start': "8.0.0.1",  'end': "8.0.0.254"}}

        # default IMIX properties
        self.imix_table = [ {'size': 60,   'pps': 28,  'isg':0 },
                            {'size': 590,  'pps': 16,  'isg':0.1 },
                            {'size': 1514, 'pps': 4,   'isg':0.2 } ]


    def create_stream (self, size, pps, isg, vm ):
        # create a base packet and pad it to size
        base_pkt = Ether()/IP()/UDP()
        pad = max(0, size - len(base_pkt)) * 'x'

        pkt = STLPktBuilder(pkt = base_pkt/pad,
                            vm = vm)

        return STLStream(isg = isg,
                         packet = pkt,
                         mode = STLTXCont(pps = pps))


    def get_streams (self, direction = 0, **kwargs):                            

        if direction == 0:                                                      
            src = self.ip_range['src']
            dst = self.ip_range['dst']
        else:
            src = self.ip_range['dst']
            dst = self.ip_range['src']

        # construct the base packet for the profile

        vm =[                                                                   
            # src
            STLVmFlowVar(name="src",
                         min_value=src['start'],
                         max_value=src['end'],
                         size=4,op="inc"),
            STLVmWrFlowVar(fv_name="src",pkt_offset= "IP.src"),

            # dst
            STLVmFlowVar(name="dst",
                         min_value=dst['start'],
                         max_value=dst['end'],
                         size=4,
                         op="inc"),
            STLVmWrFlowVar(fv_name="dst",pkt_offset= "IP.dst"),

            # checksum
            STLVmFixIpv4(offset = "IP")

            ]

        # create imix streams
        return [self.create_stream(x['size'], x['pps'],x['isg'] , vm) for x in self.imix_table]