test/lisp.py

   1 import socket
   2
   3 from vpp_object import VppObject
   4
   5
   6 class VppLispLocatorSet(VppObject):
   7     """ Represents LISP locator set in VPP """
   8
   9     def __init__(self, test, ls_name):
  10         self._test = test
  11         self._ls_name = ls_name
  12
  13     @property
  14     def test(self):
  15         return self._test
  16
  17     @property
  18     def ls_name(self):
  19         return self._ls_name
  20
  21     def add_vpp_config(self):
  22         self.test.vapi.lisp_locator_set(ls_name=self._ls_name)
  23         self._test.registry.register(self, self.test.logger)
  24
  25     def get_lisp_locator_sets_dump_entry(self):
  26         result = self.test.vapi.lisp_locator_set_dump()
  27         for ls in result:
  28             if ls.ls_name.strip('\x00') == self._ls_name:
  29                 return ls
  30         return None
  31
  32     def query_vpp_config(self):
  33         return self.get_lisp_locator_sets_dump_entry() is not None
  34
  35     def remove_vpp_config(self):
  36         self.test.vapi.lisp_locator_set(ls_name=self._ls_name, is_add=0)
  37
  38     def object_id(self):
  39         return 'lisp-locator-set-%s' % self._ls_name
  40
  41
  42 class VppLispLocator(VppObject):
  43     """ Represents LISP locator in VPP """
  44
  45     def __init__(self, test, sw_if_index, ls_name, priority=1, weight=1):
  46         self._test = test
  47         self._sw_if_index = sw_if_index
  48         self._ls_name = ls_name
  49         self._priority = priority
  50         self._weight = weight
  51
  52     @property
  53     def test(self):
  54         """ Test which created this locator """
  55         return self._test
  56
  57     @property
  58     def ls_name(self):
  59         """ Locator set name """
  60         return self._ls_name
  61
  62     @property
  63     def sw_if_index(self):
  64         return self._sw_if_index
  65
  66     @property
  67     def priority(self):
  68         return self._priority
  69
  70     @property
  71     def weight(self):
  72         return self._weight
  73
  74     def add_vpp_config(self):
  75         self.test.vapi.lisp_locator(ls_name=self._ls_name,
  76                                     sw_if_index=self._sw_if_index,
  77                                     priority=self._priority,
  78                                     weight=self._weight)
  79         self._test.registry.register(self, self.test.logger)
  80
  81     def get_lisp_locator_dump_entry(self):
  82         locators = self.test.vapi.lisp_locator_dump(
  83                 is_index_set=0, ls_name=self._ls_name)
  84         for locator in locators:
  85             if locator.sw_if_index == self._sw_if_index:
  86                 return locator
  87         return None
  88
  89     def query_vpp_config(self):
  90         locator = self.get_lisp_locator_dump_entry()
  91         return locator is not None
  92
  93     def remove_vpp_config(self):
  94         self.test.vapi.lisp_locator(
  95                 ls_name=self._ls_name, sw_if_index=self._sw_if_index,
  96                 priority=self._priority, weight=self._weight, is_add=0)
  97         self._test.registry.register(self, self.test.logger)
  98
  99     def object_id(self):
 100         return 'lisp-locator-%s-%d' % (self._ls_name, self._sw_if_index)
 101
 102
 103 class LispEIDType(object):
 104     IP4 = 0
 105     IP6 = 1
 106     MAC = 2
 107
 108
 109 class LispKeyIdType(object):
 110     NONE = 0
 111     SHA1 = 1
 112     SHA256 = 2
 113
 114
 115 class LispEID(object):
 116     """ Lisp endpoint identifier """
 117     def __init__(self, eid):
 118         self.eid = eid
 119
 120         # find out whether EID is ip4 prefix, ip6 prefix or MAC
 121         if self.eid.find("/") != -1:
 122             if self.eid.find(":") == -1:
 123                 self.eid_type = LispEIDType.IP4
 124                 self.data_length = 4
 125             else:
 126                 self.eid_type = LispEIDType.IP6
 127                 self.data_length = 16
 128
 129             self.eid_address = self.eid.split("/")[0]
 130             self.prefix_length = int(self.eid.split("/")[1])
 131         elif self.eid.count(":") == 5:  # MAC address
 132             self.eid_type = LispEIDType.MAC
 133             self.eid_address = self.eid
 134             self.prefix_length = 0
 135             self.data_length = 6
 136         else:
 137             raise Exception('Unsupported EID format {}!'.format(eid))
 138
 139     def __str__(self):
 140         if self.eid_type == LispEIDType.IP4:
 141             return socket.inet_pton(socket.AF_INET, self.eid_address)
 142         elif self.eid_type == LispEIDType.IP6:
 143             return socket.inet_pton(socket.AF_INET6, self.eid_address)
 144         elif self.eid_type == LispEIDType.MAC:
 145             return Exception('Unimplemented')
 146         raise Exception('Unknown EID type {}!'.format(self.eid_type))
 147
 148
 149 class VppLispMapping(VppObject):
 150     """ Represents common features for remote and local LISP mapping in VPP """
 151
 152     def __init__(self, test, eid, vni=0, priority=1, weight=1):
 153         self._eid = LispEID(eid)
 154         self._test = test
 155         self._priority = priority
 156         self._weight = weight
 157         self._vni = vni
 158
 159     @property
 160     def test(self):
 161         return self._test
 162
 163     @property
 164     def vni(self):
 165         return self._vni
 166
 167     @property
 168     def eid(self):
 169         return self._eid
 170
 171     @property
 172     def priority(self):
 173         return self._priority
 174
 175     @property
 176     def weight(self):
 177         return self._weight
 178
 179     def get_lisp_mapping_dump_entry(self):
 180         return self.test.vapi.lisp_eid_table_dump(
 181                 eid_set=1, prefix_length=self._eid.prefix_length,
 182                 vni=self._vni, eid_type=self._eid.eid_type, eid=str(self._eid))
 183
 184     def query_vpp_config(self):
 185         mapping = self.get_lisp_mapping_dump_entry()
 186         return mapping
 187
 188     def object_id(self):
 189         return 'lisp-mapping-[%s]-%s-%s-%s' % (
 190             self.vni, self.eid, self.priority, self.weight)
 191
 192
 193 class VppLocalMapping(VppLispMapping):
 194     """ LISP Local mapping """
 195     def __init__(self, test, eid, ls_name, vni=0, priority=1, weight=1,
 196                  key_id=LispKeyIdType.NONE, key=''):
 197         super(VppLocalMapping, self).__init__(test, eid, vni, priority, weight)
 198         self._ls_name = ls_name
 199         self._key_id = key_id
 200         self._key = key
 201
 202     @property
 203     def ls_name(self):
 204         return self._ls_name
 205
 206     @property
 207     def key_id(self):
 208         return self._key_id
 209
 210     @property
 211     def key(self):
 212         return self._key
 213
 214     def add_vpp_config(self):
 215         self.test.vapi.lisp_local_mapping(
 216                 ls_name=self._ls_name, eid_type=self._eid.eid_type,
 217                 eid=str(self._eid), prefix_len=self._eid.prefix_length,
 218                 vni=self._vni, key_id=self._key_id, key=self._key)
 219         self._test.registry.register(self, self.test.logger)
 220
 221     def remove_vpp_config(self):
 222         self.test.vapi.lisp_local_mapping(
 223                 ls_name=self._ls_name, eid_type=self._eid.eid_type,
 224                 eid=str(self._eid), prefix_len=self._eid.prefix_length,
 225                 vni=self._vni, is_add=0)
 226
 227     def object_id(self):
 228         return 'lisp-eid-local-mapping-%s[%d]' % (self._eid, self._vni)
 229
 230
 231 class VppRemoteMapping(VppLispMapping):
 232
 233     def __init__(self, test, eid, rlocs=None, vni=0, priority=1, weight=1):
 234         super(VppRemoteMapping, self).__init__(test, eid, vni, priority,
 235                                                weight)
 236         self._rlocs = rlocs
 237
 238     @property
 239     def rlocs(self):
 240         return self._rlocs
 241
 242     def add_vpp_config(self):
 243         self.test.vapi.lisp_remote_mapping(
 244                 rlocs=self._rlocs, eid_type=self._eid.eid_type,
 245                 eid=str(self._eid), eid_prefix_len=self._eid.prefix_length,
 246                 vni=self._vni, rlocs_num=len(self._rlocs))
 247         self._test.registry.register(self, self.test.logger)
 248
 249     def remove_vpp_config(self):
 250         self.test.vapi.lisp_remote_mapping(
 251                 eid_type=self._eid.eid_type, eid=str(self._eid),
 252                 eid_prefix_len=self._eid.prefix_length, vni=self._vni,
 253                 is_add=0, rlocs_num=0)
 254
 255     def object_id(self):
 256         return 'lisp-eid-remote-mapping-%s[%d]' % (self._eid, self._vni)
 257
 258
 259 class VppLispAdjacency(VppObject):
 260     """ Represents LISP adjacency in VPP """
 261
 262     def __init__(self, test, leid, reid, vni=0):
 263         self._leid = LispEID(leid)
 264         self._reid = LispEID(reid)
 265         if self._leid.eid_type != self._reid.eid_type:
 266             raise Exception('remote and local EID are different types!')
 267         self._vni = vni
 268         self._test = test
 269
 270     @property
 271     def test(self):
 272         return self._test
 273
 274     @property
 275     def leid(self):
 276         return self._leid
 277
 278     @property
 279     def reid(self):
 280         return self._reid
 281
 282     @property
 283     def vni(self):
 284         return self._vni
 285
 286     def add_vpp_config(self):
 287         self.test.vapi.lisp_adjacency(
 288                 leid=str(self._leid),
 289                 reid=str(self._reid), eid_type=self._leid.eid_type,
 290                 leid_len=self._leid.prefix_length,
 291                 reid_len=self._reid.prefix_length, vni=self._vni)
 292         self._test.registry.register(self, self.test.logger)
 293
 294     @staticmethod
 295     def eid_equal(eid, eid_type, eid_data, prefix_len):
 296         if eid.eid_type != eid_type:
 297             return False
 298
 299         if eid_type == LispEIDType.IP4 or eid_type == LispEIDType.IP6:
 300             if eid.prefix_length != prefix_len:
 301                 return False
 302
 303         if str(eid) != eid_data[0:eid.data_length]:
 304             return False
 305
 306         return True
 307
 308     def query_vpp_config(self):
 309         res = self.test.vapi.lisp_adjacencies_get(vni=self._vni)
 310         for adj in res.adjacencies:
 311             if self.eid_equal(self._leid, adj.eid_type, adj.leid,
 312                               adj.leid_prefix_len) and \
 313                 self.eid_equal(self._reid, adj.eid_type, adj.reid,
 314                                adj.reid_prefix_len):
 315                 return True
 316         return False
 317
 318     def remove_vpp_config(self):
 319         self.test.vapi.lisp_adjacency(
 320                 leid=str(self._leid),
 321                 reid=str(self._reid), eid_type=self._leid.eid_type,
 322                 leid_len=self._leid.prefix_length,
 323                 reid_len=self._reid.prefix_length, vni=self._vni, is_add=0)
 324
 325     def object_id(self):
 326         return 'lisp-adjacency-%s-%s[%d]' % (self._leid, self._reid, self._vni)