3.6. l2

3.6.1. l2_bridge_domain suite

3.6.1.1. Show Bridge Domain Data On All DUTs

Show Bridge Domain data on all DUTs.


FOR  ${dut}  IN  @{duts}
\    VPP Get Bridge Domain Data  ${nodes['${dut}']}

3.6.1.2. Add interface to bridge domain

Set given interface admin state to up and add this interface to required L2 bridge domain on defined VPP node. Arguments: - ${dut} - DUT node. Type: dictionary - ${dut_if} - DUT node interface name. Type: string - ${bd_id} - Bridge domain ID. Type: integer - ${shg} - Split-horizon group ID. Type: integer, default value: 0 Example: | Add interface to bridge domain | ${nodes[‘DUT2’]} | GigabitEthernet0/8/0 | 3 |


Set Interface State  ${dut}  ${dut_if}  up
Add Interface To L2 BD  ${dut}  ${dut_if}  ${bd_id}  ${shg}

3.6.1.3. Initialize L2 bridge domain on node

Setup L2 bridge domain topology by adding two interfaces on DUT into separate bridge domains that are created automatically starting with index 1. Learning is enabled. Interfaces are brought up. Arguments: - dut - DUT node. Type: string - count - Number of bridge domains interfaces. Type: integer Example: | Initialize L2 bridge domain on node | DUT1 | 1 |


FOR  ${id}  IN RANGE  1  ${count} + 1
\    Add Interface To L2 BD  ${nodes['${dut}']}  ${${dut}_${int}1_${id}}[0]  ${id}
\    Add Interface To L2 BD  ${nodes['${dut}']}  ${${dut}_${int}2_${id}}[0]  ${id}

3.6.1.4. Initialize L2 bridge domain

Setup L2 bridge domain topology by adding two interfaces on each DUT into separate bridge domains that are created automatically starting with index 1. Learning is enabled. Interfaces are brought up. Arguments: - count - Number of bridge domains. Type: integer Example: | Initialize L2 bridge domain | 1 |


FOR  ${dut}  IN  @{duts}
\    Initialize L2 bridge domain on node  ${dut}  count=${count}

3.6.1.5. 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 - virtio_feature_mask - Enabled Virtio features (Optional). Type: integer Note: Socket paths for VM are defined in following format: - /var/run/vpp/sock-${VM_ID}-1 - /var/run/vpp/sock-${VM_ID}-2 Example: | Initialize L2 bridge domains with Vhost-User on node | DUT1 | 1 | 1 |


${bd_id1}=  Evaluate  ${nf_nodes} * (${nf_chain} - 1) + ${nf_chain}
${bd_id2}=  Evaluate  ${nf_nodes} * ${nf_chain} + ${nf_chain}
Add interface to bridge domain  ${nodes['${dut}']}  ${${dut}_${int}1_${nf_chain}}[0]  ${bd_id1}
Add interface to bridge domain  ${nodes['${dut}']}  ${${dut}_${int}2_${nf_chain}}[0]  ${bd_id2}
FOR  ${nf_node}  IN RANGE  1  ${nf_nodes} + 1
\    ${qemu_id}=  Evaluate  (${nf_chain} - ${1}) * ${nf_nodes} + ${nf_node}
\    Configure vhost interfaces  ${nodes['${dut}']}  /var/run/vpp/sock-${qemu_id}-1  /var/run/vpp/sock-${qemu_id}-2  ${dut}-vhost-${qemu_id}-if1  ${dut}-vhost-${qemu_id}-if2  virtio_feature_mask=${virtio_feature_mask}
\    ${bd_id1}=  Evaluate  ${qemu_id} + (${nf_chain} - 1)
\    ${bd_id2}=  Evaluate  ${bd_id1} + 1
\    Add interface to bridge domain  ${nodes['${dut}']}  ${${dut}-vhost-${qemu_id}-if1}  ${bd_id1}
\    Add interface to bridge domain  ${nodes['${dut}']}  ${${dut}-vhost-${qemu_id}-if2}  ${bd_id2}

3.6.1.6. 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 - virtio_feature_mask - Enabled Virtio features (Optional). Type: integer Example: | Initialize L2 bridge domains with Vhost-User | 1 | 1 |


FOR  ${dut}  IN  @{duts}
\    Initialize L2 bridge domains with Vhost-User on node  ${dut}  nf_chain=${nf_chain}  nf_nodes=${nf_nodes}  virtio_feature_mask=${virtio_feature_mask}

3.6.1.7. 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. Put all interfaces in path up. Arguments: - nf_chains - Number of chains of NFs. Type: integer - nf_nodes - Number of NFs nodes per chain. Type: integer - start - Id of first chain, allows to add chains during test. Type: integer - virtio_feature_mask - Enabled Virtio features (Optional). Type: integer Example: | Initialize L2 bridge domains for multiple chains with Vhost-User | 3 | 1 | 2 |


Set interfaces in path up
FOR  ${nf_chain}  IN RANGE  ${start}  ${nf_chains} + 1
\    Initialize L2 bridge domains with Vhost-User  nf_chain=${nf_chain}  nf_nodes=${nf_nodes}  virtio_feature_mask=${virtio_feature_mask}

3.6.1.8. 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
VPP Interface Set IP Address  ${dut1}  ${DUT1_${int}2}[0]  172.16.0.1  24
VPP Interface Set IP Address  ${dut2}  ${DUT2_${int}1}[0]  172.16.0.2  24
VPP Add IP Neighbor  ${dut1}  ${DUT1_${int}2}[0]  172.16.0.2  ${DUT2_${int}1_mac}[0]
VPP Add IP Neighbor  ${dut2}  ${DUT2_${int}1}[0]  172.16.0.1  ${DUT1_${int}2_mac}[0]
${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
VPP Add L2 Bridge Domain  ${dut1}  ${1}  ${DUT1_${int}1}[0]  ${dut1s_vxlan}
Set Interface State  ${dut1}  ${dut1s_vxlan}  up
VPP Add L2 Bridge Domain  ${dut2}  ${1}  ${DUT2_${int}2}[0]  ${dut2s_vxlan}
Set Interface State  ${dut2}  ${dut2s_vxlan}  up

3.6.1.9. 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
Vpp create multiple VXLAN IPv4 tunnels  node=${dut1}  node_vxlan_if=${DUT1_${int}2}[0]  node_vlan_if=${DUT1_${int}1}[0]  op_node=${dut2}  op_node_if=${DUT2_${int}1}[0]  n_tunnels=${vxlan_count}  vni_start=${vni_start}  src_ip_start=${dut1_ip_start}  dst_ip_start=${dut2_ip_start}  ip_step=${ip_step}  bd_id_start=${bd_id_start}
Vpp create multiple VXLAN IPv4 tunnels  node=${dut2}  node_vxlan_if=${DUT2_${int}1}[0]  node_vlan_if=${DUT2_${int}2}[0]  op_node=${dut1}  op_node_if=${DUT1_${int}2}[0]  n_tunnels=${vxlan_count}  vni_start=${vni_start}  src_ip_start=${dut2_ip_start}  dst_ip_start=${dut1_ip_start}  ip_step=${ip_step}  bd_id_start=${bd_id_start}

3.6.1.10. 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 - virtio_feature_mask - Enabled Virtio features (Optional). Type: integer Example: | L2 bridge domains with Vhost-User and VXLANoIPv4 initialized in a3-node circular topology | 1 | 2 |


VPP Interface Set IP Address  ${dut1}  ${DUT1_${int}2}[0]  172.16.0.1  24
VPP Interface Set IP Address  ${dut2}  ${DUT2_${int}1}[0]  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  ${dut1}  /var/run/vpp/sock-1-${bd_id1}  /var/run/vpp/sock-1-${bd_id2}  virtio_feature_mask=${virtio_feature_mask}
Add interface to bridge domain  ${dut1}  ${DUT1_${int}1}[0]  ${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  ${dut2}  /var/run/vpp/sock-1-${bd_id1}  /var/run/vpp/sock-1-${bd_id2}  virtio_feature_mask=${virtio_feature_mask}
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_${int}2}[0]  ${bd_id2}

3.6.1.11. 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_${int}2}[0]  ${dut2}  ${DUT2_${int}1}[0]  SUB_ID=${subid}  ELSE  Initialize VLAN dot1q sub-interfaces in circular topology  ${dut1}  ${DUT1_${int}2}[0]  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_METHOD=${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_${int}1}[0]  ${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_${int}2}[0]  ${bd_id2}

3.6.1.12. 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 - subid - ID of the sub-interface to be created. Type: string - tag_rewrite - Method of tag rewrite. Type: string - virtio_feature_mask - Enabled Virtio features (Optional). Type: integer Example: | L2 bridge domains with Vhost-User and VLAN initialized 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_${int}2}[0]  ${dut2}  ${DUT2_${int}1}[0]  SUB_ID=${subid}  ELSE  Initialize VLAN dot1q sub-interfaces in circular topology  ${dut1}  ${DUT1_${int}2}[0]  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_METHOD=${tag_rewrite}  ELSE  Configure L2 tag rewrite method on interfaces  ${dut1}  ${subif_index_1}  TAG_REWRITE_METHOD=${tag_rewrite}
Configure vhost interfaces  ${dut1}  /var/run/vpp/sock-1-${bd_id1}  /var/run/vpp/sock-1-${bd_id2}  virtio_feature_mask=${virtio_feature_mask}
Add interface to bridge domain  ${dut1}  ${DUT1_${int}1}[0]  ${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  ${dut2}  /var/run/vpp/sock-1-${bd_id1}  /var/run/vpp/sock-1-${bd_id2}  virtio_feature_mask=${virtio_feature_mask}
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_${int}2}[0]  ${bd_id2}

3.6.1.14. 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_id1}=  Evaluate  ${nf_nodes} * (${nf_chain} - 1) + ${nf_chain}
${bd_id2}=  Evaluate  ${nf_nodes} * ${nf_chain} + ${nf_chain}
Add interface to bridge domain  ${nodes['${dut}']}  ${${dut}_${int}1_${nf_chain}}[0]  ${bd_id1}
Add interface to bridge domain  ${nodes['${dut}']}  ${${dut}_${int}2_${nf_chain}}[0]  ${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
\    ${bd_id1}=  Evaluate  ${nf_id} + (${nf_chain} - 1)
\    ${bd_id2}=  Evaluate  ${bd_id1} + 1
\    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}
\    Add interface to bridge domain  ${nodes['${dut}']}  ${${dut}-memif-${nf_id}-if1}  ${bd_id1}
\    Add interface to bridge domain  ${nodes['${dut}']}  ${${dut}-memif-${nf_id}-if2}  ${bd_id2}

3.6.1.15. 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. This keyword does not wait for memifs to go up. Use the “for multiple chains” keyword for that functionality. 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 |


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.6.1.16. 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.6.1.17. 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}
${bd_id1}=  Evaluate  ${nf_nodes} * (${nf_chain} - 1) + ${nf_chain}
${bd_id2}=  Evaluate  ${nf_nodes} * ${nf_chain} + ${nf_chain}
FOR  ${dut}  IN  @{duts}
\    Add interface to bridge domain  ${nodes['${dut}']}  ${${dut}_${int}1_${nf_chain}}[0]  ${bd_id1}
\    Add interface to bridge domain  ${nodes['${dut}']}  ${${dut}_${int}2_${nf_chain}}[0]  ${bd_id2}
\    ${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}  ${bd_id1}
\    Add interface to bridge domain  ${nodes['${dut}']}  ${${dut}-memif-${nf_id_last}-if2}  ${bd_id2}

3.6.1.18. 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.6.1.19. 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_${int}2}[0]  ${dut2}  ${DUT2_${int}1}[0]  SUB_ID=${subid}  ELSE  Initialize VLAN dot1q sub-interfaces in circular topology  ${dut1}  ${DUT1_${int}2}[0]  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_METHOD=${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_${int}1}[0]  ${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_${int}2}[0]  ${bd_id2}
Set interfaces in path up
Show Memif on all DUTs  ${nodes}
VPP round robin RX placement on all DUTs  ${nodes}  prefix=memif

3.6.1.20. 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 |


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}_${int}1}[]0  ${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.6.1.21. Initialize L2 bridge domain with MACIP ACLs in 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.


Set interfaces in path up
VPP Add L2 Bridge Domain  ${dut1}  ${1}  ${DUT1_${int}1}[0]  ${DUT1_${int}2}[0]
Configure MACIP ACLs  ${dut1}  ${DUT1_${int}1}[0]  ${DUT1_${int}2}[0]
Run Keyword If  ${duts_count} == 2  Configure L2XC  ${dut2}  ${DUT2_${int}1}[0]  ${DUT2_${int}2}[0]

3.6.1.22. Initialize L2 bridge domain with IPv4 ACLs in 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.


Set interfaces in path up
VPP Add L2 Bridge Domain  ${dut1}  ${1}  ${DUT1_${int}1}[0]  ${DUT1_${int}2}[0]
Configure IPv4 ACLs  ${dut1}  ${DUT1_${int}1}[0]  ${DUT1_${int}2}[0]
Run Keyword If  ${duts_count} == 2  Configure L2XC  ${dut2}  ${DUT2_${int}1}[0]  ${DUT2_${int}2}[0]

3.6.2. l2_patch suite

3.6.2.1. Initialize L2 patch

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


FOR  ${dut}  IN  @{duts}
\    VPP Setup Bidirectional L2 patch  ${nodes['${dut}']}  ${${dut}_${int}1}[0]  ${${dut}_${int}2}[0]
Set interfaces in path up

3.6.3. l2_traffic suite

3.6.3.1. Send IP packet and verify received packet

Send IPv4/IPv6 packet from source interface to destination interface. Packet can be set with Dot1q or Dot1ad tag(s) when required. Arguments: - tg_node - TG node. Type: dictionary - src_int - Source interface. Type: string - dst_int - Destination interface. Type: string - src_ip - Source IP address (Optional). Type: string - dst_ip - Destination IP address (Optional). Type: string - encaps - Encapsulation: Dot1q or Dot1ad (Optional). Type: string - vlan1 - VLAN (outer) tag (Optional). Type: integer - vlan2 - VLAN inner tag (Optional). Type: integer - encaps_rx - Expected encapsulation on RX side: Dot1q or Dot1ad (Optional). Type: string - vlan1_rx - VLAN (outer) tag on RX side (Optional). Type: integer - vlan2_rx - VLAN inner tag on RX side (Optional). Type: integer Return: - No value returned Example: _NOTE:_ Default IP is IPv4 | Send IP packet and verify received packet | ${nodes[‘TG’]} | ${tg_to_dut_if1} | ${tg_to_dut_if2} | | Send IP packet and verify received packet | ${nodes[‘TG’]} | ${tg_to_dut1} | ${tg_to_dut2} | encaps=Dot1q | vlan1=100 | | Send IP packet and verify received packet | ${nodes[‘TG’]} | ${tg_to_dut1} | ${tg_to_dut2} | encaps=Dot1ad | vlan1=110 | vlan2=220 | | Send IP packet and verify received packet | ${nodes[‘TG’]} | ${tg_to_dut1} | ${tg_to_dut2} | encaps=Dot1q | vlan1=110 | encaps_rx=Dot1q | | Send IP packet and verify received packet | ${nodes[‘TG’]} | ${tg_to_dut1} | ${tg_to_dut2} | encaps=Dot1q | vlan1=110 | encaps_rx=Dot1q | vlan1_rx=120 |


${tx_src_mac}=  Get Interface Mac  ${tg_node}  ${tx_src_port}
${rx_dst_mac}=  Get Interface Mac  ${tg_node}  ${rx_dst_port}
 Then Send packet and verify headers  ${tg}  192.168.0.1  192.168.0.2  ${tx_src_port}  ${tx_src_mac}  ${rx_dst_mac}  ${rx_dst_port}  ${tx_src_mac}  ${rx_dst_mac}  encaps_tx=${encaps}  vlan_tx=${vlan1}  vlan_outer_tx=${vlan2}  encaps_rx=${encaps_rx}  vlan_rx=${vlan1_rx}  vlan_outer_rx=${vlan2_rx}

3.6.3.2. Send IPv4 bidirectionally and verify received packets

Send IPv4 packets from both directions, from interface1 to interface2 and from interface2 to interface1. Arguments: - tg_node - TG node. Type: dictionary - src_int - Source interface. Type: string - dst_int - Destination interface. Type: string - src_ip - Source IP address (Optional). Type: string - dst_ip - Destination IP address (Optional). Type: string Return: - No value returned Example: | Send IPv4 bidirectionally and verify received packets | ${nodes[‘TG’]} | ${tg_to_dut_if1} | ${tg_to_dut_if2} |


Send IP packet and verify received packet  ${tg_node}  ${int1}  ${int2}  ${src_ip}  ${dst_ip}
Send IP packet and verify received packet  ${tg_node}  ${int2}  ${int1}  ${dst_ip}  ${src_ip}

3.6.3.3. Send IPv6 bidirectionally and verify received packets

Send IPv6 packets from both directions, from interface1 to interface2 and from interface2 to interface1. Arguments: - tg_node - TG node. Type: dictionary - src_int - Source interface. Type: string - dst_int - Destination interface. Type: string - src_ip - Source IP address (Optional). Type: string - dst_ip - Destination IP address (Optional). Type: string Return: - No value returned Example: | Send IPv6 bidirectionally and verify received packets | ${nodes[‘TG’]} | ${tg_to_dut_if1} | ${tg_to_dut_if2} |


Send IP packet and verify received packet  ${tg_node}  ${int1}  ${int2}  ${src_ip}  ${dst_ip}
Send IP packet and verify received packet  ${tg_node}  ${int2}  ${int1}  ${dst_ip}  ${src_ip}

3.6.4. l2_xconnect suite

3.6.4.1. Configure L2XC

Setup Bidirectional Cross Connect on DUTs Arguments: - dut - DUT node. Type: string - if1 - First interface. Type: string - if2 - Second interface. Type: string Example: | Initialize L2 cross connect on node | DUT1 | 1 |


Set Interface State  ${dut}  ${if1}  up
Set Interface State  ${dut}  ${if2}  up
Vpp Setup Bidirectional Cross Connect  ${dut}  ${if1}  ${if2}

3.6.4.2. Initialize L2 cross connect on node

Setup L2 cross connect topology by connecting RX/TX of two interfaces on each DUT. Interfaces are brought up. Arguments: - dut - DUT node. Type: string - count - Number of interfaces pairs to connect. Type: integer Example: | Initialize L2 cross connect on node | DUT1 | 1 |


FOR  ${id}  IN RANGE  1  ${count} + 1
\    VPP Setup Bidirectional Cross Connect  ${nodes['${dut}']}  ${${dut}_${int}1_${id}}[0]  ${${dut}_${int}2_${id}}[0]

3.6.4.3. Initialize L2 cross connect

Setup L2 cross connect topology by connecting RX/TX of two interfaces on each DUT. Interfaces are brought up. Arguments: - count - Number of interfaces pairs to connect. Type: integer Example: | Initialize L2 cross connect | 1 |


FOR  ${dut}  IN  @{duts}
\    Initialize L2 cross connect on node  ${dut}  count=${count}

3.6.4.4. 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
VPP Interface Set IP Address  ${dut1}  ${DUT1_${int}2}[0]  172.16.0.1  24
VPP Interface Set IP Address  ${dut2}  ${DUT2_${int}1}[0]  172.16.0.2  24
VPP Add IP Neighbor  ${dut1}  ${DUT1_${int}2}[0]  172.16.0.2  ${DUT2_${int}1_mac}[0]
VPP Add IP Neighbor  ${dut2}  ${DUT2_${int}1}[0]  172.16.0.1  ${DUT1_${int}2_mac}[0]
${dut1s_vxlan}=  Create VXLAN interface  ${dut1}  24  172.16.0.1  172.16.0.2
Configure L2XC  ${dut1}  ${DUT1_${int}1}[0]  ${dut1s_vxlan}
${dut2s_vxlan}=  Create VXLAN interface  ${dut2}  24  172.16.0.2  172.16.0.1
Configure L2XC  ${dut2}  ${DUT2_${int}2}[0]  ${dut2s_vxlan}

3.6.4.5. 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 - nf_nodes - VM count. Type: integer - virtio_feature_mask - Enabled Virtio features (Optional). 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  ${nf_nodes}+1
\    ${sock1}=  Set Variable  /run/vpp/sock-${number}-1
\    ${sock2}=  Set Variable  /run/vpp/sock-${number}-2
\    ${prev_index}=  Evaluate  ${number}-1
\    Configure vhost interfaces  ${nodes['${dut}']}  ${sock1}  ${sock2}  ${dut}-vhost-${number}-if1  ${dut}-vhost-${number}-if2  virtio_feature_mask=${virtio_feature_mask}
\    ${dut_xconnect_if1}=  Set Variable If  ${number}==1  ${${dut}_${int}1}[0]  ${${dut}-vhost-${prev_index}-if2}
\    Configure L2XC  ${nodes['${dut}']}  ${dut_xconnect_if1}  ${${dut}-vhost-${number}-if1}
\    Run Keyword If  ${number}==${nf_nodes}  Configure L2XC  ${nodes['${dut}']}  ${${dut}-vhost-${number}-if2}  ${${dut}_${int}2}[0]

3.6.4.6. 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: - nf_nodes - VM count. Type: integer - virtio_feature_mask - Enabled Virtio features (Optional). Type: integer Example: | Initialize L2 xconnect with Vhost-User | 1 |


FOR  ${dut}  IN  @{duts}
\    Initialize L2 xconnect with Vhost-User on node  ${dut}  nf_nodes=${nf_nodes}  virtio_feature_mask=${virtio_feature_mask}

3.6.4.7. Initialize L2 xconnect with Vhost-User and VLAN in 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: - subid - ID of the sub-interface to be created. Type: string - tag_rewrite - Method of tag rewrite. Type: string - virtio_feature_mask - Enabled Virtio features (Optional). Type: integer Example: | L2 xconnect with Vhost-User and VLAN initialized in a 3-nodecircular topology | 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_${int}2}[0]  ${dut2}  ${DUT2_${int}1}[0]  SUB_ID=${subid}  ELSE  Initialize VLAN dot1q sub-interfaces in circular topology  ${dut1}  ${DUT1_${int}2}[0]  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_METHOD=${tag_rewrite}  ELSE  Configure L2 tag rewrite method on interfaces  ${dut1}  ${subif_index_1}  TAG_REWRITE_METHOD=${tag_rewrite}
Configure vhost interfaces  ${dut1}  /run/vpp/sock-1-1  /run/vpp/sock-1-2  virtio_feature_mask=${virtio_feature_mask}
Configure L2XC  ${dut1}  ${DUT1_${int}1}[0]  ${vhost_if1}
Configure L2XC  ${dut1}  ${subif_index_1}  ${vhost_if2}
Run Keyword If  '${dut2_status}' == 'PASS'  Configure vhost interfaces  ${dut2}  /run/vpp/sock-1-1  /run/vpp/sock-1-2  virtio_feature_mask=${virtio_feature_mask}
Run Keyword If  '${dut2_status}' == 'PASS'  Configure L2XC  ${dut2}  ${subif_index_2}  ${vhost_if1}
Run Keyword If  '${dut2_status}' == 'PASS'  Configure L2XC  ${dut2}  ${DUT2_${int}2}[0]  ${vhost_if2}

3.6.4.9. 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}_${int}1}[0]  ${${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}_${int}2}[0]

3.6.4.10. 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} |


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.6.5. tagging suite

3.6.5.1. Initialize VLAN sub-interfaces in 3-node circular topology

Create two subinterfaces on DUTs. Arguments: - DUT1 - Node to add sub-interface. - INT1 - Interface key on which create sub-interface. - DUT2 - Node to add sub-interface. - INT2 - Interface key on which create sub-interface. - SUB_ID - ID of the sub-interface to be created. - OUTER_VLAN_ID - Outer VLAN ID. - INNER_VLAN_ID - Inner VLAN ID. - TYPE_SUBIF - Type of sub-interface. _Set testcase variables with name and index of created interfaces:_ - subif_name_1 - subif_index_1 - subif_name_2 - subif_index_2


Set Interface State  ${DUT1}  ${INT1}  up
Set Interface State  ${DUT2}  ${INT2}  up
${INT1_name}=  Get interface name  ${DUT1}  ${INT1}
${subif_name_1}  ${subif_index_1}=  Create subinterface  ${DUT1}  ${INT1_name}  ${SUB_ID}  ${OUTER_VLAN_ID}  ${INNER_VLAN_ID}  ${TYPE_SUBIF}
${INT2_name}=  Get interface name  ${DUT2}  ${INT2}
${subif_name_2}  ${subif_index_2}=  Create subinterface  ${DUT2}  ${INT2_name}  ${SUB_ID}  ${OUTER_VLAN_ID}  ${INNER_VLAN_ID}  ${TYPE_SUBIF}
Set Interface State  ${DUT1}  ${subif_index_1}  up
Set Interface State  ${DUT2}  ${subif_index_2}  up
Set Test Variable  ${subif_name_1}
Set Test Variable  ${subif_index_1}
Set Test Variable  ${subif_name_2}
Set Test Variable  ${subif_index_2}

3.6.5.2. Initialize VLAN dot1q sub-interfaces in circular topology

Create two dot1q subinterfaces on DUTs. Arguments: - DUT1 - Node to add sub-interface. - INT1 - Interface key on which create VLAN sub-interface. - DUT2 - Node to add sub-interface. - INT2 - Interface key on which create VLAN sub-interface. - SUB_ID - ID of the sub-interface to be created. _Set testcase variables with name and index of created interfaces:_ - subif_name_1 - subif_index_1 - subif_name_2 - subif_index_2 Example: | Initialize VLAN dot1q sub-interfaces in circular topology | ${nodes[‘DUT1’]} | ${dut1_if2} | ${nodes[‘DUT2’]} | ${dut1_if2} | 10 |


Set Interface State  ${DUT1}  ${INT1}  up
Run Keyword Unless  ${DUT2} == ${None}  Set Interface State  ${DUT2}  ${INT2}  up
${INT1_NAME}=  Get interface name  ${DUT1}  ${INT1}
${INT2_NAME}=  Run Keyword Unless  ${DUT2} == ${None}  Get interface name  ${DUT2}  ${INT2}
${subif_name_1}  ${subif_index_1}=  Create Vlan Subinterface  ${DUT1}  ${INT1_NAME}  ${SUB_ID}
${subif_name_2}  ${subif_index_2}=  Run Keyword Unless  ${DUT2} == ${None}  Create Vlan Subinterface  ${DUT2}  ${INT2_NAME}  ${SUB_ID}
Set Interface State  ${DUT1}  ${subif_index_1}  up
Run Keyword Unless  ${DUT2} == ${None}  Set Interface State  ${DUT2}  ${subif_index_2}  up
Set Test Variable  ${subif_name_1}
Set Test Variable  ${subif_index_1}
Run Keyword Unless  ${DUT2} == ${None}  Set Test Variable  ${subif_name_2}
Run Keyword Unless  ${DUT2} == ${None}  Set Test Variable  ${subif_index_2}

3.6.5.3. Configure L2 tag rewrite method on interfaces

Setup tag rewrite on sub-interfaces on DUTs. Arguments: - DUT1 - Node to rewrite tags. - SUB_INT1 - Interface on which rewrite tags. - DUT2 - Node to rewrite tags. - SUB_INT2 - Interface on which rewrite tags. - TAG_REWRITE_METHOD - Method of tag rewrite.


L2 Vlan tag rewrite  ${DUT1}  ${SUB_INT1}  ${TAG_REWRITE_METHOD}
Run Keyword Unless  ${DUT2} == ${None}  L2 Vlan tag rewrite  ${DUT2}  ${SUB_INT2}  ${TAG_REWRITE_METHOD}

3.6.5.4. Configure L2 tag rewrite method on interface

Set L2 tag rewrite on (sub-)interface on DUT Arguments: - dut_node - Node to set L2 tag rewrite method. Type: dictionary - interface - (Sub-)interface name or SW index to set L2 tag rewrite method. Type: string or integer - tag_rewrite_method - Tag rewrite method. Type: string - push_dot1q - True to push tags as Dot1q, False to push tags as Dot1ad (Optional). Type: boolean - tag1_id - VLAN tag1 ID (Optional). Type: integer - tag2_id - VLAN tag2 ID (Optional). Type: integer Return: - No value returned Example: | Configure L2 tag rewrite method on interface | ${nodes[‘DUT1’]} | 9 | pop-1 | | Configure L2 tag rewrite method on interface | ${nodes[‘DUT2’]} | 10 | translate-1-2 | push_dot1q=${False} | tag1_id=10 | tag1_id=20 |


${result}=  Evaluate  isinstance($interface, int)
${interface_name}=  Run Keyword If  ${result}  Set Variable  ${interface}  ELSE  Get interface name  ${dut_node}  ${interface}
L2 Vlan Tag Rewrite  ${dut_node}  ${interface_name}  ${tag_rewrite_method}  push_dot1q=${push_dot1q}  tag1_id=${tag1_id}  tag2_id=${tag2_id}