3.10. performance

3.10.1. performance_configuration suite

3.10.1.1. Set interfaces in path up

Set UP state on VPP interfaces in path on all DUT nodes and set maximal MTU.


${duts}=  Get Matches  ${nodes}  DUT*
: FOR  ${dut}  IN  @{duts}
\    ${if1_status}  ${value}=  Run Keyword And Ignore Error  Variable Should Exist  ${${dut}_if1}
\    Run Keyword If  '${if1_status}' == 'PASS'  Set Interface State  ${nodes['${dut}']}  ${${dut}_if1}  up  ELSE  Set Interface State  ${nodes['${dut}']}  ${${dut}_if1_1}  up
\    Run Keyword Unless  '${if1_status}' == 'PASS'  Set Interface State  ${nodes['${dut}']}  ${${dut}_if1_2}  up
\    ${if2_status}  ${value}=  Run Keyword And Ignore Error  Variable Should Exist  ${${dut}_if2}
\    Run Keyword If  '${if2_status}' == 'PASS'  Set Interface State  ${nodes['${dut}']}  ${${dut}_if2}  up  ELSE  Set Interface State  ${nodes['${dut}']}  ${${dut}_if2_1}  up
\    Run Keyword Unless  '${if2_status}' == 'PASS'  Set Interface State  ${nodes['${dut}']}  ${${dut}_if2_2}  up
All VPP Interfaces Ready Wait  ${nodes}
${duts}=  Get Matches  ${nodes}  DUT*
: FOR  ${dut}  IN  @{duts}
\    ${if1_status}  ${value}=  Run Keyword And Ignore Error  Variable Should Exist  ${${dut}_if1}
\    Run Keyword If  '${if1_status}' == 'PASS'  VPP Set Interface MTU  ${nodes['${dut}']}  ${${dut}_if1}  ELSE  VPP Set Interface MTU  ${nodes['${dut}']}  ${${dut}_if1_1}
\    Run Keyword Unless  '${if1_status}' == 'PASS'  VPP Set Interface MTU  ${nodes['${dut}']}  ${${dut}_if1_2}
\    ${if2_status}  ${value}=  Run Keyword And Ignore Error  Variable Should Exist  ${${dut}_if2}
\    Run Keyword If  '${if2_status}' == 'PASS'  VPP Set Interface MTU  ${nodes['${dut}']}  ${${dut}_if2}  ELSE  VPP Set Interface MTU  ${nodes['${dut}']}  ${${dut}_if2_1}
\    Run Keyword Unless  '${if2_status}' == 'PASS'  VPP Set Interface MTU  ${nodes['${dut}']}  ${${dut}_if2_2}
All VPP Interfaces Ready Wait  ${nodes}

3.10.1.2. Set single interfaces in path up

Set UP state on single VPP interfaces in path on all DUT nodes and set maximal MTU.


${duts}=  Get Matches  ${nodes}  DUT*
: FOR  ${dut}  IN  @{duts}
\    ${if1_status}  ${value}=  Run Keyword And Ignore Error  Variable Should Exist  ${${dut}_if1}
\    Run Keyword If  '${if1_status}' == 'PASS'  Set Interface State  ${nodes['${dut}']}  ${${dut}_if1}  up  ELSE  Set Interface State  ${nodes['${dut}']}  ${${dut}_if1_1}  up
\    Run Keyword Unless  '${if1_status}' == 'PASS'  Set Interface State  ${nodes['${dut}']}  ${${dut}_if1_2}  up
All VPP Interfaces Ready Wait  ${nodes}
${duts}=  Get Matches  ${nodes}  DUT*
: FOR  ${dut}  IN  @{duts}
\    ${if1_status}  ${value}=  Run Keyword And Ignore Error  Variable Should Exist  ${${dut}_if1}
\    Run Keyword If  '${if1_status}' == 'PASS'  VPP Set Interface MTU  ${nodes['${dut}']}  ${${dut}_if1}  ELSE  VPP Set Interface MTU  ${nodes['${dut}']}  ${${dut}_if1_1}
\    Run Keyword Unless  '${if1_status}' == 'PASS'  VPP Set Interface MTU  ${nodes['${dut}']}  ${${dut}_if1_2}
All VPP Interfaces Ready Wait  ${nodes}

3.10.1.3. Initialize AVF interfaces

Initialize AVF interfaces on each DUT. Interfaces are brought up.


${duts}=  Get Matches  ${nodes}  DUT*
: FOR  ${dut}  IN  @{duts}
\    ${if1_pci}=  Get Interface PCI Addr  ${nodes['${dut}']}  ${${dut}_if1_vf0}
\    ${if2_pci}=  Get Interface PCI Addr  ${nodes['${dut}']}  ${${dut}_if2_vf0}
\    ${dut_eth_vf_if1}=  VPP Create AVF Interface  ${nodes['${dut}']}  ${if1_pci}  ${rxq_count_int}
\    ${dut_eth_vf_if2}=  VPP Create AVF Interface  ${nodes['${dut}']}  ${if2_pci}  ${rxq_count_int}
\    Set Test Variable  ${${dut}_if1}  ${dut_eth_vf_if1}
\    Set Test Variable  ${${dut}_if2}  ${dut_eth_vf_if2}
Set interfaces in path up

3.10.1.4. Initialize IPSec in 3-node circular topology

Set UP state on VPP interfaces in path on nodes in 3-node circular topology. Get the interface MAC addresses and setup ARP on all VPP interfaces. Setup IPv4 addresses with /24 prefix on DUT-TG and DUT1-DUT2 links. Set routing for encrypted traffic on both DUT nodes with prefix /8 and next hop of neighbour DUT or TG interface IPv4 address.


Set interfaces in path up
VPP Show Crypto Device Mapping  ${dut1}
VPP Show Crypto Device Mapping  ${dut2}
${tg_if1_mac}=  Get Interface MAC  ${tg}  ${tg_if1}
${tg_if2_mac}=  Get Interface MAC  ${tg}  ${tg_if2}
${dut1_if1_mac}=  Get Interface MAC  ${dut1}  ${dut1_if1}
${dut1_if2_mac}=  Get Interface MAC  ${dut1}  ${dut1_if2}
${dut2_if1_mac}=  Get Interface MAC  ${dut2}  ${dut2_if1}
${dut2_if2_mac}=  Get Interface MAC  ${dut2}  ${dut2_if2}
Set Test Variable  ${tg_if1_mac}
Set Test Variable  ${tg_if2_mac}
Set Test Variable  ${dut1_if1_mac}
Set Test Variable  ${dut1_if2_mac}
Set Test Variable  ${dut2_if1_mac}
Set Test Variable  ${dut2_if2_mac}
Configure IP addresses on interfaces  ${dut1}  ${dut1_if1}  ${dut1_if1_ip4}  24
Configure IP addresses on interfaces  ${dut1}  ${dut1_if2}  ${dut1_if2_ip4}  24
Configure IP addresses on interfaces  ${dut2}  ${dut2_if1}  ${dut2_if1_ip4}  24
Configure IP addresses on interfaces  ${dut2}  ${dut2_if2}  ${dut2_if2_ip4}  24
Add arp on dut  ${dut1}  ${dut1_if1}  ${tg_if1_ip4}  ${tg_if1_mac}
Add arp on dut  ${dut1}  ${dut1_if2}  ${dut2_if1_ip4}  ${dut2_if1_mac}
Add arp on dut  ${dut2}  ${dut2_if2}  ${tg_if2_ip4}  ${tg_if2_mac}
Add arp on dut  ${dut2}  ${dut2_if1}  ${dut1_if2_ip4}  ${dut1_if2_mac}
Vpp Route Add  ${dut1}  ${laddr_ip4}  8  gateway=${tg_if1_ip4}  interface=${dut1_if1}
Vpp Route Add  ${dut2}  ${raddr_ip4}  8  gateway=${tg_if2_ip4}  interface=${dut2_if2}

3.10.1.5. Initialize IPv4 forwarding in circular topology

Set UP state on VPP interfaces in path on nodes in 2-node / 3-node circular topology. Get the interface MAC addresses and setup ARP on all VPP interfaces. Setup IPv4 addresses with /24 prefix on DUT-TG links. In case of 3-node topology setup IPv4 adresses with /30 prefix on DUT1-DUT2 link and set routing on both DUT nodes with prefix /24 and next hop of neighbour DUT interface IPv4 address.


${dut2_status}  ${value}=  Run Keyword And Ignore Error  Variable Should Exist  ${dut2}
Set interfaces in path up
${tg1_if1_mac}=  Get Interface MAC  ${tg}  ${tg_if1}
${tg1_if2_mac}=  Get Interface MAC  ${tg}  ${tg_if2}
${dut1_if2_mac}=  Run Keyword If  '${dut2_status}' == 'PASS'  Get Interface MAC  ${dut1}  ${dut1_if2}
${dut2_if1_mac}=  Run Keyword If  '${dut2_status}' == 'PASS'  Get Interface MAC  ${dut2}  ${dut2_if1}
Add arp on dut  ${dut1}  ${dut1_if1}  10.10.10.2  ${tg1_if1_mac}
Run Keyword If  '${dut2_status}' == 'PASS'  Add arp on dut  ${dut1}  ${dut1_if2}  1.1.1.2  ${dut2_if1_mac}
Run Keyword If  '${dut2_status}' == 'PASS'  Add arp on dut  ${dut2}  ${dut2_if1}  1.1.1.1  ${dut1_if2_mac}
${dut}=  Run Keyword If  '${dut2_status}' == 'PASS'  Set Variable  ${dut2}  ELSE  Set Variable  ${dut1}
${dut_if2}=  Run Keyword If  '${dut2_status}' == 'PASS'  Set Variable  ${dut2_if2}  ELSE  Set Variable  ${dut1_if2}
Add arp on dut  ${dut}  ${dut_if2}  20.20.20.2  ${tg1_if2_mac}
Configure IP addresses on interfaces  ${dut1}  ${dut1_if1}  10.10.10.1  24
Run Keyword If  '${dut2_status}' == 'PASS'  Configure IP addresses on interfaces  ${dut1}  ${dut1_if2}  1.1.1.1  30
Run Keyword If  '${dut2_status}' == 'PASS'  Configure IP addresses on interfaces  ${dut2}  ${dut2_if1}  1.1.1.2  30
Configure IP addresses on interfaces  ${dut}  ${dut_if2}  20.20.20.1  24
Run Keyword If  '${dut2_status}' == 'PASS'  Vpp Route Add  ${dut1}  20.20.20.0  24  gateway=1.1.1.2  interface=${dut1_if2}
Run Keyword If  '${dut2_status}' == 'PASS'  Vpp Route Add  ${dut2}  10.10.10.0  24  gateway=1.1.1.1  interface=${dut2_if1}

3.10.1.6. Initialize IPv4 forwarding with scaling in circular topology

Custom setup of IPv4 topology with scalability of ip routes on all DUT nodes in 2-node / 3-node circular topology

Arguments: - count - IP route count. Type: integer

Return: - No value returned

Example:

| Initialize IPv4 forwarding with scaling in 3-node circular topology | 100000 |


${dut2_status}  ${value}=  Run Keyword And Ignore Error  Variable Should Exist  ${dut2}
Set interfaces in path up
${tg1_if1_mac}=  Get Interface MAC  ${tg}  ${tg_if1}
${tg1_if2_mac}=  Get Interface MAC  ${tg}  ${tg_if2}
${dut1_if2_mac}=  Run Keyword If  '${dut2_status}' == 'PASS'  Get Interface MAC  ${dut1}  ${dut1_if2}
${dut2_if1_mac}=  Run Keyword If  '${dut2_status}' == 'PASS'  Get Interface MAC  ${dut2}  ${dut2_if1}
Add arp on dut  ${dut1}  ${dut1_if1}  1.1.1.1  ${tg1_if1_mac}
Run Keyword If  '${dut2_status}' == 'PASS'  Add arp on dut  ${dut1}  ${dut1_if2}  2.2.2.2  ${dut2_if1_mac}
Run Keyword If  '${dut2_status}' == 'PASS'  Add arp on dut  ${dut2}  ${dut2_if1}  2.2.2.1  ${dut1_if2_mac}
${dut}=  Run Keyword If  '${dut2_status}' == 'PASS'  Set Variable  ${dut2}  ELSE  Set Variable  ${dut1}
${dut_if2}=  Run Keyword If  '${dut2_status}' == 'PASS'  Set Variable  ${dut2_if2}  ELSE  Set Variable  ${dut1_if2}
Add arp on dut  ${dut}  ${dut_if2}  3.3.3.1  ${tg1_if2_mac}
Configure IP addresses on interfaces  ${dut1}  ${dut1_if1}  1.1.1.2  30
Run Keyword If  '${dut2_status}' == 'PASS'  Configure IP addresses on interfaces  ${dut1}  ${dut1_if2}  2.2.2.1  30
Run Keyword If  '${dut2_status}' == 'PASS'  Configure IP addresses on interfaces  ${dut2}  ${dut2_if1}  2.2.2.2  30
Configure IP addresses on interfaces  ${dut}  ${dut_if2}  3.3.3.2  30
Vpp Route Add  ${dut1}  10.0.0.0  32  gateway=1.1.1.1  interface=${dut1_if1}  count=${count}
Run Keyword If  '${dut2_status}' == 'PASS'  Vpp Route Add  ${dut1}  20.0.0.0  32  gateway=2.2.2.2  interface=${dut1_if2}  count=${count}
Run Keyword If  '${dut2_status}' == 'PASS'  Vpp Route Add  ${dut2}  10.0.0.0  32  gateway=2.2.2.1  interface=${dut2_if1}  count=${count}
Vpp Route Add  ${dut}  20.0.0.0  32  gateway=3.3.3.1  interface=${dut_if2}  count=${count}

3.10.1.7. Initialize IPv4 forwarding with vhost in 2-node circular topology

Create pairs of Vhost-User interfaces for defined number of VMs on VPP node. Set UP state of all VPP interfaces in path. Create vm_count+1 FIB tables on DUT with multipath routing. Assign each Virtual interface to FIB table with Physical interface or Virtual interface on both nodes. Setup IPv4 addresses with /30 prefix on DUT-TG links. Set routing on DUT nodes in all FIB tables with prefix /24 and next hop of neighbour IPv4 address. Setup ARP on all VPP interfaces.

Arguments: - vm_count - Number of guest VMs. Type: integer

Note: Socket paths for VM are defined in following format: - /tmp/sock-${VM_ID}-1 - /tmp/sock-${VM_ID}-2

Example:

| IPv4 forwarding with Vhost-User initialized in a 2-node circulartopology | 1 |


Set interfaces in path up
${fib_table_1}=  Set Variable  ${101}
${fib_table_2}=  Evaluate  ${fib_table_1}+${vm_count}
Add Fib Table  ${dut1}  ${fib_table_1}
  And Vpp Route Add  ${dut1}  10.10.10.0  24  vrf=${fib_table_1}  gateway=1.1.1.2  interface=${dut1_if1}  multipath=${TRUE}
Add Fib Table  ${dut1}  ${fib_table_2}
  And Vpp Route Add  ${dut1}  20.20.20.0  24  vrf=${fib_table_2}  gateway=2.2.2.2  interface=${dut1_if2}  multipath=${TRUE}
Assign Interface To Fib Table  ${dut1}  ${dut1_if1}  ${fib_table_1}
Assign Interface To Fib Table  ${dut1}  ${dut1_if2}  ${fib_table_2}
Configure IP addresses on interfaces  ${dut1}  ${dut1_if1}  1.1.1.2  30
Configure IP addresses on interfaces  ${dut1}  ${dut1_if2}  2.2.2.1  30
${tg1_if1_mac}=  Get Interface MAC  ${tg}  ${tg_if1}
${tg1_if2_mac}=  Get Interface MAC  ${tg}  ${tg_if2}
Add arp on dut  ${dut1}  ${dut1_if1}  1.1.1.1  ${tg1_if1_mac}
Add arp on dut  ${dut1}  ${dut1_if2}  2.2.2.2  ${tg1_if2_mac}
Vpp Route Add  ${dut1}  10.10.10.0  24  gateway=1.1.1.1  interface=${dut1_if1}  vrf=${fib_table_1}
Vpp Route Add  ${dut1}  20.20.20.0  24  gateway=2.2.2.2  interface=${dut1_if2}  vrf=${fib_table_2}
${ip_base_start}=  Set Variable  ${4}
: FOR  ${number}  IN RANGE  1  ${vm_count}+1
\    ${sock1}=  Set Variable  /tmp/sock-${number}-1
\    ${sock2}=  Set Variable  /tmp/sock-${number}-2
\    ${fib_table_1}=  Evaluate  ${100}+${number}
\    ${fib_table_2}=  Evaluate  ${fib_table_1}+${1}
\    ${ip_base_vif1}=  Evaluate  ${ip_base_start}+(${number}-1)*2
\    ${ip_base_vif2}=  Evaluate  ${ip_base_vif1}+1
\    ${ip_net_vif1}=  Set Variable  ${ip_base_vif1}.${ip_base_vif1}.${ip_base_vif1}
\    ${ip_net_vif2}=  Set Variable  ${ip_base_vif2}.${ip_base_vif2}.${ip_base_vif2}
\    Configure vhost interfaces for L2BD forwarding  ${dut1}  ${sock1}  ${sock2}  dut1-vhost-${number}-if1  dut1-vhost-${number}-if2
\    Set Interface State  ${dut1}  ${dut1-vhost-${number}-if1}  up
\    Set Interface State  ${dut1}  ${dut1-vhost-${number}-if2}  up
\    Add Fib Table  ${dut1}  ${fib_table_1}
  \    And Vpp Route Add  ${dut1}  20.20.20.0  24  vrf=${fib_table_1}  gateway=${ip_net_vif1}.1  interface=${dut1-vhost-${number}-if1}  multipath=${TRUE}
\    Add Fib Table  ${dut1}  ${fib_table_2}
  \    And Vpp Route Add  ${dut1}  10.10.10.0  24  vrf=${fib_table_2}  gateway=${ip_net_vif2}.2  interface=${dut1-vhost-${number}-if2}  multipath=${TRUE}
\    Assign Interface To Fib Table  ${dut1}  ${dut1-vhost-${number}-if1}  ${fib_table_1}
\    Assign Interface To Fib Table  ${dut1}  ${dut1-vhost-${number}-if2}  ${fib_table_2}
\    Configure IP addresses on interfaces  ${dut1}  ${dut1-vhost-${number}-if1}  ${ip_net_vif1}.1  30  ${dut1}  ${dut1-vhost-${number}-if2}  ${ip_net_vif2}.1  30
\    ${dut1_vif1_idx}=  Get Interface SW Index  ${dut1}  ${dut1-vhost-${number}-if1}
\    ${dut1_vif2_idx}=  Get Interface SW Index  ${dut1}  ${dut1-vhost-${number}-if2}
\    ${dut1_vif1_mac}=  Get Vhost User Mac By Sw Index  ${dut1}  ${dut1_vif1_idx}
\    ${dut1_vif2_mac}=  Get Vhost User Mac By Sw Index  ${dut1}  ${dut1_vif2_idx}
\    Set Test Variable  ${dut1-vhost-${number}-if1_mac}  ${dut1_vif1_mac}
\    Set Test Variable  ${dut1-vhost-${number}-if2_mac}  ${dut1_vif2_mac}
\    ${qemu_id}=  Set Variable If  ${number} < 10  0${number}  ${number}
\    Add arp on dut  ${dut1}  ${dut1-vhost-${number}-if1}  ${ip_net_vif1}.2  52:54:00:00:${qemu_id}:01
\    Add arp on dut  ${dut1}  ${dut1-vhost-${number}-if2}  ${ip_net_vif2}.2  52:54:00:00:${qemu_id}:02
\    Vpp Route Add  ${dut1}  20.20.20.0  24  gateway=${ip_net_vif1}.2  interface=${dut1-vhost-${number}-if1}  vrf=${fib_table_1}
\    Vpp Route Add  ${dut1}  10.10.10.0  24  gateway=${ip_net_vif2}.2  interface=${dut1-vhost-${number}-if2}  vrf=${fib_table_2}

3.10.1.8. Initialize IPv4 forwarding with vhost in 3-node circular topology

Create pairs of Vhost-User interfaces for defined number of VMs on all VPP nodes. Set UP state of all VPP interfaces in path. Create vm_count+1 FIB tables on each DUT with multipath routing. Assign each Virtual interface to FIB table with Physical interface or Virtual interface on both nodes. Setup IPv4 addresses with /30 prefix on DUT-TG links and /30 prefix on DUT1-DUT2 link. Set routing on all DUT nodes in all FIB tables with prefix /24 and next hop of neighbour IPv4 address. Setup ARP on all VPP interfaces.

Arguments: - vm_count - Number of guest VMs. Type: integer

Note: Socket paths for VM are defined in following format: - /tmp/sock-${VM_ID}-1 - /tmp/sock-${VM_ID}-2

Example:

| IPv4 forwarding with Vhost-User initialized in a 3-node circulartopology | 1 |


Set interfaces in path up
${fib_table_1}=  Set Variable  ${101}
${fib_table_2}=  Evaluate  ${fib_table_1}+${vm_count}
Add Fib Table  ${dut1}  ${fib_table_1}
  And Vpp Route Add  ${dut1}  10.10.10.0  24  vrf=${fib_table_1}  gateway=1.1.1.2  interface=${dut1_if1}  multipath=${TRUE}
Add Fib Table  ${dut1}  ${fib_table_2}
  And Vpp Route Add  ${dut1}  20.20.20.0  24  vrf=${fib_table_2}  gateway=2.2.2.2  interface=${dut1_if2}  multipath=${TRUE}
Add Fib Table  ${dut2}  ${fib_table_1}
  And Vpp Route Add  ${dut2}  10.10.10.0  24  vrf=${fib_table_1}  gateway=2.2.2.1  interface=${dut2_if1}  multipath=${TRUE}
Add Fib Table  ${dut2}  ${fib_table_2}
  And Vpp Route Add  ${dut2}  20.20.20.0  24  vrf=${fib_table_2}  gateway=3.3.3.2  interface=${dut2_if2}  multipath=${TRUE}
Assign Interface To Fib Table  ${dut1}  ${dut1_if1}  ${fib_table_1}
Assign Interface To Fib Table  ${dut1}  ${dut1_if2}  ${fib_table_2}
Assign Interface To Fib Table  ${dut2}  ${dut2_if1}  ${fib_table_1}
Assign Interface To Fib Table  ${dut2}  ${dut2_if2}  ${fib_table_2}
Configure IP addresses on interfaces  ${dut1}  ${dut1_if1}  1.1.1.2  30
Configure IP addresses on interfaces  ${dut1}  ${dut1_if2}  2.2.2.1  30
Configure IP addresses on interfaces  ${dut2}  ${dut2_if1}  2.2.2.2  30
Configure IP addresses on interfaces  ${dut2}  ${dut2_if2}  3.3.3.1  30
${tg1_if1_mac}=  Get Interface MAC  ${tg}  ${tg_if1}
${tg1_if2_mac}=  Get Interface MAC  ${tg}  ${tg_if2}
${dut1_if2_mac}=  Get Interface MAC  ${dut1}  ${dut1_if2}
${dut2_if1_mac}=  Get Interface MAC  ${dut2}  ${dut2_if1}
Add arp on dut  ${dut1}  ${dut1_if1}  1.1.1.1  ${tg1_if1_mac}
Add arp on dut  ${dut1}  ${dut1_if2}  2.2.2.2  ${dut2_if1_mac}
Add arp on dut  ${dut2}  ${dut2_if1}  2.2.2.1  ${dut1_if2_mac}
Add arp on dut  ${dut2}  ${dut2_if2}  3.3.3.2  ${tg1_if2_mac}
Vpp Route Add  ${dut1}  10.10.10.0  24  gateway=1.1.1.1  interface=${dut1_if1}  vrf=${fib_table_1}
Vpp Route Add  ${dut1}  20.20.20.0  24  gateway=2.2.2.2  interface=${dut1_if2}  vrf=${fib_table_2}
Vpp Route Add  ${dut2}  10.10.10.0  24  gateway=2.2.2.1  interface=${dut2_if1}  vrf=${fib_table_1}
Vpp Route Add  ${dut2}  20.20.20.0  24  gateway=3.3.3.2  interface=${dut2_if2}  vrf=${fib_table_2}
${ip_base_start}=  Set Variable  ${4}
: FOR  ${number}  IN RANGE  1  ${vm_count}+1
\    ${sock1}=  Set Variable  /tmp/sock-${number}-1
\    ${sock2}=  Set Variable  /tmp/sock-${number}-2
\    ${fib_table_1}=  Evaluate  ${100}+${number}
\    ${fib_table_2}=  Evaluate  ${fib_table_1}+${1}
\    ${ip_base_vif1}=  Evaluate  ${ip_base_start}+(${number}-1)*2
\    ${ip_base_vif2}=  Evaluate  ${ip_base_vif1}+1
\    ${ip_net_vif1}=  Set Variable  ${ip_base_vif1}.${ip_base_vif1}.${ip_base_vif1}
\    ${ip_net_vif2}=  Set Variable  ${ip_base_vif2}.${ip_base_vif2}.${ip_base_vif2}
\    Configure vhost interfaces for L2BD forwarding  ${dut1}  ${sock1}  ${sock2}  dut1-vhost-${number}-if1  dut1-vhost-${number}-if2
\    Set Interface State  ${dut1}  ${dut1-vhost-${number}-if1}  up
\    Set Interface State  ${dut1}  ${dut1-vhost-${number}-if2}  up
\    Configure vhost interfaces for L2BD forwarding  ${dut2}  ${sock1}  ${sock2}  dut2-vhost-${number}-if1  dut2-vhost-${number}-if2
\    Set Interface State  ${dut2}  ${dut2-vhost-${number}-if1}  up
\    Set Interface State  ${dut2}  ${dut2-vhost-${number}-if2}  up
\    Add Fib Table  ${dut1}  ${fib_table_1}
  \    And Vpp Route Add  ${dut1}  20.20.20.0  24  vrf=${fib_table_1}  gateway=${ip_net_vif1}.1  interface=${dut1-vhost-${number}-if1}  multipath=${TRUE}
\    Add Fib Table  ${dut1}  ${fib_table_2}
  \    And Vpp Route Add  ${dut1}  10.10.10.0  24  vrf=${fib_table_2}  gateway=${ip_net_vif2}.2  interface=${dut1-vhost-${number}-if2}  multipath=${TRUE}
\    Add Fib Table  ${dut2}  ${fib_table_1}
  \    And Vpp Route Add  ${dut2}  20.20.20.0  24  vrf=${fib_table_1}  gateway=${ip_net_vif1}.1  interface=${dut2-vhost-${number}-if1}  multipath=${TRUE}
\    Add Fib Table  ${dut2}  ${fib_table_2}
  \    And Vpp Route Add  ${dut2}  10.10.10.0  24  vrf=${fib_table_2}  gateway=${ip_net_vif2}.2  interface=${dut2-vhost-${number}-if2}  multipath=${TRUE}
\    Assign Interface To Fib Table  ${dut1}  ${dut1-vhost-${number}-if1}  ${fib_table_1}
\    Assign Interface To Fib Table  ${dut1}  ${dut1-vhost-${number}-if2}  ${fib_table_2}
\    Assign Interface To Fib Table  ${dut2}  ${dut2-vhost-${number}-if1}  ${fib_table_1}
\    Assign Interface To Fib Table  ${dut2}  ${dut2-vhost-${number}-if2}  ${fib_table_2}
\    Configure IP addresses on interfaces  ${dut1}  ${dut1-vhost-${number}-if1}  ${ip_net_vif1}.1  30  ${dut1}  ${dut1-vhost-${number}-if2}  ${ip_net_vif2}.1  30  ${dut2}  ${dut2-vhost-${number}-if1}  ${ip_net_vif1}.1  30  ${dut2}  ${dut2-vhost-${number}-if2}  ${ip_net_vif2}.1  30
\    ${dut1_vif1_idx}=  Get Interface SW Index  ${dut1}  ${dut1-vhost-${number}-if1}
\    ${dut1_vif2_idx}=  Get Interface SW Index  ${dut1}  ${dut1-vhost-${number}-if2}
\    ${dut2_vif1_idx}=  Get Interface SW Index  ${dut2}  ${dut2-vhost-${number}-if1}
\    ${dut2_vif2_idx}=  Get Interface SW Index  ${dut2}  ${dut2-vhost-${number}-if2}
\    ${dut1_vif1_mac}=  Get Vhost User Mac By Sw Index  ${dut1}  ${dut1_vif1_idx}
\    ${dut1_vif2_mac}=  Get Vhost User Mac By Sw Index  ${dut1}  ${dut1_vif2_idx}
\    ${dut2_vif1_mac}=  Get Vhost User Mac By Sw Index  ${dut2}  ${dut2_vif1_idx}
\    ${dut2_vif2_mac}=  Get Vhost User Mac By Sw Index  ${dut2}  ${dut2_vif2_idx}
\    Set Test Variable  ${dut1-vhost-${number}-if1_mac}  ${dut1_vif1_mac}
\    Set Test Variable  ${dut1-vhost-${number}-if2_mac}  ${dut1_vif2_mac}
\    Set Test Variable  ${dut2-vhost-${number}-if1_mac}  ${dut2_vif1_mac}
\    Set Test Variable  ${dut2-vhost-${number}-if2_mac}  ${dut2_vif2_mac}
\    ${qemu_id}=  Set Variable If  ${number} < 10  0${number}  ${number}
\    Add arp on dut  ${dut1}  ${dut1-vhost-${number}-if1}  ${ip_net_vif1}.2  52:54:00:00:${qemu_id}:01
\    Add arp on dut  ${dut1}  ${dut1-vhost-${number}-if2}  ${ip_net_vif2}.2  52:54:00:00:${qemu_id}:02
\    Add arp on dut  ${dut2}  ${dut2-vhost-${number}-if1}  ${ip_net_vif1}.2  52:54:00:00:${qemu_id}:01
\    Add arp on dut  ${dut2}  ${dut2-vhost-${number}-if2}  ${ip_net_vif2}.2  52:54:00:00:${qemu_id}:02
\    Vpp Route Add  ${dut1}  20.20.20.0  24  gateway=${ip_net_vif1}.2  interface=${dut1-vhost-${number}-if1}  vrf=${fib_table_1}
\    Vpp Route Add  ${dut1}  10.10.10.0  24  gateway=${ip_net_vif2}.2  interface=${dut1-vhost-${number}-if2}  vrf=${fib_table_2}
\    Vpp Route Add  ${dut2}  20.20.20.0  24  gateway=${ip_net_vif1}.2  interface=${dut2-vhost-${number}-if1}  vrf=${fib_table_1}
\    Vpp Route Add  ${dut2}  10.10.10.0  24  gateway=${ip_net_vif2}.2  interface=${dut2-vhost-${number}-if2}  vrf=${fib_table_2}

3.10.1.9. Initialize IPv4 forwarding with VLAN dot1q sub-interfaces in circular topology

Set UP state on VPP interfaces in path on nodes in 2-node / 3-node circular topology. In case of 3-node topology create VLAN sub-interfaces between DUTs. In case of 2-node topology create VLAN sub-interface on dut1-if2 interface. Get the interface MAC addresses and setup ARPs. Setup IPv4 addresses with /30 prefix on DUT-TG links and set routing with prefix /30. In case of 3-node set IPv4 adresses with /30 prefix on VLAN and set routing on both DUT nodes with prefix /30. Set next hop of neighbour DUT interface IPv4 address. All interfaces are brought up.

Arguments: - tg_if1_net - TG interface 1 IP subnet used by traffic generator. Type: integer - tg_if2_net - TG interface 2 IP subnet used by traffic generator. Type: integer - subid - ID of the sub-interface to be created. Type: string - tag_rewrite - Method of tag rewrite. Type: string

_NOTE:_ This KW uses following test case variables: - dut1 - DUT1 node. - dut2 - DUT2 node. - dut1_if2 - DUT1 interface towards DUT2. - dut2_if1 - DUT2 interface towards DUT1.

Example:

| Initialize IPv4 forwarding with VLAN dot1q sub-interfacesin circular topology | 10.10.10.0 | 20.20.20.0 | 10 | pop-1 |


${dut2_status}  ${value}=  Run Keyword And Ignore Error  Variable Should Exist  ${dut2}
Set interfaces in path up
Run Keyword If  '${dut2_status}' == 'PASS'  Initialize VLAN dot1q sub-interfaces in circular topology  ${dut1}  ${dut1_if2}  ${dut2}  ${dut2_if1}  ${subid}  ELSE  Initialize VLAN dot1q sub-interfaces in circular topology  ${dut1}  ${dut1_if2}  SUB_ID=${subid}
Run Keyword If  '${dut2_status}' == 'PASS'  Configure L2 tag rewrite method on interfaces  ${dut1}  ${subif_index_1}  ${dut2}  ${subif_index_2}  ${tag_rewrite}  ELSE  Configure L2 tag rewrite method on interfaces  ${dut1}  ${subif_index_1}  TAG_REWRITE_METHOD=${tag_rewrite}
${tg1_if1_mac}=  Get Interface MAC  ${tg}  ${tg_if1}
${tg1_if2_mac}=  Get Interface MAC  ${tg}  ${tg_if2}
${dut1_if2_mac}=  Run Keyword If  '${dut2_status}' == 'PASS'  Get Interface MAC  ${dut1}  ${dut1_if2}
${dut2_if1_mac}=  Run Keyword If  '${dut2_status}' == 'PASS'  Get Interface MAC  ${dut2}  ${dut2_if1}
Add arp on dut  ${dut1}  ${dut1_if1}  1.1.1.1  ${tg1_if1_mac}
Run Keyword If  '${dut2_status}' == 'PASS'  Add arp on dut  ${dut1}  ${subif_index_1}  2.2.2.2  ${dut2_if1_mac}
Run Keyword If  '${dut2_status}' == 'PASS'  Add arp on dut  ${dut2}  ${subif_index_2}  2.2.2.1  ${dut1_if2_mac}
${dut}=  Run Keyword If  '${dut2_status}' == 'PASS'  Set Variable  ${dut2}  ELSE  Set Variable  ${dut1}
${dut_if2}=  Run Keyword If  '${dut2_status}' == 'PASS'  Set Variable  ${dut2_if2}  ELSE  Set Variable  ${subif_index_1}
Add arp on dut  ${dut}  ${dut_if2}  3.3.3.1  ${tg1_if2_mac}
Configure IP addresses on interfaces  ${dut1}  ${dut1_if1}  1.1.1.2  30
Run Keyword If  '${dut2_status}' == 'PASS'  Configure IP addresses on interfaces  ${dut1}  ${subif_index_1}  2.2.2.1  30
Run Keyword If  '${dut2_status}' == 'PASS'  Configure IP addresses on interfaces  ${dut2}  ${subif_index_2}  2.2.2.2  30
Configure IP addresses on interfaces  ${dut}  ${dut_if2}  3.3.3.2  30
Vpp Route Add  ${dut1}  ${tg_if1_net}  30  gateway=1.1.1.1  interface=${dut1_if1}
Run Keyword If  '${dut2_status}' == 'PASS'  Vpp Route Add  ${dut1}  ${tg_if2_net}  30  gateway=2.2.2.2  interface=${subif_index_1}
Run Keyword If  '${dut2_status}' == 'PASS'  Vpp Route Add  ${dut2}  ${tg_if1_net}  30  gateway=2.2.2.1  interface=${subif_index_2}
Vpp Route Add  ${dut}  ${tg_if2_net}  30  gateway=3.3.3.1  interface=${dut_if2}

3.10.1.10. Initialize IPv4 policer 2r3c-${t} in circular topology

Setup of 2r3c color-aware or color-blind policer with dst ip match on all DUT nodes in 2-node / 3-node circular topology. Policer is applied on links TG - DUTx.

${t}
${dscp}=  DSCP AF22
Policer Set Name  policer1
Policer Set CIR  ${cir}
Policer Set EIR  ${eir}
Policer Set CB  ${cb}
Policer Set EB  ${eb}
Policer Set Rate Type pps
Policer Set Round Type Closest
Policer Set Type 2R3C 2698
Policer Set Conform Action Transmit
Policer Set Exceed Action Mark and Transmit  ${dscp}
Policer Set Violate Action Transmit
Policer Enable Color Aware
Run Keyword If  ${t} == 'ca'  Policer Enable Color Aware
Policer Classify Set Precolor Exceed
Policer Set Node  ${dut1}
Policer Classify Set Interface  ${dut1_if1}
Policer Classify Set Match IP  20.20.20.2  ${False}
Policer Set Configuration
${dut2_status}  ${value}=  Run Keyword And Ignore Error  Variable Should Exist  ${dut2}
${dut}=  Run Keyword If  '${dut2_status}' == 'PASS'  Set Variable  ${dut2}  ELSE  Set Variable  ${dut1}
${dut_if2}=  Run Keyword If  '${dut2_status}' == 'PASS'  Set Variable  ${dut2_if2}  ELSE  Set Variable  ${dut1_if2}
Run Keyword Unless  '${dut2_status}' == 'PASS'  Policer Set Name  policer2
Policer Set Node  ${dut}
Policer Classify Set Interface  ${dut_if2}
Policer Classify Set Match IP  10.10.10.2  ${False}
Policer Set Configuration

3.10.1.11. Initialize IPv6 forwarding in 2-node circular topology

Set UP state on VPP interfaces in path on nodes in 2-node circular topology. Get the interface MAC addresses and setup neighbour on all VPP interfaces. Setup IPv6 addresses with /128 prefixes on all interfaces.


Set interfaces in path up
${prefix}=  Set Variable  64
${tg1_if1_mac}=  Get Interface MAC  ${tg}  ${tg_if1}
${tg1_if2_mac}=  Get Interface MAC  ${tg}  ${tg_if2}
VPP Set If IPv6 Addr  ${dut1}  ${dut1_if1}  2001:1::1  ${prefix}
VPP Set If IPv6 Addr  ${dut1}  ${dut1_if2}  2001:2::1  ${prefix}
Suppress ICMPv6 router advertisement message  ${nodes}
Add Ip Neighbor  ${dut1}  ${dut1_if1}  2001:1::2  ${tg1_if1_mac}
Add Ip Neighbor  ${dut1}  ${dut1_if2}  2001:2::2  ${tg1_if2_mac}

3.10.1.12. Initialize IPv6 forwarding in 3-node circular topology

Set UP state on VPP interfaces in path on nodes in 3-node circular topology. Get the interface MAC addresses and setup neighbour on all VPP interfaces. Setup IPv6 addresses with /128 prefixes on all interfaces. Set routing on both DUT nodes with prefix /64 and next hop of neighbour DUT interface IPv6 address.


Set interfaces in path up
${prefix}=  Set Variable  64
${tg1_if1_mac}=  Get Interface MAC  ${tg}  ${tg_if1}
${tg1_if2_mac}=  Get Interface MAC  ${tg}  ${tg_if2}
${dut1_if2_mac}=  Get Interface MAC  ${dut1}  ${dut1_if2}
${dut2_if1_mac}=  Get Interface MAC  ${dut2}  ${dut2_if1}
VPP Set If IPv6 Addr  ${dut1}  ${dut1_if1}  2001:1::1  ${prefix}
VPP Set If IPv6 Addr  ${dut1}  ${dut1_if2}  2001:3::1  ${prefix}
VPP Set If IPv6 Addr  ${dut2}  ${dut2_if1}  2001:3::2  ${prefix}
VPP Set If IPv6 Addr  ${dut2}  ${dut2_if2}  2001:2::1  ${prefix}
Suppress ICMPv6 router advertisement message  ${nodes}
Add Ip Neighbor  ${dut1}  ${dut1_if1}  2001:1::2  ${tg1_if1_mac}
Add Ip Neighbor  ${dut2}  ${dut2_if2}  2001:2::2  ${tg1_if2_mac}
Add Ip Neighbor  ${dut1}  ${dut1_if2}  2001:3::2  ${dut2_if1_mac}
Add Ip Neighbor  ${dut2}  ${dut2_if1}  2001:3::1  ${dut1_if2_mac}
Vpp Route Add  ${dut1}  2001:2::0  ${prefix}  gateway=2001:3::2  interface=${dut1_if2}
Vpp Route Add  ${dut2}  2001:1::0  ${prefix}  gateway=2001:3::1  interface=${dut2_if1}

3.10.1.13. Initialize IPv6 forwarding with scaling in circular topology

Custom setup of IPv6 topology with scalability of ip routes on all DUT nodes in 2-node / 3-node circular topology

Arguments: - count - IP route count. Type: integer

Return: - No value returned

Example:

| Initialize IPv6 forwarding with scaling in circular topology | 100000 |


${dut2_status}  ${value}=  Run Keyword And Ignore Error  Variable Should Exist  ${dut2}
Set interfaces in path up
${tg1_if1_mac}=  Get Interface MAC  ${tg}  ${tg_if1}
${tg1_if2_mac}=  Get Interface MAC  ${tg}  ${tg_if2}
${dut1_if2_mac}=  Run Keyword If  '${dut2_status}' == 'PASS'  Get Interface MAC  ${dut1}  ${dut1_if2}
${dut2_if1_mac}=  Run Keyword If  '${dut2_status}' == 'PASS'  Get Interface MAC  ${dut2}  ${dut2_if1}
${prefix}=  Set Variable  64
${host_prefix}=  Set Variable  128
VPP Set If IPv6 Addr  ${dut1}  ${dut1_if1}  2001:3::1  ${prefix}
Run Keyword If  '${dut2_status}' == 'PASS'  VPP Set If IPv6 Addr  ${dut1}  ${dut1_if2}  2001:4::1  ${prefix}
Run Keyword If  '${dut2_status}' == 'PASS'  VPP Set If IPv6 Addr  ${dut2}  ${dut2_if1}  2001:4::2  ${prefix}
${dut}=  Run Keyword If  '${dut2_status}' == 'PASS'  Set Variable  ${dut2}  ELSE  Set Variable  ${dut1}
${dut_if2}=  Run Keyword If  '${dut2_status}' == 'PASS'  Set Variable  ${dut2_if2}  ELSE  Set Variable  ${dut1_if2}
VPP Set If IPv6 Addr  ${dut}  ${dut_if2}  2001:5::1  ${prefix}
Suppress ICMPv6 router advertisement message  ${nodes}
Add Ip Neighbor  ${dut1}  ${dut1_if1}  2001:3::2  ${tg1_if1_mac}
Run Keyword If  '${dut2_status}' == 'PASS'  Add Ip Neighbor  ${dut1}  ${dut1_if2}  2001:4::2  ${dut2_if1_mac}
Run Keyword If  '${dut2_status}' == 'PASS'  Add Ip Neighbor  ${dut2}  ${dut2_if1}  2001:4::1  ${dut1_if2_mac}
Add Ip Neighbor  ${dut}  ${dut_if2}  2001:5::2  ${tg1_if2_mac}
Vpp Route Add  ${dut1}  2001:1::0  ${host_prefix}  gateway=2001:3::2  interface=${dut1_if1}  count=${count}
Run Keyword If  '${dut2_status}' == 'PASS'  Vpp Route Add  ${dut1}  2001:2::0  ${host_prefix}  gateway=2001:4::2  interface=${dut1_if2}  count=${count}
Run Keyword If  '${dut2_status}' == 'PASS'  Vpp Route Add  ${dut2}  2001:1::0  ${host_prefix}  gateway=2001:4::1  interface=${dut2_if1}  count=${count}
Vpp Route Add  ${dut}  2001:2::0  ${host_prefix}  gateway=2001:5::2  interface=${dut_if2}  count=${count}

3.10.1.14. Initialize IPv6 forwarding with VLAN dot1q sub-interfaces in circular topology

Set UP state on VPP interfaces in path on nodes in 2-node / 3-node circular topology. In case of 3-node topology create VLAN sub-interfaces between DUTs. In case of 2-node topology create VLAN sub-interface on dut1-if2 interface. Get the interface MAC addresses and setup ARPs. Setup IPv6 addresses with /64 prefix on DUT-TG links and set routing with prefix /64. In case of 3-node set IPv6 adresses with /64 prefix on VLAN and set routing on both DUT nodes with prefix /64. Set next hop of neighbour DUT interface IPv6 address. All interfaces are brought up.

Arguments: - tg_if1_net - TG interface 1 IPv6 subnet used by traffic generator. Type: integer - tg_if2_net - TG interface 2 IPv6 subnet used by traffic generator. Type: integer - subid - ID of the sub-interface to be created. Type: string - tag_rewrite - Method of tag rewrite. Type: string

_NOTE:_ This KW uses following test case variables: - dut1 - DUT1 node. - dut2 - DUT2 node. - dut1_if2 - DUT1 interface towards DUT2. - dut2_if1 - DUT2 interface towards DUT1.

Example:

| Initialize IPv6 forwarding with VLAN dot1q sub-interfacesin circular topology | 2001:1::0 | 2001:2::0 | 10 | pop-1 |


${dut2_status}  ${value}=  Run Keyword And Ignore Error  Variable Should Exist  ${dut2}
Set interfaces in path up
Run Keyword If  '${dut2_status}' == 'PASS'  Initialize VLAN dot1q sub-interfaces in circular topology  ${dut1}  ${dut1_if2}  ${dut2}  ${dut2_if1}  ${subid}  ELSE  Initialize VLAN dot1q sub-interfaces in circular topology  ${dut1}  ${dut1_if2}  SUB_ID=${subid}
Run Keyword If  '${dut2_status}' == 'PASS'  Configure L2 tag rewrite method on interfaces  ${dut1}  ${subif_index_1}  ${dut2}  ${subif_index_2}  ${tag_rewrite}  ELSE  Configure L2 tag rewrite method on interfaces  ${dut1}  ${subif_index_1}  TAG_REWRITE_METHOD=${tag_rewrite}
${prefix}=  Set Variable  64
${host_prefix}=  Set Variable  64
${tg1_if1_mac}=  Get Interface MAC  ${tg}  ${tg_if1}
${tg1_if2_mac}=  Get Interface MAC  ${tg}  ${tg_if2}
${dut1_if2_mac}=  Run Keyword If  '${dut2_status}' == 'PASS'  Get Interface MAC  ${dut1}  ${dut1_if2}
${dut2_if1_mac}=  Run Keyword If  '${dut2_status}' == 'PASS'  Get Interface MAC  ${dut2}  ${dut2_if1}
Add Ip Neighbor  ${dut1}  ${dut1_if1}  2002:1::1  ${tg1_if1_mac}
Run Keyword If  '${dut2_status}' == 'PASS'  Add Ip Neighbor  ${dut1}  ${subif_index_1}  2002:2::2  ${dut2_if1_mac}
Run Keyword If  '${dut2_status}' == 'PASS'  Add Ip Neighbor  ${dut2}  ${subif_index_2}  2002:2::1  ${dut1_if2_mac}
${dut}=  Run Keyword If  '${dut2_status}' == 'PASS'  Set Variable  ${dut2}  ELSE  Set Variable  ${dut1}
${dut_if2}=  Run Keyword If  '${dut2_status}' == 'PASS'  Set Variable  ${dut2_if2}  ELSE  Set Variable  ${subif_index_1}
Add Ip Neighbor  ${dut}  ${dut_if2}  2002:3::1  ${tg1_if2_mac}
VPP Set If IPv6 Addr  ${dut1}  ${dut1_if1}  2002:1::2  ${prefix}
Run Keyword If  '${dut2_status}' == 'PASS'  VPP Set If IPv6 Addr  ${dut1}  ${subif_index_1}  2002:2::1  ${prefix}
Run Keyword If  '${dut2_status}' == 'PASS'  VPP Set If IPv6 Addr  ${dut2}  ${subif_index_2}  2002:2::2  ${prefix}
VPP Set If IPv6 Addr  ${dut}  ${dut_if2}  2002:3::2  ${prefix}
Suppress ICMPv6 router advertisement message  ${nodes}
Vpp Route Add  ${dut1}  ${tg_if1_net}  ${host_prefix}  gateway=2002:1::1  interface=${dut1_if1}
Run Keyword If  '${dut2_status}' == 'PASS'  Vpp Route Add  ${dut1}  ${tg_if2_net}  ${host_prefix}  gateway=2002:2::2  interface=${subif_index_1}
Run Keyword If  '${dut2_status}' == 'PASS'  Vpp Route Add  ${dut2}  ${tg_if1_net}  ${host_prefix}  gateway=2002:2::1  interface=${subif_index_2}
Vpp Route Add  ${dut}  ${tg_if2_net}  ${host_prefix}  gateway=2002:3::1  interface=${dut_if2}

3.10.1.15. Initialize IPv6 iAcl whitelist in 3-node circular topology

Creates classify L3 table on DUTs. IPv6 iAcl security whitelist ingress /64 filter entries applied on links TG - DUT1 and DUT2 - TG.


${table_idx}  ${skip_n}  ${match_n}=  And Vpp Creates Classify Table L3  ${dut1}  ip6  dst
  And Vpp Configures Classify Session L3  ${dut1}  permit  ${table_idx}  ${skip_n}  ${match_n}  ip6  dst  2001:2::2
  And Vpp Enable Input Acl Interface  ${dut1}  ${dut1_if1}  ip6  ${table_idx}
${table_idx}  ${skip_n}  ${match_n}=  And Vpp Creates Classify Table L3  ${dut2}  ip6  dst
  And Vpp Configures Classify Session L3  ${dut2}  permit  ${table_idx}  ${skip_n}  ${match_n}  ip6  dst  2001:1::2
  And Vpp Enable Input Acl Interface  ${dut2}  ${dut2_if2}  ip6  ${table_idx}

3.10.1.16. Initialize IPv6 forwarding over SRv6 with encapsulation with ‘${n}’ x SID ‘${prepos}’ decapsulation in 3-node circular topology

Set UP state on VPP interfaces in path on nodes in 3-node circular topology. Get the interface MAC addresses and setup neighbours on all VPP interfaces. Setup IPv6 addresses on all interfaces. Set segment routing for IPv6 for required number of SIDs and configure IPv6 routes on both DUT nodes.

${n}${prepos}
${tg1_if1_mac}=  Get Interface MAC  ${tg}  ${tg_if1}
${tg1_if2_mac}=  Get Interface MAC  ${tg}  ${tg_if2}
${dut1_if2_mac}=  Get Interface MAC  ${dut1}  ${dut1_if2}
${dut2_if1_mac}=  Get Interface MAC  ${dut2}  ${dut2_if1}
VPP Set If IPv6 Addr  ${dut1}  ${dut1_if1}  ${dut1_if1_ip6}  ${prefix}
VPP Set If IPv6 Addr  ${dut1}  ${dut1_if2}  ${dut1_if2_ip6}  ${prefix}
VPP Set If IPv6 Addr  ${dut2}  ${dut2_if1}  ${dut2_if1_ip6}  ${prefix}
VPP Set If IPv6 Addr  ${dut2}  ${dut2_if2}  ${dut2_if2_ip6}  ${prefix}
Suppress ICMPv6 router advertisement message  ${nodes}
: FOR  ${number}  IN RANGE  2  ${dst_addr_nr}+2
\    ${hexa_nr}=  Convert To Hex  ${number}
\    Add Ip Neighbor  ${dut1}  ${dut1_if1}  ${tg_if1_ip6_subnet}${hexa_nr}  ${tg1_if1_mac}
\    Add Ip Neighbor  ${dut2}  ${dut2_if2}  ${tg_if2_ip6_subnet}${hexa_nr}  ${tg1_if2_mac}
Add Ip Neighbor  ${dut1}  ${dut1_if2}  ${dut2_if1_ip6}  ${dut2_if1_mac}
Add Ip Neighbor  ${dut2}  ${dut2_if1}  ${dut1_if2_ip6}  ${dut1_if2_mac}
${sid1}=  Set Variable If  "${n}" == "1"  ${dut2_sid1}  "${n}" == "2"  ${dut2_sid1_1}
${sid2}=  Set Variable If  "${n}" == "1"  ${dut1_sid2}  "${n}" == "2"  ${dut1_sid2_1}
Vpp Route Add  ${dut1}  ${sid1}  ${sid_prefix}  gateway=${dut2_if1_ip6}  interface=${dut1_if2}
Vpp Route Add  ${dut2}  ${sid2}  ${sid_prefix}  gateway=${dut1_if2_ip6}  interface=${dut2_if1}
Set SR Encaps Source Address on DUT  ${dut1}  ${dut1_sid1}
@{sid_list_dir0}=  Run Keyword If  "${n}" == "1"  Create List  ${dut2_sid1}  ELSE IF  "${n}" == "2"  Create List  ${dut2_sid1_1}  ${dut2_sid1_2}
Configure SR Policy on DUT  ${dut1}  ${dut1_bsid}  encap  @{sid_list_dir0}
Configure SR Steer on DUT  ${dut1}  L3  ${dut1_bsid}  ip_addr=${tg_if2_ip6_subnet}  prefix=${sid_prefix}
Run Keyword If  "${n}" == "1"  Configure SR LocalSID on DUT  ${dut2}  ${dut2_sid1}  end.dx6  interface=${dut2_if2}  next_hop=${tg_if2_ip6_subnet}2
Run Keyword If  "${n}" == "2"  Configure SR LocalSID on DUT  ${dut2}  ${dut2_sid1_1}  end
Run Keyword If  "${n}" == "2" and "${prepos}" != "without"  Configure SR LocalSID on DUT  ${dut2}  ${dut2_sid1_2}  end.dx6  interface=${dut2_if2}  next_hop=${tg_if2_ip6_subnet}2
Run Keyword If  "${n}" == "2" and "${prepos}" == "without"  Vpp Route Add  ${dut2}  ${dut2_sid1_2}  ${sid_prefix}  gateway=${tg_if2_ip6_subnet}2  interface=${dut2_if2}
Set SR Encaps Source Address on DUT  ${dut2}  ${dut2_sid2}
@{sid_list_dir1}=  Run Keyword If  "${n}" == "1"  Create List  ${dut1_sid2}  ELSE IF  "${n}" == "2"  Create List  ${dut1_sid2_1}  ${dut1_sid2_2}
Configure SR Policy on DUT  ${dut2}  ${dut2_bsid}  encap  @{sid_list_dir1}
Configure SR Steer on DUT  ${dut2}  L3  ${dut2_bsid}  ip_addr=${tg_if1_ip6_subnet}  prefix=${sid_prefix}
Run Keyword If  "${n}" == "1"  Configure SR LocalSID on DUT  ${dut1}  ${dut1_sid2}  end.dx6  interface=${dut1_if1}  next_hop=${tg_if1_ip6_subnet}2
Run Keyword If  "${n}" == "2"  Configure SR LocalSID on DUT  ${dut1}  ${dut1_sid2_1}  end
Run Keyword If  "${n}" == "2" and "${prepos}" != "without"  Configure SR LocalSID on DUT  ${dut1}  ${dut1_sid2_2}  end.dx6  interface=${dut1_if1}  next_hop=${tg_if1_ip6_subnet}2
Run Keyword If  "${n}" == "2" and "${prepos}" == "without"  Vpp Route Add  ${dut1}  ${dut1_sid2_2}  ${sid_prefix}  gateway=${tg_if1_ip6_subnet}2  interface=${dut1_if1}
Set interfaces in path up

3.10.1.17. Initialize IPv6 forwarding over SRv6 with endpoint to SR-unaware Service Function via ‘${behavior}’ behaviour in 3-node circular topology

Create pair of Memif interfaces on all defined VPP nodes. Set UP state on VPP interfaces in path on nodes in 3-node circular topology. Get the interface MAC addresses and setup neighbours on all VPP interfaces. Setup IPv6 addresses on all interfaces. Set segment routing for IPv6 with defined behaviour function and configure IPv6 routes on both DUT nodes.

Note: KW uses test variable rxq_count_int set by KW Add worker threads and rxqueues to all DUTs

${behavior}
${tg1_if1_mac}=  Get Interface MAC  ${tg}  ${tg_if1}
${tg1_if2_mac}=  Get Interface MAC  ${tg}  ${tg_if2}
${dut1_if2_mac}=  Get Interface MAC  ${dut1}  ${dut1_if2}
${dut2_if1_mac}=  Get Interface MAC  ${dut2}  ${dut2_if1}
${sock1}=  Set Variable  memif-DUT1_CNF
${sock2}=  Set Variable  memif-DUT2_CNF
Set up memif interfaces on DUT node  ${dut1}  ${sock1}  ${sock1}  ${1}  dut1-memif-1-if1  dut1-memif-1-if2  ${rxq_count_int}  ${rxq_count_int}
VPP Set interface MTU  ${dut1}  ${dut1-memif-1-if1}
VPP Set interface MTU  ${dut1}  ${dut1-memif-1-if2}
Set up memif interfaces on DUT node  ${dut2}  ${sock2}  ${sock2}  ${1}  dut2-memif-1-if1  dut2-memif-1-if2  ${rxq_count_int}  ${rxq_count_int}
VPP Set interface MTU  ${dut2}  ${dut2-memif-1-if1}
VPP Set interface MTU  ${dut2}  ${dut2-memif-1-if2}
${duts}=  Get Matches  ${nodes}  DUT*
: FOR  ${dut}  IN  @{duts}
\    Show Memif  ${nodes['${dut}']}
VPP Set If IPv6 Addr  ${dut1}  ${dut1_if1}  ${dut1_if1_ip6}  ${prefix}
VPP Set If IPv6 Addr  ${dut1}  ${dut1_if2}  ${dut1_if2_ip6}  ${prefix}
VPP Set If IPv6 Addr  ${dut1}  ${dut1-memif-1-if1}  ${dut1-memif-1-if1_ip6}  ${prefix}
VPP Set If IPv6 Addr  ${dut1}  ${dut1-memif-1-if2}  ${dut1-memif-1-if2_ip6}  ${prefix}
VPP Set If IPv6 Addr  ${dut2}  ${dut2_if1}  ${dut2_if1_ip6}  ${prefix}
VPP Set If IPv6 Addr  ${dut2}  ${dut2_if2}  ${dut2_if2_ip6}  ${prefix}
VPP Set If IPv6 Addr  ${dut2}  ${dut2-memif-1-if1}  ${dut2-memif-1-if1_ip6}  ${prefix}
VPP Set If IPv6 Addr  ${dut2}  ${dut2-memif-1-if2}  ${dut2-memif-1-if2_ip6}  ${prefix}
Suppress ICMPv6 router advertisement message  ${nodes}
Add Ip Neighbor  ${dut1}  ${dut1_if2}  ${dut2_if1_ip6}  ${dut2_if1_mac}
Add Ip Neighbor  ${dut2}  ${dut2_if1}  ${dut1_if2_ip6}  ${dut1_if2_mac}
Add Ip Neighbor  ${dut1}  ${dut1_if1}  ${tg_if1_ip6_subnet}2  ${tg1_if1_mac}
Add Ip Neighbor  ${dut2}  ${dut2_if2}  ${tg_if2_ip6_subnet}2  ${tg1_if2_mac}
${dut1-memif-1-if2_mac}=  Get Interface MAC  ${dut1}  memif2
${dut2-memif-1-if2_mac}=  Get Interface MAC  ${dut2}  memif2
Add Ip Neighbor  ${dut1}  ${dut1-memif-1-if1}  ${dut1_nh}  ${dut1-memif-1-if2_mac}
Add Ip Neighbor  ${dut2}  ${dut2-memif-1-if1}  ${dut2_nh}  ${dut2-memif-1-if2_mac}
Vpp Route Add  ${dut1}  ${dut2_sid1}  ${sid_prefix}  gateway=${dut2_if1_ip6}  interface=${dut1_if2}
Vpp Route Add  ${dut1}  ${out_sid2_1}  ${sid_prefix}  gateway=${tg_if1_ip6_subnet}2  interface=${dut1_if1}
Vpp Route Add  ${dut2}  ${dut1_sid2}  ${sid_prefix}  gateway=${dut1_if2_ip6}  interface=${dut2_if1}
Vpp Route Add  ${dut2}  ${out_sid1_1}  ${sid_prefix}  gateway=${tg_if2_ip6_subnet}2  interface=${dut2_if2}
Set SR Encaps Source Address on DUT  ${dut1}  ${dut1_sid1}
@{sid_list_dir0}=  Create List  ${dut2_sid1}  ${out_sid1_1}  ${out_sid1_2}
Configure SR Policy on DUT  ${dut1}  ${dut1_bsid}  encap  @{sid_list_dir0}
Configure SR Steer on DUT  ${dut1}  L3  ${dut1_bsid}  ip_addr=${tg_if2_ip6_subnet}  prefix=${sid_prefix}
Set SR Encaps Source Address on DUT  ${dut2}  ${dut2_sid2}
@{sid_list_dir1}=  Create List  ${dut1_sid2}  ${out_sid2_1}  ${out_sid2_2}
Configure SR Policy on DUT  ${dut2}  ${dut2_bsid}  encap  @{sid_list_dir1}
Configure SR Steer on DUT  ${dut2}  L3  ${dut2_bsid}  ip_addr=${tg_if1_ip6_subnet}  prefix=${sid_prefix}
${dut2_out_if}=  Get Interface Name  ${dut2}  memif1
${dut2_in_if}=  Get Interface Name  ${dut2}  memif2
Remove Values From List  ${sid_list_dir0}  ${dut2_sid1}
Run Keyword If  "${behavior}" == "static_proxy"  Configure SR LocalSID on DUT  ${dut2}  ${dut2_sid1}  end.as  ${NONE}  ${dut2_nh}  ${NONE}  ${dut2_out_if}  ${dut2_in_if}  ${dut1_sid1}  @{sid_list_dir0}  ELSE IF  "${behavior}" == "dynamic_proxy"  Configure SR LocalSID on DUT  ${dut2}  ${dut2_sid1}  end.ad  next_hop=${dut2_nh}  out_if=${dut2_out_if}  in_if=${dut2_in_if}  ELSE IF  "${behavior}" == "masquerading"  Configure SR LocalSID on DUT  ${dut2}  ${dut2_sid1}  end.am  next_hop=${dut2_nh}  out_if=${dut2_out_if}  in_if=${dut2_in_if}  ELSE  Fail  Unsupported behaviour: ${behavior}
${dut1_out_if}=  Get Interface Name  ${dut1}  memif1
${dut1_in_if}=  Get Interface Name  ${dut1}  memif2
Remove Values From List  ${sid_list_dir1}  ${dut1_sid2}
Run Keyword If  "${behavior}" == "static_proxy"  Configure SR LocalSID on DUT  ${dut1}  ${dut1_sid2}  end.as  ${NONE}  ${dut1_nh}  ${NONE}  ${dut1_out_if}  ${dut1_in_if}  ${dut2_sid2}  @{sid_list_dir1}  ELSE IF  "${behavior}" == "dynamic_proxy"  Configure SR LocalSID on DUT  ${dut1}  ${dut1_sid2}  end.ad  next_hop=${dut1_nh}  out_if=${dut1_out_if}  in_if=${dut1_in_if}  ELSE IF  "${behavior}" == "masquerading"  Configure SR LocalSID on DUT  ${dut1}  ${dut1_sid2}  end.am  next_hop=${dut1_nh}  out_if=${dut1_out_if}  in_if=${dut1_in_if}  ELSE  Fail  Unsupported behaviour: ${behavior}
Set interfaces in path up

3.10.1.18. Initialize L2 patch

Setup L2 patch topology by cross connecting two interfaces on each DUT. Interfaces are brought up.


Set interfaces in path up
${duts}=  Get Matches  ${nodes}  DUT*
: FOR  ${dut}  IN  @{duts}
\    Configure L2patch  ${nodes['${dut}']}  ${${dut}_if1}  ${${dut}_if2}

3.10.1.19. Initialize L2 xconnect in 2-node circular topology

Setup L2 xconnect topology by cross connecting two interfaces on each DUT. Interfaces are brought up.


Set interfaces in path up
Configure L2XC  ${dut1}  ${dut1_if1}  ${dut1_if2}

3.10.1.20. Initialize L2 xconnect in 3-node circular topology

Setup L2 xconnect topology by cross connecting two interfaces on each DUT. Interfaces are brought up.


Set interfaces in path up
Configure L2XC  ${dut1}  ${dut1_if1}  ${dut1_if2}
Configure L2XC  ${dut2}  ${dut2_if1}  ${dut2_if2}

3.10.1.21. Initialize L2 xconnect with VXLANoIPv4 in 3-node circular topology

Setup L2 xconnect topology with VXLANoIPv4 by cross connecting physical and vxlan interfaces on each DUT. All interfaces are brought up. IPv4 addresses with prefix /24 are configured on interfaces between DUTs. VXLAN sub-interfaces has same IPv4 address as interfaces.


Set interfaces in path up
Configure IP addresses on interfaces  ${dut1}  ${dut1_if2}  172.16.0.1  24
Configure IP addresses on interfaces  ${dut2}  ${dut2_if1}  172.16.0.2  24
${dut1_if2_mac}=  Get Interface MAC  ${dut1}  ${dut1_if2}
${dut2_if1_mac}=  Get Interface MAC  ${dut2}  ${dut2_if1}
Add arp on dut  ${dut1}  ${dut1_if2}  172.16.0.2  ${dut2_if1_mac}
Add arp on dut  ${dut2}  ${dut2_if1}  172.16.0.1  ${dut1_if2_mac}
${dut1s_vxlan}=  Create VXLAN interface  ${dut1}  24  172.16.0.1  172.16.0.2
Configure L2XC  ${dut1}  ${dut1_if1}  ${dut1s_vxlan}
${dut2s_vxlan}=  Create VXLAN interface  ${dut2}  24  172.16.0.2  172.16.0.1
Configure L2XC  ${dut2}  ${dut2_if2}  ${dut2s_vxlan}

3.10.1.22. Initialize L2 xconnect with Vhost-User on node

Create pairs of Vhost-User interfaces for defined number of VMs on defined VPP node. Add each Vhost-User interface into L2 cross-connect with with physical inteface or Vhost-User interface of another VM.

Arguments: - dut - DUT node. Type: string - vm_count - VM count. Type: integer

Note: Socket paths for VM are defined in following format: - /tmp/sock-${VM_ID}-1 - /tmp/sock-${VM_ID}-2

Example:

| Initialize L2 xconnect with Vhost-User on node | DUT1 | 1 |


: FOR  ${number}  IN RANGE  1  ${vm_count}+1
\    ${sock1}=  Set Variable  /tmp/sock-${number}-1
\    ${sock2}=  Set Variable  /tmp/sock-${number}-2
\    ${prev_index}=  Evaluate  ${number}-1
\    Configure vhost interfaces for L2BD forwarding  ${nodes['${dut}']}  ${sock1}  ${sock2}  ${dut}-vhost-${number}-if1  ${dut}-vhost-${number}-if2
\    ${dut_xconnect_if1}=  Set Variable If  ${number}==1  ${${dut}_if1}  ${${dut}-vhost-${prev_index}-if2}
\    Configure L2XC  ${nodes['${dut}']}  ${dut_xconnect_if1}  ${${dut}-vhost-${number}-if1}
\    Run Keyword If  ${number}==${vm_count}  Configure L2XC  ${nodes['${dut}']}  ${${dut}-vhost-${number}-if2}  ${${dut}_if2}

3.10.1.23. Initialize L2 xconnect with Vhost-User

Create pairs of Vhost-User interfaces for defined number of VMs on all VPP nodes. Add each Vhost-User interface into L2 cross-connect with with physical inteface or Vhost-User interface of another VM.

Arguments: - vm_count - VM count. Type: integer

Example:

| Initialize L2 xconnect with Vhost-User | 1 |


${duts}=  Get Matches  ${nodes}  DUT*
: FOR  ${dut}  IN  @{duts}
\    Initialize L2 xconnect with Vhost-User on node  ${dut}  vm_count=${vm_count}

3.10.1.24. Initialize L2 xconnect with Vhost-User and VLAN in 3-node circular topology

Create two Vhost-User interfaces on all defined VPP nodes. Cross connect each Vhost interface with one physical interface. Setup VLAN between DUTs. All interfaces are brought up.

Arguments: - sock1 - Socket path for first Vhost-User interface. Type: string - sock2 - Socket path for second Vhost-User interface. Type: string - subid - ID of the sub-interface to be created. Type: string - tag_rewrite - Method of tag rewrite. Type: string

Example:

| L2 xconnect with Vhost-User and VLAN initialized in a 3-nodecircular topology | /tmp/sock1 | /tmp/sock2 | 10 | pop-1 |


Set interfaces in path up
Initialize VLAN dot1q sub-interfaces in circular topology  ${dut1}  ${dut1_if2}  ${dut2}  ${dut2_if1}  ${subid}
Configure L2 tag rewrite method on interfaces  ${dut1}  ${subif_index_1}  ${dut2}  ${subif_index_2}  ${tag_rewrite}
Configure vhost interfaces for L2BD forwarding  ${dut1}  ${sock1}  ${sock2}
Configure L2XC  ${dut1}  ${dut1_if1}  ${vhost_if1}
Configure L2XC  ${dut1}  ${subif_index_1}  ${vhost_if2}
Configure vhost interfaces for L2BD forwarding  ${dut2}  ${sock1}  ${sock2}
Configure L2XC  ${dut2}  ${subif_index_2}  ${vhost_if1}
Configure L2XC  ${dut2}  ${dut2_if2}  ${vhost_if2}

3.10.1.27. Initialize L2 bridge domain in circular topology

Setup L2 DB topology by adding two interfaces on each DUT into BD that is created automatically with index 1. Learning is enabled. Interfaces are brought up.

Arguments: - bd_id - Bridge domain ID. Type: integer

Example:

| Initialize L2 bridge domain in circular topology | 1 |


${dut2_status}  ${value}=  Run Keyword And Ignore Error  Variable Should Exist  ${dut2}
Set interfaces in path up
Add interface to bridge domain  ${dut1}  ${dut1_if1}  ${bd_id}
Add interface to bridge domain  ${dut1}  ${dut1_if2}  ${bd_id}
Run Keyword If  '${dut2_status}' == 'PASS'  Add interface to bridge domain  ${dut2}  ${dut2_if1}  ${bd_id}
Run Keyword If  '${dut2_status}' == 'PASS'  Add interface to bridge domain  ${dut2}  ${dut2_if2}  ${bd_id}

3.10.1.28. Configure IPv4 ACLs

Configure ACL with required number of not-hitting permit ACEs plus two hitting ACEs for both traffic directions.

Arguments: - dut_node - DUT node. Type: dictionary - dut_if1 - DUT node interface1 name (Optional). Type: string - dut_if2 - DUT node interface2 name (Optional). Type: string

Example:

| Configure IPv4 ACLs | ${nodes[‘DUT1’]} | GigabitEthernet0/7/0 | GigabitEthernet0/8/0 |

_NOTE:_ This KW uses following test case variables: - src_ip_start - Source IP address start. Type: string - dst_ip_start - Destination IP address start. Type: string - ip_step - IP address step. Type: string - sport_start - Source port number start. Type: string - dport_start - Destination port number start. Type: string - port_step - Port number step. Type: string - no_hit_aces_number - Number of not-hitting ACEs to be configured. Type: integer - acl_apply_type - To what path apply the ACL - input or output. Type: string - acl_action - Action for the rule - deny, permit, permit+reflect. Type: string - trex_stream1_subnet - IP subnet used by T-Rex in direction 0->1. Type: string - trex_stream2_subnet - IP subnet used by T-Rex in direction 1->0. Type: string


${src_ip_int} =  Evaluate  int(ipaddress.ip_address(unicode($src_ip_start))) - $ip_step  modules=ipaddress
${dst_ip_int} =  Evaluate  int(ipaddress.ip_address(unicode($dst_ip_start))) - $ip_step  modules=ipaddress
${ip_limit} =  Set Variable  255.255.255.255
${ip_limit_int} =  Evaluate  int(ipaddress.ip_address(unicode($ip_limit)))  modules=ipaddress
${sport}=  Evaluate  $sport_start - $port_step
${dport}=  Evaluate  $dport_start - $port_step
${port_limit}=  Set Variable  ${65535}
${acl}=  Set Variable  ipv4 permit
: FOR  ${nr}  IN RANGE  0  ${no_hit_aces_number}
\    ${src_ip_int} =  Evaluate  $src_ip_int + $ip_step
\    ${dst_ip_int} =  Evaluate  $dst_ip_int + $ip_step
\    ${sport}=  Evaluate  $sport + $port_step
\    ${dport}=  Evaluate  $dport + $port_step
\    ${ipv4_limit_reached}=  Set Variable If  $src_ip_int > $ip_limit_int or $src_ip_int > $ip_limit_int  ${TRUE}
\    ${udp_limit_reached}=  Set Variable If  $sport > $port_limit or $dport > $port_limit  ${TRUE}
\    Run Keyword If  $ipv4_limit_reached is True  Log  Can't do more iterations - IPv4 address limit has been reached.  WARN
\    Run Keyword If  $udp_limit_reached is True  Log  Can't do more iterations - UDP port limit has been reached.  WARN
\    ${src_ip} =  Run Keyword If  $ipv4_limit_reached is True  Set Variable  ${ip_limit}  ELSE  Evaluate  str(ipaddress.ip_address($src_ip_int))  modules=ipaddress
\    ${dst_ip} =  Run Keyword If  $ipv4_limit_reached is True  Set Variable  ${ip_limit}  ELSE  Evaluate  str(ipaddress.ip_address($dst_ip_int))  modules=ipaddress
\    ${sport}=  Set Variable If  ${sport} > $port_limit  $port_limit  ${sport}
\    ${dport}=  Set Variable If  ${dport} > $port_limit  $port_limit  ${dport}
\    ${acl}=  Catenate  ${acl}  src ${src_ip}/32 dst ${dst_ip}/32  sport ${sport}  dport ${dport},
\    Exit For Loop If  $ipv4_limit_reached is True or $udp_limit_reached is True
${acl}=  Catenate  ${acl}  ipv4 ${acl_action} src ${trex_stream1_subnet},  ipv4 ${acl_action} src ${trex_stream2_subnet}
Add Replace Acl Multi Entries  ${dut}  rules=${acl}
@{acl_list}=  Create List  ${0}
Run Keyword If  'input' in $acl_apply_type and $dut_if1 is not None  Set Acl List For Interface  ${dut}  ${dut_if1}  input  ${acl_list}
Run Keyword If  'input' in $acl_apply_type and $dut_if2 is not None  Set Acl List For Interface  ${dut}  ${dut_if2}  input  ${acl_list}
Run Keyword If  'output' in $acl_apply_type and $dut_if1 is not None  Set Acl List For Interface  ${dut}  ${dut_if1}  output  ${acl_list}
Run Keyword If  'output' in $acl_apply_type and $dut_if2 is not None  Set Acl List For Interface  ${dut}  ${dut_if2}  output  ${acl_list}

3.10.1.29. Initialize L2 bridge domain with IPv4 ACLs on DUT1 in 3-node circular topology

Setup L2BD topology by adding two interfaces on DUT1 into bridge domain that is created automatically with index 1. Learning is enabled. Interfaces are brought up. Apply required ACL rules to DUT1 interfaces.

Arguments: _None_

Example:

| Initialize L2 bridge domain with IPv4 ACLs on DUT1 in 3-node circular topology |

_NOTE:_ This KW uses following test case variables: - dut1 - DUT1 node. - dut2 - DUT2 node. - dut1_if1 - DUT1 interface towards TG. - dut1_if2 - DUT1 interface towards DUT2. - dut2_if1 - DUT2 interface towards DUT1. - dut2_if2 - DUT2 interface towards TG.


Set interfaces in path up
Configure L2BD forwarding  ${dut1}  ${dut1_if1}  ${dut1_if2}
Configure L2XC  ${dut2}  ${dut2_if1}  ${dut2_if2}
Configure IPv4 ACLs  ${dut1}  ${dut1_if1}  ${dut1_if2}

3.10.1.30. Initialize IPv4 routing for ‘${ip_nr}’ addresses with IPv4 ACLs on DUT1 in circular topology

Set UP state on VPP interfaces in path on nodes in 2-node / 3-node circular topology. Get the interface MAC addresses and setup ARP on all VPP interfaces. Setup IPv4 addresses with /24 prefix on DUT-TG links. In case of 3-node topology setup IPv4 adresses with /30 prefix on DUT1-DUT2 link and set routing on both DUT nodes with prefix /24 and next hop of neighbour DUT interface IPv4 address. Apply required ACL rules to DUT1 interfaces.

Arguments: - ip_nr - Number of IPs to be used. Type: integer or string

Example:

| Initialize IPv4 routing for ‘10’ addresses with IPv4 ACLs on DUT1 in 3-node circular topology |

_NOTE:_ This KW uses following test case variables: - tg - TG node. - dut1 - DUT1 node. - dut2 - DUT2 node. - tg_if1 - TG interface 1 towards DUT1. - tg_if2 - TG interface 2 towards DUT2 (3-node topo) or DUT1 (2-node topo). - dut1_if1 - DUT1 interface 1 towards TG. - dut1_if2 - DUT1 interface 2 towards DUT2 (3-node topo) or TG (2-node topo). - dut2_if1 - DUT2 interface 1 towards DUT1. - dut2_if2 - DUT2 interface 2 towards TG.

${ip_nr}
${dut2_status}  ${value}=  Run Keyword And Ignore Error  Variable Should Exist  ${dut2}
${dut}=  Run Keyword If  '${dut2_status}' == 'PASS'  Set Variable  ${dut2}  ELSE  Set Variable  ${dut1}
${dut_if2}=  Run Keyword If  '${dut2_status}' == 'PASS'  Set Variable  ${dut2_if2}  ELSE  Set Variable  ${dut1_if2}
Set interfaces in path up
${tg1_if1_mac}=  Get Interface MAC  ${tg}  ${tg_if1}
${tg1_if2_mac}=  Get Interface MAC  ${tg}  ${tg_if2}
${dut1_if2_mac}=  Run Keyword If  '${dut2_status}' == 'PASS'  Get Interface MAC  ${dut1}  ${dut1_if2}
${dut2_if1_mac}=  Run Keyword If  '${dut2_status}' == 'PASS'  Get Interface MAC  ${dut2}  ${dut2_if1}
: FOR  ${number}  IN RANGE  2  ${ip_nr}+2
\    Add arp on dut  ${dut1}  ${dut1_if1}  10.10.10.${number}  ${tg1_if1_mac}
\    Add arp on dut  ${dut}  ${dut_if2}  20.20.20.${number}  ${tg1_if2_mac}
Run Keyword If  '${dut2_status}' == 'PASS'  Add arp on dut  ${dut1}  ${dut1_if2}  1.1.1.2  ${dut2_if1_mac}
Run Keyword If  '${dut2_status}' == 'PASS'  Add arp on dut  ${dut2}  ${dut2_if1}  1.1.1.1  ${dut1_if2_mac}
Configure IP addresses on interfaces  ${dut1}  ${dut1_if1}  10.10.10.1  24  ${dut}  ${dut_if2}  20.20.20.1  24
Run Keyword If  '${dut2_status}' == 'PASS'  Configure IP addresses on interfaces  ${dut1}  ${dut1_if2}  1.1.1.1  30  ${dut2}  ${dut2_if1}  1.1.1.2  30
Run Keyword If  '${dut2_status}' == 'PASS'  Vpp Route Add  ${dut1}  20.20.20.0  24  gateway=1.1.1.2  interface=${dut1_if2}
Run Keyword If  '${dut2_status}' == 'PASS'  Vpp Route Add  ${dut2}  10.10.10.0  24  gateway=1.1.1.1  interface=${dut2_if1}
Configure IPv4 ACLs  ${dut1}  ${dut1_if1}  ${dut1_if2}

3.10.1.31. Configure MACIP ACLs

Configure MACIP ACL with required number of not-hitting permit ACEs plus two hitting ACEs for both traffic directions.

Arguments: - dut_node - DUT node. Type: dictionary - dut_if1 - DUT node interface1 name (Optional). Type: string - dut_if2 - DUT node interface2 name (Optional). Type: string

Example:

| Configure MACIP ACLs | ${nodes[‘DUT1’]} | GigabitEthernet0/7/0 | GigabitEthernet0/8/0 |

_NOTE:_ This KW uses following test case variables: - src_ip_start - Source IP address start. Type: string - ip_step - IP address step. Type: string - src_mac_start - Source MAC address start in format with colons. Type: string - src_mac_step - Source MAC address step. Type: string - src_mac_mask - Source MAC address mask. 00:00:00:00:00:00 is a wildcard mask. Type: string - no_hit_aces_number - Number of not-hitting ACEs to be configured. Type: integer - acl_action - Action for the rule - deny, permit, permit+reflect. Type: string - tg_stream1_subnet - IP subnet used by TG in direction 0->1. Type: string - tg_stream2_subnet - IP subnet used by TG in direction 1->0. Type: string - tg_stream1_mac - Source MAC address of traffic stream 1. Type: string - tg_stream2_mac - Source MAC address of traffic stream 2. Type: string - tg_mac_mask - MAC address mask for traffic streams. 00:00:00:00:00:00 is a wildcard mask. Type: string


${src_ip_int} =  IP To Int  ${src_ip_start}
${src_ip_int} =  Evaluate  ${src_ip_int} - ${ip_step}
${ip_limit} =  Set Variable  255.255.255.255
${ip_limit_int} =  IP To Int  ${ip_limit}
${src_mac_int} =  Mac To Int  ${src_mac_start}
${src_mac_int} =  Evaluate  ${src_mac_int} - ${src_mac_step}
${mac_limit} =  Set Variable  ff:ff:ff:ff:ff:ff
${mac_limit_int} =  Mac To Int  ${mac_limit}
${acl}=  Set Variable  ipv4 permit
: FOR  ${nr}  IN RANGE  0  ${no_hit_aces_number}
\    ${src_ip_int} =  Evaluate  ${src_ip_int} + ${ip_step}
\    ${src_mac_int} =  Evaluate  ${src_mac_int} + ${src_mac_step}
\    ${ipv4_limit_reached}=  Set Variable If  ${src_ip_int} > ${ip_limit_int}  ${TRUE}
\    ${mac_limit_reached}=  Set Variable If  ${src_mac_int} > ${mac_limit_int}  ${TRUE}
\    Run Keyword If  '${ipv4_limit_reached}' == '${TRUE}'  Log  Can't do more iterations - IPv4 address limit has been reached.  WARN
\    Run Keyword If  '${mac_limit_reached}' == '${TRUE}'  Log  Can't do more iterations - MAC address limit has been reached.  WARN
\    ${src_ip} =  Run Keyword If  '${ipv4_limit_reached}' == '${TRUE}'  Set Variable  ${ip_limit}  ELSE  Int To IP  ${src_ip_int}
\    ${src_mac}=  Run Keyword If  '${mac_limit_reached}' == '${TRUE}'  Set Variable  ${mac_limit}  ELSE  Int To Mac  ${src_mac_int}
\    ${acl}=  Catenate  ${acl}  ip ${src_ip}/32  mac ${src_mac}  mask ${src_mac_mask},
\    Exit For Loop If  '${ipv4_limit_reached}' == '${TRUE}' or '${mac_limit_reached}' == '${TRUE}'
${acl0}=  Catenate  ${acl}  ipv4 ${acl_action} ip ${tg_stream1_subnet} mac ${tg_stream1_mac}  mask ${tg_mac_mask}
${acl1}=  Catenate  ${acl}  ipv4 ${acl_action} ip ${tg_stream2_subnet} mac ${tg_stream2_mac}  mask ${tg_mac_mask}
Add Macip Acl Multi Entries  ${dut}  rules=${acl0}
Add Macip Acl Multi Entries  ${dut}  rules=${acl1}
${acl_idx}=  Set Variable  0
Run Keyword Unless  '${dut_if1}' == '${NONE}'  Add Del Macip Acl Interface  ${dut}  ${dut_if1}  add  ${acl_idx}
${acl_idx}=  Set Variable  1
Run Keyword Unless  '${dut_if2}' == '${NONE}'  Add Del Macip Acl Interface  ${dut}  ${dut_if2}  add  ${acl_idx}

3.10.1.32. Initialize L2 bridge domain with MACIP ACLs on DUT1 in 3-node circular topology

Setup L2BD topology by adding two interfaces on DUT1 into bridge domain that is created automatically with index 1. Learning is enabled. Interfaces are brought up. Apply required MACIP ACL rules to DUT1 interfaces.

Arguments: _None_

Example:

| Initialize L2 bridge domain with MACIP ACLs on DUT1 in 3-node circular topology |

_NOTE 1:_ This KW uses following test case variables: - tg - TG node. - dut1 - DUT1 node. - dut2 - DUT2 node. - tg_if1 - TG interface towards DUT1. - tg_if2 - TG interface towards DUT2. - dut1_if1 - DUT1 interface towards TG. - dut1_if2 - DUT1 interface towards DUT2. - dut2_if1 - DUT2 interface towards DUT1. - dut2_if2 - DUT2 interface towards TG.


Set interfaces in path up
Configure L2BD forwarding  ${dut1}  ${dut1_if1}  ${dut1_if2}
Configure L2XC  ${dut2}  ${dut2_if1}  ${dut2_if2}
Configure MACIP ACLs  ${dut1}  ${dut1_if1}  ${dut1_if2}

3.10.1.33. Initialize L2 bridge domains with Vhost-User on node

Create pairs of Vhost-User interfaces for defined number of VMs on defined VPP node. Add each Vhost-User interface into L2 bridge domains with learning enabled with physical inteface or Vhost-User interface of another VM.

Arguments: - dut - DUT node. Type: string - nf_chain - NF chain. Type: integer - nf_nodes - Number of NFs nodes per chain. Type: integer

Note: Socket paths for VM are defined in following format: - /tmp/sock-${VM_ID}-1 - /tmp/sock-${VM_ID}-2

Example:

| Initialize L2 bridge domains with Vhost-User on node | DUT1 | 1 | 1 |


${bd_id2}=  Evaluate  ${nf_nodes}+1
Add interface to bridge domain  ${nodes['${dut}']}  ${${dut}_if1}  ${1}
Add interface to bridge domain  ${nodes['${dut}']}  ${${dut}_if2}  ${bd_id2}
: FOR  ${nf_node}  IN RANGE  1  ${nf_nodes}+1
\    ${qemu_id}=  Evaluate  (${nf_chain} - ${1}) * ${nf_nodes} + ${nf_node}
\    ${sock1}=  Set Variable  /tmp/sock-${qemu_id}-1
\    ${sock2}=  Set Variable  /tmp/sock-${qemu_id}-2
\    Configure vhost interfaces for L2BD forwarding  ${nodes['${dut}']}  ${sock1}  ${sock2}  ${dut}-vhost-${qemu_id}-if1  ${dut}-vhost-${qemu_id}-if2
\    ${bd_id2}=  Evaluate  ${nf_node}+1
\    Add interface to bridge domain  ${nodes['${dut}']}  ${${dut}-vhost-${qemu_id}-if1}  ${nf_node}
\    Add interface to bridge domain  ${nodes['${dut}']}  ${${dut}-vhost-${qemu_id}-if2}  ${bd_id2}

3.10.1.34. Initialize L2 bridge domains with Vhost-User

Create pairs of Vhost-User interfaces for defined number of VNF nodes on all defined VPP nodes. Add each Vhost-User interface into L2 bridge domains with learning enabled with physical inteface or Vhost-User interface of another VM.

Arguments: - nf_chain - NF chain. Type: integer - nf_nodes - Number of NFs nodes per chain. Type: integer

Example:

| Initialize L2 bridge domains with Vhost-User | 1 | 1 |


${duts}=  Get Matches  ${nodes}  DUT*
: FOR  ${dut}  IN  @{duts}
\    Initialize L2 bridge domains with Vhost-User on node  ${dut}  nf_chain=${nf_chain}  nf_nodes=${nf_nodes}

3.10.1.35. Initialize L2 bridge domains for multiple chains with Vhost-User

Create pairs of Vhost-User interfaces for defined number of NF chains with defined number of VNF nodes on all defined VPP nodes. Add each Vhost-User interface into L2 bridge domains with learning enabled with physical inteface or Vhost-User interface of another VM.

Arguments: - nf_chains - Number of chains of NFs. Type: integer - nf_nodes - Number of NFs nodes per chain. Type: integer

Example:

| Initialize L2 bridge domains for multiple chains with Vhost-User | 1 | 1 |


: FOR  ${nf_chain}  IN RANGE  1  ${nf_chains}+1
\    Initialize L2 bridge domains with Vhost-User  nf_chain=${nf_chain}  nf_nodes=${nf_nodes}

3.10.1.36. Initialize L2 bridge domain with VXLANoIPv4 in 3-node circular topology

Setup L2 bridge domain topology with VXLANoIPv4 by connecting physical and vxlan interfaces on each DUT. All interfaces are brought up. IPv4 addresses with prefix /24 are configured on interfaces between DUTs. VXLAN sub-interfaces has same IPv4 address as interfaces.


Set interfaces in path up
Configure IP addresses on interfaces  ${dut1}  ${dut1_if2}  172.16.0.1  24
Configure IP addresses on interfaces  ${dut2}  ${dut2_if1}  172.16.0.2  24
${dut1_if2_mac}=  Get Interface MAC  ${dut1}  ${dut1_if2}
${dut2_if1_mac}=  Get Interface MAC  ${dut2}  ${dut2_if1}
Add arp on dut  ${dut1}  ${dut1_if2}  172.16.0.2  ${dut2_if1_mac}
Add arp on dut  ${dut2}  ${dut2_if1}  172.16.0.1  ${dut1_if2_mac}
${dut1s_vxlan}=  Create VXLAN interface  ${dut1}  24  172.16.0.1  172.16.0.2
${dut2s_vxlan}=  Create VXLAN interface  ${dut2}  24  172.16.0.2  172.16.0.1
Configure L2BD forwarding  ${dut1}  ${dut1_if1}  ${dut1s_vxlan}
Configure L2BD forwarding  ${dut2}  ${dut2_if2}  ${dut2s_vxlan}

3.10.1.37. Initialize L2 bridge domain with VLAN and VXLANoIPv4 in 3-node circular topology

Setup L2 bridge domain topology with VLAN and VXLANoIPv4 by connecting pairs of VLAN sub-interface and VXLAN interface to separate L2 bridge domain on each DUT. All interfaces are brought up. IPv4 addresses with prefix /32 are configured on interfaces between DUTs. VXLAN sub-interfaces has same IPv4 address as interfaces.

Arguments: - vxlan_count - VXLAN count. Type: integer

Example:

| Initialize L2 bridge domain with VLAN and VXLANoIPv4 in 3-node | circular topology | ${1} |


Set interfaces in path up
${bd_id_start}=  Set Variable  ${1}
${vni_start} =  Set Variable  ${20}
${ip_step} =  Set Variable  ${2}
${dut1_ip_start}=  Set Variable  172.16.0.1
${dut2_ip_start}=  Set Variable  172.16.0.2
${ip_limit} =  Set Variable  255.255.255.255
Vpp create multiple VXLAN IPv4 tunnels  node=${dut1}  node_vxlan_if=${dut1_if2}  node_vlan_if=${dut1_if1}  op_node=${dut2}  op_node_if=${dut2_if1}  n_tunnels=${vxlan_count}  vni_start=${vni_start}  src_ip_start=${dut1_ip_start}  dst_ip_start=${dut2_ip_start}  ip_step=${ip_step}  ip_limit=${ip_limit}  bd_id_start=${bd_id_start}
Vpp create multiple VXLAN IPv4 tunnels  node=${dut2}  node_vxlan_if=${dut2_if1}  node_vlan_if=${dut2_if2}  op_node=${dut1}  op_node_if=${dut1_if2}  n_tunnels=${vxlan_count}  vni_start=${vni_start}  src_ip_start=${dut2_ip_start}  dst_ip_start=${dut1_ip_start}  ip_step=${ip_step}  ip_limit=${ip_limit}  bd_id_start=${bd_id_start}

3.10.1.38. Initialize L2 bridge domains with Vhost-User and VXLANoIPv4 in 3-node circular topology

Create two Vhost-User interfaces on all defined VPP nodes. Add each Vhost-User interface into L2 bridge domains with learning enabled with physical inteface. Setup VXLANoIPv4 between DUTs by connecting physical and vxlan interfaces on each DUT. All interfaces are brought up. IPv4 addresses with prefix /24 are configured on interfaces between DUTs. VXLAN sub-interfaces has same IPv4 address as interfaces.

Arguments: - bd_id1 - Bridge domain ID. Type: integer - bd_id2 - Bridge domain ID. Type: integer - sock1 - Sock path for first Vhost-User interface. Type: string - sock2 - Sock path for second Vhost-User interface. Type: string

Example:

| L2 bridge domains with Vhost-User and VXLANoIPv4 initialized in a3-node circular topology | 1 | 2 | /tmp/sock1 | /tmp/sock2 |


Configure IP addresses on interfaces  ${dut1}  ${dut1_if2}  172.16.0.1  24
Configure IP addresses on interfaces  ${dut2}  ${dut2_if1}  172.16.0.2  24
Set interfaces in path up
${dut1s_vxlan}=  Create VXLAN interface  ${dut1}  24  172.16.0.1  172.16.0.2
${dut2s_vxlan}=  Create VXLAN interface  ${dut2}  24  172.16.0.2  172.16.0.1
Configure vhost interfaces for L2BD forwarding  ${dut1}  ${sock1}  ${sock2}
Add interface to bridge domain  ${dut1}  ${dut1_if1}  ${bd_id1}
Add interface to bridge domain  ${dut1}  ${vhost_if1}  ${bd_id1}
Add interface to bridge domain  ${dut1}  ${vhost_if2}  ${bd_id2}
Add interface to bridge domain  ${dut1}  ${dut1s_vxlan}  ${bd_id2}
Configure vhost interfaces for L2BD forwarding  ${dut2}  ${sock1}  ${sock2}
Add interface to bridge domain  ${dut2}  ${dut2s_vxlan}  ${bd_id1}
Add interface to bridge domain  ${dut2}  ${vhost_if1}  ${bd_id1}
Add interface to bridge domain  ${dut2}  ${vhost_if2}  ${bd_id2}
Add interface to bridge domain  ${dut2}  ${dut2_if2}  ${bd_id2}

3.10.1.39. Init L2 bridge domains with single DUT with Vhost-User and VXLANoIPv4 in 3-node circular topology

Create two Vhost-User interfaces on one VPP node. Add each Vhost-User interface into L2 bridge domains with learning enabled one connected to physical interface, the other to VXLAN. Setup VXLANoIPv4 between DUTs and TG by connecting physical and vxlan interfaces on the DUT. All interfaces are brought up. IPv4 addresses with prefix /24 are configured on interfaces between DUT and TG.

Arguments: - dut1_address - Address of physical interface on DUT1. Type: string - dut1_address_subnet - Subnet of the address of physical interface on DUT1. Type: string - dut2_address - Address of physical interface on DUT2. Type: string - dut2_address_subnet - Subnet of the address of physical interface on DUT2. Type: string - dut1_gw - Address of the _gateway_ to which the traffic will be forwarded on DUT1. Type: string - dut2_gw - Address of the _gateway_ to which the traffic will be forwarded on DUT2. Type: string - dut1_vxlans - List of VXLAN params to be configured on DUT1. Type: list of dicts, dict params vni, vtep - dut2_vxlans - List of VXLAN params to be configured on DUT2. Type: list of dicts, dict params vni, vtep - dut1_route_subnet - Subnet address to forward to _gateway_ on DUT1. Type: string - dut1_route_mask - Subnet address mask to forward to _gateway_ on DUT1. Type: string - dut2_route_subnet - Subnet address to forward to _gateway_ on DUT2. Type: string - dut2_route_mask - Subnet address mask to forward to _gateway_ on DUT2. Type: string

Example:


Configure IP addresses on interfaces  ${dut1}  ${dut1_if1}  ${dut1_address}  ${dut1_address_subnet}
Configure IP addresses on interfaces  ${dut2}  ${dut2_if2}  ${dut2_address}  ${dut2_address_subnet}
${dut1_bd_id1}=  Set Variable  1
${dut1_bd_id2}=  Set Variable  2
${dut2_bd_id1}=  Set Variable  1
: FOR  ${vxlan}  IN  @{dut1_vxlans}
\    ${dut1s_vxlan}=  Create VXLAN interface  ${dut1}  ${vxlan.vni}  ${dut1_address}  ${vxlan.vtep}
\    Add interface to bridge domain  ${dut1}  ${dut1s_vxlan}  ${dut1_bd_id1}
: FOR  ${vxlan}  IN  @{dut2_vxlans}
\    ${dut2s_vxlan}=  Create VXLAN interface  ${dut2}  ${vxlan.vni}  ${dut2_address}  ${vxlan.vtep}
\    Add interface to bridge domain  ${dut2}  ${dut2s_vxlan}  ${dut2_bd_id1}
${tg_if1_mac}=  Get Interface MAC  ${tg}  ${tg_if1}
${tg_if2_mac}=  Get Interface MAC  ${tg}  ${tg_if2}
Add arp on dut  ${dut1}  ${dut1_if1}  ${dut1_gw}  ${tg_if1_mac}
Add arp on dut  ${dut2}  ${dut2_if2}  ${dut2_gw}  ${tg_if2_mac}
Vpp Route Add  ${dut1}  ${dut1_route_subnet}  ${dut1_route_mask}  gateway=${dut1_gw}  interface=${dut1_if1}
Vpp Route Add  ${dut2}  ${dut2_route_subnet}  ${dut2_route_mask}  gateway=${dut2_gw}  interface=${dut2_if2}
Add interface to bridge domain  ${dut1}  ${dut1_if2}  ${dut1_bd_id2}
Add interface to bridge domain  ${dut2}  ${dut2_if1}  ${dut2_bd_id1}
Add interface to bridge domain  ${dut1}  ${vhost_if1}  ${dut1_bd_id1}
Add interface to bridge domain  ${dut1}  ${vhost_if2}  ${dut1_bd_id2}

3.10.1.40. Initialize L2 bridge domains with VLAN dot1q sub-interfaces in circular topology

Setup L2 bridge domain topology with learning enabled with VLAN by connecting physical and vlan interfaces on each DUT. In case of 3-node topology create VLAN sub-interfaces between DUTs. In case of 2-node topology create VLAN sub-interface on dut1-if2 interface. All interfaces are brought up.

Arguments: - bd_id1 - Bridge domain ID. Type: integer - bd_id2 - Bridge domain ID. Type: integer - subid - ID of the sub-interface to be created. Type: string - tag_rewrite - Method of tag rewrite. Type: string

_NOTE:_ This KW uses following test case variables: - dut1 - DUT1 node. - dut2 - DUT2 node. - dut1_if2 - DUT1 interface towards DUT2. - dut2_if1 - DUT2 interface towards DUT1.

Example:

| Initialize L2 bridge domains with VLAN dot1q sub-interfaces in a 3-node circular topology | 1 | 2 | 10 | pop-1 |


${dut2_status}  ${value}=  Run Keyword And Ignore Error  Variable Should Exist  ${dut2}
Set interfaces in path up
Run Keyword If  '${dut2_status}' == 'PASS'  Initialize VLAN dot1q sub-interfaces in circular topology  ${dut1}  ${dut1_if2}  ${dut2}  ${dut2_if1}  ${subid}  ELSE  Initialize VLAN dot1q sub-interfaces in circular topology  ${dut1}  ${dut1_if2}  SUB_ID=${subid}
Run Keyword If  '${dut2_status}' == 'PASS'  Configure L2 tag rewrite method on interfaces  ${dut1}  ${subif_index_1}  ${dut2}  ${subif_index_2}  ${tag_rewrite}  ELSE  Configure L2 tag rewrite method on interfaces  ${dut1}  ${subif_index_1}  TAG_REWRITE_METHOD=${tag_rewrite}
Add interface to bridge domain  ${dut1}  ${dut1_if1}  ${bd_id1}
Add interface to bridge domain  ${dut1}  ${subif_index_1}  ${bd_id1}
Run Keyword If  '${dut2_status}' == 'PASS'  Add interface to bridge domain  ${dut2}  ${subif_index_2}  ${bd_id2}
Run Keyword If  '${dut2_status}' == 'PASS'  Add interface to bridge domain  ${dut2}  ${dut2_if2}  ${bd_id2}

3.10.1.41. Initialize L2 bridge domains with Vhost-User and VLAN in circular topology

Create two Vhost-User interfaces on all defined VPP nodes. Add each Vhost-User interface into L2 bridge domains with learning enabled with physical inteface. In case of 3-node topology create VLAN sub-interfaces between DUTs. In case of 2-node topology create VLAN sub-interface on dut1-if2 interface. All interfaces are brought up.

Arguments: - bd_id1 - Bridge domain ID. Type: integer - bd_id2 - Bridge domain ID. Type: integer - sock1 - Sock path for first Vhost-User interface. Type: string - sock2 - Sock path for second Vhost-User interface. Type: string - subid - ID of the sub-interface to be created. Type: string - tag_rewrite - Method of tag rewrite. Type: string

Example:

| L2 bridge domains with Vhost-User and VLAN initialized in circulartopology | 1 | 2 | /tmp/sock1 | /tmp/sock2 | 10 | pop-1 |


${dut2_status}  ${value}=  Run Keyword And Ignore Error  Variable Should Exist  ${dut2}
Set interfaces in path up
Run Keyword If  '${dut2_status}' == 'PASS'  Initialize VLAN dot1q sub-interfaces in circular topology  ${dut1}  ${dut1_if2}  ${dut2}  ${dut2_if1}  ${subid}  ELSE  Initialize VLAN dot1q sub-interfaces in circular topology  ${dut1}  ${dut1_if2}  SUB_ID=${subid}
Run Keyword If  '${dut2_status}' == 'PASS'  Configure L2 tag rewrite method on interfaces  ${dut1}  ${subif_index_1}  ${dut2}  ${subif_index_2}  ${tag_rewrite}  ELSE  Configure L2 tag rewrite method on interfaces  ${dut1}  ${subif_index_1}  TAG_REWRITE_METHOD=${tag_rewrite}
Configure vhost interfaces for L2BD forwarding  ${dut1}  ${sock1}  ${sock2}
Add interface to bridge domain  ${dut1}  ${dut1_if1}  ${bd_id1}
Add interface to bridge domain  ${dut1}  ${vhost_if1}  ${bd_id1}
Add interface to bridge domain  ${dut1}  ${vhost_if2}  ${bd_id2}
Add interface to bridge domain  ${dut1}  ${subif_index_1}  ${bd_id2}
Run Keyword If  '${dut2_status}' == 'PASS'  Configure vhost interfaces for L2BD forwarding  ${dut2}  ${sock1}  ${sock2}
Run Keyword If  '${dut2_status}' == 'PASS'  Add interface to bridge domain  ${dut2}  ${subif_index_2}  ${bd_id1}
Run Keyword If  '${dut2_status}' == 'PASS'  Add interface to bridge domain  ${dut2}  ${vhost_if1}  ${bd_id1}
Run Keyword If  '${dut2_status}' == 'PASS'  Add interface to bridge domain  ${dut2}  ${vhost_if2}  ${bd_id2}
Run Keyword If  '${dut2_status}' == 'PASS'  Add interface to bridge domain  ${dut2}  ${dut2_if2}  ${bd_id2}

3.10.1.44. Add PCI devices to all DUTs

Add PCI devices to VPP configuration file.


${duts}=  Get Matches  ${nodes}  DUT*
: FOR  ${dut}  IN  @{duts}
\    ${if1_status}  ${value}=  Run Keyword And Ignore Error  Variable Should Exist  ${${dut}_if1}
\    ${if1_pci}=  Run Keyword If  '${if1_status}' == 'PASS'  Get Interface PCI Addr  ${nodes['${dut}']}  ${${dut}_if1}
\    ${if1_1_pci}=  Run Keyword Unless  '${if1_status}' == 'PASS'  Get Interface PCI Addr  ${nodes['${dut}']}  ${${dut}_if1_1}
\    ${if1_2_pci}=  Run Keyword Unless  '${if1_status}' == 'PASS'  Get Interface PCI Addr  ${nodes['${dut}']}  ${${dut}_if1_2}
\    ${if2_status}  ${value}=  Run Keyword And Ignore Error  Variable Should Exist  ${${dut}_if2}
\    ${if2_pci}=  Run Keyword If  '${if2_status}' == 'PASS'  Get Interface PCI Addr  ${nodes['${dut}']}  ${${dut}_if2}
\    ${if2_1_pci}=  Run Keyword Unless  '${if2_status}' == 'PASS'  Get Interface PCI Addr  ${nodes['${dut}']}  ${${dut}_if2_1}
\    ${if2_2_pci}=  Run Keyword Unless  '${if2_status}' == 'PASS'  Get Interface PCI Addr  ${nodes['${dut}']}  ${${dut}_if2_2}
\    @{pci_devs}=  Run Keyword If  '${if1_status}' == 'PASS'  Create List  ${if1_pci}  ELSE  Create List  ${if1_1_pci}  ${if1_2_pci}
\    Run Keyword If  '${if2_status}' == 'PASS'  Append To List  ${pci_devs}  ${if2_pci}  ELSE  Append To List  ${pci_devs}  ${if2_1_pci}  ${if2_2_pci}
\    Run keyword  ${dut}.Add DPDK Dev  @{pci_devs}
\    Run Keyword If  '${if1_status}' == 'PASS'  Set Test Variable  ${${dut}_if1_pci}  ${if1_pci}
\    Run Keyword Unless  '${if1_status}' == 'PASS'  Set Test Variable  ${${dut}_if1_1_pci}  ${if1_1_pci}
\    Run Keyword Unless  '${if1_status}' == 'PASS'  Set Test Variable  ${${dut}_if1_2_pci}  ${if1_2_pci}
\    Run Keyword If  '${if2_status}' == 'PASS'  Set Test Variable  ${${dut}_if2_pci}  ${if2_pci}
\    Run Keyword Unless  '${if2_status}' == 'PASS'  Set Test Variable  ${${dut}_if2_1_pci}  ${if2_1_pci}
\    Run Keyword Unless  '${if2_status}' == 'PASS'  Set Test Variable  ${${dut}_if2_2_pci}  ${if2_2_pci}

3.10.1.45. Add single PCI device to all DUTs

Add single (first) PCI device on DUT1 and single (last) PCI device on DUT2 to VPP configuration file.


${duts}=  Get Matches  ${nodes}  DUT*
: FOR  ${dut}  IN  @{duts}
\    ${if1_pci}=  Get Interface PCI Addr  ${nodes['${dut}']}  ${${dut}_if1}
\    Run keyword  ${dut}.Add DPDK Dev  ${if1_pci}
\    Set Test Variable  ${${dut}_if1_pci}  ${if1_pci}

3.10.1.50. Configure guest VM with dpdk-testpmd connected via vhost-user

Start QEMU guest with two vhost-user interfaces and interconnectingDPDK testpmd.

Arguments: - dut - DUT node to start guest VM on. Type: dictionary - sock1 - Socket path for first Vhost-User interface. Type: string - sock2 - Socket path for second Vhost-User interface. Type: string - vm_name - QemuUtil instance name. Type: string - nf_cpus: List of allocated CPUs. Type: list - qemu_id - Qemu Id when starting more then one guest VM on DUT node. Type: integer - jumbo - Set True if jumbo frames are used in the test. Type: bool - perf_qemu_qsz - Virtio Queue Size. Type: int - use_tuned_cfs - Set True if CFS RR should be used for Qemu SMP. Type: bool - auto_scale - Whether to use same amount of RXQs for vhost interface in VM as vswitch, otherwise use single RXQ. Type: boolean

Note: KW uses test variables ${rxq_count_int}, ${thr_count_int} and ${cpu_count_int} set by “Add worker threads and rxqueues to all DUTs”

Example:

| Configure guest VM with dpdk-testpmd connected via vhost-user | ${nodes[‘DUT1’]} | /tmp/sock-1-1 | /tmp/sock-1-2 | DUT1_VM2 | qemu_id=${2} |


${nf_cpus_count}=  Get Length  ${nf_cpus}
${rxq}=  Run Keyword If  ${auto_scale} == ${True}  Set Variable  ${rxq_count_int}  ELSE  Set Variable  ${1}
Import Library  resources.libraries.python.QemuUtils  qemu_id=${qemu_id}  WITH NAME  ${vm_name}
Run keyword  ${vm_name}.Qemu Set Node  ${nodes['${dut}']}
${serial_port}=  Evaluate  ${qemu_id} + ${4555}
Run keyword  ${vm_name}.Qemu Set Serial Port  ${serial_port}
${ssh_fwd_port}=  Evaluate  ${qemu_id} + ${10021}
Run keyword  ${vm_name}.Qemu Set Ssh Fwd Port  ${ssh_fwd_port}
Run keyword  ${vm_name}.Qemu Set Queue Count  ${rxq_count_int}
Run keyword  ${vm_name}.Qemu Set Queue Size  ${perf_qemu_qsz}
Run keyword  ${vm_name}.Qemu Add Vhost User If  ${sock1}  jumbo_frames=${jumbo}
Run keyword  ${vm_name}.Qemu Add Vhost User If  ${sock2}  jumbo_frames=${jumbo}
${apply_patch}=  Set Variable  ${False}
${perf_qemu_path}=  Set Variable If  ${apply_patch}  ${perf_qemu_path}-patch/bin/  ${perf_qemu_path}-base/bin/
Run Keyword If  ${qemu_build}  ${vm_name}.Build QEMU  ${nodes['${dut}']}  apply_patch=${apply_patch}
Run keyword  ${vm_name}.Qemu Set Path  ${perf_qemu_path}
Run keyword  ${vm_name}.Qemu Set Smp  ${nf_cpus_count}  ${nf_cpus_count}  1  1
Run keyword  ${vm_name}.Qemu Set Mem Size  2048
Run keyword  ${vm_name}.Qemu Set Disk Image  ${perf_vm_image}
${vm}=  Run keyword  ${vm_name}.Qemu Start
Run keyword  ${vm_name}.Qemu Set Affinity  @{nf_cpus}
Run keyword If  ${use_tuned_cfs}  ${vm_name}.Qemu Set Scheduler Policy
${max_pkt_len}=  Set Variable If  ${jumbo}  9200  ${EMPTY}
${testpmd_cpus}=  Cpu list per node str  ${nodes['${dut}']}  ${0}  cpu_cnt=${nf_cpus_count}
Dpdk Testpmd Start  ${vm}  eal_corelist=${testpmd_cpus}  eal_mem_channels=4  pmd_fwd_mode=io  pmd_disable_hw_vlan=${TRUE}  pmd_rxd=${perf_qemu_qsz}  pmd_txd=${perf_qemu_qsz}  pmd_rxq=${rxq}  pmd_txq=${rxq}  pmd_max_pkt_len=${max_pkt_len}
Return From Keyword  ${vm}

3.10.1.51. Configure guest VMs with dpdk-testpmd connected via vhost-user on node

Start vm_count QEMU guests with two vhost-user interfaces andinterconnecting DPDK testpmd for defined number of VMs on all definedVPP nodes.

Arguments: - dut - DUT node to start guest VM on. Type: dictionary - vm_count - Number of guest VMs. Type: int - jumbo - Jumbo frames are used (True) or are not used (False) in the test. Type: boolean - perf_qemu_qsz - Virtio Queue Size. Type: int - use_tuned_cfs - Set True if CFS RR should be used for Qemu SMP. Type: bool

Example:

| Configure guest VMs with dpdk-testpmd connected via vhost-user on node | DUT1 | 1 | False | 256 |


: FOR  ${number}  IN RANGE  1  ${vm_count}+1
\    ${nf_cpus}=  Create network function CPU list  ${dut}  chains=${1}  nodeness=${vm_count}  chain_id=${1}  node_id=${number}  auto_scale=${True}
\    ${sock1}=  Set Variable  /tmp/sock-${number}-1
\    ${sock2}=  Set Variable  /tmp/sock-${number}-2
\    ${vm}=  Configure guest VM with dpdk-testpmd connected via vhost-user  ${dut}  ${sock1}  ${sock2}  ${dut}_VM${number}  ${nf_cpus}  qemu_id=${number}  jumbo=${jumbo}  perf_qemu_qsz=${perf_qemu_qsz}  use_tuned_cfs=${use_tuned_cfs}
\    Set To Dictionary  ${${dut}_vm_refs}  ${dut}_VM${number}  ${vm}

3.10.1.52. Configure guest VMs with dpdk-testpmd connected via vhost-user

Start vm_count QEMU guests with two vhost-user interfaces andinterconnecting DPDK testpmd defined number of VMs on all defined VPPnodes.

Arguments: - vm_count - Number of guest VMs. Type: int - jumbo - Jumbo frames are used (True) or are not used (False) in the test. Type: boolean - perf_qemu_qsz - Virtio Queue Size. Type: int - use_tuned_cfs - Set True if CFS RR should be used for Qemu SMP. Type: bool

Example:

| Configure guest VMs with dpdk-testpmd connected via vhost-user| 1 | False | 256 |


${duts}=  Get Matches  ${nodes}  DUT*
: FOR  ${dut}  IN  @{duts}
\    Configure guest VMs with dpdk-testpmd connected via vhost-user on node  ${dut}  vm_count=${vm_count}  jumbo=${jumbo}  perf_qemu_qsz=${perf_qemu_qsz}  use_tuned_cfs=${False}
All VPP Interfaces Ready Wait  ${nodes}
VPP round robin RX placement on all DUTs  ${nodes}  prefix=Virtual

3.10.1.53. Configure guest VM with dpdk-testpmd-mac connected via vhost-user

Start QEMU guest with two vhost-user interfaces and interconnectingDPDK testpmd.

Arguments: - dut - DUT node to start guest VM on. Type: dictionary - sock1 - Socket path for first Vhost-User interface. Type: string - sock2 - Socket path for second Vhost-User interface. Type: string - vm_name - QemuUtil instance name. Type: string - eth0_mac - MAC address of first Vhost interface. Type: string - eth1_mac - MAC address of second Vhost interface. Type: string - nf_cpus: List of allocated CPUs. Type: list - qemu_id - Qemu Id when starting more then one guest VM on DUT node. Type: integer - jumbo - Set True if jumbo frames are used in the test. Type: bool - perf_qemu_qsz - Virtio Queue Size. Type: int - use_tuned_cfs - Set True if CFS RR should be used for Qemu SMP. Type: bool - auto_scale - Whether to use same amount of RXQs for vhost interface in VM as vswitch, otherwise use single RXQ. Type: boolean

Note: KW uses test variables ${rxq_count_int}, ${thr_count_int} and ${cpu_count_int} set by “Add worker threads and rxqueues to all DUTs”

Example:

| Configure guest VM with dpdk-testpmd-mac connected via vhost-user | ${nodes[‘DUT1’]} | /tmp/sock1 | /tmp/sock2 | DUT1_VM | 00:00:00:00:00:01 | 00:00:00:00:00:02 |


${nf_cpus_count}=  Get Length  ${nf_cpus}
${rxq}=  Run Keyword If  ${auto_scale} == ${True}  Set Variable  ${rxq_count_int}  ELSE  Set Variable  ${1}
Import Library  resources.libraries.python.QemuUtils  qemu_id=${qemu_id}  WITH NAME  ${vm_name}
Run keyword  ${vm_name}.Qemu Set Node  ${nodes['${dut}']}
${serial_port}=  Evaluate  ${qemu_id} + ${4555}
Run keyword  ${vm_name}.Qemu Set Serial Port  ${serial_port}
${ssh_fwd_port}=  Evaluate  ${qemu_id} + ${10021}
Run keyword  ${vm_name}.Qemu Set Ssh Fwd Port  ${ssh_fwd_port}
Run keyword  ${vm_name}.Qemu Set Queue Count  ${rxq_count_int}
Run keyword  ${vm_name}.Qemu Set Queue Size  ${perf_qemu_qsz}
Run keyword  ${vm_name}.Qemu Add Vhost User If  ${sock1}  jumbo_frames=${jumbo}
Run keyword  ${vm_name}.Qemu Add Vhost User If  ${sock2}  jumbo_frames=${jumbo}
${apply_patch}=  Set Variable  ${False}
${perf_qemu_path}=  Set Variable If  ${apply_patch}  ${perf_qemu_path}-patch/bin/  ${perf_qemu_path}-base/bin/
Run Keyword If  ${qemu_build}  ${vm_name}.Build QEMU  ${nodes['${dut}']}  apply_patch=${False}
Run keyword  ${vm_name}.Qemu Set Path  ${perf_qemu_path}
Run keyword  ${vm_name}.Qemu Set Smp  ${nf_cpus_count}  ${nf_cpus_count}  1  1
Run keyword  ${vm_name}.Qemu Set Mem Size  2048
Run keyword  ${vm_name}.Qemu Set Disk Image  ${perf_vm_image}
${vm}=  Run keyword  ${vm_name}.Qemu Start
Run keyword  ${vm_name}.Qemu Set Affinity  @{nf_cpus}
Run keyword If  ${use_tuned_cfs}  ${vm_name}.Qemu Set Scheduler Policy
${max_pkt_len}=  Set Variable If  ${jumbo}  9200  ${EMPTY}
${testpmd_cpus}=  Cpu list per node str  ${nodes['${dut}']}  ${0}  cpu_cnt=${nf_cpus_count}
Dpdk Testpmd Start  ${vm}  eal_corelist=${testpmd_cpus}  eal_mem_channels=4  pmd_fwd_mode=mac  pmd_eth_peer_0=0,${eth0_mac}  pmd_eth_peer_1=1,${eth1_mac}  pmd_disable_hw_vlan=${TRUE}  pmd_rxd=${perf_qemu_qsz}  pmd_txd=${perf_qemu_qsz}  pmd_rxq=${rxq}  pmd_txq=${rxq}  pmd_max_pkt_len=${max_pkt_len}
Return From Keyword  ${vm}

3.10.1.54. Configure guest VMs with dpdk-testpmd-mac connected via vhost-user on node

Start vm_count QEMU guests with two vhost-user interfaces andinterconnecting DPDK testpmd with fwd mode set to mac rewrite fordefined number of VMs on all defined VPP nodes.

Arguments: - dut - DUT node to start guest VM on. Type: dictionary - vm_count - Number of guest VMs. Type: int - jumbo - Jumbo frames are used (True) or are not used (False) in the test. Type: boolean - perf_qemu_qsz - Virtio Queue Size. Type: int - use_tuned_cfs - Set True if CFS RR should be used for Qemu SMP. Type: bool

_NOTE:_ This KW expects following test case variables to be set: - cpu_count_int - Number of Physical CPUs allocated for DUT.

Example:

| Configure guest VMs with dpdk-testpmd-mac connected via vhost-user on node | DUT1 | 1 | False | 256 |


: FOR  ${number}  IN RANGE  1  ${vm_count}+1
\    ${nf_cpus}=  Create network function CPU list  ${dut}  chains=${1}  nodeness=${vm_count}  chain_id=${1}  node_id=${number}  auto_scale=${True}
\    ${sock1}=  Set Variable  /tmp/sock-${number}-1
\    ${sock2}=  Set Variable  /tmp/sock-${number}-2
\    ${vm}=  Configure guest VM with dpdk-testpmd-mac connected via vhost-user  ${dut}  ${sock1}  ${sock2}  ${dut}_VM${number}  ${${dut}-vhost-${number}-if1_mac}  ${${dut}-vhost-${number}-if2_mac}  nf_cpus=${nf_cpus}  qemu_id=${number}  jumbo=${jumbo}  perf_qemu_qsz=${perf_qemu_qsz}  use_tuned_cfs=${use_tuned_cfs}
\    Set To Dictionary  ${${dut}_vm_refs}  ${dut}_VM${number}  ${vm}

3.10.1.55. Configure guest VMs with dpdk-testpmd-mac connected via vhost-user

Start vm_count QEMU guests with two vhost-user interfaces andinterconnecting DPDK testpmd with fwd mode set to mac rewrite fordefined number of VMs on all defined VPP nodes.

Arguments: - vm_count - Number of guest VMs. Type: int - jumbo - Jumbo frames are used (True) or are not used (False) in the test. Type: boolean - perf_qemu_qsz - Virtio Queue Size. Type: int - use_tuned_cfs - Set True if CFS RR should be used for Qemu SMP. Type: bool

Example:

| Configure guest VMs with dpdk-testpmd-mac connected via vhost-user| 1 | False | 256 |


${duts}=  Get Matches  ${nodes}  DUT*
: FOR  ${dut}  IN  @{duts}
\    Configure guest VMs with dpdk-testpmd-mac connected via vhost-user on node  ${dut}  vm_count=${vm_count}  jumbo=${jumbo}  perf_qemu_qsz=${perf_qemu_qsz}  use_tuned_cfs=${False}
All VPP Interfaces Ready Wait  ${nodes}
VPP round robin RX placement on all DUTs  ${nodes}  prefix=Virtual

3.10.1.56. Configure chain of NFs with dpdk-testpmd-mac connected via vhost-user on node

Start 1 chain of 1..N QEMU guests (VNFs) with two vhost-userinterfaces and interconnecting DPDK testpmd with fwd mode set to macrewrite on VPP node.

Arguments: - dut - DUT node to start guest VM on. Type: dictionary - nf_chains - Number of chains of NFs. Type: integer - nf_chain - NF chain ID. Type: integer - nf_nodes - Number of guest VMs. Type: integer - jumbo - Jumbo frames are used (True) or are not used (False) in the test. Type: boolean - perf_qemu_qsz - Virtio Queue Size. Type: integer - use_tuned_cfs - Set True if CFS RR should be used for Qemu SMP. Type: boolean - auto_scale - Whether to use same amount of RXQs for vhost interface in VM as vswitch, otherwise use single RXQ. Type: boolean

Example:

| Configure chain of NFs with dpdk-testpmd-mac connected via vhost-user on node | DUT1 | 1 | 1 | 1 | False | 256 |


${tg_if1_mac}=  Get Interface MAC  ${tg}  ${tg_if1}
${tg_if2_mac}=  Get Interface MAC  ${tg}  ${tg_if2}
: FOR  ${nf_node}  IN RANGE  1  ${nf_nodes} + ${1}
\    ${nf_cpus}=  Create network function CPU list  ${dut}  chains=${nf_chains}  nodeness=${nf_nodes}  chain_id=${nf_chain}  node_id=${nf_node}  auto_scale=${False}
\    ${qemu_id}=  Evaluate  (${nf_chain} - ${1}) * ${nf_nodes} + ${nf_node}
\    ${sock1}=  Set Variable  /tmp/sock-${qemu_id}-1
\    ${sock2}=  Set Variable  /tmp/sock-${qemu_id}-2
\    ${nf_name}=  Set Variable  ${dut}_VM${qemu_id}
\    ${prev_qemu_id}=  Evaluate  ${qemu_id} - ${1}
\    ${next_qemu_id}=  Evaluate  ${qemu_id} + ${1}
\    ${prev_qemu_id_hex}=  Convert To Hex  ${prev_qemu_id}  length=2  lowercase=yes
\    ${next_qemu_id_hex}=  Convert To Hex  ${next_qemu_id}  length=2  lowercase=yes
\    ${vif1_mac}=  Set Variable If  ${nf_node} == ${1}  ${tg_if1_mac}  52:54:00:00:${prev_qemu_id_hex}:02
\    ${vif2_mac}=  Set Variable If  ${nf_node} == ${nf_nodes}  ${tg_if2_mac}  52:54:00:00:${next_qemu_id_hex}:01
\    ${vm}=  Configure guest VM with dpdk-testpmd-mac connected via vhost-user  ${dut}  ${sock1}  ${sock2}  ${nf_name}  ${vif1_mac}  ${vif2_mac}  ${nf_cpus}  qemu_id=${qemu_id}  jumbo=${jumbo}  perf_qemu_qsz=${perf_qemu_qsz}  use_tuned_cfs=${use_tuned_cfs}  auto_scale=${auto_scale}
\    Set To Dictionary  ${${dut}_vm_refs}  ${nf_name}  ${vm}

3.10.1.57. Configure chain of NFs with dpdk-testpmd-mac connected via vhost-user

Start 1 chain of 1..N QEMU guests (VNFs) with two vhost-userinterfaces and interconnecting DPDK testpmd with fwd mode set to macrewrite on all defined VPP nodes.

Arguments: - nf_chains - Number of chains of NFs. Type: integer - nf_chain - NF chain ID. Type: integer - nf_nodes - Number of NFs nodes per chain. Type: integer - jumbo - Jumbo frames are used (True) or are not used (False) in the test. Type: boolean - perf_qemu_qsz - Virtio Queue Size. Type: integer - use_tuned_cfs - Set True if CFS RR should be used for Qemu SMP. Type: boolean - auto_scale - Whether to use same amount of RXQs for vhost interface in VM as vswitch, otherwise use single RXQ. Type: boolean

Example:

| Configure chain of NFs with dpdk-testpmd-mac connected viavhost-user | 1 | 1 | 1 | False | 256 |


${duts}=  Get Matches  ${nodes}  DUT*
: FOR  ${dut}  IN  @{duts}
\    Configure chain of NFs with dpdk-testpmd-mac connected via vhost-user on node  ${dut}  nf_chains=${nf_chains}  nf_chain=${nf_chain}  nf_nodes=${nf_nodes}  jumbo=${jumbo}  perf_qemu_qsz=${perf_qemu_qsz}  use_tuned_cfs=${False}  auto_scale=${auto_scale}

3.10.1.58. Configure chains of NFs with dpdk-testpmd-mac connected via vhost-user

Start 1..N chains of 1..N QEMU guests (VNFs) with two vhost-userinterfaces and interconnecting DPDK testpmd with fwd mode set to macrewrite on all defined VPP nodes.

Arguments: - nf_chains - Number of chains of NFs. Type: integer - nf_nodes - Number of NFs nodes per chain. Type: integer - jumbo - Jumbo frames are used (True) or are not used (False) in the test. Type: boolean - perf_qemu_qsz - Virtio Queue Size. Type: integer - use_tuned_cfs - Set True if CFS RR should be used for Qemu SMP. Type: boolean - auto_scale - Whether to use same amount of RXQs for memif interface in containers as vswitch, otherwise use single RXQ. Type: boolean

Example:

| Configure chains of VMs with dpdk-testpmd-mac connected via vhost-user | 1 | 1 | False | 256 |


: FOR  ${nf_chain}  IN RANGE  1  ${nf_chains}+1
\    Configure chain of NFs with dpdk-testpmd-mac connected via vhost-user  nf_chains=${nf_chains}  nf_chain=${nf_chain}  nf_nodes=${nf_nodes}  jumbo=${jumbo}  perf_qemu_qsz=${perf_qemu_qsz}  use_tuned_cfs=${False}  auto_scale=${auto_scale}
All VPP Interfaces Ready Wait  ${nodes}
VPP round robin RX placement on all DUTs  ${nodes}  prefix=Virtual

3.10.1.59. Initialize LISP IPv4 forwarding in 3-node circular topology

Custom setup of IPv4 addresses on all DUT nodes and TG Don`t set route.

Arguments: - dut1_dut2_address - Ip address from DUT1 to DUT2. Type: string - dut1_tg_address - Ip address from DUT1 to tg. Type: string - dut2_dut1_address - Ip address from DUT2 to DUT1. Type: string - dut1_tg_address - Ip address from DUT1 to tg. Type: string - duts_prefix - ip prefix. Type: int

Return: - No value returned

Example: | Initialize LISP IPv4 forwarding in 3-node circular topology | ${dut1_dut2_address} | ${dut1_tg_address} | ${dut2_dut1_address} | ${dut2_tg_address} | ${duts_prefix} |


Set interfaces in path up
${tg1_if1_mac}=  Get Interface MAC  ${tg}  ${tg_if1}
${tg1_if2_mac}=  Get Interface MAC  ${tg}  ${tg_if2}
${dut1_if2_mac}=  Get Interface MAC  ${dut1}  ${dut1_if2}
${dut2_if1_mac}=  Get Interface MAC  ${dut2}  ${dut2_if1}
Add arp on dut  ${dut1}  ${dut1_if1}  10.10.10.2  ${tg1_if1_mac}
Add arp on dut  ${dut1}  ${dut1_if2}  ${dut2_dut1_address}  ${dut2_if1_mac}
Add arp on dut  ${dut2}  ${dut2_if1}  ${dut1_dut2_address}  ${dut1_if2_mac}
Add arp on dut  ${dut2}  ${dut2_if2}  20.20.20.2  ${tg1_if2_mac}
Configure IP addresses on interfaces  ${dut1}  ${dut1_if1}  ${dut1_tg_address}  ${duts_prefix}
Configure IP addresses on interfaces  ${dut1}  ${dut1_if2}  ${dut1_dut2_address}  ${duts_prefix}
Configure IP addresses on interfaces  ${dut2}  ${dut2_if1}  ${dut2_dut1_address}  ${duts_prefix}
Configure IP addresses on interfaces  ${dut2}  ${dut2_if2}  ${dut2_tg_address}  ${duts_prefix}

3.10.1.60. Initialize LISP GPE IPv4 over IPsec in 3-node circular topology

Setup Lisp GPE IPv4 forwarding over IPsec.

Arguments: - encr_alg - Encryption algorithm. Type: string - auth_alg - Authentication algorithm. Type: string

Return: - No value returned

Example: | Initialize LISP GPE IPv4 over IPsec in 3-node circular topology| ${encr_alg} | ${auth_alg}


Generate keys for IPSec  ${encr_alg}  ${auth_alg}
Initialize LISP IPv4 forwarding in 3-node circular topology  ${dut1_to_dut2_ip4}  ${dut1_to_tg_ip4}  ${dut2_to_dut1_ip4}  ${dut2_to_tg_ip4}  ${prefix4}
Configure LISP GPE topology in 3-node circular topology  ${dut1}  ${dut1_if2}  ${NONE}  ${dut2}  ${dut2_if1}  ${NONE}  ${duts_locator_set}  ${dut1_ip4_eid}  ${dut2_ip4_eid}  ${dut1_ip4_static_adjacency}  ${dut2_ip4_static_adjacency}
Configure manual keyed connection for IPSec  ${dut1}  ${dut1_if2}  ${encr_alg}  ${encr_key}  ${auth_alg}  ${auth_key}  ${dut1_spi}  ${dut2_spi}  ${dut1_to_dut2_ip4}  ${dut2_to_dut1_ip4}
Configure manual keyed connection for IPSec  ${dut2}  ${dut2_if1}  ${encr_alg}  ${encr_key}  ${auth_alg}  ${auth_key}  ${dut2_spi}  ${dut1_spi}  ${dut2_to_dut1_ip4}  ${dut1_to_dut2_ip4}

3.10.1.61. Initialize LISP IPv6 forwarding in 3-node circular topology

Custom setup of IPv6 topology on all DUT nodes Don`t set route.

Arguments: - dut1_dut2_address - Ip address from DUT1 to DUT2. Type: string - dut1_tg_address - Ip address from DUT1 to tg. Type: string - dut2_dut1_address - Ip address from DUT2 to DUT1. Type: string - dut1_tg_address - Ip address from DUT1 to tg. Type: string - duts_prefix - ip prefix. Type: int

Return: - No value returned

Example: | Initialize LISP IPv6 forwarding in 3-node circular topology | ${dut1_dut2_address} | ${dut1_tg_address} | ${dut2_dut1_address} | ${dut2_tg_address} | ${duts_prefix} |


Set interfaces in path up
${tg1_if1_mac}=  Get Interface MAC  ${tg}  ${tg_if1}
${tg1_if2_mac}=  Get Interface MAC  ${tg}  ${tg_if2}
${dut1_if2_mac}=  Get Interface MAC  ${dut1}  ${dut1_if2}
${dut2_if1_mac}=  Get Interface MAC  ${dut2}  ${dut2_if1}
VPP Set If IPv6 Addr  ${dut1}  ${dut1_if1}  ${dut1_tg_address}  ${prefix}
VPP Set If IPv6 Addr  ${dut1}  ${dut1_if2}  ${dut1_dut2_address}  ${prefix}
VPP Set If IPv6 Addr  ${dut2}  ${dut2_if1}  ${dut2_dut1_address}  ${prefix}
VPP Set If IPv6 Addr  ${dut2}  ${dut2_if2}  ${dut2_tg_address}  ${prefix}
Suppress ICMPv6 router advertisement message  ${nodes}
Add Ip Neighbor  ${dut1}  ${dut1_if1}  2001:1::2  ${tg1_if1_mac}
Add Ip Neighbor  ${dut2}  ${dut2_if2}  2001:2::2  ${tg1_if2_mac}
Add Ip Neighbor  ${dut1}  ${dut1_if2}  ${dut2_dut1_address}  ${dut2_if1_mac}
Add Ip Neighbor  ${dut2}  ${dut2_if1}  ${dut1_dut2_address}  ${dut1_if2_mac}

3.10.1.62. Initialize LISP IPv4 over IPv6 forwarding in 3-node circular topology

Custom setup of IPv4 over IPv6 topology on all DUT nodes Don`t set route.

Arguments: - dut1_dut2_ip6_address - IPv6 address from DUT1 to DUT2. Type: string - dut1_tg_ip4_address - IPv4 address from DUT1 to tg. Type: string - dut2_dut1_ip6_address - IPv6 address from DUT2 to DUT1. Type: string - dut1_tg_ip4_address - IPv4 address from DUT1 to tg. Type: string - prefix4 - IPv4 prefix. Type: int - prefix6 - IPv6 prefix. Type: int

Return: - No value returned

Example: | Lisp IPv4 over IPv6 forwarding initialized in a 3-node circular topology | ${dut1_dut2_ip6_address} | ${dut1_tg_ip4_address} | ${dut2_dut1_ip6_address} | ${dut2_tg_ip4_address} | ${prefix4} | ${prefix6} |


Set interfaces in path up
${tg1_if1_mac}=  Get Interface MAC  ${tg}  ${tg_if1}
${tg1_if2_mac}=  Get Interface MAC  ${tg}  ${tg_if2}
${dut1_if2_mac}=  Get Interface MAC  ${dut1}  ${dut1_if2}
${dut2_if1_mac}=  Get Interface MAC  ${dut2}  ${dut2_if1}
Configure IP addresses on interfaces  ${dut1}  ${dut1_if1}  ${dut1_tg_ip4_address}  ${prefix4}
VPP Set If IPv6 Addr  ${dut1}  ${dut1_if2}  ${dut1_dut2_ip6_address}  ${prefix6}
VPP Set If IPv6 Addr  ${dut2}  ${dut2_if1}  ${dut2_dut1_ip6_address}  ${prefix6}
Configure IP addresses on interfaces  ${dut2}  ${dut2_if2}  ${dut2_tg_ip4_address}  ${prefix4}
Suppress ICMPv6 router advertisement message  ${nodes}
Add arp on dut  ${dut1}  ${dut1_if1}  10.10.10.2  ${tg1_if1_mac}
Add arp on dut  ${dut2}  ${dut2_if2}  20.20.20.2  ${tg1_if2_mac}
Add Ip Neighbor  ${dut1}  ${dut1_if2}  ${dut2_dut1_ip6_address}  ${dut2_if1_mac}
Add Ip Neighbor  ${dut2}  ${dut2_if1}  ${dut1_dut2_ip6_address}  ${dut1_if2_mac}

3.10.1.63. Initialize LISP IPv6 over IPv4 forwarding in 3-node circular topology

Custom setup of IPv4 over IPv6 topology on all DUT nodes Don`t set route.

Arguments: - dut1_dut2_ip4_address - IPv4 address from DUT1 to DUT2. Type: string - dut1_tg_ip6_address - IPv6 address from DUT1 to tg. Type: string - dut2_dut1_ip4_address - IPv4 address from DUT2 to DUT1. Type: string - dut1_tg_ip6_address - IPv6 address from DUT1 to tg. Type: string - prefix4 - IPv4 prefix. Type: int - prefix6 - IPv6 prefix. Type: int

Return: - No value returned

Example: | Lisp IPv6 over IPv4 forwarding initialized in a 3-node circular topology | ${dut1_dut2_ip4_address} | ${dut1_tg_ip6_address} | ${dut2_dut1_ip4_address} | ${dut2_tg_ip6_address} | ${prefix6} | ${prefix4} |


Set interfaces in path up
${tg1_if1_mac}=  Get Interface MAC  ${tg}  ${tg_if1}
${tg1_if2_mac}=  Get Interface MAC  ${tg}  ${tg_if2}
${dut1_if2_mac}=  Get Interface MAC  ${dut1}  ${dut1_if2}
${dut2_if1_mac}=  Get Interface MAC  ${dut2}  ${dut2_if1}
VPP Set If IPv6 Addr  ${dut1}  ${dut1_if1}  ${dut1_tg_ip6_address}  ${prefix6}
Configure IP addresses on interfaces  ${dut1}  ${dut1_if2}  ${dut1_dut2_ip4_address}  ${prefix4}
Configure IP addresses on interfaces  ${dut2}  ${dut2_if1}  ${dut2_dut1_ip4_address}  ${prefix4}
VPP Set If IPv6 Addr  ${dut2}  ${dut2_if2}  ${dut2_tg_ip6_address}  ${prefix6}
Suppress ICMPv6 router advertisement message  ${nodes}
Add Ip Neighbor  ${dut1}  ${dut1_if1}  2001:1::2  ${tg1_if1_mac}
Add Ip Neighbor  ${dut2}  ${dut2_if2}  2001:2::2  ${tg1_if2_mac}
Add arp on dut  ${dut1}  ${dut1_if2}  ${dut2_dut1_ip4_address}  ${dut2_if1_mac}
Add arp on dut  ${dut2}  ${dut2_if1}  ${dut1_dut2_ip4_address}  ${dut1_if2_mac}

3.10.1.64. Initialize NAT44 in circular topology

Initialization of 2-node / 3-node topology with NAT44 between DUTs: - set interfaces up - set IP addresses - set ARP - create routes - set NAT44 - only on DUT1


${dut2_status}  ${value}=  Run Keyword And Ignore Error  Variable Should Exist  ${dut2}
Set interfaces in path up
Configure IP addresses on interfaces  ${dut1}  ${dut1_if1}  10.0.0.1  20
Run Keyword If  '${dut2_status}' == 'PASS'  Configure IP addresses on interfaces  ${dut1}  ${dut1_if2}  11.0.0.1  20
Run Keyword If  '${dut2_status}' == 'PASS'  Configure IP addresses on interfaces  ${dut2}  ${dut2_if1}  11.0.0.2  20
${dut}=  Run Keyword If  '${dut2_status}' == 'PASS'  Set Variable  ${dut2}  ELSE  Set Variable  ${dut1}
${dut_if2}=  Run Keyword If  '${dut2_status}' == 'PASS'  Set Variable  ${dut2_if2}  ELSE  Set Variable  ${dut1_if2}
Configure IP addresses on interfaces  ${dut}  ${dut_if2}  12.0.0.1  20
${tg_if1_mac}=  Get Interface MAC  ${tg}  ${tg_if1}
${tg_if2_mac}=  Get Interface MAC  ${tg}  ${tg_if2}
${dut1_if2_mac}=  Run Keyword If  '${dut2_status}' == 'PASS'  Get Interface MAC  ${dut1}  ${dut1_if2}
${dut2_if1_mac}=  Run Keyword If  '${dut2_status}' == 'PASS'  Get Interface MAC  ${dut2}  ${dut2_if1}
Add arp on dut  ${dut1}  ${dut1_if1}  10.0.0.2  ${tg_if1_mac}
Run Keyword If  '${dut2_status}' == 'PASS'  Add arp on dut  ${dut1}  ${dut1_if2}  11.0.0.2  ${dut2_if1_mac}
Run Keyword If  '${dut2_status}' == 'PASS'  Add arp on dut  ${dut2}  ${dut2_if1}  11.0.0.1  ${dut1_if2_mac}
Add arp on dut  ${dut}  ${dut_if2}  12.0.0.2  ${tg_if2_mac}
Vpp Route Add  ${dut1}  20.0.0.0  18  gateway=10.0.0.2  interface=${dut1_if1}
Run Keyword If  '${dut2_status}' == 'PASS'  Vpp Route Add  ${dut1}  12.0.0.2  32  gateway=11.0.0.2  interface=${dut1_if2}
Run Keyword If  '${dut2_status}' == 'PASS'  Vpp Route Add  ${dut2}  12.0.0.0  24  gateway=12.0.0.2  interface=${dut2_if2}
Run Keyword If  '${dut2_status}' == 'PASS'  Vpp Route Add  ${dut2}  200.0.0.0  30  gateway=11.0.0.1  interface=${dut2_if1}
Configure inside and outside interfaces  ${dut1}  ${dut1_if1}  ${dut1_if2}
Configure deterministic mode for NAT44  ${dut1}  20.0.0.0  18  200.0.0.0  30

3.10.1.65. Initialize L2 xconnect with memif pairs on DUT node

Create pairs of Memif interfaces on DUT node. Cross connect each Memif interface with one physical interface or virtual interface to create a chain accross DUT node.

Arguments: - dut - DUT node. Type: dictionary - count - Number of memif pairs (containers). Type: integer

Note: Socket paths for Memif are defined in following format: - /tmp/memif-${dut}_CNF${number}-${sid}

KW uses test variable ${rxq_count_int} set by KW Add worker threads and rxqueues to all DUTs

Example:

| Initialize L2 xconnect with memif pairs on DUT node | ${dut} | ${1} |


: FOR  ${number}  IN RANGE  1  ${count}+1
\    ${sock1}=  Set Variable  memif-${dut}_CNF
\    ${sock2}=  Set Variable  memif-${dut}_CNF
\    ${prev_index}=  Evaluate  ${number}-1
\    Set up memif interfaces on DUT node  ${nodes['${dut}']}  ${sock1}  ${sock2}  ${number}  ${dut}-memif-${number}-if1  ${dut}-memif-${number}-if2  ${rxq_count_int}  ${rxq_count_int}
\    ${xconnect_if1}=  Set Variable If  ${number}==1  ${${dut}_if1}  ${${dut}-memif-${prev_index}-if2}
\    Configure L2XC  ${nodes['${dut}']}  ${xconnect_if1}  ${${dut}-memif-${number}-if1}
\    Run Keyword If  ${number}==${count}  Configure L2XC  ${nodes['${dut}']}  ${${dut}-memif-${number}-if2}  ${${dut}_if2}

3.10.1.66. Initialize L2 xconnect with memif pairs

Create pairs of Memif interfaces on all defined VPP nodes. Cross connect each Memif interface with one physical interface or virtual interface to create a chain accross DUT node.

Arguments: - count - Number of memif pairs (containers). Type: integer

Example:

| Initialize L2 xconnect with memif pairs | ${1} |


${duts}=  Get Matches  ${nodes}  DUT*
: FOR  ${dut}  IN  @{duts}
\    Initialize L2 xconnect with memif pairs on DUT node  ${dut}  ${count}
Set interfaces in path up
Show Memif on all DUTs  ${nodes}
VPP round robin RX placement on all DUTs  ${nodes}  prefix=memif

3.10.1.67. Initialize L2 Bridge Domain with memif pairs on DUT node

Create pairs of Memif interfaces on DUT node. Put each Memif interface to separate L2 bridge domain with one physical or memif interface to create a chain accross DUT node.

Arguments: - dut - DUT node. Type: dictionary - nf_chain - NF chain. Type: integer - nf_nodes - Number of NFs nodes per chain. Type: integer - auto_scale - Whether to use same amount of RXQs for memif interface in containers as vswitch, otherwise use single RXQ. Type: boolean

Note: Socket paths for Memif are defined in following format: - /tmp/memif-${dut}_CNF${nf_id}-${sid}

Example:

| Initialize L2 Bridge Domain with memif pairs on DUT node | ${dut} | 1 | 1 |


${rxq}=  Run Keyword If  ${auto_scale} == ${True}  Set Variable  ${rxq_count_int}  ELSE  Set Variable  ${1}
${bd_id2}=  Evaluate  ${nf_nodes}+1
Add interface to bridge domain  ${nodes['${dut}']}  ${${dut}_if1}  ${1}
Add interface to bridge domain  ${nodes['${dut}']}  ${${dut}_if2}  ${bd_id2}
: FOR  ${nf_node}  IN RANGE  1  ${nf_nodes}+1
\    ${nf_id}=  Evaluate  (${nf_chain} - ${1}) * ${nf_nodes} + ${nf_node}
\    ${sock1}=  Set Variable  memif-${dut}_CNF
\    ${sock2}=  Set Variable  memif-${dut}_CNF
\    Set up memif interfaces on DUT node  ${nodes['${dut}']}  ${sock1}  ${sock2}  ${nf_id}  ${dut}-memif-${nf_id}-if1  ${dut}-memif-${nf_id}-if2  ${rxq}  ${rxq}
\    ${bd_id2}=  Evaluate  ${nf_node}+1
\    Add interface to bridge domain  ${nodes['${dut}']}  ${${dut}-memif-${nf_id}-if1}  ${nf_node}
\    Add interface to bridge domain  ${nodes['${dut}']}  ${${dut}-memif-${nf_id}-if2}  ${bd_id2}

3.10.1.68. Initialize L2 Bridge Domain with memif pairs

Create pairs of Memif interfaces on all defined VPP nodes. Put each Memif interface to separate L2 bridge domain with one physical or virtual interface to create a chain accross DUT node.

Arguments: - nf_chain - NF chain. Type: integer - nf_nodes - Number of NFs nodes per chain. Type: integer - auto_scale - Whether to use same amount of RXQs for memif interface in containers as vswitch, otherwise use single RXQ. Type: boolean

Example:

| Initialize L2 Bridge Domain with memif pairs | 1 | 1 |


${duts}=  Get Matches  ${nodes}  DUT*
: FOR  ${dut}  IN  @{duts}
\    Initialize L2 Bridge Domain with memif pairs on DUT node  ${dut}  nf_chain=${nf_chain}  nf_nodes=${nf_nodes}  auto_scale=${auto_scale}

3.10.1.69. Initialize L2 Bridge Domain for multiple chains with memif pairs

Create pairs of Memif interfaces for defined number of NF chains with defined number of NF nodes on all defined VPP nodes. Add each Memif interface into L2 bridge domains with learning enabled with physical inteface or Memif interface of another NF.

Arguments: - nf_chains - Number of chains of NFs. Type: integer - nf_nodes - Number of NFs nodes per chain. Type: integer - auto_scale - Whether to use same amount of RXQs for memif interface in containers as vswitch, otherwise use single RXQ. Type: boolean

Example:

| Initialize L2 Bridge Domain for multiple chains with memif pairs | 1 | 1 |


: FOR  ${nf_chain}  IN RANGE  1  ${nf_chains}+1
\    Initialize L2 Bridge Domain with memif pairs  nf_chain=${nf_chain}  nf_nodes=${nf_nodes}  auto_scale=${auto_scale}
Set interfaces in path up
Show Memif on all DUTs  ${nodes}
VPP round robin RX placement on all DUTs  ${nodes}  prefix=memif

3.10.1.70. Initialize L2 Bridge Domain for pipeline with memif pairs

Create pairs of Memif interfaces on all defined VPP nodes. Put each Memif interface to separate L2 bridge domain with one physical or virtual interface to create a service pipeline on DUT node.

Arguments: - nf_chain - NF pipe. Type: integer - nf_nodes - Number of NFs nodes per pipeline. Type: integer - auto_scale - Whether to use same amount of RXQs for memif interface in containers as vswitch, otherwise use single RXQ. Type: boolean

Example:

| Initialize L2 Bridge Domain for pipeline with memif pairs | 1 | 1 |


${rxq}=  Run Keyword If  ${auto_scale} == ${True}  Set Variable  ${rxq_count_int}  ELSE  Set Variable  ${1}
${duts}=  Get Matches  ${nodes}  DUT*
: FOR  ${dut}  IN  @{duts}
\    Add interface to bridge domain  ${nodes['${dut}']}  ${${dut}_if1}  ${1}
\    Add interface to bridge domain  ${nodes['${dut}']}  ${${dut}_if2}  ${2}
\    ${nf_id_frst}=  Evaluate  (${nf_chain}-${1}) * ${nf_nodes} + ${1}
\    ${nf_id_last}=  Evaluate  (${nf_chain}-${1}) * ${nf_nodes} + ${nf_nodes}
\    ${sid_frst}=  Evaluate  ${nf_id_frst} * ${2} - ${1}
\    ${sid_last}=  Evaluate  ${nf_id_last} * ${2}
\    Set up single memif interface on DUT node  ${nodes['${dut}']}  memif-${dut}_CNF  mid=${nf_id_frst}  sid=${sid_frst}  memif_if=${dut}-memif-${nf_id_frst}-if1  rxq=${rxq}  txq=${rxq}
\    Set up single memif interface on DUT node  ${nodes['${dut}']}  memif-${dut}_CNF  mid=${nf_id_last}  sid=${sid_last}  memif_if=${dut}-memif-${nf_id_last}-if2  rxq=${rxq}  txq=${rxq}
\    Add interface to bridge domain  ${nodes['${dut}']}  ${${dut}-memif-${nf_id_frst}-if1}  ${1}
\    Add interface to bridge domain  ${nodes['${dut}']}  ${${dut}-memif-${nf_id_last}-if2}  ${2}

3.10.1.71. Initialize L2 Bridge Domain for multiple pipelines with memif pairs

Create pairs of Memif interfaces for defined number of NF pipelines with defined number of NF nodes on all defined VPP nodes. Add each Memif interface into L2 bridge domains with learning enabled with physical inteface or Memif interface of another NF.

Arguments: - nf_chains - Number of pipelines of NFs. Type: integer - nf_nodes - Number of NFs nodes per pipeline. Type: integer - auto_scale - Whether to use same amount of RXQs for memif interface in containers as vswitch, otherwise use single RXQ. Type: boolean

Example:

| Initialize L2 Bridge Domain for multiple pipelines with memif pairs | 1 | 1 |


: FOR  ${nf_chain}  IN RANGE  1  ${nf_chains}+1
\    Initialize L2 Bridge Domain for pipeline with memif pairs  nf_chain=${nf_chain}  nf_nodes=${nf_nodes}  auto_scale=${auto_scale}
Set interfaces in path up
Show Memif on all DUTs  ${nodes}
VPP round robin RX placement on all DUTs  ${nodes}  prefix=memif

3.10.1.72. Initialize L2 Bridge Domain with memif pairs and VLAN in circular topology

Create pairs of Memif interfaces on all defined VPP nodes. Put each Memif interface to separate L2 bridge domain with one physical or virtual interface to create a chain accross DUT node. In case of 3-node topology create VLAN sub-interfaces between DUTs. In case of 2-node topology create VLAN sub-interface on dut1-if2 interface. All interfaces are brought up.

Arguments: - bd_id1 - Bridge domain ID. Type: integer - bd_id2 - Bridge domain ID. Type: integer - subid - ID of the sub-interface to be created. Type: string - tag_rewrite - Method of tag rewrite. Type: string

Example:

| Initialize L2 Bridge Domain with memif pairs and VLAN in circulartopology | 1 | 2 | 10 | pop-1 |


${dut2_status}  ${value}=  Run Keyword And Ignore Error  Variable Should Exist  ${dut2}
Set interfaces in path up
Run Keyword If  '${dut2_status}' == 'PASS'  Initialize VLAN dot1q sub-interfaces in circular topology  ${dut1}  ${dut1_if2}  ${dut2}  ${dut2_if1}  ${subid}  ELSE  Initialize VLAN dot1q sub-interfaces in circular topology  ${dut1}  ${dut1_if2}  SUB_ID=${subid}
Run Keyword If  '${dut2_status}' == 'PASS'  Configure L2 tag rewrite method on interfaces  ${dut1}  ${subif_index_1}  ${dut2}  ${subif_index_2}  ${tag_rewrite}  ELSE  Configure L2 tag rewrite method on interfaces  ${dut1}  ${subif_index_1}  TAG_REWRITE_METHOD=${tag_rewrite}
${number}=  Set Variable  ${1}
${sock1}=  Set Variable  memif-DUT1_CNF
${sock2}=  Set Variable  memif-DUT1_CNF
${memif_if1_name}=  Set Variable  DUT1-memif-${number}-if1
${memif_if2_name}=  Set Variable  DUT1-memif-${number}-if2
Set up memif interfaces on DUT node  ${dut1}  ${sock1}  ${sock2}  ${number}  ${memif_if1_name}  ${memif_if2_name}  ${rxq_count_int}  ${rxq_count_int}
Add interface to bridge domain  ${dut1}  ${dut1_if1}  ${bd_id1}
Add interface to bridge domain  ${dut1}  ${${memif_if1_name}}  ${bd_id1}
Add interface to bridge domain  ${dut1}  ${${memif_if2_name}}  ${bd_id2}
Add interface to bridge domain  ${dut1}  ${subif_index_1}  ${bd_id2}
${sock1}=  Run Keyword If  '${dut2_status}' == 'PASS'  Set Variable  memif-DUT2_CNF
${sock2}=  Run Keyword If  '${dut2_status}' == 'PASS'  Set Variable  memif-DUT2_CNF
${memif_if1_name}=  Run Keyword If  '${dut2_status}' == 'PASS'  Set Variable  DUT2-memif-${number}-if1
${memif_if2_name}=  Run Keyword If  '${dut2_status}' == 'PASS'  Set Variable  DUT2-memif-${number}-if2
Run Keyword If  '${dut2_status}' == 'PASS'  Set up memif interfaces on DUT node  ${dut2}  ${sock1}  ${sock2}  ${number}  ${memif_if1_name}  ${memif_if2_name}  ${rxq_count_int}  ${rxq_count_int}
Run Keyword If  '${dut2_status}' == 'PASS'  Add interface to bridge domain  ${dut2}  ${subif_index_2}  ${bd_id1}
Run Keyword If  '${dut2_status}' == 'PASS'  Add interface to bridge domain  ${dut2}  ${${memif_if1_name}}  ${bd_id1}
Run Keyword If  '${dut2_status}' == 'PASS'  Add interface to bridge domain  ${dut2}  ${${memif_if2_name}}  ${bd_id2}
Run Keyword If  '${dut2_status}' == 'PASS'  Add interface to bridge domain  ${dut2}  ${dut2_if2}  ${bd_id2}
Show Memif on all DUTs  ${nodes}
VPP round robin RX placement on all DUTs  ${nodes}  prefix=memif

3.10.1.73. Initialize IPv4 routing with memif pairs on DUT node

Create pairs of Memif interfaces on DUT node. Put each Memif interface to separate IPv4 VRF with one physical or virtual interface to create a chain accross DUT node.

Arguments: - dut - DUT node. Type: dictionary - count - Number of memif pairs (containers). Type: integer

Note: Socket paths for Memif are defined in following format: - /tmp/memif-${dut}_CNF${number}-${sid}

Example:

| Initialize IPv4 routing with memif pairs on DUT node | ${dut} | ${1} |


@{duts}=  Get Matches  ${nodes}  DUT*
${dut_index}=  Get Index From List  ${duts}  ${dut}
${duts_length}=  Get Length  ${duts}
${last_dut_index}=  Evaluate  ${duts_length} - ${1}
${tg_if1_net}=  Set Variable  10.10.10.0
${tg_if2_net}=  Set Variable  20.20.20.0
${fib_table_1}=  Set Variable  ${10}
Run Keyword If  ${fib_table_1} > ${0}  Add Fib Table  ${nodes['${dut}']}  ${fib_table_1}
${ip_base_if1}=  Evaluate  ${dut_index} + ${1}
${ip_net_if1}=  Set Variable  ${ip_base_if1}.${ip_base_if1}.${ip_base_if1}
Vpp Route Add  ${nodes['${dut}']}  ${tg_if1_net}  24  vrf=${fib_table_1}  gateway=${ip_net_if1}.1  interface=${${dut}_if1}  multipath=${TRUE}
Assign Interface To Fib Table  ${nodes['${dut}']}  ${${dut}_if1}  ${fib_table_1}
Configure IP addresses on interfaces  ${nodes['${dut}']}  ${${dut}_if1}  ${ip_net_if1}.2  30
${prev_node}=  Run Keyword If  ${dut_index} == ${0}  Set Variable  TG  ELSE  Get From List  ${duts}  ${dut_index-${1}}
${prev_if}=  Run Keyword If  ${dut_index} == ${0}  Set Variable  if1  ELSE  Set Variable  if2
${prev_if_mac}=  Get Interface MAC  ${nodes['${prev_node}']}  ${${prev_node}_${prev_if}}
Add ARP on DUT  ${nodes['${dut}']}  ${${dut}_if1}  ${ip_net_if1}.1  ${prev_if_mac}
${fib_table_2}=  Evaluate  ${fib_table_1} + ${count}
Add Fib Table  ${nodes['${dut}']}  ${fib_table_2}
${ip_base_if2}=  Evaluate  ${ip_base_if1} + ${1}
${ip_net_if2}=  Set Variable  ${ip_base_if2}.${ip_base_if2}.${ip_base_if2}
Vpp Route Add  ${nodes['${dut}']}  ${tg_if2_net}  24  vrf=${fib_table_2}  gateway=${ip_net_if2}.2  interface=${${dut}_if2}  multipath=${TRUE}
Assign Interface To Fib Table  ${nodes['${dut}']}  ${${dut}_if2}  ${fib_table_2}
Configure IP addresses on interfaces  ${nodes['${dut}']}  ${${dut}_if2}  ${ip_net_if2}.1  30
${next_node}=  Run Keyword If  ${dut_index} == ${last_dut_index}  Set Variable  TG  ELSE  Get From List  ${duts}  ${dut_index+${1}}
${next_if}=  Run Keyword If  ${dut_index} == ${last_dut_index}  Set Variable  if2  ELSE  Set Variable  if1
${next_if_mac}=  Get Interface MAC  ${nodes['${next_node}']}  ${${next_node}_${next_if}}
Add ARP on DUT  ${nodes['${dut}']}  ${${dut}_if2}  ${ip_net_if2}.2  ${next_if_mac}
${fib_table_1}=  Evaluate  ${fib_table_1} - ${1}
${ip_base_start}=  Set Variable  ${31}
: FOR  ${number}  IN RANGE  1  ${count+${1}}
\    ${sock1}=  Set Variable  memif-${dut}_CNF
\    ${sock2}=  Set Variable  memif-${dut}_CNF
\    Set up memif interfaces on DUT node  ${nodes['${dut}']}  ${sock1}  ${sock2}  ${number}  ${dut}-memif-${number}-if1  ${dut}-memif-${number}-if2  ${rxq_count_int}  ${rxq_count_int}
\    ${memif1}=  Set Variable  ${${dut}-memif-${number}-if1}
\    ${memif2}=  Set Variable  ${${dut}-memif-${number}-if2}
\    ${fib_table_1}=  Evaluate  ${fib_table_1} + ${1}
\    ${fib_table_2}=  Evaluate  ${fib_table_1} + ${1}
\    Run Keyword Unless  ${number} == ${count}  Add Fib Table  ${nodes['${dut}']}  ${fib_table_2}
\    Assign Interface To Fib Table  ${nodes['${dut}']}  ${memif1}  ${fib_table_1}
\    Assign Interface To Fib Table  ${nodes['${dut}']}  ${memif2}  ${fib_table_2}
\    ${ip_base_memif1}=  Evaluate  ${ip_base_start} + (${number} - ${1}) * ${2}
\    ${ip_base_memif2}=  Evaluate  ${ip_base_memif1} + ${1}
\    ${ip_net_memif1}=  Set Variable  ${ip_base_memif1}.${ip_base_memif1}.${ip_base_memif1}
\    ${ip_net_memif2}=  Set Variable  ${ip_base_memif2}.${ip_base_memif2}.${ip_base_memif2}
\    Configure IP addresses on interfaces  ${nodes['${dut}']}  ${memif1}  ${ip_net_memif1}.1  30  ${nodes['${dut}']}  ${memif2}  ${ip_net_memif2}.1  30
\    Vpp Route Add  ${nodes['${dut}']}  ${tg_if2_net}  24  vrf=${fib_table_1}  gateway=${ip_net_memif2}.1  interface=${memif1}
\    Vpp Route Add  ${nodes['${dut}']}  ${tg_if1_net}  24  vrf=${fib_table_2}  gateway=${ip_net_memif1}.1  interface=${memif2}
\    ${memif_if1_key}=  Get interface by sw index  ${nodes['${dut}']}  ${memif1}
\    ${memif_if1_mac}=  Get interface mac  ${nodes['${dut}']}  ${memif_if1_key}
\    ${memif_if2_key}=  Get interface by sw index  ${nodes['${dut}']}  ${memif2}
\    ${memif_if2_mac}=  Get interface mac  ${nodes['${dut}']}  ${memif_if2_key}
\    Add arp on dut  ${nodes['${dut}']}  ${memif1}  ${ip_net_memif2}.1  ${memif_if2_mac}
\    Add arp on dut  ${nodes['${dut}']}  ${memif2}  ${ip_net_memif1}.1  ${memif_if1_mac}

3.10.1.74. Initialize IPv4 routing with memif pairs

Create pairs of Memif interfaces on all defined VPP nodes. Put each Memif interface to separate IPv4 VRF with one physical or virtual interface to create a chain accross DUT node.

Arguments: - count - Number of memif pairs (containers). Type: integer

Example:

| Initialize IPv4 routing with memif pairs | ${1} |


${duts}=  Get Matches  ${nodes}  DUT*
: FOR  ${dut}  IN  @{duts}
\    Initialize IPv4 routing with memif pairs on DUT node  ${dut}  ${count}
Set interfaces in path up
Show Memif on all DUTs  ${nodes}
VPP round robin RX placement on all DUTs  ${nodes}  prefix=memif

3.10.1.75. Initialize L2 xconnect for single memif

Create single Memif interface on all defined VPP nodes. Cross connect Memif interface with one physical interface.

Arguments: - number - Memif ID. Type: integer

Note: Socket paths for Memif are defined in following format: - /tmp/memif-DUT1_CNF${number}-${sid}

KW uses test variable ${rxq_count_int} set by KW Add worker threads and rxqueues to all DUTs

Example:

| Initialize L2 xconnect for single memif | 1 |


${duts}=  Get Matches  ${nodes}  DUT*
: FOR  ${dut}  IN  @{duts}
\    ${sock}=  Set Variable  memif-${dut}_CNF
\    ${sid}=  Evaluate  (${number} * ${2}) - ${1}
\    Set up single memif interface on DUT node  ${nodes['${dut}']}  ${sock}  mid=${number}  sid=${sid}  memif_if=${dut}-memif-${number}-if1  rxq=${rxq_count_int}  txq=${rxq_count_int}
\    Configure L2XC  ${nodes['${dut}']}  ${${dut}_if1}  ${${dut}-memif-${number}-if1}
Set single interfaces in path up
Show Memif on all DUTs  ${nodes}
VPP round robin RX placement on all DUTs  ${nodes}  prefix=memif

3.10.1.76. Initialize L2 Bridge Domain for single memif

Create single Memif interface on all defined VPP nodes. Put Memif interface to separate L2 bridge domain with one physical interface.

Arguments: - number - Memif ID. Type: integer

Note: Socket paths for Memif are defined in following format: - /tmp/memif-DUT1_CNF${number}-${sid}

KW uses test variable ${rxq_count_int} set by KW Add worker threads and rxqueues to all DUTs

Example:

| Initialize L2 Bridge Domain for single memif | 1 |


${duts}=  Get Matches  ${nodes}  DUT*
: FOR  ${dut}  IN  @{duts}
\    ${sock}=  Set Variable  memif-${dut}_CNF
\    ${sid}=  Evaluate  (${number} * ${2}) - ${1}
\    Set up single memif interface on DUT node  ${nodes['${dut}']}  ${sock}  mid=${number}  sid=${sid}  memif_if=${dut}-memif-${number}-if1  rxq=${rxq_count_int}  txq=${rxq_count_int}
\    Add interface to bridge domain  ${nodes['${dut}']}  ${${dut}_if1}  ${number}
\    Add interface to bridge domain  ${nodes['${dut}']}  ${${dut}-memif-${number}-if1}  ${number}
Set single interfaces in path up
Show Memif on all DUTs  ${nodes}

3.10.1.77. Configure ACLs on a single interface

Configure ACL

Arguments: - dut - DUT node. Type: string - dut_if - DUT node interface name. Type: string - acl_apply_type - To what path apply the ACL - input or output. - acl_action - Action for the rule - deny, permit, permit+reflect. - subnets - Subnets to apply the specific ACL. Type: list

Example:

| Configure ACLs on a single interface | ${nodes[‘DUT1’]} | ... | GigabitEthernet0/7/0 | input | permit 0.0.0.0/0


Set Test variable  ${acl}  ${EMPTY}
: FOR  ${subnet}  IN  @{subnets}
\    ${acl} =  Run Keyword If  '${acl}' == '${EMPTY}'  Set Variable  ipv4 ${acl_action} src ${subnet}  ELSE  Catenate  SEPARATOR=,  ${acl}  ipv4 ${acl_action} src ${subnet}
Add Replace Acl Multi Entries  ${dut}  rules=${acl}
@{acl_list} =  Create List  ${0}
Set Acl List For Interface  ${dut}  ${dut_if}  ${acl_apply_type}  ${acl_list}

3.10.2. performance_setup suite

3.10.2.1. Set variables in 2-node circular topology with DUT interface model

Compute path for testing on two given nodes in circular topology based on interface model provided as an argument and set corresponding suite variables.

Arguments: - iface_model - Interface model. Type: string

_NOTE:_ This KW sets following suite variables: - tg - TG node - tg_if1 - 1st TG interface towards DUT. - tg_if1 - 1st TG interface MAC address. - tg_if2 - 2nd TG interface towards DUT. - tg_if2 - 2nd TG interface MAC address. - dut1 - DUT1 node - dut1_if1 - 1st DUT interface towards TG. - dut1_if2 - 2nd DUT interface towards TG.

Example:

| Set variables in 2-node circular topology with DUT interface model| Intel-X520-DA2 |


${iface_model_list}=  Create list  ${iface_model}
Append Node  ${nodes['TG']}
Append Node  ${nodes['DUT1']}  filter_list=${iface_model_list}
Append Node  ${nodes['TG']}
Compute Path  always_same_link=${FALSE}
${tg_if1}  ${tg}=  First Interface
${dut1_if1}  ${dut1}=  First Ingress Interface
${dut1_if2}  ${dut1}=  Last Egress Interface
${tg_if2}  ${tg}=  Last Interface
${tg_if1_mac}=  Get Interface MAC  ${tg}  ${tg_if1}
${tg_if2_mac}=  Get Interface MAC  ${tg}  ${tg_if2}
Set Suite Variable  ${tg}
Set Suite Variable  ${tg_if1}
Set Suite Variable  ${tg_if1_mac}
Set Suite Variable  ${tg_if2}
Set Suite Variable  ${tg_if2_mac}
Set Suite Variable  ${dut1}
Set Suite Variable  ${dut1_if1}
Set Suite Variable  ${dut1_if2}

3.10.2.2. Set variables in 3-node circular topology with DUT interface model

Compute path for testing on three given nodes in circular topology based on interface model provided as an argument and set corresponding suite variables.

Arguments: - iface_model - Interface model. Type: string

_NOTE:_ This KW sets following suite variables: - tg - TG node - tg_if1 - 1st TG interface towards DUT. - tg_if1 - 1st TG interface MAC address. - tg_if2 - 2nd TG interface towards DUT. - tg_if2 - 2nd TG interface MAC address. - dut1 - DUT1 node - dut1_if1 - DUT1 interface towards TG. - dut1_if2 - DUT1 interface towards DUT2. - dut2 - DUT2 node - dut2_if1 - DUT2 interface towards DUT1. - dut2_if2 - DUT2 interface towards TG.

Example:

| Set variables in 3-node circular topology with DUT interface model| Intel-X520-DA2 |


${iface_model_list}=  Create list  ${iface_model}
Append Node  ${nodes['TG']}
Append Node  ${nodes['DUT1']}  filter_list=${iface_model_list}
Append Node  ${nodes['DUT2']}  filter_list=${iface_model_list}
Append Node  ${nodes['TG']}
Compute Path
${tg_if1}  ${tg}=  Next Interface
${dut1_if1}  ${dut1}=  Next Interface
${dut1_if2}  ${dut1}=  Next Interface
${dut2_if1}  ${dut2}=  Next Interface
${dut2_if2}  ${dut2}=  Next Interface
${tg_if2}  ${tg}=  Next Interface
${tg_if1_mac}=  Get Interface MAC  ${tg}  ${tg_if1}
${tg_if2_mac}=  Get Interface MAC  ${tg}  ${tg_if2}
Set Suite Variable  ${tg}
Set Suite Variable  ${tg_if1}
Set Suite Variable  ${tg_if1_mac}
Set Suite Variable  ${tg_if2}
Set Suite Variable  ${tg_if2_mac}
Set Suite Variable  ${dut1}
Set Suite Variable  ${dut1_if1}
Set Suite Variable  ${dut1_if2}
Set Suite Variable  ${dut2}
Set Suite Variable  ${dut2_if1}
Set Suite Variable  ${dut2_if2}

3.10.2.4. Tear down guest VM with dpdk-testpmd

Stop all qemu processes with dpdk-testpmd running on ${dut_node}. Argument is dictionary of all qemu nodes running with its names. Dpdk-testpmd is stopped gracefully with printing stats.

Arguments: - dut_node - Node where to clean qemu. Type: dictionary - dut_vm_refs - VM references on node. Type: dictionary

Example:

| Tear down guest VM with dpdk-testpmd | ${node[‘DUT1’]} | ${dut_vm_refs} |


${vms_number}=  Get Length  ${dut_vm_refs}
${index}=  Set Variable  ${0}
: FOR  ${vm_name}  IN  @{dut_vm_refs}
\    ${vm}=  Get From Dictionary  ${dut_vm_refs}  ${vm_name}
\    ${index}=  Evaluate  ${index} + 1
\    Dpdk Testpmd Stop  ${vm}
\    Run Keyword  ${vm_name}.Qemu Set Node  ${dut_node}
\    Run Keyword  ${vm_name}.Qemu Clear Socks
\    Run Keyword If  '${index}' == '${vms_number}'  ${vm_name}.Qemu Kill All

3.10.2.5. Tear down guest VM

Stop all qemu processes running on ${dut_node}. Argument is dictionary of all qemu nodes running with its names.

Arguments: - dut_node - Node where to clean qemu. Type: dictionary - dut_vm_refs - VM references on node. Type: dictionary

Example:

| Tear down guest VM | ${node[‘DUT1’]} | ${dut_vm_refs} |


${vms_number}=  Get Length  ${dut_vm_refs}
${index}=  Set Variable  ${0}
: FOR  ${vm_name}  IN  @{dut_vm_refs}
\    ${vm}=  Get From Dictionary  ${dut_vm_refs}  ${vm_name}
\    ${index}=  Evaluate  ${index} + 1
\    Run Keyword  ${vm_name}.Qemu Set Node  ${dut_node}
\    Run Keyword  ${vm_name}.Qemu Clear Socks
\    Run Keyword If  '${index}' == '${vms_number}'  ${vm_name}.Qemu Kill All

3.10.2.6. Set up 2-node performance topology with DUT’s NIC model

Suite preparation phase that sets the default startup configuration of VPP on all DUTs. Updates interfaces on all nodes and sets the global variables used in test cases based on interface model provided as an argument. Initializes traffic generator.

Arguments: - topology_type - Topology type. Type: string - nic_model - Interface model. Type: string

Example:

| 2-node Performance Suite Setup | L2 | Intel-X520-DA2 |


Set variables in 2-node circular topology with DUT interface model  ${nic_model}
Initialize traffic generator  ${tg}  ${tg_if1}  ${tg_if2}  ${dut1}  ${dut1_if1}  ${dut1}  ${dut1_if2}  ${topology_type}

3.10.2.7. Set up 2-node-switched performance topology with DUT’s NIC model

Suite preparation phase that sets the default startup configuration of VPP on all DUTs. Updates interfaces on all nodes and sets the global variables used in test cases based on interface model provided as an argument. Initializes traffic generator.

Arguments: - topology_type - Topology type. Type: string - nic_model - Interface model. Type: string - tg_if1_dest_mac - Interface 1 destination MAC address. Type: string - tg_if2_dest_mac - Interface 2 destination MAC address. Type: string

Example:

| 2-node Performance Suite Setup | L2 | Intel-X520-DA2 | 22:22:33:44:55:66 | 22:22:33:44:55:55 |


Set variables in 2-node circular topology with DUT interface model  ${nic_model}
Initialize traffic generator  ${tg}  ${tg_if1}  ${tg_if2}  ${dut1}  ${dut1_if1}  ${dut1}  ${dut1_if2}  ${topology_type}  ${tg_if1_dest_mac}  ${tg_if2_dest_mac}

3.10.2.8. Set up 3-node performance topology with DUT’s NIC model

Suite preparation phase that sets the default startup configuration of VPP on all DUTs. Updates interfaces on all nodes and sets the global variables used in test cases based on interface model provided as an argument. Initializes traffic generator.

Arguments: - topology_type - Topology type. Type: string - nic_model - Interface model. Type: string

Example:

| Set up 3-node performance topology with DUT’s NIC model | L2 | Intel-X520-DA2 |


Set variables in 3-node circular topology with DUT interface model  ${nic_model}
Initialize traffic generator  ${tg}  ${tg_if1}  ${tg_if2}  ${dut1}  ${dut1_if1}  ${dut2}  ${dut2_if2}  ${topology_type}

3.10.2.10. Set up DPDK 2-node performance topology with DUT’s NIC model

Updates interfaces on all nodes and sets the global variables used in test cases based on interface model provided as an argument. Initializes traffic generator. Initializes DPDK test environment.

Arguments: - topology_type - Topology type. Type: string - nic_model - Interface model. Type: string

Example:

| Set up DPDK 2-node performance topology with DUT’s NIC model | L2 | Intel-X520-DA2 |


Set variables in 2-node circular topology with DUT interface model  ${nic_model}
Initialize traffic generator  ${tg}  ${tg_if1}  ${tg_if2}  ${dut1}  ${dut1_if1}  ${dut1}  ${dut1_if2}  ${topology_type}
Initialize DPDK Environment  ${dut1}  ${dut1_if1}  ${dut1_if2}

3.10.2.11. Set up DPDK 3-node performance topology with DUT’s NIC model

Updates interfaces on all nodes and sets the global variables used in test cases based on interface model provided as an argument. Initializes traffic generator. Initializes DPDK test environment.

Arguments: - topology_type - Topology type. Type: string - nic_model - Interface model. Type: string

Example:

| 3-node Performance Suite Setup | L2 | Intel-X520-DA2 |


Set variables in 3-node circular topology with DUT interface model  ${nic_model}
Initialize traffic generator  ${tg}  ${tg_if1}  ${tg_if2}  ${dut1}  ${dut1_if1}  ${dut2}  ${dut2_if2}  ${topology_type}
Initialize DPDK Environment  ${dut1}  ${dut1_if1}  ${dut1_if2}
Initialize DPDK Environment  ${dut2}  ${dut2_if1}  ${dut2_if2}

3.10.2.12. Set up SRIOV 2-node performance topology with DUT’s NIC model

Suite preparation phase that sets default startup configuration of VPP on all DUTs. Updates interfaces on all nodes and sets global variables used in test cases based on interface model provided as an argument. Initializes traffic generator. It configures PCI device with VFs on all DUTs.

Arguments: - topology_type - Topology type. Type: string - nic_model - Interface model. Type: string - vf_driver - Virtual function driver. Type: string - numvfs - Number of VFs. Type: integer

Example:

| Set up SRIOV 2-node performance topology with DUT’s NIC model | L2 | Intel-X520-DA2 | AVF |


Set variables in 2-node circular topology with DUT interface model  ${nic_model}
Run Keyword If  '${vf_driver}' == 'AVF'  Configure AVF interfaces on all DUTs  numvfs=${numvfs}  topology_type=${topology_type}
Initialize traffic generator  ${tg}  ${tg_if1}  ${tg_if2}  ${dut1}  ${dut1_if1_vf0}  ${dut1}  ${dut1_if2_vf0}  ${topology_type}

3.10.2.13. Set up SRIOV 3-node performance topology with DUT’s NIC model

Suite preparation phase that sets default startup configuration of VPP on all DUTs. Updates interfaces on all nodes and sets global variables used in test cases based on interface model provided as an argument. Initializes traffic generator. It configures PCI device with VFs on all DUTs.

Arguments: - topology_type - Topology type. Type: string - nic_model - Interface model. Type: string - vf_driver - Virtual function driver. Type: string - numvfs - Number of VFs. Type: integer

Example:

| Set up SRIOV 3-node performance topology with DUT’s NIC model | L2 | Intel-X520-DA2 | AVF |


Set variables in 3-node circular topology with DUT interface model  ${nic_model}
Run Keyword If  '${vf_driver}' == 'AVF'  Configure AVF interfaces on all DUTs  numvfs=${numvfs}  topology_type=${topology_type}
Initialize traffic generator  ${tg}  ${tg_if1}  ${tg_if2}  ${dut1}  ${dut1_if1_vf0}  ${dut2}  ${dut2_if2_vf0}  ${topology_type}

3.10.2.14. Set up IPSec performance test suite

Suite preparation phase that sets default startup configuration of VPP on all DUTs. Updates interfaces on all nodes and sets global variables used in test cases based on interface model provided as an argument. Initializes traffic generator. Then it configures crypto device and kernel module on all DUTs.

Arguments: - topology_type - Topology type. Type: string - nic_model - Interface model. Type: string - crypto_type - Crypto device type - HW_cryptodev or SW_cryptodev (Optional). Type: string, default value: HW_cryptodev

Example:

| Set up IPSec performance test suite | L2 | Intel-X520-DA2 |


Set up 3-node performance topology with DUT's NIC model  ${topology_type}  ${nic_model}
${numvfs}=  Set Variable If  '${crypto_type}' == 'HW_cryptodev'  ${32}  '${crypto_type}' == 'SW_cryptodev'  ${0}
Configure crypto device on all DUTs  force_init=${True}  numvfs=${numvfs}
Run Keyword If  '${crypto_type}' == 'HW_cryptodev'  Configure kernel module on all DUTs  vfio_pci  force_load=${True}

3.10.2.15. Set up performance test suite with MEMIF

Append memif_plugin.so to the list of enabled plugins.


Set Suite Variable  @{plugins_to_enable}
Append To List  ${plugins_to_enable}  memif_plugin.so

3.10.2.16. Set up performance test suite with NAT

Append nat_plugin.so to the list of enabled plugins.


Set Suite Variable  @{plugins_to_enable}
Append To List  ${plugins_to_enable}  nat_plugin.so

3.10.2.17. Set up performance test suite with ACL

Append acl_plugin.so to the list of enabled plugins.


Set Suite Variable  @{plugins_to_enable}
Append To List  ${plugins_to_enable}  acl_plugin.so

3.10.2.18. Set up performance test suite with AVF driver

Append avf_plugin.so to the list of enabled plugins.


Set Suite Variable  @{plugins_to_enable}
Append To List  ${plugins_to_enable}  avf_plugin.so

3.10.2.19. Set up performance test suite with Static SRv6 proxy

Append srv6as_plugin.so to the list of enabled plugins.


Set Suite Variable  @{plugins_to_enable}
Append To List  ${plugins_to_enable}  srv6as_plugin.so

3.10.2.20. Set up performance test suite with Dynamic SRv6 proxy

Append srv6ad_plugin.so to the list of enabled plugins.


Set Suite Variable  @{plugins_to_enable}
Append To List  ${plugins_to_enable}  srv6ad_plugin.so

3.10.2.21. Set up performance test suite with Masquerading SRv6 proxy

Append srv6am_plugin.so to the list of enabled plugins.


Set Suite Variable  @{plugins_to_enable}
Append To List  ${plugins_to_enable}  srv6am_plugin.so

3.10.2.23. Set up 3-node performance topology with wrk and DUT’s NIC model

Suite preparation phase that sets the default startup configuration of VPP on all DUTs. Updates interfaces on all nodes and sets the global variables used in test cases based on interface model provided as an argument. Installs the traffic generator.

Arguments: - iface_model - Interface model. Type: string

Example:

| Set up 3-node performance topology with wrk and DUT’s NIC model| Intel-X520-DA2 |


Set variables in 3-node circular topology with DUT interface model  ${iface_model}
Iface update numa node  ${tg}
${running}=  Is TRex running  ${tg}
Run keyword if  ${running}==${True}  Teardown traffic generator  ${tg}
${curr_driver}=  Get PCI dev driver  ${tg}  ${tg['interfaces']['${tg_if1}']['pci_address']}
Run keyword if  '${curr_driver}'!='${None}'  PCI Driver Unbind  ${tg}  ${tg['interfaces']['${tg_if1}']['pci_address']}
${driver}=  Get Variable Value  ${tg['interfaces']['${tg_if1}']['driver']}
PCI Driver Bind  ${tg}  ${tg['interfaces']['${tg_if1}']['pci_address']}  ${driver}
${intf_name}=  Get Linux interface name  ${tg}  ${tg['interfaces']['${tg_if1}']['pci_address']}
Set Linux interface IP  ${tg}  ${intf_name}  192.168.10.1  24
Set Linux interface IP  ${tg}  ${intf_name}  192.168.20.1  24
Set Linux interface IP  ${tg}  ${intf_name}  192.168.30.1  24
Set Linux interface IP  ${tg}  ${intf_name}  192.168.40.1  24
Set Linux interface IP  ${tg}  ${intf_name}  192.168.50.1  24
Set Linux interface IP  ${tg}  ${intf_name}  192.168.60.1  24
Set Linux interface IP  ${tg}  ${intf_name}  192.168.70.1  24
Set Linux interface IP  ${tg}  ${intf_name}  192.168.80.1  24
Set Linux interface up  ${tg}  ${intf_name}
Install wrk  ${tg}

3.10.2.24. Tear down 2-node performance topology

Suite teardown phase with traffic generator teardown.


Teardown traffic generator  ${tg}

3.10.2.25. Tear down 3-node performance topology

Suite teardown phase with traffic generator teardown.


Teardown traffic generator  ${tg}

3.10.2.26. Set up performance test

Common test setup for performance tests.


Reset VAT History On All DUTs  ${nodes}
Create base startup configuration of VPP on all DUTs

3.10.2.27. Set up tcp performance test

Common test setup for TCP performance tests.


Reset VAT History On All DUTs  ${nodes}
Create base startup configuration of VPP for TCP tests on all DUTs

3.10.2.28. Set up performance test with Ligato Kubernetes

Common test setup for performance tests with Ligato Kubernetes.


Apply Kubernetes resource on all duts  ${nodes}  namespaces/csit.yaml
Apply Kubernetes resource on all duts  ${nodes}  pods/kafka.yaml
Apply Kubernetes resource on all duts  ${nodes}  pods/etcdv3.yaml
Apply Kubernetes resource on all duts  ${nodes}  configmaps/vswitch-agent-cfg.yaml
Apply Kubernetes resource on all duts  ${nodes}  configmaps/vnf-agent-cfg.yaml
Apply Kubernetes resource on all duts  ${nodes}  pods/contiv-sfc-controller.yaml
Apply Kubernetes resource on all duts  ${nodes}  pods/contiv-vswitch.yaml

3.10.2.29. Set up performance test with containers

Common test setup for performance tests with containers

Arguments: - chains: Total number of chains. Type: integer - nodeness: Total number of nodes per chain. Type: integer - auto_scale - If True, use same amount of Dataplane threads for network function as DUT, otherwise use single physical core for every network function. Type: boolean

Example:

| Set up performance test with containers | 1 | 1 |


Set Test Variable  @{container_groups}  @{EMPTY}
Set Test Variable  ${container_group}  CNF
Set Test Variable  ${nf_nodes}
Import Library  resources.libraries.python.ContainerUtils.ContainerManager  engine=${container_engine}  WITH NAME  ${container_group}
Construct chains of containers on all DUTs  ${nf_chains}  ${nf_nodes}  auto_scale=${auto_scale}
Acquire all '${container_group}' containers
Create all '${container_group}' containers
Configure VPP in all '${container_group}' containers
Stop VPP service on all DUTs  ${nodes}
Start VPP in all '${container_group}' containers
Start VPP service on all DUTs  ${nodes}
Append To List  ${container_groups}  ${container_group}

3.10.2.30. Tear down performance discovery test

Common test teardown for ndrdisc and pdrdisc performance tests.

Arguments: - rate - Rate for sending packets. Type: string - framesize - L2 Frame Size [B]. Type: integer - topology_type - Topology type. Type: string

Example:

| Tear down performance discovery test | 4.0mpps | 64 | 3-node-IPv4 |


Remove All Added Ports On All DUTs From Topology  ${nodes}
Show VAT History On All DUTs  ${nodes}
Run Keyword If Test Failed  Set Test Variable  ${pkt_trace}  ${True}
Run Keyword If Test Failed  Traffic should pass with no loss  ${perf_trial_duration}  ${rate}  ${framesize}  ${topology_type}  fail_on_loss=${False}

3.10.2.31. Tear down performance mrr test

Common test teardown for max-received-rate performance tests.


Remove All Added Ports On All DUTs From Topology  ${nodes}
Show VAT History On All DUTs  ${nodes}

3.10.2.32. Tear down performance test with wrk

Common test teardown for ndrdisc and pdrdisc performance tests.

Example:

| Tear down performance test with wrk |


Remove All Added Ports On All DUTs From Topology  ${nodes}
Show VAT History On All DUTs  ${nodes}
Show statistics on all DUTs  ${nodes}

3.10.2.33. Tear down performance test with container

Common test teardown for performance tests which uses containers.


: FOR  ${container_group}  IN  @{container_groups}
\    Destroy all '${container_group}' containers

3.10.2.34. Tear down performance test with vhost and VM with dpdk-testpmd

Common test teardown for performance tests which use vhost(s) and VM(s) with dpdk-testpmd.

Arguments: - rate - Rate for sending packets. Type: string - framesize - L2 Frame Size [B]. Type: integer - topology_type - Topology type. Type: string - dut1_node - Node where to clean qemu. Type: dictionary - dut1_vm_refs - VM references on node. Type: dictionary - dut2_node - Node where to clean qemu. Type: dictionary - dut2_vm_refs - VM references on node. Type: dictionary

Example:

| Tear down performance test with vhost and VM with dpdk-testpmd | 4.0mpps | 64 | 3-node-IPv4 | ${node[‘DUT1’]} | ${dut_vm_refs} | ${node[‘DUT2’]} | ${dut_vm_refs} |


Remove All Added Ports On All DUTs From Topology  ${nodes}
Show VAT History On All DUTs  ${nodes}
Show VPP vhost on all DUTs  ${nodes}
Show statistics on all DUTs  ${nodes}
Run Keyword If Test Failed  Traffic should pass with no loss  ${perf_trial_duration}  ${rate}  ${framesize}  ${topology_type}  fail_on_loss=${False}
Run keyword unless  ${dut1_node}==${None}  Tear down guest VM with dpdk-testpmd  ${dut1}  ${dut1_vm_refs}
Run keyword unless  ${dut2_node}==${None}  Tear down guest VM with dpdk-testpmd  ${dut2}  ${dut2_vm_refs}

3.10.2.35. Tear down mrr test with vhost and VM with dpdk-testpmd

Common test teardown for mrr tests which use vhost(s) and VM(s) with dpdk-testpmd.

Arguments: - dut1_node - Node where to clean qemu. Type: dictionary - dut1_vm_refs - VM references on node. Type: dictionary - dut2_node - Node where to clean qemu. Type: dictionary - dut2_vm_refs - VM references on node. Type: dictionary

Example:

| Tear down performance test with vhost and VM with dpdk-testpmd | ${node[‘DUT1’]} | ${dut_vm_refs} | ${node[‘DUT2’]} | ${dut_vm_refs} |


Remove All Added Ports On All DUTs From Topology  ${nodes}
Show VAT History On All DUTs  ${nodes}
Show VPP vhost on all DUTs  ${nodes}
Show statistics on all DUTs  ${nodes}
Run keyword unless  ${dut1_node}==${None}  Tear down guest VM with dpdk-testpmd  ${dut1}  ${dut1_vm_refs}
Run keyword unless  ${dut2_node}==${None}  Tear down guest VM with dpdk-testpmd  ${dut2}  ${dut2_vm_refs}

3.10.2.36. Tear down performance test with vhost and VM with dpdk-testpmd and ACL

Common test teardown for performance tests which use vhost(s) and VM(s) with ACL and dpdk-testpmd.

Arguments: - rate - Rate for sending packets. Type: string - framesize - L2 Frame Size [B]. Type: integer - topology_type - Topology type. Type: string - dut1_node - Node where to clean qemu. Type: dictionary - dut1_vm_refs - VM references on node. Type: dictionary - dut2_node - Node where to clean qemu. Type: dictionary - dut2_vm_refs - VM references on node. Type: dictionary


Tear down performance test with vhost and VM with dpdk-testpmd  ${rate}  ${framesize}  ${topology_type}  ${dut1_node}  ${dut1_vm_refs}  ${dut2_node}  ${dut2_vm_refs}
Run Keyword If Test Failed  Vpp Log Plugin Acl Settings  ${dut1}
Run Keyword If Test Failed  Run Keyword And Ignore Error  Vpp Log Plugin Acl Interface Assignment  ${dut1}

3.10.2.37. Tear down mrr test with vhost and VM with dpdk-testpmd and ACL

Common test teardown for mrr tests which use vhost(s) and VM(s) with ACL and dpdk-testpmd.

Arguments: - dut1_node - Node where to clean qemu. Type: dictionary - dut1_vm_refs - VM references on node. Type: dictionary - dut2_node - Node where to clean qemu. Type: dictionary - dut2_vm_refs - VM references on node. Type: dictionary


Tear down mrr test with vhost and VM with dpdk-testpmd  ${dut1_node}  ${dut1_vm_refs}  ${dut2_node}  ${dut2_vm_refs}
Run Keyword If Test Failed  Vpp Log Plugin Acl Settings  ${dut1}
Run Keyword If Test Failed  Run Keyword And Ignore Error  Vpp Log Plugin Acl Interface Assignment  ${dut1}

3.10.2.38. Tear down performance pdrchk test with vhost and VM with dpdk-testpmd

Common test teardown for performance pdrchk tests which use vhost(s) and VM(s) with dpdk-testpmd.

Arguments: - rate - Rate for sending packets. Type: string - framesize - L2 Frame Size [B]. Type: integer - topology_type - Topology type. Type: string - dut1_node - Node where to clean qemu. Type: dictionary - dut1_vm_refs - VM references on node. Type: dictionary - dut2_node - Node where to clean qemu. Type: dictionary - dut2_vm_refs - VM references on node. Type: dictionary

Example:

| Tear down performance pdrchk test with vhost and VM with dpdk-testpmd | 4.0mpps | 64 | 3-node-IPv4 | ${node[‘DUT1’]} | ${dut_vm_refs} | ${node[‘DUT2’]} | ${dut_vm_refs} |


Remove All Added Ports On All DUTs From Topology  ${nodes}
Show VAT History On All DUTs  ${nodes}
Show VPP vhost on all DUTs  ${nodes}
Show statistics on all DUTs  ${nodes}
Run keyword unless  ${dut1_node}==${None}  Tear down guest VM with dpdk-testpmd  ${dut1}  ${dut1_vm_refs}
Run keyword unless  ${dut2_node}==${None}  Tear down guest VM with dpdk-testpmd  ${dut2}  ${dut2_vm_refs}

3.10.2.39. Tear down performance mrr test with vhost and VM with dpdk-testpmd

Common test teardown for performance mrr tests which use vhost(s) and VM(s) with dpdk-testpmd.

Arguments: - dut1_node - Node where to clean qemu. Type: dictionary - dut1_vm_refs - VM references on node. Type: dictionary - dut2_node - Node where to clean qemu. Type: dictionary - dut2_vm_refs - VM references on node. Type: dictionary

Example:

| Tear down performance mrr test with vhost and VM with dpdk-testpmd | ${node[‘DUT1’]} | ${dut_vm_refs} | ${node[‘DUT2’]} | ${dut_vm_refs} |


Remove All Added Ports On All DUTs From Topology  ${nodes}
Show VAT History On All DUTs  ${nodes}
Show VPP vhost on all DUTs  ${nodes}
Run keyword unless  ${dut1_node}==${None}  Tear down guest VM with dpdk-testpmd  ${dut1}  ${dut1_vm_refs}
Run keyword unless  ${dut2_node}==${None}  Tear down guest VM with dpdk-testpmd  ${dut2}  ${dut2_vm_refs}

3.10.2.40. Tear down DPDK 2-node performance topology

Suite teardown phase with traffic generator teardown. Cleanup DPDK test environment.


Teardown traffic generator  ${tg}
Cleanup DPDK Environment  ${dut1}  ${dut1_if1}  ${dut1_if2}

3.10.2.41. Tear down DPDK 3-node performance topology

Suite teardown phase with traffic generator teardown. Cleanup DPDK test environment.


Teardown traffic generator  ${tg}
Cleanup DPDK Environment  ${dut1}  ${dut1_if1}  ${dut1_if2}
Cleanup DPDK Environment  ${dut2}  ${dut2_if1}  ${dut2_if2}

3.10.2.42. Tear down performance discovery test with NAT

Common test teardown for ndrdisc and pdrdisc performance tests with NAT feature used.

Arguments: - rate - Rate for sending packets. Type: string - framesize - L2 Frame Size [B]. Type: integer - traffic_profile - Traffic profile. Type: string

Example:

| Tear down performance discovery test with NAT | 100000pps | 64 | ${traffic_profile} |


Tear down performance discovery test  ${rate}  ${framesize}  ${traffic_profile}
Show NAT verbose  ${dut1}
Show NAT verbose  ${dut2}

3.10.2.43. Tear down mrr test with NAT

Common test teardown for mrr performance tests with NAT feature used.

| Tear down mrr test with NAT |


Tear down performance mrr test
Show NAT verbose  ${dut1}
Show NAT verbose  ${dut2}

3.10.2.44. Tear down performance test with ACL

Common test teardown for ndrdisc and pdrdisc performance tests with ACL feature used.

Arguments: - rate - Rate for sending packets. Type: string - framesize - L2 Frame Size [B]. Type: integer - traffic_profile - Traffic profile. Type: string

Example:

| Tear down performance test with ACL | 100000pps | 64 | ${traffic_profile} |


Tear down performance discovery test  ${rate}  ${framesize}  ${traffic_profile}
Run Keyword If Test Failed  Vpp Log Plugin Acl Settings  ${dut1}
Run Keyword If Test Failed  Run Keyword And Ignore Error  Vpp Log Plugin Acl Interface Assignment  ${dut1}

3.10.2.45. Tear down mrr test with ACL

Common test teardown for mrr performance tests with ACL feature used.

Example:

| Tear down mrr test with ACL |


Tear down performance mrr test
Run Keyword If Test Failed  Vpp Log Plugin Acl Settings  ${dut1}
Run Keyword If Test Failed  Run Keyword And Ignore Error  Vpp Log Plugin Acl Interface Assignment  ${dut1}

3.10.2.46. Tear down performance test with MACIP ACL

Common test teardown for ndrdisc and pdrdisc performance tests with MACIP ACL feature used.

Arguments: - rate - Rate for sending packets. Type: string - framesize - L2 Frame Size [B]. Type: integer - traffic_profile - Traffic profile. Type: string

Example:

| Tear down performance test with MACIP ACL | 100000pps | 64 | ${traffic_profile} |


Tear down performance discovery test  ${rate}  ${framesize}  ${traffic_profile}
Run Keyword If Test Failed  Run Keyword And Ignore Error  Vpp Log Macip Acl Settings  ${dut1}
Run Keyword And Ignore Error  Vpp Log Macip Acl Interface Assignment  ${dut1}

3.10.2.47. Tear down mrr test with MACIP ACL

Common test teardown for mrr performance tests with MACIP ACL feature used.

Example:

| Tear down mrr test with MACIP ACL |


Tear down performance mrr test
Run Keyword If Test Failed  Run Keyword And Ignore Error  Vpp Log Macip Acl Settings  ${dut1}
Run Keyword And Ignore Error  Vpp Log Macip Acl Interface Assignment  ${dut1}

3.10.2.48. Tear down performance test with Ligato Kubernetes

Common test teardown for ndrdisc and pdrdisc performance tests with Ligato Kubernetes.


Run Keyword If Test Failed  Get Kubernetes logs on all DUTs  ${nodes}  csit
Run Keyword If Test Failed  Describe Kubernetes resource on all DUTs  ${nodes}  csit
Delete Kubernetes resource on all DUTs  ${nodes}  csit

3.10.2.49. Tear down performance test with SRv6 with encapsulation

Common test teardown for ndrdisc and pdrdisc performance tests with SRv6 with encapsulation feature used.

Arguments: - rate - Rate for sending packets. Type: string - framesize - L2 Frame Size [B]. Type: integer/string - traffic_profile - Traffic profile. Type: string

Example:

| Tear down performance test with SRv6 with encapsulation | 100000pps | 64 | ${traffic_profile} |


Tear down performance discovery test  ${rate}  ${framesize}  ${traffic_profile}
Run Keyword If Test Failed  Show SR Policies on all DUTs  ${nodes}
Run Keyword If Test Failed  Show SR Steering Policies on all DUTs  ${nodes}
Run Keyword If Test Failed  Show SR LocalSIDs on all DUTs  ${nodes}

3.10.2.50. Tear down mrr test with SRv6 with encapsulation

Common test teardown for mrr tests with SRv6 with encapsulation feature used.

Example:

| Tear down mrr test with SRv6 with encapsulation |


Remove All Added Ports On All DUTs From Topology  ${nodes}
Show VAT History On All DUTs  ${nodes}
Run Keyword If Test Failed  Show SR Policies on all DUTs  ${nodes}
Run Keyword If Test Failed  Show SR Steering Policies on all DUTs  ${nodes}
Run Keyword If Test Failed  Show SR LocalSIDs on all DUTs  ${nodes}

3.10.3. performance_utils suite

3.10.3.1. Get Max Rate And Jumbo

Argument framesize can be either integer in case of a single packet in stream, or IMIX string defining mix of packets. For jumbo frames detection, the maximal packet size is relevant. For maximal transmit rate, the average packet size is relevant. In both cases, encapsulation overhead (if any) has effect. The maximal rate is computed from line limit bandwidth, but NICs also have an independent limit in packet rate. For some NICs, the limit is not reachable (bps limit is stricter), in those cases None is used (meaning no limiting).

This keyword returns computed maximal unidirectional transmit rate and jumbo boolean (some suites need that).

Arguments: - bps_limit - Line rate limit in bps. Type: integer - framesize - Framesize in bytes or IMIX. Type: integer or string - overhead - Overhead in bytes. Default: 0. Type: integer - pps_limit - NIC limit rate value in pps. Type: integer or None

Returns: - 2-tuple, consisting of: - Calculated unidirectional maximal transmit rate. Type: integer or float - Jumbo boolean, true if jumbo packet support has to be enabled. Type: boolean

Example:

| Get Max Rate And Jumbo ${10000000} | IMIX_v4_1 | overhead=${40} | pps_limit=${18750000} |


${avg_size} =  Set Variable If  '${framesize}' == 'IMIX_v4_1'  ${353.83333}  ${framesize}
${max_size} =  Set Variable If  '${framesize}' == 'IMIX_v4_1'  ${1518}  ${framesize}
${avg_swo} =  Evaluate  ${avg_size} + ${overhead}
${max_swo} =  Evaluate  ${max_size} + ${overhead}
${jumbo} =  Set Variable If  ${max_swo} < 1522  ${False}  ${True}
${limit_set} =  Set Variable  ${pps_limit != None}
${rate} =  Evaluate  (${bps_limit}/((${avg_swo}+20)*8)).__trunc__()
${max_rate} =  Set Variable If  ${limit_set} and ${rate} > ${pps_limit}  ${pps_limit}  ${rate}
Return From Keyword  ${max_rate}  ${jumbo}

3.10.3.2. Get Max Rate And Jumbo And Handle Multi Seg

This keyword adds correct multi seg configuration, then returns the result of Get Max Rate And Jumbo keyword.

See Documentation of Get Max Rate And Jumbo for more details.

Arguments: - bps_limit - Line rate limit in bps. Type: integer - framesize - Framesize in bytes. Type: integer or string - overhead - Overhead in bytes. Default: 0. Type: integer - pps_limit - NIC limit rate value in pps. Type: integer or None

Returns: - 2-tuple, consisting of: - Calculated unidirectional maximal transmit rate. Type: integer or float - Jumbo boolean, true if jumbo packet support has to be enabled. Type: boolean

Example:

| Get Max Rate And Jumbo And Handle Multi Seg ${10000000} | IMIX_v4_1 | overhead=${40} | pps_limit=${18750000} |


${max_rate}  ${jumbo} =  Get Max Rate And Jumbo  ${bps_limit}  ${framesize}  ${overhead}  ${pps_limit}
Run Keyword If  not ${jumbo}  Add no multi seg to all DUTs
Return From Keyword  ${max_rate}  ${jumbo}

3.10.3.3. Calculate pps

Calculate pps for given rate and L2 frame size, additional 20B are added to L2 frame size as padding.

FIXME: Migrate callers to Get Max Rate And Jumbo

Arguments - bps - Rate in bps. Type: integer - framesize - L2 frame size in Bytes. Type: integer

Return - Calculated pps. Type: integer

Example:

| Calculate pps | 10000000000 | 64 |


${framesize}=  Get Frame Size  ${framesize}
${ret}=  Evaluate  (${bps}/((${framesize}+20)*8)).__trunc__()
Return From Keyword  ${ret}

3.10.3.4. Get Frame Size

Framesize can be either integer in case of a single packet in stream, or set of packets in case of IMIX type or simmilar. This keyword returns average framesize.

FIXME: Migrate callers to Get Max Rate And Jumbo

Arguments: - framesize - Framesize. Type: integer or string

Example:

| Get Frame Size | IMIX_v4_1 |


Return From Keyword If  '${framesize}' == 'IMIX_v4_1'  ${353.83333}
Return From Keyword  ${framesize}

3.10.3.6. Find critical load using PLRsearch

Find boundaries for troughput (of given target loss ratio) using PLRsearch algorithm. Display results as formatted test message. Fail if computed lower bound is below minimal rate. Input rates are understood as uni-directional, reported result contains bi-directional rates. TODO: Any additional measurements for debug purposes?

Arguments: - frame_size - L2 Frame Size [B] or IMIX string. Type: int or str - topology_type - Topology type. Type: string - minimum_transmit_rate - Lower limit of search [pps]. Type: float - maximum_transmit_rate - Upper limit of search [pps]. Type: float - packet_loss_ratio - Accepted loss during search. Type: float - timeout - Stop when search duration is longer [s]. Type: float

Example:

| Find critical load usingPLR search | ${64} | 3-node-IPv4 | ${100000} | ${14880952} | ${1e-7} | ${1800}


${min_rate} =  Set Variable  ${minimum_transmit_rate*2}
${average}  ${stdev} =  Perform soak search  ${frame_size}  ${topology_type}  ${min_rate}  ${maximum_transmit_rate*2}  ${packet_loss_ratio}  timeout=${timeout}
${lower}  ${upper} =  Display result of soak search  ${average}  ${stdev}  ${frame_size}
Should Not Be True  ${lower} < ${min_rate}  Lower bound ${lower} is below bidirectional minimum ${min_rate}.

3.10.3.7. Display single bound

Display one bound of NDR+PDR search, in packet per seconds (total and per stream) and Gbps total bandwidth with untagged packet. Througput is calculated as: Measured rate per stream * Total number of streams Bandwidth is calculated as: (Throughput * (L2 Frame Size + IPG) * 8) / Max bitrate of NIC The given result should contain latency data as well.

Arguments: - text - Flavor text describing which bound is this. Type: string - rate_total - Total (not per stream) measured Tr [pps]. Type: float - framesize - L2 Frame Size [B]. Type: integer - latency - Latency data to display if non-empty. Type: string

Example:

| Display single bound | NDR lower bound | ${12345.67} | ${64} | show_latency=${EMPTY} |


${bandwidth_total} =  Evaluate  ${rate_total} * (${framesize}+20)*8 / 1e9
Set Test Message  ${\n}${text}: ${rate_total} pps,  append=yes
Set Test Message  ${bandwidth_total} Gbps (untagged)  append=yes
Return From Keyword If  not """${latency}"""
Set Test Message  ${\n}LATENCY usec [min/avg/max] per stream: ${latency}  append=yes

3.10.3.10. Check NDRPDR interval validity

Extract loss ratio of lower bound of the interval. Fail if it does not reach the allowed value.

Arguments: - interval - Measured interval. Type: ReceiveRateInterval - packet_loss_ratio - Accepted loss (0.0 for NDR). Type: float

Example:

| Check NDRPDR interval validity | ${result.pdr_interval} | ${0.005} |


${lower_bound} =  Set Variable  ${interval.measured_low}
${lower_bound_lf} =  Set Variable  ${lower_bound.loss_fraction}
Return From Keyword If  ${lower_bound_lf} <= ${packet_loss_ratio}
${message}=  Catenate  SEPARATOR=${SPACE}  Minimal rate loss fraction ${lower_bound_lf}  does not reach target ${packet_loss_ratio}.
${message_zero} =  Set Variable  Zero packets forwarded!
${message_other} =  Set Variable  ${lower_bound.loss_count} packets lost.
${message} =  Set Variable If  ${lower_bound_lf} >= 1.0  ${message}${\n}${message_zero}  ${message}${\n}${message_other}
Fail  ${message}

3.10.3.11. Perform additional measurements based on NDRPDR result

Perform any additional measurements which are not directly needed for determining NDR nor PDR, but which are needed for gathering additional data for debug purposes. Currently, just “Traffic should pass with no loss” is called. TODO: Move latency measurements from optimized search here.

Arguments: - result - Measured result data per stream [pps]. Type: NdrPdrResult - frame_size - L2 Frame Size [B] or IMIX string. Type: int or str - topology_type - Topology type. Type: string

Example: | Perform additional measurements based on NDRPDR result | ${result} | ${64} | 3-node-IPv4 |


${duration}=  Set Variable  5.0
${rate_per_stream}=  Evaluate  ${result.ndr_interval.measured_low.target_tr} / 2.0
Traffic should pass with no loss  ${duration}  ${rate_per_stream}pps  ${framesize}  ${topology_type}  fail_on_loss=${False}

3.10.3.12. Measure latency pps

Send traffic at specified rate. Measure min/avg/max latency

Arguments: - duration - Duration of traffic run [s]. Type: integer - rate - Rate for sending packets. Type: integer - framesize - L2 Frame Size [B] or IMIX_v4_1. Type: integer/string - topology_type - Topology type. Type: string

Example:

| Measure latency | 10 | 4.0 | 64 | 3-node-IPv4 |


Return From Keyword If  ${rate} <= 10000  ${-1}
Send traffic on tg  ${duration}  ${rate}pps  ${framesize}  ${topology_type}  warmup_time=0
Run keyword and return  Get latency

3.10.3.13. Traffic should pass with no loss

Send traffic at specified rate. No packet loss is accepted at loss evaluation.

Arguments: - duration - Duration of traffic run [s]. Type: integer - rate - Rate for sending packets. Type: string - framesize - L2 Frame Size [B] or IMIX_v4_1. Type: integer/string - topology_type - Topology type. Type: string - fail_on_loss - If True, the keyword fails if loss occurred. Type: boolean

Example:

| Traffic should pass with no loss | 10 | 4.0mpps | 64 | 3-node-IPv4 |


Send traffic at specified rate  ${duration}  ${rate}  ${framesize}  ${topology_type}
Run Keyword If  ${fail_on_loss}  No traffic loss occurred

3.10.3.14. Traffic should pass with maximum rate

Send traffic at maximum rate.

Arguments: - rate - Rate for sending packets. Type: string - framesize - L2 Frame Size [B] or IMIX_v4_1. Type: integer/string - topology_type - Topology type. Type: string - subsamples - How many trials in this measurement. Type:int - trial_duration - Duration of single trial [s]. Type: float - fail_no_traffic - Whether to fail on zero receive count. Type: boolean - unidirection - False if traffic is bidirectional. Type: boolean - tx_port - TX port of TG, default 0. Type: integer - rx_port - RX port of TG, default 1. Type: integer

Example:

| Traffic should pass with maximum rate | 4.0mpps | 64 | 3-node-IPv4 | ${1} | ${10.0} | ${False} | ${False} | ${0} ${1} |


${results} =  Send traffic at specified rate  ${trial_duration}  ${rate}  ${framesize}  ${topology_type}  ${subsamples}  ${unidirection}  ${tx_port}  ${rx_port}
Set Test Message  ${\n}Maximum Receive Rate trial results
Set Test Message  in packets per second: ${results}  append=yes
Run Keyword If  ${fail_no_traffic}  Fail if no traffic forwarded

3.10.3.15. Send traffic at specified rate

Send traffic at specified rate. Return list of measured receive rates.

Arguments: - trial_duration - Duration of single trial [s]. Type: float - rate - Rate for sending packets. Type: string - framesize - L2 Frame Size [B]. Type: integer/string - topology_type - Topology type. Type: string - subsamples - How many trials in this measurement. Type: int - unidirection - False if traffic is bidirectional. Type: boolean - tx_port - TX port of TG, default 0. Type: integer - rx_port - RX port of TG, default 1. Type: integer

Example:

| Send traffic at specified rate | ${1.0} | 4.0mpps | 64 | 3-node-IPv4 | ${10} | ${False} | ${0} ${1} |


Clear and show runtime counters with running traffic  ${trial_duration}  ${rate}  ${framesize}  ${topology_type}  ${unidirection}  ${tx_port}  ${rx_port}
Run Keyword If  ${dut_stats}==${True}  Clear all counters on all DUTs
Run Keyword If  ${dut_stats}==${True} and ${pkt_trace}==${True}  VPP Enable Traces On All DUTs  ${nodes}
Run Keyword If  ${dut_stats}==${True}  VPP enable elog traces on all DUTs  ${nodes}
${results} =  Create List
: FOR  ${i}  IN RANGE  ${subsamples}
\    Send traffic on tg  ${trial_duration}  ${rate}  ${framesize}  ${topology_type}  warmup_time=${0}  unidirection=${unidirection}  tx_port=${tx_port}  rx_port=${rx_port}
\    ${rx} =  Get Received
\    ${rr} =  Evaluate  ${rx} / ${trial_duration}
\    Append To List  ${results}  ${rr}
Run Keyword If  ${dut_stats}==${True}  Show event logger on all DUTs  ${nodes}
Run Keyword If  ${dut_stats}==${True}  Show statistics on all DUTs  ${nodes}
Run Keyword If  ${dut_stats}==${True} and ${pkt_trace}==${True}  Show Packet Trace On All Duts  ${nodes}  maximum=${100}
Return From Keyword  ${results}

3.10.3.16. Clear and show runtime counters with running traffic

Start traffic at specified rate then clear runtime counters on all DUTs. Wait for specified amount of time and capture runtime counters on all DUTs. Finally stop traffic

Arguments: - duration - Duration of traffic run [s]. Type: integer - rate - Rate for sending packets. Type: string - framesize - L2 Frame Size [B] or IMIX_v4_1. Type: integer/string - topology_type - Topology type. Type: string - unidirection - False if traffic is bidirectional. Type: boolean - tx_port - TX port of TG, default 0. Type: integer - rx_port - RX port of TG, default 1. Type: integer

Example:

| Clear and show runtime counters with running traffic | 10 | 4.0mpps | 64 | 3-node-IPv4 | ${False} | ${0} ${1} |


Send traffic on tg  ${-1}  ${rate}  ${framesize}  ${topology_type}  warmup_time=${0}  async_call=${True}  latency=${False}  unidirection=${unidirection}  tx_port=${tx_port}  rx_port=${rx_port}
Run Keyword If  ${dut_stats}==${True}  Clear runtime counters on all DUTs  ${nodes}
Sleep  ${duration}
Run Keyword If  ${dut_stats}==${True}  Show runtime counters on all DUTs  ${nodes}
Stop traffic on tg

3.10.3.17. Create network function CPU list

Create list of CPUs allocated for network function base on SUT/DUT placement and other network functions placement.

Arguments: - dut - DUT node. Type: dictionary - chains: Total number of chains. Type: integer - nodeness: Total number of nodes per chain. Type: integer - chain_id - Network function chain ID. Type: integer - node_id - Network function node ID within chain. Type: integer - mtcr - Main thread to core ratio. Type: integer - dtcr - Dataplane thread to core ratio. Type: integer - auto_scale - If True, use same amount of Dataplane threads for network function as DUT, otherwise use single physical core for every network function. Type: boolean

Note: KW uses test variables ${cpu_count_int} set by “Add worker threads and rxqueues to all DUTs”

Example:

| Create network function CPU list | ${nodes[‘DUT1’]} | 1 | 1 | 1 | 1 |


${sut_sc}=  Set Variable  ${1}
${dut_mc}=  Set Variable  ${1}
${dut_dc}=  Set Variable  ${cpu_count_int}
${skip}=  Evaluate  ${sut_sc} + ${dut_mc} + ${dut_dc}
${dtc}=  Set Variable If  ${auto_scale}  ${cpu_count_int}  ${1}
${if1_status}  ${value}=  Run Keyword And Ignore Error  Variable Should Exist  ${${dut}_if1}
@{if_list}=  Run Keyword If  '${if1_status}' == 'PASS'  Create List  ${${dut}_if1}  ELSE  Create List  ${${dut}_if1_1}  ${${dut}_if1_2}
${if2_status}  ${value}=  Run Keyword And Ignore Error  Variable Should Exist  ${${dut}_if2}
Run Keyword If  '${if2_status}' == 'PASS'  Append To List  ${if_list}  ${${dut}_if2}  ELSE  Append To List  ${if_list}  ${${dut}_if2_1}  ${${dut}_if2_2}
${dut_numa}=  Get interfaces numa node  ${nodes['${dut}']}  @{if_list}
${nf_cpus}=  Cpu slice of list for NF  node=${nodes['${dut}']}  cpu_node=${dut_numa}  chains=${chains}  nodeness=${nodeness}  chain_id=${chain_id}  node_id=${node_id}  mtcr=${mtcr}  dtcr=${dtcr}  dtc=${dtc}  skip_cnt=${skip}
Return From Keyword  ${nf_cpus}