lisp package

l2lisp module

Set up L2 Lisp on DUT

Set up LISP L2 topology.

Arguments: - dut_node - DUT node. Type: dictionary - adjacency - DUT static adjacency settings. Type: dict - settings - DUT other LISP related settings. Type: dict

Return: - No value returned

Example: | Set up LISP GPE topology | ${dut_node} | ${adjacency} | ${settings} |


${int_idx}=  Get Interface Sw Index  ${dut_node}  ${${adjacency['int']}}
Enable Lisp  ${dut_node}
Vpp Add Lisp Locator Set  ${dut_node}  ${settings['locator_name']}
Vpp Add Lisp Locator  ${dut_node}  ${settings['locator_name']}  ${int_idx}  ${settings['priority']}  ${settings['weight']}
Vpp Lisp Eid Table Mapping  ${dut_node}  ${settings['vni']}  bd_id=${settings['bd']}
Vpp Add Lisp Local Eid  ${dut_node}  ${settings['locator_name']}  ${settings['vni']}  ${adjacency['seid']}
Vpp Add Map Resolver  ${dut_node}  ${adjacency['map_res']}
Vpp Add Lisp Remote Mapping  ${dut_node}  ${settings['vni']}  ${adjacency['eid']}  0  ${adjacency['seid']}  0  ${adjacency['rloc']}  is_mac=${TRUE}
Vpp Add Lisp Adjacency  ${dut_node}  ${settings['vni']}  ${adjacency['eid']}  0  ${adjacency['seid']}  0  is_mac=${TRUE}

lisp_api module

Lisp locator_set data is prepared

Generate lisp locator_set data for test the lisp locator_set and locator API.

Arguments: - dut_node - DUT node. Type: dictionary - locator_set_number - Number how many locator_set data will be generated. Type: integer

Return: - No value returned

_NOTE:_ This KW sets following test case variables: - locator_set_values - New generated locator_set data. - locator_set_values_vat - New generated locator_set data expectedfrom VAT.

Example: | Given Lisp locator_set data is prepared | ${nodes[‘DUT1’]} | ${locator_set_number} |


${locator_set_values}  ${locator_set_values_vat}=  Generate Unique Lisp Locator Set Data  ${dut_node}  ${locator_set_number}
Set Test Variable  ${locator_set_values}
Set Test Variable  ${locator_set_values_vat}

Lisp locator_set data is set

Set the lisp locator_set and locator on the VPP node.

Arguments: - dut_node - DUT node. Type: dictionary

Return: - No value returned

_NOTE:_ This KW requires following test case variables: - locator_set_values - Generated locator_set data from KW locator_set data is prepared, which will be set on the VPP node.

Example: | When Lisp locator_set data is set | ${nodes[‘DUT1’]} |


Vpp Set Lisp Locator Set  ${dut_node}  ${locator_set_values}

Lisp locator_set is set correctly

Test if the locator_set is set correctly on the VPP node.

Arguments: - dut_node - DUT node. Type: dictionary

Return: - No value returned

_NOTE:_ This KW requires following test case variables: - locator_set_values_vat - Generated locator_set data from KW locator_set data is prepared, which are expected from VPP via VAT.

Example: | Then Lisp locator_set is set correctly | ${nodes[‘DUT1’]} |


${show_locator_set}=  Vpp Show Lisp Locator Set  ${dut_node}  local
Lisp Locator S Should Be Equal  ${locator_set_values_vat}  ${show_locator_set}

Delete all lisp locator_set from VPP

Delete all lisp locator_set on the VPP node.

Arguments: - dut_node - DUT node. Type: dictionary

Return: - No value returned

_NOTE:_ This KW requires following test case variables: - locator_set_values - Generated locator_set data from KW locator_set data is prepared, which was set on the VPP node.

Example: | When Delete all lisp locator_set from VPP | ${nodes[‘DUT1’]} |


Vpp Unset Lisp Locator Set  ${dut_node}  ${locator_set_values}

Lisp locator_set should be unset

Test if all locator_set are unset from VPP node.

Arguments: - dut_node - DUT node. Type: dictionary

Return: - No value returned

Example: | Then Lisp locator_set should be unset | ${nodes[‘DUT1’]} |


${show_locator_set}=  Vpp Show Lisp Locator Set  ${dut_node}  ${EMPTY}
Lisp Is Empty  ${show_locator_set}

Lisp locator_set data use for test reset locator_set are prepared

Generate lisp special type of locator_set data. This data will be use for test reset locator_set.

Arguments: - dut_node - DUT node. Type: dictionary - locator_set_number - Number how many locator_set data it will generate. Type: integer

Return: - No value returned

_NOTE:_ This KW sets following test case variables: - locator_set_values - New generate locator_set data. - locator_set_values_vat - New generated locator_set data expectedfrom VAT.

Example: | Given Lisp locator_set data use for test reset locator_set are prepared | ${nodes[‘DUT1’]} | ${locator_set_number} |


${locator_set_values}  ${locator_set_values_vat}=  Generate Duplicate Lisp Locator Set Data  ${dut_node}  ${locator_set_number}
Set Test Variable  ${locator_set_values}
Set Test Variable  ${locator_set_values_vat}

Lisp eid address is set

Set the lisp eid address on the VPP node.

Arguments: - dut_node - DUT node. Type: dictionary - set_eid - Test eid data. Type: list

Return: - No value returned

Example: | When Lisp eid address is set | ${nodes[‘DUT1’]} | ${eid_table} |


Vpp Set Lisp Eid Table  ${dut_node}  ${set_eid}

Lisp eid address is set correctly to eid table

Test if the locator_set is set correctly on the VPP node.

Arguments: - dut_node - DUT node. Type: dictionary - set_eid - Example eid data, which was set to the VPP node. Type: list

Return: - No value returned

_NOTE:_ This KW requires following test case variables: - set_eid - Generated eid data, which will be set to the VPP node.

Example: | Then Lisp eid address is set correctly to eid table | ${nodes[‘DUT1’]} | ${eid_table} |


${show_eid}=  Vpp Show Lisp Eid Table  ${dut_node}
Lisp Should Be Equal  ${set_eid}  ${show_eid}

Delete all lisp eid address from VPP

Delete all lisp eid address from the VPP node.

Arguments: - dut_node - DUT node. Type: dictionary - set_eid - Eid data which will be removed from the VPP node. Type: list

Return: - No value returned

Example: | When Delete all lisp eid address from VPP | ${nodes[‘DUT1’]} | ${eid_table} |


Vpp Unset Lisp Eid Table  ${dut_node}  ${set_eid}

Lisp eid table should be empty

Test if the eid table is empty.

Arguments: - dut_node - DUT node. Type: dictionary

Return: - No value returned

Example: | Then Lisp eid table should be empty | ${nodes[‘DUT1’]} |


${show_eid}=  Vpp Show Lisp Eid Table  ${dut_node}
Lisp Is Empty  ${show_eid}

Lisp map resolver address is set

Set the lisp map resolver address in the VPP node.

Arguments: - dut_node - DUT node. Type: dictionary - set_map_resolver - Map resolver data, which will be set on the VPP node. Type: list

Return: - No value returned

Example: | When Lisp map resolver address is set | ${nodes[‘DUT1’]} | ${map_resolver} |


Vpp Set Lisp Map Resolver  ${dut_node}  ${set_map_resolver}

Lisp map resolver address is set correctly

Test if the map resolver address is set correctly on the VPP node.

Arguments: - dut_node - DUT node. Type: dictionary - set_map_resolver - Map resolver data, which was set on the VPP node. Type: list

Return: - No value returned

Example: | Then Lisp map resolver address is set correctly | ${nodes[‘DUT1’]} | ${map_resolver} |


${show_map_resolver}=  Vpp Show Lisp Map Resolver  ${dut_node}
Lisp Should Be Equal  ${set_map_resolver}  ${show_map_resolver}

Delete all lisp map resolver address from VPP

Delete all lisp map resolver address on the VPP node.

Arguments: - dut_node - DUT node. Type: dictionary - map_resolver - Map resolver data, which will be remove from the VPP. Type: list

Return: - No value returned

Example: | When Delete all lisp map resolver address from VPP | ${nodes[‘DUT1’]} | ${map_resolver} |


Vpp Unset Lisp Map Resolver  ${dut_node}  ${set_map_resolver}

Lip map resolver address should be empty

Test if the map resolver are empty.

Arguments: - dut_node - DUT node. Type: dictionary

Return: - No value returned

Example: | Then Lip map resolver address should be empty | ${nodes[‘DUT1’]} |


${show_map_resolver}=  Vpp Show Lisp Map Resolver  ${dut_node}
Lisp Is Empty  ${show_map_resolver}

Enable lisp

Enable lisp on VPP node.

Arguments: - dut_node - DUT node. Type: dictionary

Return: - No value returned

Example: | Enable lisp | ${nodes[‘DUT1’]} |


Vpp Lisp Enable Disable  ${dut_node}  enable

Check if lisp is enabled

Check if the lisp is enabled.

Arguments: - dut_node - DUT node. Type: dictionary - lisp_status_data - Lisp status data, which was set on the VPP node. Type: list

Return: - No value returned

Example: | Check if lisp is enabled | ${nodes[‘DUT1’]} | ${lisp_status_data} |


${show_lisp_stat}=  Vpp Show Lisp State  ${dut_node}
Lisp Should Be Equal  ${show_lisp_stat}  ${lisp_status_data[1]}

Disable lisp

Disable lisp on VPP node.

Arguments: - dut_node - DUT node. Type: dictionary

Return: - No value returned

Example: | Disable lisp | ${nodes[‘DUT1’]} |


Vpp Lisp Enable Disable  ${dut_node}  disable

Check if lisp is disabled

Check if lisp is disabled.

Arguments: - dut_node - DUT node. Type: dictionary - lisp_status_data - Lisp status data, which was set on the VPP node. Type: list

Return: - No value returned

Example: | Check if lisp is disabled | ${nodes[‘DUT1’]} | ${lisp_status_data} |


${show_lisp_stat}=  Vpp Show Lisp State  ${dut_node}
Lisp Should Be Equal  ${show_lisp_stat}  ${lisp_status_data[0]}

Enable Lisp Gpe

Enable Lisp Gpe on VPP node.

Arguments: - dut_node - DUT node. Type: dictionary

Return: - No value returned

Example: | Enable Lisp Gpe | ${nodes[‘DUT1’]} |


Vpp Lisp Gpe Enable Disable  ${dut_node}  enable

Disable Lisp Gpe

Disable Lisp Gpe on VPP node.

Arguments: - dut_node - DUT node. Type: dictionary

Return: - No value returned

Example: | Disable Lisp Gpe | ${nodes[‘DUT1’]} |


Vpp Lisp Gpe Enable Disable  ${dut_node}  disable

lisp_static_adjacency module

Set up Lisp topology

Set up Lisp static adjacency topology.

Arguments: - dut1_node - DUT1 node. Type: dictionary - dut1_int_name - DUT1 node interface name. Type: string - dut1_int_index - DUT1 node interface index. Type: integer - dut2_node - DUT2 node. Type: dictionary - dut2_int_name - DUT2 node interface name. Type: string - dut2_int_index - DUT2 node interface index. Type: integer - locator_set - Locator set values. Type: dictionary - dut1_eid - Dut1 node eid address. Type: dictionary - dut2_eid - Dut2 node eid address. Type: dictionary - dut1_static_adjacency - Dut1 static adjacency. Type: dictionary - dut2_static_adjacency - Dut2 static address. Type: dictionary

Return: - No value returned

Example: | Set up Lisp topology | ${dut1_node} | ${interface_name} | None | ${dut2_node} | ${interface_name} | None | ${locator_set} | ${dut1_eid} | ${dut2_eid} | ${dut1_static_adjacency} | ${dut2_static_adjacency} |


${dut1_int_index}=  Run Keyword If  ${dut1_int_index} is None  Get Interface Sw Index  ${dut1_node}  ${dut1_int_name}  ELSE  Set Variable  ${dut1_int_index}
${dut2_int_index}=  Run Keyword If  ${dut2_int_index} is None  Get Interface Sw Index  ${dut2_node}  ${dut2_int_name}  ELSE  Set Variable  ${dut2_int_index}
Enable Lisp  ${dut1_node}
Vpp Add Lisp Locator Set  ${dut1_node}  ${locator_set['locator_name']}
Vpp Add Lisp Locator  ${dut1_node}  ${locator_set['locator_name']}  ${dut1_int_index}  ${locator_set['priority']}  ${locator_set['weight']}
Vpp Add Lisp Local Eid  ${dut1_node}  ${dut1_eid['locator_name']}  ${dut1_eid['vni']}  ${dut1_eid['eid']}  ${dut1_eid['prefix']}
Vpp Add Lisp Remote Mapping  ${dut1_node}  ${dut1_static_adjacency['vni']}  ${dut1_static_adjacency['deid']}  ${dut1_static_adjacency['prefix']}  ${dut1_static_adjacency['seid']}  ${dut1_static_adjacency['prefix']}  ${dut1_static_adjacency['rloc']}
Vpp Add Lisp Adjacency  ${dut1_node}  ${dut1_static_adjacency['vni']}  ${dut1_static_adjacency['deid']}  ${dut1_static_adjacency['prefix']}  ${dut1_static_adjacency['seid']}  ${dut1_static_adjacency['prefix']}
Enable Lisp  ${dut2_node}
Vpp Add Lisp Locator Set  ${dut2_node}  ${locator_set['locator_name']}
Vpp Add Lisp Locator  ${dut2_node}  ${locator_set['locator_name']}  ${dut2_int_index}  ${locator_set['priority']}  ${locator_set['weight']}
Vpp Add Lisp Local Eid  ${dut2_node}  ${dut2_eid['locator_name']}  ${dut2_eid['vni']}  ${dut2_eid['eid']}  ${dut2_eid['prefix']}
Vpp Add Lisp Remote Mapping  ${dut2_node}  ${dut2_static_adjacency['vni']}  ${dut2_static_adjacency['deid']}  ${dut2_static_adjacency['prefix']}  ${dut2_static_adjacency['seid']}  ${dut2_static_adjacency['prefix']}  ${dut2_static_adjacency['rloc']}
Vpp Add Lisp Adjacency  ${dut2_node}  ${dut2_static_adjacency['vni']}  ${dut2_static_adjacency['deid']}  ${dut2_static_adjacency['prefix']}  ${dut2_static_adjacency['seid']}  ${dut2_static_adjacency['prefix']}

Change Lisp Configuration

Change configuration of the Lisp protocol.

Arguments: - dut1_node - DUT1 node. Type: dictionary - dut2_node - DUT2 node. Type: dictionary - dut1_to_dut2 - DUT1 towards DUT2 interface name. Type: string - dut2_to_dut1 - DUT2 towards DUT1 interface name. Type: string - dut1_to_dut2_mac - DUT1 towards DUT2 interface mac address. Type: string - dut2_to_dut1_mac - DUT2 towards DUT1 interface mac address. Type: string - new_dut1_ip - New DUT1 towards DUT2 interface IP address. Type: string - new_dut2_ip - New DUT2 towards DUT1 interface IP address. Type: string - prefix - Prefix of the DUT nodes. Type: integer - old_dut1_static_adjacency - Old DUT1 static adjacency. Type: dictionary - new_dut1_static_adjacency - New DUT1 static adjacency. Type: dictionary

Return: - No value returned

Example: | Change Lisp Configuration | ${dut1_node} | ${dut2_node} | ${dut1_to_dut2} | ${dut2_to_dut1} “08:00:27:20:e0:0d” | “08:00:27:b1:94:b1” | “6.3.0.1” | “6.3.0.20” | “24” | ${old_dut1_static_adjacency} | ${new_dut1_static_adjacency} |


Flush IPv4 Addresses "${dut2_to_dut1}" "${dut2_node}"
Vpp Del Lisp Remote Mapping  ${dut1_node}  ${old_dut1_static_adjacency['vni']}  ${old_dut1_static_adjacency['deid']}  ${old_dut1_static_adjacency['prefix']}  ${old_dut1_static_adjacency['seid']}  ${old_dut1_static_adjacency['prefix']}  ${old_dut1_static_adjacency['rloc']}
Vpp Del Lisp Adjacency  ${dut1_node}  ${old_dut1_static_adjacency['vni']}  ${old_dut1_static_adjacency['deid']}  ${old_dut1_static_adjacency['prefix']}  ${old_dut1_static_adjacency['seid']}  ${old_dut1_static_adjacency['prefix']}
Set Interface Address  ${dut2_node}  ${dut2_to_dut1}  ${new_dut2_ip}  ${prefix}
Add Arp On Dut  ${dut1_node}  ${dut1_to_dut2}  ${new_dut2_ip}  ${dut2_to_dut1_mac}
Add Arp On Dut  ${dut2_node}  ${dut2_to_dut1}  ${new_dut1_ip}  ${dut1_to_dut2_mac}
Vpp Add Lisp Remote Mapping  ${dut1_node}  ${new_dut1_static_adjacency['vni']}  ${new_dut1_static_adjacency['deid']}  ${new_dut1_static_adjacency['prefix']}  ${new_dut1_static_adjacency['seid']}  ${new_dut1_static_adjacency['prefix']}  ${new_dut1_static_adjacency['rloc']}
Vpp Add Lisp Adjacency  ${dut1_node}  ${new_dut1_static_adjacency['vni']}  ${new_dut1_static_adjacency['deid']}  ${new_dut1_static_adjacency['prefix']}  ${new_dut1_static_adjacency['seid']}  ${new_dut1_static_adjacency['prefix']}

lispgpe module

Set up LISP GPE topology

Set up LISP GPE topology.

Arguments: - dut1_node - DUT1 node. Type: dictionary - dut1_if - DUT1 node interface. Type: string - dut1_int_index - DUT1 node interface index. Type: integer - dut2_node - DUT2 node. Type: dictionary - dut2_if - DUT2 node interface. Type: string - dut2_int_index - DUT2 node interface index. Type: integer - locator_set - Locator set values. Type: dictionary - dut1_eid - DUT1 node eid address. Type: dictionary - dut2_eid - DUT2 node eid address. Type: dictionary - dut1_static_adjacency - DUT1 static adjacency. Type: dictionary - dut2_static_adjacency - DUT2 static adjacency. Type: dictionary

Return: - No value returned

Example: | Set up LISP GPE topology | ${dut1_node} | ${interface_name} | None | ${dut2_node} | ${interface_name} | None | ${locator_set} | ${dut1_eid} | ${dut2_eid} | ${dut1_static_adjacency} | ${dut2_static_adjacency} |


${dut1_int_index}=  Run Keyword If  ${dut1_int_index} is None  Get Interface Sw Index  ${dut1_node}  ${dut1_if}  ELSE  Set Variable  ${dut1_int_index}
Enable Lisp  ${dut1_node}
Enable Lisp GPE  ${dut1_node}
Vpp Add Lisp Locator Set  ${dut1_node}  ${locator_set['locator_name']}
Vpp Add Lisp Locator  ${dut1_node}  ${locator_set['locator_name']}  ${dut1_int_index}  ${locator_set['priority']}  ${locator_set['weight']}
Vpp Lisp Eid Table Mapping  ${dut1_node}  ${vni_table}  vrf=${vrf_table}
Vpp Add Lisp Local Eid  ${dut1_node}  ${dut1_eid['locator_name']}  ${vni_table}  ${dut1_eid['eid']}  ${dut1_eid['prefix']}
Vpp Add Lisp Remote Mapping  ${dut1_node}  ${vni_table}  ${dut1_static_adjacency['deid']}  ${dut1_static_adjacency['prefix']}  ${dut1_static_adjacency['seid']}  ${dut1_static_adjacency['prefix']}  ${dut1_static_adjacency['rloc']}
Vpp Add Lisp Adjacency  ${dut1_node}  ${vni_table}  ${dut1_static_adjacency['deid']}  ${dut1_static_adjacency['prefix']}  ${dut1_static_adjacency['seid']}  ${dut1_static_adjacency['prefix']}
${dut2_int_index}=  Run Keyword If  ${dut2_int_index} is None  Get Interface Sw Index  ${dut2_node}  ${dut2_if}  ELSE  Set Variable  ${dut2_int_index}
Enable Lisp  ${dut2_node}
Enable Lisp GPE  ${dut2_node}
Vpp Add Lisp Locator Set  ${dut2_node}  ${locator_set['locator_name']}
Vpp Add Lisp Locator  ${dut2_node}  ${locator_set['locator_name']}  ${dut2_int_index}  ${locator_set['priority']}  ${locator_set['weight']}
Vpp Lisp Eid Table Mapping  ${dut2_node}  ${vni_table}  vrf=${vrf_table}
Vpp Add Lisp Local Eid  ${dut2_node}  ${dut2_eid['locator_name']}  ${vni_table}  ${dut2_eid['eid']}  ${dut2_eid['prefix']}
Vpp Add Lisp Remote Mapping  ${dut2_node}  ${vni_table}  ${dut2_static_adjacency['deid']}  ${dut2_static_adjacency['prefix']}  ${dut2_static_adjacency['seid']}  ${dut2_static_adjacency['prefix']}  ${dut2_static_adjacency['rloc']}
Vpp Add Lisp Adjacency  ${dut2_node}  ${vni_table}  ${dut2_static_adjacency['deid']}  ${dut2_static_adjacency['prefix']}  ${dut2_static_adjacency['seid']}  ${dut2_static_adjacency['prefix']}