TRex学习之旅十一

本节中的教程演示了基本的 TRex无状态用例。示例包括常见和中等高级的 TRex 概念。

 如何构建 TRex

$cd linux_dpdk
$./b configure  (only once)
$./b build

如何为 vscode 建立索引

安装 clang-tools/clang-8

apt-get install clang-8 lldb-8 lld-8 clang-tools-8

$cd linux_dpdk
$CC=clang-8  CXX=clang++-8 ./b configure
$./b build

这将在 linux_dpdk/build_dpdk/ 下创建 compile_commands.json

	"settings": {
 
		"clangd.arguments": [
			"-background-index",
			"--compile-commands-dir=linux_dpdk/build_dpdk"
		],

构建输出将在“脚本”文件夹中

更多选择

$./b configure --sanitized
$./b configure --gcc6
$./b configure --no-mlx
$./b configure --with-ntacc

如何使用 gdb TRex 进行调试

$./t-rex-64-debug-gdb [args]

$cd linux
$./b configure  (only once)
$./b build

如何构建文档

$cd doc
$./b configure  (only once)
$./b build

$cd script
$./bp-sim-64 --ut
$./bp-sim-64-debug --ut

运行仿真功能

$cd script
$ ./run_regression --func

TRex 无状态 Python API

TRex 是流量生成器

该站点涵盖了 TRex 的 Python API，并解释了如何根据您的需要使用它。要完全了解 API 的工作原理以及如何设置服务器端，请查看TRex 网站文档部分下的trex-core Wiki 。

如何安装

使用命令解包：

tar -xzf trex_client.tar.gz

如何使用

客户端假定服务器正在运行。
解压缩客户端包后，您可以在开箱即用的示例目录中验证基本测试：

cd trex_client/stl/examples
python stl_imix.py -s <server address>

如果您看到如下内容，您可以验证流量是否已发送并正确到达：

Mapped ports to sides [0, 2] <--> [1, 3]
Injecting [0, 2] <--> [1, 3] on total rate of '30%' for 10 seconds
 
Packets injected from [0, 2]: 473,856
Packets injected from [1, 3]: 473,856
 
packets lost from [0, 2] --> [0, 2]:   0 pkts
packets lost from [1, 3] --> [1, 3]:   0 pkts
 
Test has passed :-)

此外，在 stl 文件夹中有一些目录，其中包含定义流和控制台的配置文件（您可以使用它们轻松发送配置文件）

如何 pyATS 

pyATS 兼容性

TRex 支持 Python2 和 Python3 pyATS。

• 安装 python2/python3 pyats

  /auto/pyats/bin/pyats-install –python2 /auto/pyats/bin/pyats-install –python3

• 更新路径

  • 选项1（更好）

    export PYTHONPATH=[your path]/automation/trex_control_plane/interactive 或者如果是客户端库 export PYTHONPATH=[your path]trex_client_v2xx/interactive

    $PYTHON -m [你的主要] -p $PWD $INPUT_ARGS

  • 选项 2

    setenv TREX_PATH 到 trex 无状态库路径 setenv TREX_PATH <your path>/automation/trex_control_plane/interactive/ 或者如果是客户端库 setenv TREX_PATH <your path>/trex_client_v2xx/interactive

    在脚本或作业文件中，将 TREX_PATH 添加到 sys.path：

    import sys, os; sys.path.append(os.environ['TREX_PATH'])

• 在任何情况下都不要包含 ../interactive 之外的内部路径。这可能会导致意外行为

• 脚本中的源 trex 无状态库：

from trex.stl.api import *
from scapy.contrib.mpls import *
from trex.stl.trex_stl_hltapi import *

教程：准备 TRex 配置文件

教程：加载 TRex 服务器，简单 IPv4 UDP

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')                   1
                    ),
             mode = STLTXCont())                                                    2
 
 
    def get_streams (self, direction = 0, **kwargs):                                3
        # create 1 stream
        return [ self.create_stream() ]
 
 
# dynamic load - used for TRex console or simulator
def register():                                                                     4
    return STLS1()

说明：

1、定义数据包。在这种情况下，数据包是具有 10 个字节x的 IP/UDP 。有关更多信息，请参阅Scapy 文档。

2、模式：连续。费率：1 PPS（默认费率为 1 PPS）

3、该get_streams功能是强制性的。

4、每个流量配置文件模块都需要一个register功能。

SRC/DST MAC 地址取自 /etc/trex_cfg.yaml。要更改它们，请将 Ether(dst="00:00:dd:dd:00:01") 添加到所需的目的地。

启动 TRex 作为服务器

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

[bash]>trex-console                                                    #1
 
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                      #2
 
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                                                              #3
 
# resume  the traffic on all port
>resume -a                                                             #4
 
# stop traffic on all port
>stop -a                                                               #5
 
# show dynamic statistic
>tui

说明：

1、从本地计算机连接到 TRex 服务器。

2、以 10 mbps 的速度启动所有端口上的流量。也可以指定为 MPPS。示例：14 MPPS ( -m 14mpps)。

3、暂停流量。

4、简述。

5、停止所有端口上的流量。

如果出现连接错误，请打开 /etc/trex_cfg.yaml 文件，将enable_zmq_pub : true，zmq_pub_port : 4501 从文件中删除和等关键字。

查看流

要显示所有端口的流数据，请使用streams -a.

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

查看命令帮助

要查看命令的帮助，请使用<command> --help.

查看一般统计信息

要查看一般统计数据，请使用tui打开“文本用户界面”。

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

在此示例中，所有数据包都被路由到该TenGigabitEthernet0/1/0端口。以下示例使用该direction标志来更改它。

文件

stl/udp_1pkt_simple_bdir.py

 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:                                                        1
            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()) ]

说明：

1、标志的这种使用direction导致为每个方向发送不同的数据包。

教程：从远程服务器连接

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

与控制台连接

从远程机器，用于trex-console连接。包括-s标志，如下所示，以指定服务器。

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

说明：

1、TRex 服务器是 csi-kiwi-02。

TRex 客户端需要 Python 版本 2.7.x 或 3.4.x。要更改 Python 版本，请按如下方式设置PYTHON环境变量：

tcsh shell

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

bash shell

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

客户端计算机应运行 Python 2.7.x 或 3.4.x。支持 Cisco CEL/ADS。TRex 包包括所需的客户端存档。

教程：源和目标 MAC 地址

                                                                表 3. MAC 地址

文件

stl/udp_1pkt_1mac_override.py

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

说明：

1、指定源接口 MAC 将替换配置 YAML 文件中指定的默认值。

/etc/trex_cfg.yaml仅当数据包的目标 MAC 与配置文件中为该端口定义的 HW Src MAC 匹配时，TRex 端口才会接收数据包。或者，可以将端口置于混杂模式，允许端口接收线路上的所有数据包。该端口可以通过 API 或控制台上的以下命令配置为混杂模式：portattr -a --prom。

将端口设置为混杂模式并显示端口状态：

trex>portattr -a --prom on                                          #1
trex>stats --ps                                                     #2
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           |     #3
  --            |                      |                      |
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           |

说明：

1、将所有端口配置为混杂模式。

2、显示端口状态。

3、“on”表示端口混杂模式。

        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)                         1
 
        c.set_port_attr(my_ports, promiscuous = True)           2

说明：

1、获取所有端口的端口信息。

2、将端口属性更改为promiscuous = True。

有关更多信息，请参阅Python 客户端 API。

默认情况下，接口未设置为混杂模式。通常，在将端口更改为特定测试的混杂模式后，建议将其更改回非混杂模式。

教程：Python 自动化

                                                          图 4. RPC 服务器组件

文件

stl_bi_dir_flows.py

import stl_path                                                         1
from trex_stl_lib.api import *                                          2
 
import time
import json
 
# simple packet creation                                                3
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                                                            4
        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()                                                                5
 
        # prepare our ports (my machine has 0 <--> 1 with static route)
        c.reset(ports = [0, 1]) #  Acquire port 0,1 for $USER                      6
 
        # 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)                     7
 
        # block until done
        c.wait_on_traffic(ports = [0, 1])                                          8
 
        # read the stats after the test
        stats = c.get_stats()                                                      9
 
        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()                                                             10
 
    if passed:
        print "\nTest has passed :-)\n"
    else:
        print "\nTest has failed :-(\n"
 
 
# run the tests
simple_burst()

说明：

1、导入 stl_path。此处的路径特定于此示例。配置时，提供 stl_trex 库的路径。

2、导入 TRex 无状态库。配置时，提供您的 TRex 无状态库的路径。

3、使用 Scapy 按方向创建数据包。

4、有关信息，请参阅现场引擎部分。

5、连接到本地 TRex。可以添加用户名和服务器。

6、获取端口。

7、加载流量配置文件并开始生成流量。

8、等待流量完成。有一个轮询功能，因此您可以在等待时测试做某事。

9、获取端口统计信息。

10、断开连接。

有关使用 Python API 的详细信息，请参阅TRex Stateless Python API。

教程：HLT Python API

文件

hlt_udp_simple.py

import sys
import argparse
import stl_path
from trex_stl_lib.api import *                                          1
from trex_stl_lib.trex_stl_hltapi import *                              2
 
 
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'

说明：

1、导入本机 TRex API。

2、导入 HLT API。

教程：简单的 IPv4/UDP 数据包模拟器

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')                       1
                    ),
             mode = STLTXCont())                                                        2
 
 
    def get_streams (self, direction = 0, **kwargs):
        # create 1 stream
        return [ self.create_stream() ]
 
 
# dynamic load - used for TRex console or simulator
def register():                                                                         3
    return STLS1()

说明：

1、定义数据包 - 在这种情况下，IP/UDP 具有 10 个字节的x。

2、模式是连续的，速率为 1 PPS。（默认费率：1 PPS）

3、每个流量配置文件模块都需要一个register功能。

下面通过 TRex 模拟器运行流量配置文件，将数据包数量限制为 10，并将输出存储在 PCAP 文件中。

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

上一步模拟器生成的输出PCAP文件内容：

                                       图 5. 存储在 PCAP 文件中的 TRex 模拟器输出

[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: ''

要显示数据包详细信息，请使用该--pkt选项（使用 Scapy）。

[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()

扩展

以下是主要的流量配置文件格式。本机是首选格式。如何定义流量与如何控制/激活流量之间存在分离。API/控制台/GUI 可以加载流量配置文件并启动/停止/获取统计信息。由于这种分离，可以共享流量配置文件。

表 4. 流量配置文件格式

教程：端口层模式配置

                                                      表 5. 端口层模式

                                                  配置 L2 模式 Console 示例 

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

                                              配置L2模式示例- Python API

  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)

                                               配置 L3 模式示例-Console

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

                                           配置 L3 模式示例 - Python API

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)