3.7. l2

3.7.1. l2_bridge_domain suite

3.7.1.1. Configure L2BD forwarding

Setup BD between 2 interfaces on VPP node and if learning is off set static L2FIB entry on second interface


Set Interface State  ${dut_node}  ${if1}  up
Set Interface State  ${dut_node}  ${if2}  up
Vpp Add L2 Bridge Domain  ${dut_node}  ${1}  ${if1}  ${if2}  ${learn}
Run Keyword If  ${learn} == ${FALSE}  Vpp Add L2fib Entry  ${dut_node}  ${mac}  ${if2}  ${1}
Vpp Node Interfaces Ready Wait  ${dut_node}

3.7.1.2. Configure path for 3-node BD-SHG test

Compute path for bridge domain split-horizon group testing on three given nodes with following interconnections TG - (2 links) - DUT1 - (1 link) - DUT2 - (2 links) - TG and set corresponding test case variables.

Arguments: - ${tg_node} - TG node. Type: dictionary - ${dut1_node} - DUT1 node. Type: dictionary - ${dut2_node} - DUT2 node. Type: dictionary

Return: - No value returned

_NOTE:_ This KW sets following test case variables: - ${tg_node} - TG node. - ${tg_to_dut1_if1} - TG interface 1 towards DUT1. - ${tg_to_dut1_if2} - TG interface 2 towards DUT1. - ${tg_to_dut2_if1} - TG interface 1 towards DUT2. - ${tg_to_dut2_if2} - TG interface 2 towards DUT2. - ${dut1_node} - DUT1 node. - ${dut1_to_tg_if1} - DUT1 interface 1 towards TG. - ${dut1_to_tg_if2} - DUT1 interface 2 towards TG. - ${dut1_to_dut2} - DUT1 interface towards DUT2. - ${dut2_node} - DUT2 node. - ${dut2_to_tg_if1} - DUT2 interface 1 towards TG. - ${dut2_to_tg_if2} - DUT2 interface 2 towards TG. - ${dut2_to_dut1} - DUT2 interface towards DUT1.

Example:

| Given Configure path for 3-node BD-SHG test | ${nodes[‘TG’]} | ${nodes[‘DUT1’]} | ${nodes[‘DUT2’]} |


Append Nodes  ${tg_node}  ${dut1_node}  ${tg_node}
Compute Path  always_same_link=${FALSE}
${tg_to_dut1_if1}  ${tmp}=  First Interface
${tg_to_dut1_if2}  ${tmp}=  Last Interface
${dut1_to_tg_if1}  ${tmp}=  First Ingress Interface
${dut1_to_tg_if2}  ${tmp}=  Last Egress Interface
Clear Path
Append Nodes  ${tg_node}  ${dut2_node}  ${tg_node}
Compute Path  always_same_link=${FALSE}
${tg_to_dut2_if1}  ${tmp}=  First Interface
${tg_to_dut2_if2}  ${tmp}=  Last Interface
${dut2_to_tg_if1}  ${tmp}=  First Ingress Interface
${dut2_to_tg_if2}  ${tmp}=  Last Egress Interface
Clear Path
Append Nodes  ${dut1_node}  ${dut2_node}
Compute Path
${dut1_to_dut2}  ${tmp}=  Next Interface
${dut2_to_dut1}  ${tmp}=  Next Interface
Set Test Variable  ${tg_to_dut1_if1}
Set Test Variable  ${tg_to_dut1_if2}
Set Test Variable  ${tg_to_dut2_if1}
Set Test Variable  ${tg_to_dut2_if2}
Set Test Variable  ${dut1_to_tg_if1}
Set Test Variable  ${dut1_to_tg_if2}
Set Test Variable  ${dut2_to_tg_if1}
Set Test Variable  ${dut2_to_tg_if2}
Set Test Variable  ${dut1_to_dut2}
Set Test Variable  ${dut2_to_dut1}
Set Test Variable  ${tg_node}
Set Test Variable  ${dut1_node}
Set Test Variable  ${dut2_node}

3.7.1.3. Set interfaces in 3-node BD-SHG test up

Set UP state on interfaces in 3-node path on nodes and wait for all interfaces are ready.

Arguments: - No arguments.

Return: - No value returned.

_NOTE:_ This KW uses test variables sets in “Configure path for 3-node BD-SHG test” KW.

Example:

| Configure path for 3-node BD-SHG test | ${nodes[‘TG’]} | ${nodes[‘DUT1’]} | ${nodes[‘DUT2’]} | | Set interfaces in 3-node BD-SHG test up |


Set Interface State  ${tg_node}  ${tg_to_dut1_if1}  up
Set Interface State  ${tg_node}  ${tg_to_dut1_if2}  up
Set Interface State  ${tg_node}  ${tg_to_dut2_if1}  up
Set Interface State  ${tg_node}  ${tg_to_dut2_if2}  up
Set Interface State  ${dut1_node}  ${dut1_to_tg_if1}  up
Set Interface State  ${dut1_node}  ${dut1_to_tg_if2}  up
Set Interface State  ${dut2_node}  ${dut2_to_tg_if1}  up
Set Interface State  ${dut2_node}  ${dut2_to_tg_if2}  up
Set Interface State  ${dut1_node}  ${dut1_to_dut2}  up
Set Interface State  ${dut2_node}  ${dut2_to_dut1}  up
Vpp Node Interfaces Ready Wait  ${dut1_node}
Vpp Node Interfaces Ready Wait  ${dut2_node}

3.7.1.4. Create bridge domain

Create bridge domain on given VPP node with defined learning status.

Arguments: - ${dut_node} - DUT node. Type: dictionary - ${bd_id} - Bridge domain ID. Type: integer - ${learn} - Enable/disable MAC learn. Type: boolean, default value: ${TRUE}

Return: - No value returned

Example:

| Create bridge domain | ${nodes[‘DUT1’]} | 2 | | Create bridge domain | ${nodes[‘DUT1’]} | 5 | learn=${FALSE} |


${learn} =  Set Variable If  ${learn} == ${TRUE}  ${1}  ${0}
Create L2 BD  ${dut_node}  ${bd_id}  learn=${learn}

3.7.1.5. 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_node} - 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

Return: - No value returned

Example:

| Add interface to bridge domain | ${nodes[‘DUT2’]} | GigabitEthernet0/8/0 | 3 |


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

3.7.1.6. Add destination port to L2FIB

Create a static L2FIB entry for required destination port on defined interface and bridge domain ID of the given VPP node.

Arguments: - ${dest_node} - Destination node. Type: dictionary - ${dest_node_if} - Destination node interface name. Type: string - ${vpp_node} - DUT node to add L2FIB entry on. Type: dictionary - ${vpp_node_if} - DUT node interface name. Type: string - ${bd_id} - Bridge domain ID. Type: integer

Return: - No value returned

Example:

| Add destination port to L2FIB | ${nodes[‘TG’]} | eth1 | ${nodes[‘DUT2’]} | GigabitEthernet0/8/0 | 3 |


${mac}=  Get Interface Mac  ${dest_node}  ${dest_node_if}
Vpp Add L2fib Entry  ${vpp_node}  ${mac}  ${vpp_node_if}  ${bd_id}

3.7.1.7. Configure VM for vhost L2BD forwarding

Setup QEMU and start VM with two vhost interfaces.

Arguments: - ${dut_node} - DUT node to start VM on. Type: dictionary - ${sock1} - Socket path for first Vhost-User interface. Type: string - ${sock2} - Socket path for second Vhost-User interface. Type: string - ${qemu_name} - Qemu instance name by which the object will be accessed (Optional). Type: string

_NOTE:_ This KW sets following test case variable: - ${${qemu_name}} - VM node info. Type: dictionary

Example:

| Configure VM for vhost L2BD forwarding | ${nodes[‘DUT1’]} | /tmp/sock1 | /tmp/sock2 | | Configure VM for vhost L2BD forwarding | ${nodes[‘DUT2’]} | /tmp/sock1 | /tmp/sock2 | qemu_instance_2 |


Run Keyword Unless  "${qemu_name}" == "vm_node"  Import Library  resources.libraries.python.QemuUtils  WITH NAME  ${qemu_name}
Set Test Variable  ${${qemu_name}}  ${None}
${qemu_set_node}=  Run Keyword If  "${qemu_name}" == "vm_node"  Set Variable  Qemu Set Node  ELSE  Replace Variables  ${qemu_name}.Qemu Set Node
Run keyword  ${qemu_set_node}  ${dut_node}
${qemu_add_vhost}=  Run Keyword If  "${qemu_name}" == "vm_node"  Set Variable  Qemu Add Vhost User If  ELSE  Replace Variables  ${qemu_name}.Qemu Add Vhost User If
Run keyword  ${qemu_add_vhost}  ${sock1}
Run keyword  ${qemu_add_vhost}  ${sock2}
${qemu_start}=  Run Keyword If  "${qemu_name}" == "vm_node"  Set Variable  Qemu Start  ELSE  Replace Variables  ${qemu_name}.Qemu Start
${vm}=  Run keyword  ${qemu_start}
${br}=  Set Variable  br0
${vhost1}=  Get Vhost User If Name By Sock  ${vm}  ${sock1}
${vhost2}=  Get Vhost User If Name By Sock  ${vm}  ${sock2}
Linux Add Bridge  ${vm}  ${br}  ${vhost1}  ${vhost2}
Set Interface State  ${vm}  ${vhost1}  up  if_type=name
Set Interface State  ${vm}  ${vhost2}  up  if_type=name
Set Interface State  ${vm}  ${br}  up  if_type=name
Set Test Variable  ${${qemu_name}}  ${vm}

3.7.1.8. Configure vhost interfaces for L2BD forwarding

Create two Vhost-User interfaces on defined VPP node.

Arguments: - ${dut_node} - DUT node. Type: dictionary - ${sock1} - Socket path for first Vhost-User interface. Type: string - ${sock2} - Socket path for second Vhost-User interface. Type: string - ${vhost_if1} - Name of the first Vhost-User interface (Optional). Type: string - ${vhost_if2} - Name of the second Vhost-User interface (Optional). Type: string

_NOTE:_ This KW sets following test case variable: - ${${vhost_if1}} - First Vhost-User interface. - ${${vhost_if2}} - Second Vhost-User interface.

Example:

| Configure vhost interfaces for L2BD forwarding | ${nodes[‘DUT1’]} | /tmp/sock1 | /tmp/sock2 | | Configure vhost interfaces for L2BD forwarding | ${nodes[‘DUT2’]} | /tmp/sock1 | /tmp/sock2 | dut2_vhost_if1 | dut2_vhost_if2 |


${vhost_1}=  Vpp Create Vhost User Interface  ${dut_node}  ${sock1}
${vhost_2}=  Vpp Create Vhost User Interface  ${dut_node}  ${sock2}
Set Interface State  ${dut_node}  ${vhost_1}  up
Set Interface State  ${dut_node}  ${vhost_2}  up
Set Test Variable  ${${vhost_if1}}  ${vhost_1}
Set Test Variable  ${${vhost_if2}}  ${vhost_2}

3.7.2. l2_patch suite

3.7.2.1. Configure L2 patch

Setup Bidirectional L2 patch on DUT


Set Interface State  ${node}  ${if1}  up
Set Interface State  ${node}  ${if2}  up
Vpp Setup Bidirectional L2 patch  ${node}  ${if1}  ${if2}

3.7.3. l2_traffic suite

3.7.3.1. Send ICMP packet and verify received packet

Send ICMPv4/ICMPv6 echo request 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 ICMP packet and verify received packet | ${nodes[‘TG’]} | ${tg_to_dut_if1} | ${tg_to_dut_if2} | | Send ICMP packet and verify received packet | ${nodes[‘TG’]} | ${tg_to_dut1} | ${tg_to_dut2} | encaps=Dot1q | vlan1=100 | | Send ICMP packet and verify received packet | ${nodes[‘TG’]} | ${tg_to_dut1} | ${tg_to_dut2} | encaps=Dot1ad | vlan1=110 | vlan2=220 | | Send ICMP packet and verify received packet | ${nodes[‘TG’]} | ${tg_to_dut1} | ${tg_to_dut2} | encaps=Dot1q | vlan1=110 | encaps_rx=Dot1q | | Send ICMP packet and verify received packet | ${nodes[‘TG’]} | ${tg_to_dut1} | ${tg_to_dut2} | encaps=Dot1q | vlan1=110 | encaps_rx=Dot1q | vlan1_rx=120 |


${src_mac}=  Get Interface Mac  ${tg_node}  ${src_int}
${dst_mac}=  Get Interface Mac  ${tg_node}  ${dst_int}
${src_int_name}=  Get interface name  ${tg_node}  ${src_int}
${dst_int_name}=  Get interface name  ${tg_node}  ${dst_int}
${args}=  Traffic Script Gen Arg  ${dst_int_name}  ${src_int_name}  ${src_mac}  ${dst_mac}  ${src_ip}  ${dst_ip}
${args}=  Run Keyword If  '${encaps}' == '${EMPTY}'  Set Variable  ${args}  ELSE  Catenate  ${args}  --encaps ${encaps}  --vlan1 ${vlan1}
${args}=  Run Keyword If  '${vlan2}' == '${EMPTY}'  Set Variable  ${args}  ELSE  Catenate  ${args}  --vlan2 ${vlan2}
${args}=  Run Keyword If  '${encaps_rx}' == '${EMPTY}'  Set Variable  ${args}  ELSE  Catenate  ${args}  --encaps_rx ${encaps_rx}
${args}=  Run Keyword If  '${vlan1_rx}' == '${EMPTY}'  Set Variable  ${args}  ELSE  Catenate  ${args}  --vlan1_rx ${vlan1_rx}
${args}=  Run Keyword If  '${vlan2_rx}' == '${EMPTY}'  Set Variable  ${args}  ELSE  Catenate  ${args}  --vlan2_rx ${vlan2_rx}
Run Traffic Script On Node  send_ip_icmp.py  ${tg_node}  ${args}

3.7.3.2. ICMP packet transmission should fail

Send ICMPv4/ICMPv6 echo request from source interface to destination interface and expect failure with ICMP echo Rx timeout error message.

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:

_NOTE:_ Default IP is IPv4

| ICMP packet transmission should fail| ${nodes[‘TG’]} | ${tg_to_dut_if1} | ${tg_to_dut_if2} |


${src_mac}=  Get Interface Mac  ${tg_node}  ${src_int}
${dst_mac}=  Get Interface Mac  ${tg_node}  ${dst_int}
${src_int_name}=  Get interface name  ${tg_node}  ${src_int}
${dst_int_name}=  Get interface name  ${tg_node}  ${dst_int}
${args}=  Traffic Script Gen Arg  ${dst_int_name}  ${src_int_name}  ${src_mac}  ${dst_mac}  ${src_ip}  ${dst_ip}
Run Keyword And Expect Error  ICMP echo Rx timeout  Run Traffic Script On Node  send_ip_icmp.py  ${tg_node}  ${args}

3.7.3.3. Send ICMPv4 bidirectionally and verify received packets

Send ICMPv4 echo request 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 ICMPv4 bidirectionally and verify received packets | ${nodes[‘TG’]} | ${tg_to_dut_if1} | ${tg_to_dut_if2} |


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

3.7.3.4. Send ICMPv6 bidirectionally and verify received packets

Send ICMPv6 echo request 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 ICMPv6 bidirectionally and verify received packets | ${nodes[‘TG’]} | ${tg_to_dut_if1} | ${tg_to_dut_if2} |


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

3.7.4. l2_xconnect suite

3.7.4.1. Configure L2XC

Setup Bidirectional Cross Connect on DUTs


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

3.7.5. tagging suite

3.7.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.7.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.7.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.7.5.4. Connect interfaces and VLAN sub-interfaces using L2XC

Add interface and subinterface to bidirectional L2-xconnect on DUTs.

Arguments: - DUT1 - Node to add bidirectional cross-connect. - INT1 - Interface to add to the cross-connect. - SUB_INT1 - Sub-interface to add to the cross-connect. - DUT2 - Node to add bidirectional cross-connect. - INT2 - Interface to add to the cross-connect. - SUB_INT2 - Sub-interface to add to the cross-connect.


Configure L2XC  ${DUT1}  ${INT1}  ${SUB_INT1}
Run Keyword Unless  ${DUT2} == ${None}  Configure L2XC  ${DUT2}  ${INT2}  ${SUB_INT2}

3.7.5.5. Create vlan sub-interface

Create VLAN sub-interface on DUT and set admin status up.

Arguments: - dut_node - Node to add VLAN sub-intreface. Type: dictionary - interface - Interface to create VLAN sub-interface. Type: string - vlan_id - VLAN ID. Type: integer

Return: - vlan_name - VLAN sub-interface name. Type: string - vlan_index - VLAN sub-interface SW index. Type: integer

Example:

| Create vlan sub-interface | ${nodes[‘DUT1’]} | port3 | 100 |


Set Interface State  ${dut_node}  ${interface}  up
${interface_name}=  Get interface name  ${dut_node}  ${interface}
${vlan_name}  ${vlan_index}=  Create Vlan Subinterface  ${dut_node}  ${interface_name}  ${vlan_id}
Set Interface State  ${dut_node}  ${vlan_index}  up

3.7.5.6. Create tagged sub-interface

Create tagged sub-interface on DUT. Type of tagged sub-intreface depends on type_subif value: - one_tag -> VLAN - two_tags -> QinQ VLAN - two_tags dot1ad - DOT1AD

Arguments: - dut_node - Node to add VLAN sub-intreface. Type: dictionary - interface - Interface to create tagged sub-interface. Type: string - subif_id - Sub-interface ID. Type: integer - outer_vlan_id - VLAN (outer) ID (Optional). Type: integer - inner_vlan_id - VLAN inner ID (Optional). Type: integer - type_subif - Sub-interface type (Optional). Type: string

Return: - subif_name - Sub-interface name. Type: string - subif_index - Sub-interface SW index. Type: integer

Example:

| Create tagged sub-interface | ${nodes[‘DUT1’]} | port1 | 10 | outer_vlan_id=100 | inner_vlan_id=200 | type_subif=two_tags dot1ad |


Set Interface State  ${dut_node}  ${interface}  up
${interface_name}=  Get interface name  ${dut_node}  ${interface}
${subif_name}  ${subif_index}=  Create Subinterface  ${dut_node}  ${interface_name}  ${subif_id}  outer_vlan_id=${outer_vlan_id}  inner_vlan_id=${inner_vlan_id}  type_subif=${type_subif}

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