docs/userguide/integration.rst

   1 .. This work is licensed under a Creative Commons Attribution 4.0 International License.
   2 .. http://creativecommons.org/licenses/by/4.0
   3 .. (c) OPNFV, Intel Corporation, AT&T and others.
   4
   5 Integration tests
   6 =================
   7
   8 VSPERF includes a set of integration tests defined in conf/integration.
   9 These tests can be run by specifying --integration as a parameter to vsperf.
  10 Current tests in conf/integration include switch functionality and Overlay
  11 tests.
  12
  13 Tests in the conf/integration can be used to test scaling of different switch
  14 configurations by adding steps into the test case.
  15
  16 For the overlay tests VSPERF supports VXLAN, GRE and GENEVE tunneling protocols.
  17 Testing of these protocols is limited to unidirectional traffic and
  18 P2P (Physical to Physical scenarios).
  19
  20 NOTE: The configuration for overlay tests provided in this guide is for
  21 unidirectional traffic only.
  22
  23 Executing Integration Tests
  24 ---------------------------
  25
  26 To execute integration tests VSPERF is run with the integration parameter. To
  27 view the current test list simply execute the following command:
  28
  29 .. code-block:: console
  30
  31     ./vsperf --integration --list
  32
  33 The standard tests included are defined inside the
  34 ``conf/integration/01_testcases.conf`` file.
  35
  36 Test Steps
  37 ----------
  38
  39 Execution of integration tests are done on a step by step work flow starting
  40 with step 0 as defined inside the test case. Each step of the test increments
  41 the step number by one which is indicated in the log.
  42
  43 .. code-block:: console
  44
  45     (testcases.integration) - Step 1 - 'vswitch add_switch ['int_br1']' ... OK
  46
  47 Each step in the test case is validated. If a step does not pass validation the
  48 test will fail and terminate. The test will continue until a failure is detected
  49 or all steps pass. A csv report file is generated after a test completes with an
  50 OK or FAIL result.
  51
  52 Test Macros
  53 -----------
  54
  55 Test profiles can include macros as part of the test step. Each step in the
  56 profile may return a value such as a port name. Recall macros use #STEP to
  57 indicate the recalled value inside the return structure. If the method the
  58 test step calls returns a value it can be later recalled, for example:
  59
  60 .. code-block:: python
  61
  62     {
  63         "Name": "vswitch_add_del_vport",
  64         "Deployment": "clean",
  65         "Description": "vSwitch - add and delete virtual port",
  66         "TestSteps": [
  67                 ['vswitch', 'add_switch', 'int_br0'],               # STEP 0
  68                 ['vswitch', 'add_vport', 'int_br0'],                # STEP 1
  69                 ['vswitch', 'del_port', 'int_br0', '#STEP[1][0]'],  # STEP 2
  70                 ['vswitch', 'del_switch', 'int_br0'],               # STEP 3
  71              ]
  72     }
  73
  74 This test profile uses the vswitch add_vport method which returns a string
  75 value of the port added. This is later called by the del_port method using the
  76 name from step 1.
  77
  78 Also commonly used steps can be created as a separate profile.
  79
  80 .. code-block:: python
  81
  82     STEP_VSWITCH_PVP_INIT = [
  83         ['vswitch', 'add_switch', 'int_br0'],           # STEP 0
  84         ['vswitch', 'add_phy_port', 'int_br0'],         # STEP 1
  85         ['vswitch', 'add_phy_port', 'int_br0'],         # STEP 2
  86         ['vswitch', 'add_vport', 'int_br0'],            # STEP 3
  87         ['vswitch', 'add_vport', 'int_br0'],            # STEP 4
  88     ]
  89
  90 This profile can then be used inside other testcases
  91
  92 .. code-block:: python
  93
  94     {
  95         "Name": "vswitch_pvp",
  96         "Deployment": "clean",
  97         "Description": "vSwitch - configure switch and one vnf",
  98         "TestSteps": STEP_VSWITCH_PVP_INIT +
  99                      [
 100                         ['vnf', 'start'],
 101                         ['vnf', 'stop'],
 102                      ] +
 103                      STEP_VSWITCH_PVP_FINIT
 104     }
 105
 106 HelloWorld and other basic Testcases
 107 ------------------------------------
 108
 109 The following examples are for demonstration purposes.
 110 You can run them by copying and pasting into the
 111 conf/integration/01_testcases.conf file.
 112 A command-line instruction is shown at the end of each
 113 example.
 114
 115 HelloWorld
 116 ^^^^^^^^^^
 117
 118 The first example is a HelloWorld testcase.
 119 It simply creates a bridge with 2 physical ports, then sets up a flow to drop
 120 incoming packets from the port that was instantiated at the STEP #1.
 121 There's no interaction with the traffic generator.
 122 Then the flow, the 2 ports and the bridge are deleted.
 123 'add_phy_port' method creates a 'dpdk' type interface that will manage the
 124 physical port. The string value returned is the port name that will be referred
 125 by 'del_port' later on.
 126
 127 .. code-block:: python
 128
 129     {
 130         "Name": "HelloWorld",
 131         "Description": "My first testcase",
 132         "Deployment": "clean",
 133         "TestSteps": [
 134             ['vswitch', 'add_switch', 'int_br0'],   # STEP 0
 135             ['vswitch', 'add_phy_port', 'int_br0'], # STEP 1
 136             ['vswitch', 'add_phy_port', 'int_br0'], # STEP 2
 137             ['vswitch', 'add_flow', 'int_br0', {'in_port': '#STEP[1][1]', \
 138                 'actions': ['drop'], 'idle_timeout': '0'}],
 139             ['vswitch', 'del_flow', 'int_br0'],
 140             ['vswitch', 'del_port', 'int_br0', '#STEP[1][0]'],
 141             ['vswitch', 'del_port', 'int_br0', '#STEP[2][0]'],
 142             ['vswitch', 'del_switch', 'int_br0'],
 143         ]
 144
 145     }
 146
 147 To run HelloWorld test:
 148
 149   .. code-block:: console
 150
 151     ./vsperf --conf-file user_settings.py --integration HelloWorld
 152
 153 Specify a Flow by the IP address
 154 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 155
 156 The next example shows how to explicitly set up a flow by specifying a
 157 destination IP address.
 158 All packets received from the port created at STEP #1 that have a destination
 159 IP address = 90.90.90.90 will be forwarded to the port created at the STEP #2.
 160
 161 .. code-block:: python
 162
 163     {
 164         "Name": "p2p_rule_l3da",
 165         "Description": "Phy2Phy with rule on L3 Dest Addr",
 166         "Deployment": "clean",
 167         "biDirectional": "False",
 168         "TestSteps": [
 169             ['vswitch', 'add_switch', 'int_br0'],   # STEP 0
 170             ['vswitch', 'add_phy_port', 'int_br0'], # STEP 1
 171             ['vswitch', 'add_phy_port', 'int_br0'], # STEP 2
 172             ['vswitch', 'add_flow', 'int_br0', {'in_port': '#STEP[1][1]', \
 173                 'dl_type': '0x0800', 'nw_dst': '90.90.90.90', \
 174                 'actions': ['output:#STEP[2][1]'], 'idle_timeout': '0'}],
 175             ['trafficgen', 'send_traffic', {'traffic_type' : 'continuous'}],
 176             ['vswitch', 'dump_flows', 'int_br0'],   # STEP 5
 177             ['vswitch', 'del_flow', 'int_br0'],     # STEP 7 == del-flows
 178             ['vswitch', 'del_port', 'int_br0', '#STEP[1][0]'],
 179             ['vswitch', 'del_port', 'int_br0', '#STEP[2][0]'],
 180             ['vswitch', 'del_switch', 'int_br0'],
 181         ]
 182     },
 183
 184 To run the test:
 185
 186   .. code-block:: console
 187
 188     ./vsperf --conf-file user_settings.py --integration p2p_rule_l3da
 189
 190 Multistream feature
 191 ^^^^^^^^^^^^^^^^^^^
 192
 193 The next testcase uses the multistream feature.
 194 The traffic generator will send packets with different UDP ports.
 195 That is accomplished by using "Stream Type" and "MultiStream" keywords.
 196 4 different flows are set to forward all incoming packets.
 197
 198 .. code-block:: python
 199
 200     {
 201         "Name": "multistream_l4",
 202         "Description": "Multistream on UDP ports",
 203         "Deployment": "clean",
 204         "Stream Type": "L4",
 205         "MultiStream": 4,
 206         "TestSteps": [
 207             ['vswitch', 'add_switch', 'int_br0'],   # STEP 0
 208             ['vswitch', 'add_phy_port', 'int_br0'], # STEP 1
 209             ['vswitch', 'add_phy_port', 'int_br0'], # STEP 2
 210             # Setup Flows
 211             ['vswitch', 'add_flow', 'int_br0', {'in_port': '#STEP[1][1]', \
 212                 'dl_type': '0x0800', 'nw_proto': '17', 'udp_dst': '0', \
 213                 'actions': ['output:#STEP[2][1]'], 'idle_timeout': '0'}],
 214             ['vswitch', 'add_flow', 'int_br0', {'in_port': '#STEP[1][1]', \
 215                 'dl_type': '0x0800', 'nw_proto': '17', 'udp_dst': '1', \
 216                 'actions': ['output:#STEP[2][1]'], 'idle_timeout': '0'}],
 217             ['vswitch', 'add_flow', 'int_br0', {'in_port': '#STEP[1][1]', \
 218                 'dl_type': '0x0800', 'nw_proto': '17', 'udp_dst': '2', \
 219                 'actions': ['output:#STEP[2][1]'], 'idle_timeout': '0'}],
 220             ['vswitch', 'add_flow', 'int_br0', {'in_port': '#STEP[1][1]', \
 221                 'dl_type': '0x0800', 'nw_proto': '17', 'udp_dst': '3', \
 222                 'actions': ['output:#STEP[2][1]'], 'idle_timeout': '0'}],
 223             # Send mono-dir traffic
 224             ['trafficgen', 'send_traffic', {'traffic_type' : 'continuous', \
 225                 'bidir' : 'False'}],
 226             # Clean up
 227             ['vswitch', 'del_flow', 'int_br0'],
 228             ['vswitch', 'del_port', 'int_br0', '#STEP[1][0]'],
 229             ['vswitch', 'del_port', 'int_br0', '#STEP[2][0]'],
 230             ['vswitch', 'del_switch', 'int_br0'],
 231          ]
 232     },
 233
 234 To run the test:
 235
 236   .. code-block:: console
 237
 238     ./vsperf --conf-file user_settings.py --integration multistream_l4
 239
 240 PVP with a VM Replacement
 241 ^^^^^^^^^^^^^^^^^^^^^^^^^
 242
 243 This example launches a 1st VM in a PVP topology, then the VM is replaced
 244 by another VM.
 245 When VNF setup parameter in ./conf/04_vnf.conf is "QemuDpdkVhostUser"
 246 'add_vport' method creates a 'dpdkvhostuser' type port to connect a VM.
 247
 248 .. code-block:: python
 249
 250     {
 251         "Name": "ex_replace_vm",
 252         "Description": "PVP with VM replacement",
 253         "Deployment": "clean",
 254         "TestSteps": [
 255             ['vswitch', 'add_switch', 'int_br0'],       # STEP 0
 256             ['vswitch', 'add_phy_port', 'int_br0'],     # STEP 1
 257             ['vswitch', 'add_phy_port', 'int_br0'],     # STEP 2
 258             ['vswitch', 'add_vport', 'int_br0'],        # STEP 3    vm1
 259             ['vswitch', 'add_vport', 'int_br0'],        # STEP 4
 260
 261             # Setup Flows
 262             ['vswitch', 'add_flow', 'int_br0', {'in_port': '#STEP[1][1]', \
 263                 'actions': ['output:#STEP[3][1]'], 'idle_timeout': '0'}],
 264             ['vswitch', 'add_flow', 'int_br0', {'in_port': '#STEP[4][1]', \
 265                 'actions': ['output:#STEP[2][1]'], 'idle_timeout': '0'}],
 266             ['vswitch', 'add_flow', 'int_br0', {'in_port': '#STEP[2][1]', \
 267                 'actions': ['output:#STEP[4][1]'], 'idle_timeout': '0'}],
 268             ['vswitch', 'add_flow', 'int_br0', {'in_port': '#STEP[3][1]', \
 269                 'actions': ['output:#STEP[1][1]'], 'idle_timeout': '0'}],
 270
 271             # Start VM 1
 272             ['vnf1', 'start'],
 273             # Now we want to replace VM 1 with another VM
 274             ['vnf1', 'stop'],
 275
 276             ['vswitch', 'add_vport', 'int_br0'],        # STEP 11    vm2
 277             ['vswitch', 'add_vport', 'int_br0'],        # STEP 12
 278             ['vswitch', 'del_flow', 'int_br0'],
 279             ['vswitch', 'add_flow', 'int_br0', {'in_port': '#STEP[1][1]', \
 280                 'actions': ['output:#STEP[11][1]'], 'idle_timeout': '0'}],
 281             ['vswitch', 'add_flow', 'int_br0', {'in_port': '#STEP[12][1]', \
 282                 'actions': ['output:#STEP[2][1]'], 'idle_timeout': '0'}],
 283
 284             # Start VM 2
 285             ['vnf2', 'start'],
 286             ['vnf2', 'stop'],
 287             ['vswitch', 'dump_flows', 'int_br0'],
 288
 289             # Clean up
 290             ['vswitch', 'del_flow', 'int_br0'],
 291             ['vswitch', 'del_port', 'int_br0', '#STEP[1][0]'],
 292             ['vswitch', 'del_port', 'int_br0', '#STEP[2][0]'],
 293             ['vswitch', 'del_port', 'int_br0', '#STEP[3][0]'],    # vm1
 294             ['vswitch', 'del_port', 'int_br0', '#STEP[4][0]'],
 295             ['vswitch', 'del_port', 'int_br0', '#STEP[11][0]'],   # vm2
 296             ['vswitch', 'del_port', 'int_br0', '#STEP[12][0]'],
 297             ['vswitch', 'del_switch', 'int_br0'],
 298         ]
 299     },
 300
 301 To run the test:
 302
 303   .. code-block:: console
 304
 305      ./vsperf --conf-file user_settings.py --integration ex_replace_vm
 306
 307 VM with a Linux bridge
 308 ^^^^^^^^^^^^^^^^^^^^^^
 309
 310 In this example a command-line parameter allows to set up a Linux bridge into
 311 the guest VM.
 312 That's one of the available ways to specify the guest application.
 313 Packets matching the flow will be forwarded to the VM.
 314
 315 .. code-block:: python
 316
 317     {
 318         "Name": "ex_pvp_rule_l3da",
 319         "Description": "PVP with flow on L3 Dest Addr",
 320         "Deployment": "clean",
 321         "TestSteps": [
 322             ['vswitch', 'add_switch', 'int_br0'],       # STEP 0
 323             ['vswitch', 'add_phy_port', 'int_br0'],     # STEP 1
 324             ['vswitch', 'add_phy_port', 'int_br0'],     # STEP 2
 325             ['vswitch', 'add_vport', 'int_br0'],        # STEP 3    vm1
 326             ['vswitch', 'add_vport', 'int_br0'],        # STEP 4
 327             # Setup Flows
 328             ['vswitch', 'add_flow', 'int_br0', {'in_port': '#STEP[1][1]', \
 329                 'dl_type': '0x0800', 'nw_dst': '90.90.90.90', \
 330                 'actions': ['output:#STEP[3][1]'], 'idle_timeout': '0'}],
 331             # Each pkt from the VM is forwarded to the 2nd dpdk port
 332             ['vswitch', 'add_flow', 'int_br0', {'in_port': '#STEP[4][1]', \
 333                 'actions': ['output:#STEP[2][1]'], 'idle_timeout': '0'}],
 334             # Start VMs
 335             ['vnf1', 'start'],
 336             ['trafficgen', 'send_traffic', {'traffic_type' : 'continuous', \
 337                 'bidir' : 'False'}],
 338             ['vnf1', 'stop'],
 339             # Clean up
 340             ['vswitch', 'dump_flows', 'int_br0'],       # STEP 10
 341             ['vswitch', 'del_flow', 'int_br0'],         # STEP 11
 342             ['vswitch', 'del_port', 'int_br0', '#STEP[1][0]'],
 343             ['vswitch', 'del_port', 'int_br0', '#STEP[2][0]'],
 344             ['vswitch', 'del_port', 'int_br0', '#STEP[3][0]'],  # vm1 ports
 345             ['vswitch', 'del_port', 'int_br0', '#STEP[4][0]'],
 346             ['vswitch', 'del_switch', 'int_br0'],
 347         ]
 348     },
 349
 350 To run the test:
 351
 352   .. code-block:: console
 353
 354     ./vsperf --conf-file user_settings.py --test-params
 355             "guest_loopback=linux_bridge" --integration ex_pvp_rule_l3da
 356
 357 Forward packets based on UDP port
 358 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 359
 360 This examples launches 2 VMs connected in parallel.
 361 Incoming packets will be forwarded to one specific VM depending on the
 362 destination UDP port.
 363
 364 .. code-block:: python
 365
 366     {
 367         "Name": "ex_2pvp_rule_l4dp",
 368         "Description": "2 PVP with flows on L4 Dest Port",
 369         "Deployment": "clean",
 370         "Stream Type": "L4",    # loop UDP ports
 371         "MultiStream": 2,
 372         "TestSteps": [
 373             ['vswitch', 'add_switch', 'int_br0'],       # STEP 0
 374             ['vswitch', 'add_phy_port', 'int_br0'],     # STEP 1
 375             ['vswitch', 'add_phy_port', 'int_br0'],     # STEP 2
 376             ['vswitch', 'add_vport', 'int_br0'],        # STEP 3    vm1
 377             ['vswitch', 'add_vport', 'int_br0'],        # STEP 4
 378             ['vswitch', 'add_vport', 'int_br0'],        # STEP 5    vm2
 379             ['vswitch', 'add_vport', 'int_br0'],        # STEP 6
 380             # Setup Flows to reply ICMPv6 and similar packets, so to
 381             # avoid flooding internal port with their re-transmissions
 382             ['vswitch', 'add_flow', 'int_br0', \
 383                 {'priority': '1', 'dl_src': '00:00:00:00:00:01', \
 384                 'actions': ['output:#STEP[3][1]'], 'idle_timeout': '0'}],
 385             ['vswitch', 'add_flow', 'int_br0', \
 386                 {'priority': '1', 'dl_src': '00:00:00:00:00:02', \
 387                 'actions': ['output:#STEP[4][1]'], 'idle_timeout': '0'}],
 388             ['vswitch', 'add_flow', 'int_br0', \
 389                 {'priority': '1', 'dl_src': '00:00:00:00:00:03', \
 390                 'actions': ['output:#STEP[5][1]'], 'idle_timeout': '0'}],
 391             ['vswitch', 'add_flow', 'int_br0', \
 392                 {'priority': '1', 'dl_src': '00:00:00:00:00:04', \
 393                 'actions': ['output:#STEP[6][1]'], 'idle_timeout': '0'}],
 394             # Forward UDP packets depending on dest port
 395             ['vswitch', 'add_flow', 'int_br0', {'in_port': '#STEP[1][1]', \
 396                 'dl_type': '0x0800', 'nw_proto': '17', 'udp_dst': '0', \
 397                 'actions': ['output:#STEP[3][1]'], 'idle_timeout': '0'}],
 398             ['vswitch', 'add_flow', 'int_br0', {'in_port': '#STEP[1][1]', \
 399                 'dl_type': '0x0800', 'nw_proto': '17', 'udp_dst': '1', \
 400                 'actions': ['output:#STEP[5][1]'], 'idle_timeout': '0'}],
 401             # Send VM output to phy port #2
 402             ['vswitch', 'add_flow', 'int_br0', {'in_port': '#STEP[4][1]', \
 403                 'actions': ['output:#STEP[2][1]'], 'idle_timeout': '0'}],
 404             ['vswitch', 'add_flow', 'int_br0', {'in_port': '#STEP[6][1]', \
 405                 'actions': ['output:#STEP[2][1]'], 'idle_timeout': '0'}],
 406             # Start VMs
 407             ['vnf1', 'start'],                          # STEP 16
 408             ['vnf2', 'start'],                          # STEP 17
 409             ['trafficgen', 'send_traffic', {'traffic_type' : 'continuous', \
 410                 'bidir' : 'False'}],
 411             ['vnf1', 'stop'],
 412             ['vnf2', 'stop'],
 413             ['vswitch', 'dump_flows', 'int_br0'],
 414             # Clean up
 415             ['vswitch', 'del_flow', 'int_br0'],
 416             ['vswitch', 'del_port', 'int_br0', '#STEP[1][0]'],
 417             ['vswitch', 'del_port', 'int_br0', '#STEP[2][0]'],
 418             ['vswitch', 'del_port', 'int_br0', '#STEP[3][0]'],  # vm1 ports
 419             ['vswitch', 'del_port', 'int_br0', '#STEP[4][0]'],
 420             ['vswitch', 'del_port', 'int_br0', '#STEP[5][0]'],  # vm2 ports
 421             ['vswitch', 'del_port', 'int_br0', '#STEP[6][0]'],
 422             ['vswitch', 'del_switch', 'int_br0'],
 423         ]
 424     },
 425
 426 To run the test:
 427
 428   .. code-block:: console
 429
 430     ./vsperf --conf-file user_settings.py --integration ex_2pvp_rule_l4dp
 431
 432 Executing Tunnel encapsulation tests
 433 ------------------------------------
 434
 435 The VXLAN OVS DPDK encapsulation tests requires IPs, MAC addresses,
 436 bridge names and WHITELIST_NICS for DPDK.
 437
 438 Default values are already provided. To customize for your environment, override
 439 the following variables in you user_settings.py file:
 440
 441   .. code-block:: python
 442
 443     # Variables defined in conf/integration/02_vswitch.conf
 444     # Tunnel endpoint for Overlay P2P deployment scenario
 445     # used for br0
 446     VTEP_IP1 = '192.168.0.1/24'
 447
 448     # Used as remote_ip in adding OVS tunnel port and
 449     # to set ARP entry in OVS (e.g. tnl/arp/set br-ext 192.168.240.10 02:00:00:00:00:02
 450     VTEP_IP2 = '192.168.240.10'
 451
 452     # Network to use when adding a route for inner frame data
 453     VTEP_IP2_SUBNET = '192.168.240.0/24'
 454
 455     # Bridge names
 456     TUNNEL_INTEGRATION_BRIDGE = 'br0'
 457     TUNNEL_EXTERNAL_BRIDGE = 'br-ext'
 458
 459     # IP of br-ext
 460     TUNNEL_EXTERNAL_BRIDGE_IP = '192.168.240.1/24'
 461
 462     # vxlan|gre|geneve
 463     TUNNEL_TYPE = 'vxlan'
 464
 465     # Variables defined conf/integration/03_traffic.conf
 466     # For OP2P deployment scenario
 467     TRAFFICGEN_PORT1_MAC = '02:00:00:00:00:01'
 468     TRAFFICGEN_PORT2_MAC = '02:00:00:00:00:02'
 469     TRAFFICGEN_PORT1_IP = '1.1.1.1'
 470     TRAFFICGEN_PORT2_IP = '192.168.240.10'
 471
 472 To run VXLAN encapsulation tests:
 473
 474   .. code-block:: console
 475
 476     ./vsperf --conf-file user_settings.py --integration
 477              --test-params 'tunnel_type=vxlan' overlay_p2p_tput
 478
 479 To run GRE encapsulation tests:
 480
 481   .. code-block:: console
 482
 483     ./vsperf --conf-file user_settings.py --integration
 484              --test-params 'tunnel_type=gre' overlay_p2p_tput
 485
 486 To run GENEVE encapsulation tests:
 487
 488   .. code-block:: console
 489
 490     ./vsperf --conf-file user_settings.py --integration
 491              --test-params 'tunnel_type=geneve' overlay_p2p_tput
 492
 493 To run OVS NATIVE tunnel tests (VXLAN/GRE/GENEVE):
 494
 495 1. Install the OVS kernel modules
 496
 497   .. code:: console
 498
 499     cd src/ovs/ovs
 500     sudo -E make modules_install
 501
 502 2. Set the following variables:
 503
 504   .. code-block:: python
 505
 506     VSWITCH = 'OvsVanilla'
 507     # Specify vport_* kernel module to test.
 508     VSWITCH_VANILLA_KERNEL_MODULES = ['vport_vxlan',
 509                                       'vport_gre',
 510                                       'vport_geneve',
 511                                       os.path.join(OVS_DIR_VANILLA,
 512                                       'datapath/linux/openvswitch.ko')]
 513
 514 3. Run tests:
 515
 516   .. code-block:: console
 517
 518     ./vsperf --conf-file user_settings.py --integration
 519              --test-params 'tunnel_type=vxlan' overlay_p2p_tput
 520
 521
 522 Executing VXLAN decapsulation tests
 523 ------------------------------------
 524
 525 To run VXLAN decapsulation tests:
 526
 527 1. Set the variables used in "Executing Tunnel encapsulation tests"
 528
 529 2. Set dstmac of DUT_NIC2_MAC to the MAC adddress of the 2nd NIC of your DUT
 530
 531   .. code-block:: python
 532
 533     DUT_NIC2_MAC = '<DUT NIC2 MAC>'
 534
 535 3. Run test:
 536
 537   .. code-block:: console
 538
 539     ./vsperf --conf-file user_settings.py --integration overlay_p2p_decap_cont
 540
 541 If you want to use different values for your VXLAN frame, you may set:
 542
 543   .. code-block:: python
 544
 545     VXLAN_FRAME_L3 = {'proto': 'udp',
 546                       'packetsize': 64,
 547                       'srcip': TRAFFICGEN_PORT1_IP,
 548                       'dstip': '192.168.240.1',
 549                      }
 550     VXLAN_FRAME_L4 = {'srcport': 4789,
 551                       'dstport': 4789,
 552                       'vni': VXLAN_VNI,
 553                       'inner_srcmac': '01:02:03:04:05:06',
 554                       'inner_dstmac': '06:05:04:03:02:01',
 555                       'inner_srcip': '192.168.0.10',
 556                       'inner_dstip': '192.168.240.9',
 557                       'inner_proto': 'udp',
 558                       'inner_srcport': 3000,
 559                       'inner_dstport': 3001,
 560                      }
 561
 562
 563 Executing GRE decapsulation tests
 564 ---------------------------------
 565
 566 To run GRE decapsulation tests:
 567
 568 1. Set the variables used in "Executing Tunnel encapsulation tests"
 569
 570 2. Set dstmac of DUT_NIC2_MAC to the MAC adddress of the 2nd NIC of your DUT
 571
 572   .. code-block:: python
 573
 574     DUT_NIC2_MAC = '<DUT NIC2 MAC>'
 575
 576 3. Run test:
 577
 578   .. code-block:: console
 579
 580     ./vsperf --conf-file user_settings.py --test-params 'tunnel_type=gre'
 581              --integration overlay_p2p_decap_cont
 582
 583
 584 If you want to use different values for your GRE frame, you may set:
 585
 586   .. code-block:: python
 587
 588     GRE_FRAME_L3 = {'proto': 'gre',
 589                     'packetsize': 64,
 590                     'srcip': TRAFFICGEN_PORT1_IP,
 591                     'dstip': '192.168.240.1',
 592                    }
 593
 594     GRE_FRAME_L4 = {'srcport': 0,
 595                     'dstport': 0
 596                     'inner_srcmac': '01:02:03:04:05:06',
 597                     'inner_dstmac': '06:05:04:03:02:01',
 598                     'inner_srcip': '192.168.0.10',
 599                     'inner_dstip': '192.168.240.9',
 600                     'inner_proto': 'udp',
 601                     'inner_srcport': 3000,
 602                     'inner_dstport': 3001,
 603                    }
 604
 605
 606 Executing GENEVE decapsulation tests
 607 ------------------------------------
 608
 609 IxNet 7.3X does not have native support of GENEVE protocol. The
 610 template, GeneveIxNetTemplate.xml_ClearText.xml, should be imported
 611 into IxNET for this testcase to work.
 612
 613 To import the template do:
 614
 615 1. Run the IxNetwork TCL Server
 616 2. Click on the Traffic menu
 617 3. Click on the Traffic actions and click Edit Packet Templates
 618 4. On the Template editor window, click Import. Select the template
 619    tools/pkt_gen/ixnet/GeneveIxNetTemplate.xml_ClearText.xml
 620    and click import.
 621 5. Restart the TCL Server.
 622
 623 To run GENEVE decapsulation tests:
 624
 625 1. Set the variables used in "Executing Tunnel encapsulation tests"
 626
 627 2. Set dstmac of DUT_NIC2_MAC to the MAC adddress of the 2nd NIC of your DUT
 628
 629   .. code-block:: python
 630
 631     DUT_NIC2_MAC = '<DUT NIC2 MAC>'
 632
 633 3. Run test:
 634
 635   .. code-block:: console
 636
 637     ./vsperf --conf-file user_settings.py --test-params 'tunnel_type=geneve'
 638              --integration overlay_p2p_decap_cont
 639
 640
 641 If you want to use different values for your GENEVE frame, you may set:
 642
 643   .. code-block:: python
 644
 645     GENEVE_FRAME_L3 = {'proto': 'udp',
 646                        'packetsize': 64,
 647                        'srcip': TRAFFICGEN_PORT1_IP,
 648                        'dstip': '192.168.240.1',
 649                       }
 650
 651     GENEVE_FRAME_L4 = {'srcport': 6081,
 652                        'dstport': 6081,
 653                        'geneve_vni': 0,
 654                        'inner_srcmac': '01:02:03:04:05:06',
 655                        'inner_dstmac': '06:05:04:03:02:01',
 656                        'inner_srcip': '192.168.0.10',
 657                        'inner_dstip': '192.168.240.9',
 658                        'inner_proto': 'udp',
 659                        'inner_srcport': 3000,
 660                        'inner_dstport': 3001,
 661                       }
 662
 663
 664 Executing Native/Vanilla OVS VXLAN decapsulation tests
 665 ------------------------------------------------------
 666
 667 To run VXLAN decapsulation tests:
 668
 669 1. Set the following variables in your user_settings.py file:
 670
 671   .. code-block:: python
 672
 673     VSWITCH_VANILLA_KERNEL_MODULES = ['vport_vxlan',
 674                                       os.path.join(OVS_DIR_VANILLA,
 675                                       'datapath/linux/openvswitch.ko')]
 676
 677     DUT_NIC1_MAC = '<DUT NIC1 MAC ADDRESS>'
 678
 679     TRAFFICGEN_PORT1_IP = '172.16.1.2'
 680     TRAFFICGEN_PORT2_IP = '192.168.1.11'
 681
 682     VTEP_IP1 = '172.16.1.2/24'
 683     VTEP_IP2 = '192.168.1.1'
 684     VTEP_IP2_SUBNET = '192.168.1.0/24'
 685     TUNNEL_EXTERNAL_BRIDGE_IP = '172.16.1.1/24'
 686     TUNNEL_INT_BRIDGE_IP = '192.168.1.1'
 687
 688     VXLAN_FRAME_L2 = {'srcmac':
 689                       '01:02:03:04:05:06',
 690                       'dstmac': DUT_NIC1_MAC
 691                      }
 692
 693     VXLAN_FRAME_L3 = {'proto': 'udp',
 694                       'packetsize': 64,
 695                       'srcip': TRAFFICGEN_PORT1_IP,
 696                       'dstip': '172.16.1.1',
 697                      }
 698
 699     VXLAN_FRAME_L4 = {
 700                       'srcport': 4789,
 701                       'dstport': 4789,
 702                       'protocolpad': 'true',
 703                       'vni': 99,
 704                       'inner_srcmac': '01:02:03:04:05:06',
 705                       'inner_dstmac': '06:05:04:03:02:01',
 706                       'inner_srcip': '192.168.1.2',
 707                       'inner_dstip': TRAFFICGEN_PORT2_IP,
 708                       'inner_proto': 'udp',
 709                       'inner_srcport': 3000,
 710                       'inner_dstport': 3001,
 711                      }
 712
 713 2. Run test:
 714
 715   .. code-block:: console
 716
 717     ./vsperf --conf-file user_settings.py --integration
 718              --test-params 'tunnel_type=vxlan' overlay_p2p_decap_cont
 719
 720 Executing Native/Vanilla OVS GRE decapsulation tests
 721 ----------------------------------------------------
 722
 723 To run GRE decapsulation tests:
 724
 725 1. Set the following variables in your user_settings.py file:
 726
 727   .. code-block:: python
 728
 729     VSWITCH_VANILLA_KERNEL_MODULES = ['vport_gre',
 730                                       os.path.join(OVS_DIR_VANILLA,
 731                                       'datapath/linux/openvswitch.ko')]
 732
 733     DUT_NIC1_MAC = '<DUT NIC1 MAC ADDRESS>'
 734
 735     TRAFFICGEN_PORT1_IP = '172.16.1.2'
 736     TRAFFICGEN_PORT2_IP = '192.168.1.11'
 737
 738     VTEP_IP1 = '172.16.1.2/24'
 739     VTEP_IP2 = '192.168.1.1'
 740     VTEP_IP2_SUBNET = '192.168.1.0/24'
 741     TUNNEL_EXTERNAL_BRIDGE_IP = '172.16.1.1/24'
 742     TUNNEL_INT_BRIDGE_IP = '192.168.1.1'
 743
 744     GRE_FRAME_L2 = {'srcmac':
 745                     '01:02:03:04:05:06',
 746                     'dstmac': DUT_NIC1_MAC
 747                    }
 748
 749     GRE_FRAME_L3 = {'proto': 'udp',
 750                     'packetsize': 64,
 751                     'srcip': TRAFFICGEN_PORT1_IP,
 752                     'dstip': '172.16.1.1',
 753                    }
 754
 755     GRE_FRAME_L4 = {
 756                     'srcport': 4789,
 757                     'dstport': 4789,
 758                     'protocolpad': 'true',
 759                     'inner_srcmac': '01:02:03:04:05:06',
 760                     'inner_dstmac': '06:05:04:03:02:01',
 761                     'inner_srcip': '192.168.1.2',
 762                     'inner_dstip': TRAFFICGEN_PORT2_IP,
 763                     'inner_proto': 'udp',
 764                     'inner_srcport': 3000,
 765                     'inner_dstport': 3001,
 766                    }
 767
 768 2. Run test:
 769
 770   .. code-block:: console
 771
 772     ./vsperf --conf-file user_settings.py --integration
 773              --test-params 'tunnel_type=gre' overlay_p2p_decap_cont
 774
 775 Executing Native/Vanilla OVS GENEVE decapsulation tests
 776 -------------------------------------------------------
 777
 778 To run GENEVE decapsulation tests:
 779
 780 1. Set the following variables in your user_settings.py file:
 781
 782   .. code-block:: python
 783
 784     VSWITCH_VANILLA_KERNEL_MODULES = ['vport_geneve',
 785                                       os.path.join(OVS_DIR_VANILLA,
 786                                       'datapath/linux/openvswitch.ko')]
 787
 788     DUT_NIC1_MAC = '<DUT NIC1 MAC ADDRESS>'
 789
 790     TRAFFICGEN_PORT1_IP = '172.16.1.2'
 791     TRAFFICGEN_PORT2_IP = '192.168.1.11'
 792
 793     VTEP_IP1 = '172.16.1.2/24'
 794     VTEP_IP2 = '192.168.1.1'
 795     VTEP_IP2_SUBNET = '192.168.1.0/24'
 796     TUNNEL_EXTERNAL_BRIDGE_IP = '172.16.1.1/24'
 797     TUNNEL_INT_BRIDGE_IP = '192.168.1.1'
 798
 799     GENEVE_FRAME_L2 = {'srcmac':
 800                        '01:02:03:04:05:06',
 801                        'dstmac': DUT_NIC1_MAC
 802                       }
 803
 804     GENEVE_FRAME_L3 = {'proto': 'udp',
 805                        'packetsize': 64,
 806                        'srcip': TRAFFICGEN_PORT1_IP,
 807                        'dstip': '172.16.1.1',
 808                       }
 809
 810     GENEVE_FRAME_L4 = {'srcport': 6081,
 811                        'dstport': 6081,
 812                        'protocolpad': 'true',
 813                        'geneve_vni': 0,
 814                        'inner_srcmac': '01:02:03:04:05:06',
 815                        'inner_dstmac': '06:05:04:03:02:01',
 816                        'inner_srcip': '192.168.1.2',
 817                        'inner_dstip': TRAFFICGEN_PORT2_IP,
 818                        'inner_proto': 'udp',
 819                        'inner_srcport': 3000,
 820                        'inner_dstport': 3001,
 821                       }
 822
 823 2. Run test:
 824
 825   .. code-block:: console
 826
 827     ./vsperf --conf-file user_settings.py --integration
 828              --test-params 'tunnel_type=geneve' overlay_p2p_decap_cont
 829