lisp: API cleanup

Use consistent API types.

Type: fix

Signed-off-by: Jakub Grajciar <jgrajcia@cisco.com>
Change-Id: Ib7f73a0b6de188982a09040f7739dc46be3cb1de
Signed-off-by: Jakub Grajciar <jgrajcia@cisco.com>

3 files changed, 94 insertions, 204 deletions

diff --git a/test/lisp.py b/test/lisp.py
index 86f0009ead1..a2e711f9d2a 100644
--- a/test/lisp.py
+++ b/test/lisp.py
@@ -1,4 +1,5 @@
 import socket
+from ipaddress import ip_network
 
 from vpp_object import VppObject
 
@@ -19,13 +20,13 @@ class VppLispLocatorSet(VppObject):
         return self._ls_name
 
     def add_vpp_config(self):
-        self.test.vapi.lisp_add_del_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(b'\x00') == self._ls_name:
+            if ls.ls_name.strip('\x00') == self._ls_name:
                 return ls
         return None
 
@@ -33,7 +34,7 @@ class VppLispLocatorSet(VppObject):
         return self.get_lisp_locator_sets_dump_entry() is not None
 
     def remove_vpp_config(self):
-        self.test.vapi.lisp_add_del_locator_set(ls_name=self._ls_name,
+        self.test.vapi.lisp_add_del_locator_set(locator_set_name=self._ls_name,
                                                 is_add=0)
 
     def object_id(self):
@@ -73,7 +74,7 @@ class VppLispLocator(VppObject):
         return self._weight
 
     def add_vpp_config(self):
-        self.test.vapi.lisp_add_del_locator(ls_name=self._ls_name,
+        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)
@@ -93,7 +94,7 @@ class VppLispLocator(VppObject):
 
     def remove_vpp_config(self):
         self.test.vapi.lisp_add_del_locator(
-                ls_name=self._ls_name, sw_if_index=self._sw_if_index,
+                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)
 
@@ -102,9 +103,9 @@ class VppLispLocator(VppObject):
 
 
 class LispEIDType(object):
-    IP4 = 0
-    IP6 = 1
-    MAC = 2
+    PREFIX = 0
+    MAC = 1
+    NSH = 2
 
 
 class LispKeyIdType(object):
@@ -117,35 +118,52 @@ class LispEID(object):
     """ 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))
 
-        # 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 {!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')
 
     @property
     def packed(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)
+        if self.eid_type == LispEIDType.PREFIX:
+            return {"type": self._type, "address": {"prefix": self.prefix}}
         elif self.eid_type == LispEIDType.MAC:
+            return {"type": self._type, "address": {"mac": self.mac}}
+        elif self.eid_type == LispEIDType.NSH:
             return Exception('Unimplemented')
-        raise Exception('Unknown EID type {!s}!'.format(self.eid_type))
+
+
+class LispKey(object):
+    """ 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):
@@ -180,9 +198,7 @@ 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=self._eid.packed)
+            eid_set=1, vni=self._vni, eid=self._eid.packed)
 
     def query_vpp_config(self):
         mapping = self.get_lisp_mapping_dump_entry()
@@ -190,7 +206,7 @@ class VppLispMapping(VppObject):
 
     def object_id(self):
         return 'lisp-mapping-[%s]-%s-%s-%s' % (
-            self.vni, self.eid, self.priority, self.weight)
+            self.vni, self.eid.address, self.priority, self.weight)
 
 
 class VppLocalMapping(VppLispMapping):
@@ -199,8 +215,7 @@ class VppLocalMapping(VppLispMapping):
                  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):
@@ -216,19 +231,29 @@ class VppLocalMapping(VppLispMapping):
 
     def add_vpp_config(self):
         self.test.vapi.lisp_add_del_local_eid(
-                ls_name=self._ls_name, eid_type=self._eid.eid_type,
-                eid=self._eid.packed, prefix_len=self._eid.prefix_length,
-                vni=self._vni, key_id=self._key_id, key=self._key)
+                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_add_del_local_eid(
-                ls_name=self._ls_name, eid_type=self._eid.eid_type,
-                eid=self._eid.packed, prefix_len=self._eid.prefix_length,
+                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 LispRemoteLocator(object):
+    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):
@@ -240,23 +265,24 @@ class VppRemoteMapping(VppLispMapping):
 
     @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_add_del_remote_mapping(
-                rlocs=self._rlocs, eid_type=self._eid.eid_type,
-                eid=self._eid.packed, eid_prefix_len=self._eid.prefix_length,
-                vni=self._vni, rlocs_num=len(self._rlocs))
+                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_add_del_remote_mapping(
-                eid_type=self._eid.eid_type, eid=self._eid.packed,
-                eid_prefix_len=self._eid.prefix_length, vni=self._vni,
-                is_add=0, rlocs_num=0)
+                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):
@@ -288,22 +314,19 @@ class VppLispAdjacency(VppObject):
 
     def add_vpp_config(self):
         self.test.vapi.lisp_add_del_adjacency(
-                leid=self._leid.packed,
-                reid=self._reid.packed, eid_type=self._leid.eid_type,
-                leid_len=self._leid.prefix_length,
-                reid_len=self._reid.prefix_length, vni=self._vni)
+                leid=self._leid.packed, reid=self._reid.packed, vni=self._vni)
         self._test.registry.register(self, self.test.logger)
 
     @staticmethod
-    def eid_equal(eid, eid_type, eid_data, prefix_len):
-        if eid.eid_type != eid_type:
+    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 eid.packed != eid_data[0:eid.data_length]:
+        if eid.address != eid_api.address:
             return False
 
         return True
@@ -311,19 +334,15 @@ 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_add_del_adjacency(
-                leid=self._leid.packed,
-                reid=self._reid.packed, eid_type=self._leid.eid_type,
-                leid_len=self._leid.prefix_length,
-                reid_len=self._reid.prefix_length, vni=self._vni, is_add=0)
+                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)
diff --git a/test/test_lisp.py b/test/test_lisp.py
index 596df8caac4..70cb4f4bf34 100644
--- a/test/test_lisp.py
+++ b/test/test_lisp.py
@@ -11,7 +11,7 @@ from scapy.layers.inet6 import IPv6
 
 from framework import VppTestCase, VppTestRunner
 from lisp import VppLocalMapping, VppLispAdjacency, VppLispLocator, \
-    VppLispLocatorSet, VppRemoteMapping
+    VppLispLocatorSet, VppRemoteMapping, LispRemoteLocator
 from util import ppp, ForeignAddressFactory
 
 # From py_lispnetworking.lisp.py:  # GNU General Public License v2.0
@@ -151,7 +151,7 @@ class TestLisp(VppTestCase):
 
     def setUp(self):
         super(TestLisp, self).setUp()
-        self.vapi.lisp_enable_disable(is_enabled=1)
+        self.vapi.lisp_enable_disable(is_enable=1)
 
     def test_lisp_basic_encap(self):
         """Test case for basic encapsulation"""
@@ -159,26 +159,21 @@ class TestLisp(VppTestCase):
         self.deid_ip4_net = self.faf.net
         self.deid_ip4 = self.faf.get_ip4()
         self.seid_ip4 = '{!s}/{!s}'.format(self.pg0.local_ip4, 32)
-        self.rloc_ip4 = self.pg1.remote_ip4n
+        self.rloc_ip4 = self.pg1.remote_ip4
 
         test_cases = [
             {
                 'name': 'basic ip4 over ip4',
-                'locator-sets': [VppLispLocatorSet(self, b'ls-4o4')],
+                'locator-sets': [VppLispLocatorSet(self, 'ls-4o4')],
                 'locators': [
-                    VppLispLocator(self, self.pg1.sw_if_index, b'ls-4o4')
+                    VppLispLocator(self, self.pg1.sw_if_index, 'ls-4o4')
                 ],
                 'local-mappings': [
-                    VppLocalMapping(self, self.seid_ip4, b'ls-4o4')
+                    VppLocalMapping(self, self.seid_ip4, 'ls-4o4')
                 ],
                 'remote-mappings': [
                     VppRemoteMapping(self, self.deid_ip4_net,
-                                     [{
-                                         "is_ip4": 1,
-                                         "priority": 1,
-                                         "weight": 1,
-                                         "addr": self.rloc_ip4
-                                     }])
+                                     [LispRemoteLocator(self.rloc_ip4)])
                 ],
                 'adjacencies': [
                     VppLispAdjacency(self, self.seid_ip4, self.deid_ip4_net)
diff --git a/test/vpp_papi_provider.py b/test/vpp_papi_provider.py
index 94de500d9f9..92820b0586e 100644
--- a/test/vpp_papi_provider.py
+++ b/test/vpp_papi_provider.py
@@ -711,130 +711,6 @@ class VppPapiProvider(object):
                             'is_ip6': is_ip6
                         }})
 
-    def lisp_enable_disable(self, is_enabled):
-        return self.api(
-            self.papi.lisp_enable_disable,
-            {
-                'is_en': is_enabled,
-            })
-
-    def lisp_add_del_locator_set(self,
-                                 ls_name,
-                                 is_add=1):
-        return self.api(
-            self.papi.lisp_add_del_locator_set,
-            {
-                'is_add': is_add,
-                'locator_set_name': ls_name
-            })
-
-    def lisp_add_del_locator(self,
-                             ls_name,
-                             sw_if_index,
-                             priority=1,
-                             weight=1,
-                             is_add=1):
-        return self.api(
-            self.papi.lisp_add_del_locator,
-            {
-                'is_add': is_add,
-                'locator_set_name': ls_name,
-                'sw_if_index': sw_if_index,
-                'priority': priority,
-                'weight': weight
-            })
-
-    def lisp_locator_dump(self, is_index_set, ls_name=None, ls_index=0):
-        return self.api(
-            self.papi.lisp_locator_dump,
-            {
-                'is_index_set': is_index_set,
-                'ls_name': ls_name,
-                'ls_index': ls_index,
-            })
-
-    def lisp_add_del_local_eid(self,
-                               ls_name,
-                               eid_type,
-                               eid,
-                               prefix_len,
-                               vni=0,
-                               key_id=0,
-                               key="",
-                               is_add=1):
-        return self.api(
-            self.papi.lisp_add_del_local_eid,
-            {
-                'locator_set_name': ls_name,
-                'is_add': is_add,
-                'eid_type': eid_type,
-                'eid': eid,
-                'prefix_len': prefix_len,
-                'vni': vni,
-                'key_id': key_id,
-                'key': key
-            })
-
-    def lisp_eid_table_dump(self,
-                            eid_set=0,
-                            prefix_length=0,
-                            vni=0,
-                            eid_type=0,
-                            eid=None,
-                            filter_opt=0):
-        return self.api(
-            self.papi.lisp_eid_table_dump,
-            {
-                'eid_set': eid_set,
-                'prefix_length': prefix_length,
-                'vni': vni,
-                'eid_type': eid_type,
-                'eid': eid,
-                'filter': filter_opt,
-            })
-
-    def lisp_add_del_remote_mapping(self,
-                                    eid_type,
-                                    eid,
-                                    eid_prefix_len=0,
-                                    vni=0,
-                                    rlocs=[],
-                                    rlocs_num=0,
-                                    is_src_dst=0,
-                                    is_add=1):
-        return self.api(
-            self.papi.lisp_add_del_remote_mapping,
-            {
-                'is_add': is_add,
-                'eid_type': eid_type,
-                'eid': eid,
-                'eid_len': eid_prefix_len,
-                'rloc_num': rlocs_num,
-                'rlocs': rlocs,
-                'vni': vni,
-                'is_src_dst': is_src_dst,
-            })
-
-    def lisp_add_del_adjacency(self,
-                               leid,
-                               reid,
-                               leid_len,
-                               reid_len,
-                               eid_type,
-                               is_add=1,
-                               vni=0):
-        return self.api(
-            self.papi.lisp_add_del_adjacency,
-            {
-                'is_add': is_add,
-                'vni': vni,
-                'eid_type': eid_type,
-                'leid': leid,
-                'reid': reid,
-                'leid_len': leid_len,
-                'reid_len': reid_len,
-            })
-
     def vxlan_gpe_add_del_tunnel(
             self,
             src_addr,