# Copyright (c) 2016 Cisco and/or its affiliates.
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at:
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Library to set up Lisp in topology."""
from resources.libraries.python.topology import NodeType
from resources.libraries.python.VatExecutor import VatExecutor
class LispGpeIface(object):
"""Class for Lisp gpe interface API."""
def __init__(self):
pass
@staticmethod
def vpp_lisp_gpe_iface(node, state):
"""Set lisp gpe interface up or down on the VPP node in topology.
:param node: VPP node.
:param state: State of the gpe iface, up or down
:type node: dict
:type state: str
"""
VatExecutor.cmd_from_template(node,
'lisp/lisp_gpe_iface.vat',
state=state)
class LispMapResolver(object):
"""Class for Lisp map resolver API."""
def __init__(self):
pass
@staticmethod
def vpp_add_map_resolver(node, map_resolver_ip):
"""Set lisp map resolver on the VPP node in topology.
:param node: VPP node.
:param map_resolver_ip: IP address of the map resolver.
:type node: dict
:type map_resolver_ip: str
"""
VatExecutor.cmd_from_template(node,
'lisp/add_lisp_map_resolver.vat',
address=map_resolver_ip)
@staticmethod
def vpp_del_map_resolver(node, map_resolver_ip):
"""Unset lisp map resolver on the VPP node in topology.
:param node: VPP node.
:param map_resolver_ip: IP address of the map resolver.
:type node: dict
:type map_resolver_ip: str
"""
VatExecutor.cmd_from_template(node,
'lisp/del_lisp_map_resolver.vat',
address=map_resolver_ip)
class LispLocalEid(object):
"""Class for Lisp local eid API."""
def __init__(self):
pass
@staticmethod
def vpp_add_lisp_local_eid(node, locator_set_name, address, prefix_len):
"""Set lisp eid addres on the VPP node in topology.
:param node: VPP node.
:param locator_set_name: Name of the locator_set.
:param address: Eid IP address.
:param prefix_len: prefix len of the eid IP address.
:type node: dict
:type locator_set_name: str
:type address: str
:type prefix_len: int
"""
VatExecutor.cmd_from_template(node,
'lisp/add_lisp_local_eid.vat',
eid_address=address,
eid_prefix=prefix_len,
locator_name=locator_set_name)
@staticmethod
def vpp_del_lisp_local_eid(node, locator_set_name, address, prefix_len):
"""Set lisp eid addres on the VPP node in topology.
:param node: VPP node.
:param locator_set_name: Name of the locator_set.
:param address: Eid IP address.
:param prefix_len: prefix len of the eid IP address.
:type node: dict
:type locator_set_name: str
:type address: str
:type prefix_len: int
"""
VatExecutor.cmd_from_template(node,
'lisp/del_lisp_local_eid.vat',
eid_address=address,
eid_prefix=prefix_len,
locator_name=locator_set_name)
class LispLocator(object):
"""Class for the Lisp Locator API."""
def __init__(self):
pass
@staticmethod
def vpp_add_lisp_locator(node, locator_name, sw_if_index, priority, weight):
"""Set lisp locator on the VPP node in topology.
:param node: VPP node.
:param locator_name: Name of the locator_set.
:param sw_if_index: sw_if_index if the interface.
:param priority: priority of the locator.
:param weight: weight of the locator.
:type node: dict
:type locator_name: str
:type sw_if_index: int
:type priority: int
:type weight: int
"""
VatExecutor.cmd_from_template(node,
'lisp/add_lisp_locator.vat',
lisp_name=locator_name,
sw_if_index=sw_if_index,
priority=priority,
weight=weight)
@staticmethod
def vpp_del_lisp_locator(node, locator_name, sw_if_index, priority, weight):
"""Unset lisp locator on the VPP node in topology.
:param node: VPP node.
:param locator_name: Name of the locator_set.
:param sw_if_index: sw_if_index if the interface.
:param priority: priority of the locator.
:param weight: weight of the locator.
:type node: dict
:type locator_name: str
:type sw_if_index: int
:type priority: int
:type weight: int
"""
VatExecutor.cmd_from_template(node,
'lisp/del_lisp_locator.vat',
lisp_name=locator_name,
sw_if_index=sw_if_index,
priority=priority,
weight=weight)
class LispLocatorSet(object):
"""Class for Lisp Locator Set API."""
def __init__(self):
pass
@staticmethod
def vpp_add_lisp_locator_set(node, name):
"""Add lisp locator_set on VPP.
:param node: VPP node.
:param name: VPP locator name.
:type node: dict
:type name: str
"""
VatExecutor.cmd_from_template(node,
'lisp/add_lisp_locator_set.vat',
lisp_name=name)
@staticmethod
def vpp_del_lisp_locator_set(node, name):
"""Del lisp locator_set on VPP.
:param node: VPP node.
:param name: VPP locator name.
:type node: dict
:type name: str
"""
VatExecutor.cmd_from_template(node,
'lisp/del_lisp_locator_set.vat',
lisp_name=name)
class LispSetup(object):
"""Lisp setup in topology."""
def __init__(self):
pass
@staticmethod
def vpp_set_lisp_locator_set(node, locator_sets):
"""Set lisp locator_sets on VPP node in topology.
There are two ways how set lisp locator_set.
One locator_set can contain multiple locators.
Add new locator_set with same name as it already save in vpp
will reset locator_set and his locator.
To not reset locator_set, use "normal" type of generate data,
where the locator_set is set just once.
To test reset locator_set use "reset" type of generate data,
where the locator_set will be set multiple times.
:param node: VPP node.
:param locator_sets: Dictionary containing information of locator_set.
:type node: dict
:type locator_sets: dict
"""
if node['type'] != NodeType.DUT:
raise ValueError('Lisp locator set, node is not DUT')
lisp_locator_set = LispLocatorSet()
lisp_locator = LispLocator()
for locator_set_type, item in locator_sets.iteritems():
if locator_set_type == 'normal':
lsm_set = 1
elif locator_set_type == 'reset':
lsm_set = 0
else:
raise ValueError('Unknown locator_set_type value: '
'{}'.format(locator_set_type))
locator_set_list = []
for locator_set in item:
locator_name = locator_set.get('locator-set')
sw_if_index = locator_set.get('locator')
priority = locator_set.get('priority')
weight = locator_set.get('weight')
if lsm_set == 1:
if locator_name not in locator_set_list:
locator_set_list.append(locator_name)
lisp_locator_set.vpp_add_lisp_locator_set(node,
locator_name)
else:
lisp_locator_set.vpp_add_lisp_locator_set(node,
locator_name)
lisp_locator.vpp_add_lisp_locator(node,
locator_name,
sw_if_index,
priority,
weight)
@staticmethod
def vpp_unset_lisp_locator_set(node, locator_sets):
"""Unset lisp locator_sets on VPP node in topology.
:param node: VPP node.
:param locator_sets: Dictionary containing information of locator_set.
:type node: dict
:type locator_sets: dict
"""
if node['type'] != NodeType.DUT:
raise ValueError('Lisp locator set, node is not DUT')
lisp_locator = LispLocator()
lisp_locator_set = LispLocatorSet()
for locator_set_type, item in locator_sets.iteritems():
if locator_set_type == 'normal':
lsm_set = 1
elif locator_set_type == 'reset':
lsm_set = 0
else:
raise ValueError('Unknown locator_set_type value: '
'{}'.format(locator_set_type))
locator_set_list = []
for locator_set in item:
locator_set_name = locator_set.get('locator-set')
sw_if_index = locator_set.get('locator')
priority = locator_set.get('priority')
weight = locator_set.get('weight')
if lsm_set == 1:
if locator_set_name not in locator_set_list:
locator_set_list.append(locator_set_name)
else:
lisp_locator.vpp_del_lisp_locator(node,
locator_set_name,
sw_if_index,
priority,
weight)
for locator_set_name in locator_set_list:
lisp_locator_set.vpp_del_lisp_locator_set(node, locator_set_name)
@staticmethod
def vpp_set_lisp_eid_table(node, eid_table):
"""Set lisp eid tables on VPP node in topology.
:param node: VPP node.
:param eid_table: Dictionary containing information of eid_table.
:type node: dict
:type eid_table: dict
"""
if node['type'] != NodeType.DUT:
raise ValueError('Lisp locator set, node is not DUT')
lisp_locator_set = LispLocatorSet()
lisp_eid = LispLocalEid()
for eid in eid_table:
eid_address = eid.get('eid address')
eid_prefix_len = eid.get('eid prefix len')
locator_set_name = eid.get('locator-set')
lisp_locator_set.vpp_add_lisp_locator_set(node, locator_set_name)
lisp_eid.vpp_add_lisp_local_eid(node,
locator_set_name,
eid_address,
eid_prefix_len)
@staticmethod
def vpp_unset_lisp_eid_table(node, eid_table):
"""Unset lisp eid tables on VPP node in topology.
:param node: VPP node.
:param eid_table: Dictionary containing information of eid_table.
:type node: dict
:type eid_table: dict
"""
if node['type'] != NodeType.DUT:
raise ValueError('Lisp locator set, node is not DUT')
locator_set_list = []
lisp_locator_set = LispLocatorSet()
lisp_eid = LispLocalEid()
for eid in eid_table:
eid_address = eid.get('eid address')
eid_prefix_len = eid.get('eid prefix len')
locator_set_name = eid.get('locator-set')
if locator_set_name not in locator_set_list:
locator_set_list.append(locator_set_name)
lisp_eid.vpp_del_lisp_local_eid(node,
locator_set_name,
eid_address,
eid_prefix_len)
for locator_set_name in locator_set_list:
lisp_locator_set.vpp_del_lisp_locator_set(node, locator_set_name)
@staticmethod
def vpp_set_lisp_map_resolver(node, map_resolver):
"""Set lisp map resolvers on VPP node in topology.
:param node: VPP node.
:param map_resolver: Dictionary containing information of map resolver.
:type node: dict
:type map_resolver: dict
"""
lisp_map_res = LispMapResolver()
for map_ip in map_resolver:
lisp_map_res.vpp_add_map_resolver(node, map_ip.get('map resolver'))
@staticmethod
def vpp_unset_lisp_map_resolver(node, map_resolver):
"""Unset lisp map resolvers on VPP node in topology.
:param node: VPP node.
:param map_resolver: Dictionary containing information of map resolver.
:type node: dict
:type map_resolver: dict
"""
lisp_map_res = LispMapResolver()
for map_ip in map_resolver:
lisp_map_res.vpp_del_map_resolver(node, map_ip.get('map resolver'))
@staticmethod
def vpp_lisp_gpe_interface_status(node, state):
"""Set lisp gpe interface status on VPP node in topology.
:param node: VPP node.
:param state: State of the gpe iface, up or down
:type node: dict
:type state: str
"""
lgi = LispGpeIface()
lgi.vpp_lisp_gpe_iface(node, state)