X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=test%2Flisp.py;h=9ebc86a35e3713b10faf8a24f9f6178606d025d9;hb=d9b0c6fbf7aa5bd9af84264105b39c82028a4a29;hp=865070dff9d7fd2afd572f743abccb390e48f973;hpb=770e89e6b916319eedd91c6edf16f0d7e89f556c;p=vpp.git diff --git a/test/lisp.py b/test/lisp.py index 865070dff9d..9ebc86a35e3 100644 --- a/test/lisp.py +++ b/test/lisp.py @@ -1,15 +1,11 @@ -from random import randint -from socket import AF_INET, AF_INET6 -from scapy.all import * -from scapy.packet import * -from scapy.fields import * -from lisp import * -from framework import * -from vpp_object import * +import socket +from ipaddress import ip_network + +from vpp_object import VppObject class VppLispLocatorSet(VppObject): - """ Represents LISP locator set in VPP """ + """Represents LISP locator set in VPP""" def __init__(self, test, ls_name): self._test = test @@ -24,13 +20,13 @@ class VppLispLocatorSet(VppObject): return self._ls_name def add_vpp_config(self): - self.test.vapi.lisp_locator_set(ls_name=self._ls_name) + self.test.vapi.lisp_add_del_locator_set(locator_set_name=self._ls_name) self._test.registry.register(self, self.test.logger) def get_lisp_locator_sets_dump_entry(self): result = self.test.vapi.lisp_locator_set_dump() for ls in result: - if ls.ls_name.strip('\x00') == self._ls_name: + if ls.ls_name.strip("\x00") == self._ls_name: return ls return None @@ -38,14 +34,16 @@ class VppLispLocatorSet(VppObject): return self.get_lisp_locator_sets_dump_entry() is not None def remove_vpp_config(self): - self.test.vapi.lisp_locator_set(ls_name=self._ls_name, is_add=0) + self.test.vapi.lisp_add_del_locator_set( + locator_set_name=self._ls_name, is_add=0 + ) def object_id(self): - return 'lisp-locator-set-%s' % self._ls_name + return "lisp-locator-set-%s" % self._ls_name class VppLispLocator(VppObject): - """ Represents LISP locator in VPP """ + """Represents LISP locator in VPP""" def __init__(self, test, sw_if_index, ls_name, priority=1, weight=1): self._test = test @@ -56,12 +54,12 @@ class VppLispLocator(VppObject): @property def test(self): - """ Test which created this locator """ + """Test which created this locator""" return self._test @property def ls_name(self): - """ Locator set name """ + """Locator set name""" return self._ls_name @property @@ -70,22 +68,25 @@ class VppLispLocator(VppObject): @property def priority(self): - return self.priority + return self._priority @property def weight(self): return self._weight def add_vpp_config(self): - self.test.vapi.lisp_locator(ls_name=self._ls_name, - sw_if_index=self._sw_if_index, - priority=self._priority, - weight=self._weight) + self.test.vapi.lisp_add_del_locator( + locator_set_name=self._ls_name, + sw_if_index=self._sw_if_index, + priority=self._priority, + weight=self._weight, + ) self._test.registry.register(self, self.test.logger) def get_lisp_locator_dump_entry(self): locators = self.test.vapi.lisp_locator_dump( - is_index_set=0, ls_name=self._ls_name) + is_index_set=0, ls_name=self._ls_name + ) for locator in locators: if locator.sw_if_index == self._sw_if_index: return locator @@ -96,63 +97,87 @@ class VppLispLocator(VppObject): return locator is not None def remove_vpp_config(self): - self.test.vapi.lisp_locator( - ls_name=self._ls_name, sw_if_index=self._sw_if_index, - priority=self._priority, weight=self._weight, is_add=0) + self.test.vapi.lisp_add_del_locator( + locator_set_name=self._ls_name, + sw_if_index=self._sw_if_index, + priority=self._priority, + weight=self._weight, + is_add=0, + ) self._test.registry.register(self, self.test.logger) def object_id(self): - return 'lisp-locator-%s-%d' % (self._ls_name, self._sw_if_index) + return "lisp-locator-%s-%d" % (self._ls_name, self._sw_if_index) -class LispEIDType(object): - IP4 = 0 - IP6 = 1 - MAC = 2 +class LispEIDType: + PREFIX = 0 + MAC = 1 + NSH = 2 -class LispKeyIdType(object): +class LispKeyIdType: NONE = 0 SHA1 = 1 SHA256 = 2 -class LispEID(object): - """ Lisp endpoint identifier """ +class LispEID: + """Lisp endpoint identifier""" + def __init__(self, eid): self.eid = eid + self._type = -1 + + # find out whether EID is ip prefix, or MAC + try: + self.prefix = ip_network(self.eid) + self._type = LispEIDType.PREFIX + return + except ValueError: + if self.eid.count(":") == 5: # MAC address + self.mac = self.eid + self._type = LispEIDType.MAC + return + raise Exception("Unsupported EID format {!s}!".format(eid)) + + @property + def eid_type(self): + return self._type + + @property + def address(self): + if self.eid_type == LispEIDType.PREFIX: + return self.prefix + elif self.eid_type == LispEIDType.MAC: + return self.mac + elif self.eid_type == LispEIDType.NSH: + return Exception("Unimplemented") - # find out whether EID is ip4 prefix, ip6 prefix or MAC - if self.eid.find("/") != -1: - if self.eid.find(":") == -1: - self.eid_type = LispEIDType.IP4 - self.data_length = 4 - else: - self.eid_type = LispEIDType.IP6 - self.data_length = 16 - - self.eid_address = self.eid.split("/")[0] - self.prefix_length = int(self.eid.split("/")[1]) - elif self.eid.count(":") == 5: # MAC address - self.eid_type = LispEIDType.MAC - self.eid_address = self.eid - self.prefix_length = 0 - self.data_length = 6 - else: - raise Exception('Unsupported EID format {}!'.format(eid)) - - def __str__(self): - if self.eid_type == LispEIDType.IP4: - return socket.inet_pton(socket.AF_INET, self.eid_address) - elif self.eid_type == LispEIDType.IP6: - return socket.inet_pton(socket.AF_INET6, self.eid_address) + @property + def packed(self): + if self.eid_type == LispEIDType.PREFIX: + return {"type": self._type, "address": {"prefix": self.prefix}} elif self.eid_type == LispEIDType.MAC: - return Exception('Unimplemented') - raise Exception('Unknown EID type {}!'.format(self.eid_type)) + return {"type": self._type, "address": {"mac": self.mac}} + elif self.eid_type == LispEIDType.NSH: + return Exception("Unimplemented") + + +class LispKey: + """Lisp Key""" + + def __init__(self, key_type, key): + self._key_type = key_type + self._key = key + + @property + def packed(self): + return {"id": self._key_type, "key": self._key} class VppLispMapping(VppObject): - """ Represents common features for remote and local LISP mapping in VPP """ + """Represents common features for remote and local LISP mapping in VPP""" def __init__(self, test, eid, vni=0, priority=1, weight=1): self._eid = LispEID(eid) @@ -183,22 +208,39 @@ class VppLispMapping(VppObject): def get_lisp_mapping_dump_entry(self): return self.test.vapi.lisp_eid_table_dump( - eid_set=1, prefix_length=self._eid.prefix_length, - vni=self._vni, eid_type=self._eid.eid_type, eid=str(self._eid)) + eid_set=1, vni=self._vni, eid=self._eid.packed + ) def query_vpp_config(self): mapping = self.get_lisp_mapping_dump_entry() return mapping + def object_id(self): + return "lisp-mapping-[%s]-%s-%s-%s" % ( + self.vni, + self.eid.address, + self.priority, + self.weight, + ) + class VppLocalMapping(VppLispMapping): - """ LISP Local mapping """ - def __init__(self, test, eid, ls_name, vni=0, priority=1, weight=1, - key_id=LispKeyIdType.NONE, key=''): + """LISP Local mapping""" + + def __init__( + self, + test, + eid, + ls_name, + vni=0, + priority=1, + weight=1, + key_id=LispKeyIdType.NONE, + key="", + ): super(VppLocalMapping, self).__init__(test, eid, vni, priority, weight) self._ls_name = ls_name - self._key_id = key_id - self._key = key + self._key = LispKey(key_id, key) @property def ls_name(self): @@ -213,58 +255,79 @@ class VppLocalMapping(VppLispMapping): return self._key def add_vpp_config(self): - self.test.vapi.lisp_local_mapping( - ls_name=self._ls_name, eid_type=self._eid.eid_type, - eid=str(self._eid), prefix_len=self._eid.prefix_length, - vni=self._vni, key_id=self._key_id, key=self._key) + self.test.vapi.lisp_add_del_local_eid( + locator_set_name=self._ls_name, + eid=self._eid.packed, + vni=self._vni, + key=self._key.packed, + ) self._test.registry.register(self, self.test.logger) def remove_vpp_config(self): - self.test.vapi.lisp_local_mapping( - ls_name=self._ls_name, eid_type=self._eid.eid_type, - eid=str(self._eid), prefix_len=self._eid.prefix_length, - vni=self._vni, is_add=0) + self.test.vapi.lisp_add_del_local_eid( + locator_set_name=self._ls_name, + eid=self._eid.packed, + vni=self._vni, + is_add=0, + ) def object_id(self): - return 'lisp-eid-local-mapping-%s[%d]' % (self._eid, self._vni) + return "lisp-eid-local-mapping-%s[%d]" % (self._eid.address, self._vni) -class VppRemoteMapping(VppLispMapping): +class LispRemoteLocator: + def __init__(self, addr, priority=1, weight=1): + self.addr = addr + self.priority = priority + self.weight = weight + + @property + def packed(self): + return { + "priority": self.priority, + "weight": self.weight, + "ip_address": self.addr, + } + +class VppRemoteMapping(VppLispMapping): def __init__(self, test, eid, rlocs=None, vni=0, priority=1, weight=1): - super(VppRemoteMapping, self).__init__(test, eid, vni, priority, - weight) + super(VppRemoteMapping, self).__init__(test, eid, vni, priority, weight) self._rlocs = rlocs @property def rlocs(self): - return self._rlocs + rlocs = [] + for rloc in self._rlocs: + rlocs.append(rloc.packed) + return rlocs def add_vpp_config(self): - self.test.vapi.lisp_remote_mapping( - rlocs=self._rlocs, eid_type=self._eid.eid_type, - eid=str(self._eid), eid_prefix_len=self._eid.prefix_length, - vni=self._vni, rlocs_num=len(self._rlocs)) + self.test.vapi.lisp_add_del_remote_mapping( + rlocs=self.rlocs, + deid=self._eid.packed, + vni=self._vni, + rloc_num=len(self._rlocs), + ) self._test.registry.register(self, self.test.logger) def remove_vpp_config(self): - self.test.vapi.lisp_remote_mapping( - eid_type=self._eid.eid_type, eid=str(self._eid), - eid_prefix_len=self._eid.prefix_length, vni=self._vni, - is_add=0, rlocs_num=0) + self.test.vapi.lisp_add_del_remote_mapping( + deid=self._eid.packed, vni=self._vni, is_add=0, rloc_num=0 + ) def object_id(self): - return 'lisp-eid-remote-mapping-%s[%d]' % (self._eid, self._vni) + return "lisp-eid-remote-mapping-%s[%d]" % (self._eid.address, self._vni) class VppLispAdjacency(VppObject): - """ Represents LISP adjacency in VPP """ + """Represents LISP adjacency in VPP""" def __init__(self, test, leid, reid, vni=0): self._leid = LispEID(leid) self._reid = LispEID(reid) if self._leid.eid_type != self._reid.eid_type: - raise Exception('remote and local EID are different types!') + raise Exception("remote and local EID are different types!") self._vni = vni self._test = test @@ -285,22 +348,21 @@ class VppLispAdjacency(VppObject): return self._vni def add_vpp_config(self): - self.test.vapi.lisp_adjacency( - leid=str(self._leid), - reid=str(self._reid), eid_type=self._leid.eid_type, - leid_len=self._leid.prefix_length, - reid_len=self._reid.prefix_length, vni=self._vni) + self.test.vapi.lisp_add_del_adjacency( + leid=self._leid.packed, reid=self._reid.packed, vni=self._vni + ) self._test.registry.register(self, self.test.logger) - def eid_equal(self, eid, eid_type, eid_data, prefix_len): - if eid.eid_type != eid_type: + @staticmethod + def eid_equal(eid, eid_api): + if eid.eid_type != eid_api.type: return False - if eid_type == LispEIDType.IP4 or eid_type == LispEIDType.IP6: - if eid.prefix_length != prefix_len: + if eid_api.type == LispEIDType.PREFIX: + if eid.address.prefixlen != eid_api.address.prefix.prefixlen: return False - if str(eid) != eid_data[0:eid.data_length]: + if eid.address != eid_api.address: return False return True @@ -308,19 +370,16 @@ class VppLispAdjacency(VppObject): def query_vpp_config(self): res = self.test.vapi.lisp_adjacencies_get(vni=self._vni) for adj in res.adjacencies: - if self.eid_equal(self._leid, adj.eid_type, adj.leid, - adj.leid_prefix_len) and \ - self.eid_equal(self._reid, adj.eid_type, adj.reid, - adj.reid_prefix_len): + if self.eid_equal(self._leid, adj.leid) and self.eid_equal( + self._reid, adj.reid + ): return True return False def remove_vpp_config(self): - self.test.vapi.lisp_adjacency( - leid=str(self._leid), - reid=str(self._reid), eid_type=self._leid.eid_type, - leid_len=self._leid.prefix_length, - reid_len=self._reid.prefix_length, vni=self._vni, is_add=0) + self.test.vapi.lisp_add_del_adjacency( + leid=self._leid.packed, reid=self._reid.packed, vni=self._vni, is_add=0 + ) def object_id(self): - return 'lisp-adjacency-%s-%s[%d]' % (self._leid, self._reid, self._vni) + return "lisp-adjacency-%s-%s[%d]" % (self._leid, self._reid, self._vni)