test/vpp_ip_route.py

   1 """
   2   IP Routes
   3
   4   object abstractions for representing IP routes in VPP
   5 """
   6
   7 from vpp_object import VppObject
   8 from socket import inet_pton, inet_ntop, AF_INET, AF_INET6
   9 from vpp_ip import DpoProto, INVALID_INDEX, VppIpAddressUnion, \
  10     VppIpMPrefix
  11 from ipaddress import ip_network, ip_address, IPv4Network, IPv6Network
  12
  13 # from vnet/vnet/mpls/mpls_types.h
  14 MPLS_IETF_MAX_LABEL = 0xfffff
  15 MPLS_LABEL_INVALID = MPLS_IETF_MAX_LABEL + 1
  16
  17 try:
  18     text_type = unicode
  19 except NameError:
  20     text_type = str
  21
  22
  23 class MRouteItfFlags:
  24     MFIB_ITF_FLAG_NONE = 0
  25     MFIB_ITF_FLAG_NEGATE_SIGNAL = 1
  26     MFIB_ITF_FLAG_ACCEPT = 2
  27     MFIB_ITF_FLAG_FORWARD = 4
  28     MFIB_ITF_FLAG_SIGNAL_PRESENT = 8
  29     MFIB_ITF_FLAG_INTERNAL_COPY = 16
  30
  31
  32 class MRouteEntryFlags:
  33     MFIB_ENTRY_FLAG_NONE = 0
  34     MFIB_ENTRY_FLAG_SIGNAL = 1
  35     MFIB_ENTRY_FLAG_DROP = 2
  36     MFIB_ENTRY_FLAG_CONNECTED = 4
  37     MFIB_ENTRY_FLAG_INHERIT_ACCEPT = 8
  38
  39
  40 class FibPathProto:
  41     FIB_PATH_NH_PROTO_IP4 = 0
  42     FIB_PATH_NH_PROTO_IP6 = 1
  43     FIB_PATH_NH_PROTO_MPLS = 2
  44     FIB_PATH_NH_PROTO_ETHERNET = 3
  45     FIB_PATH_NH_PROTO_BIER = 4
  46     FIB_PATH_NH_PROTO_NSH = 5
  47
  48
  49 class FibPathType:
  50     FIB_PATH_TYPE_NORMAL = 0
  51     FIB_PATH_TYPE_LOCAL = 1
  52     FIB_PATH_TYPE_DROP = 2
  53     FIB_PATH_TYPE_UDP_ENCAP = 3
  54     FIB_PATH_TYPE_BIER_IMP = 4
  55     FIB_PATH_TYPE_ICMP_UNREACH = 5
  56     FIB_PATH_TYPE_ICMP_PROHIBIT = 6
  57     FIB_PATH_TYPE_SOURCE_LOOKUP = 7
  58     FIB_PATH_TYPE_DVR = 8
  59     FIB_PATH_TYPE_INTERFACE_RX = 9
  60     FIB_PATH_TYPE_CLASSIFY = 10
  61
  62
  63 class FibPathFlags:
  64     FIB_PATH_FLAG_NONE = 0
  65     FIB_PATH_FLAG_RESOLVE_VIA_ATTACHED = 1
  66     FIB_PATH_FLAG_RESOLVE_VIA_HOST = 2
  67     FIB_PATH_FLAG_POP_PW_CW = 4
  68
  69
  70 class MplsLspMode:
  71     PIPE = 0
  72     UNIFORM = 1
  73
  74
  75 def mk_network(addr, len):
  76     if ip_address(text_type(addr)).version == 4:
  77         return IPv4Network("%s/%d" % (addr, len), strict=False)
  78     else:
  79         return IPv6Network("%s/%d" % (addr, len), strict=False)
  80
  81
  82 def ip_to_dpo_proto(addr):
  83     if addr.version == 6:
  84         return DpoProto.DPO_PROTO_IP6
  85     else:
  86         return DpoProto.DPO_PROTO_IP4
  87
  88
  89 def address_proto(ip_addr):
  90     if ip_addr.ip_addr.version == 4:
  91         return FibPathProto.FIB_PATH_NH_PROTO_IP4
  92     else:
  93         return FibPathProto.FIB_PATH_NH_PROTO_IP6
  94
  95
  96 def find_route(test, addr, len, table_id=0, sw_if_index=None):
  97     prefix = mk_network(addr, len)
  98
  99     if 4 == prefix.version:
 100         routes = test.vapi.ip_route_dump(table_id, False)
 101     else:
 102         routes = test.vapi.ip_route_dump(table_id, True)
 103
 104     for e in routes:
 105         if table_id == e.route.table_id \
 106            and str(e.route.prefix) == str(prefix):
 107             if not sw_if_index:
 108                 return True
 109             else:
 110                 # should be only one path if the user is looking
 111                 # for the interface the route is reachable through
 112                 if e.route.n_paths != 1:
 113                     return False
 114                 else:
 115                     return (e.route.paths[0].sw_if_index == sw_if_index)
 116
 117     return False
 118
 119
 120 def find_route_in_dump(dump, route, table):
 121     for r in dump:
 122         if table.table_id == r.route.table_id \
 123            and route.prefix == r.route.prefix:
 124             if len(route.paths) == r.route.n_paths:
 125                 return True
 126     return False
 127
 128
 129 def find_mroute_in_dump(dump, route, table):
 130     for r in dump:
 131         if table.table_id == r.route.table_id \
 132            and route.prefix == r.route.prefix:
 133             return True
 134     return False
 135
 136
 137 def find_mroute(test, grp_addr, src_addr, grp_addr_len,
 138                 table_id=0):
 139     ip_mprefix = VppIpMPrefix(text_type(src_addr),
 140                               text_type(grp_addr),
 141                               grp_addr_len)
 142
 143     if 4 == ip_mprefix.version:
 144         routes = test.vapi.ip_mroute_dump(table_id, False)
 145     else:
 146         routes = test.vapi.ip_mroute_dump(table_id, True)
 147
 148     for e in routes:
 149         if table_id == e.route.table_id and ip_mprefix == e.route.prefix:
 150             return True
 151     return False
 152
 153
 154 def find_mpls_route(test, table_id, label, eos_bit, paths=None):
 155     dump = test.vapi.mpls_route_dump(table_id)
 156     for e in dump:
 157         if label == e.mr_route.mr_label \
 158            and eos_bit == e.mr_route.mr_eos \
 159            and table_id == e.mr_route.mr_table_id:
 160             if not paths:
 161                 return True
 162             else:
 163                 if (len(paths) != len(e.mr_route.mr_paths)):
 164                     return False
 165                 for i in range(len(paths)):
 166                     if (paths[i] != e.mr_route.mr_paths[i]):
 167                         return False
 168                 return True
 169     return False
 170
 171
 172 def fib_interface_ip_prefix(test, addr, len, sw_if_index):
 173     # can't use python net here since we need the host bits in the prefix
 174     prefix = "%s/%d" % (addr, len)
 175     addrs = test.vapi.ip_address_dump(
 176         sw_if_index,
 177         is_ipv6=(6 == ip_address(addr).version))
 178
 179     for a in addrs:
 180         if a.sw_if_index == sw_if_index and \
 181            str(a.prefix) == prefix:
 182             return True
 183     return False
 184
 185
 186 class VppIpTable(VppObject):
 187
 188     def __init__(self,
 189                  test,
 190                  table_id,
 191                  is_ip6=0):
 192         self._test = test
 193         self.table_id = table_id
 194         self.is_ip6 = is_ip6
 195
 196     def add_vpp_config(self):
 197         self._test.vapi.ip_table_add_del(is_add=1,
 198                                          table={'is_ip6': self.is_ip6,
 199                                                 'table_id': self.table_id})
 200         self._test.registry.register(self, self._test.logger)
 201         return self
 202
 203     def remove_vpp_config(self):
 204         self._test.vapi.ip_table_add_del(is_add=0,
 205                                          table={'is_ip6': self.is_ip6,
 206                                                 'table_id': self.table_id})
 207
 208     def replace_begin(self):
 209         self._test.vapi.ip_table_replace_begin(
 210             table={'is_ip6': self.is_ip6,
 211                    'table_id': self.table_id})
 212
 213     def replace_end(self):
 214         self._test.vapi.ip_table_replace_end(
 215             table={'is_ip6': self.is_ip6,
 216                    'table_id': self.table_id})
 217
 218     def flush(self):
 219         self._test.vapi.ip_table_flush(table={'is_ip6': self.is_ip6,
 220                                               'table_id': self.table_id})
 221
 222     def dump(self):
 223         return self._test.vapi.ip_route_dump(self.table_id, self.is_ip6)
 224
 225     def mdump(self):
 226         return self._test.vapi.ip_mroute_dump(self.table_id, self.is_ip6)
 227
 228     def query_vpp_config(self):
 229         if self.table_id == 0:
 230             # the default table always exists
 231             return False
 232         # find the default route
 233         return find_route(self._test,
 234                           "::" if self.is_ip6 else "0.0.0.0",
 235                           0,
 236                           self.table_id)
 237
 238     def object_id(self):
 239         return ("table-%s-%d" %
 240                 ("v6" if self.is_ip6 == 1 else "v4",
 241                  self.table_id))
 242
 243
 244 class VppIpInterfaceAddress(VppObject):
 245
 246     def __init__(self, test, intf, addr, len, bind=None):
 247         self._test = test
 248         self.intf = intf
 249         self.addr = addr
 250         self.len = len
 251         self.prefix = "%s/%d" % (addr, len)
 252         self.host_len = ip_network(self.prefix, strict=False).max_prefixlen
 253         self.table_id = 0
 254         if bind:
 255             self.table_id = bind.table.table_id
 256
 257     def add_vpp_config(self):
 258         self._test.vapi.sw_interface_add_del_address(
 259             sw_if_index=self.intf.sw_if_index, prefix=self.prefix,
 260             is_add=1)
 261         self._test.registry.register(self, self._test.logger)
 262         return self
 263
 264     def remove_vpp_config(self):
 265         self._test.vapi.sw_interface_add_del_address(
 266             sw_if_index=self.intf.sw_if_index, prefix=self.prefix,
 267             is_add=0)
 268
 269     def query_vpp_config(self):
 270         # search for the IP address mapping and the two expected
 271         # FIB entries
 272         v = ip_address(self.addr).version
 273
 274         if ((v == 4 and self.len < 31) or (v == 6 and self.len < 127)):
 275             return (fib_interface_ip_prefix(self._test,
 276                                             self.addr,
 277                                             self.len,
 278                                             self.intf.sw_if_index) &
 279                     find_route(self._test,
 280                                self.addr,
 281                                self.len,
 282                                table_id=self.table_id,
 283                                sw_if_index=self.intf.sw_if_index) &
 284                     find_route(self._test,
 285                                self.addr,
 286                                self.host_len,
 287                                table_id=self.table_id,
 288                                sw_if_index=self.intf.sw_if_index))
 289         else:
 290             return (fib_interface_ip_prefix(self._test,
 291                                             self.addr,
 292                                             self.len,
 293                                             self.intf.sw_if_index) &
 294                     find_route(self._test,
 295                                self.addr,
 296                                self.host_len,
 297                                table_id=self.table_id,
 298                                sw_if_index=self.intf.sw_if_index))
 299
 300     def object_id(self):
 301         return "interface-ip-%s-%d-%s" % (self.intf,
 302                                           self.table_id,
 303                                           self.prefix)
 304
 305
 306 class VppIpInterfaceBind(VppObject):
 307
 308     def __init__(self, test, intf, table):
 309         self._test = test
 310         self.intf = intf
 311         self.table = table
 312
 313     def add_vpp_config(self):
 314         if self.table.is_ip6:
 315             self.intf.set_table_ip6(self.table.table_id)
 316         else:
 317             self.intf.set_table_ip4(self.table.table_id)
 318         self._test.registry.register(self, self._test.logger)
 319         return self
 320
 321     def remove_vpp_config(self):
 322         if 0 == self.table.table_id:
 323             return
 324         if self.table.is_ip6:
 325             self.intf.set_table_ip6(0)
 326         else:
 327             self.intf.set_table_ip4(0)
 328
 329     def query_vpp_config(self):
 330         if 0 == self.table.table_id:
 331             return False
 332         return self._test.vapi.sw_interface_get_table(
 333             self.intf.sw_if_index,
 334             self.table.is_ip6).vrf_id == self.table.table_id
 335
 336     def object_id(self):
 337         return "interface-bind-%s-%s" % (self.intf, self.table)
 338
 339
 340 class VppMplsLabel(object):
 341     def __init__(self, value, mode=MplsLspMode.PIPE, ttl=64, exp=0):
 342         self.value = value
 343         self.mode = mode
 344         self.ttl = ttl
 345         self.exp = exp
 346
 347     def encode(self):
 348         is_uniform = 0 if self.mode is MplsLspMode.PIPE else 1
 349         return {'label': self.value,
 350                 'ttl': self.ttl,
 351                 'exp': self.exp,
 352                 'is_uniform': is_uniform}
 353
 354     def __eq__(self, other):
 355         if isinstance(other, self.__class__):
 356             return (self.value == other.value and
 357                     self.ttl == other.ttl and
 358                     self.exp == other.exp and
 359                     self.mode == other.mode)
 360         elif hasattr(other, 'label'):
 361             return (self.value == other.label and
 362                     self.ttl == other.ttl and
 363                     self.exp == other.exp and
 364                     (self.mode == MplsLspMode.UNIFORM) == other.is_uniform)
 365         else:
 366             return False
 367
 368     def __ne__(self, other):
 369         return not (self == other)
 370
 371
 372 class VppFibPathNextHop(object):
 373     def __init__(self, addr,
 374                  via_label=MPLS_LABEL_INVALID,
 375                  next_hop_id=INVALID_INDEX):
 376         self.addr = VppIpAddressUnion(addr)
 377         self.via_label = via_label
 378         self.obj_id = next_hop_id
 379
 380     def encode(self):
 381         if self.via_label is not MPLS_LABEL_INVALID:
 382             return {'via_label': self.via_label}
 383         if self.obj_id is not INVALID_INDEX:
 384             return {'obj_id': self.obj_id}
 385         else:
 386             return {'address': self.addr.encode()}
 387
 388     def proto(self):
 389         if self.via_label is MPLS_LABEL_INVALID:
 390             return address_proto(self.addr)
 391         else:
 392             return FibPathProto.FIB_PATH_NH_PROTO_MPLS
 393
 394     def __eq__(self, other):
 395         if not isinstance(other, self.__class__):
 396             # try the other instance's __eq__.
 397             return NotImplemented
 398         return (self.addr == other.addr and
 399                 self.via_label == other.via_label and
 400                 self.obj_id == other.obj_id)
 401
 402
 403 class VppRoutePath(object):
 404
 405     def __init__(
 406             self,
 407             nh_addr,
 408             nh_sw_if_index,
 409             nh_table_id=0,
 410             labels=[],
 411             nh_via_label=MPLS_LABEL_INVALID,
 412             rpf_id=0,
 413             next_hop_id=INVALID_INDEX,
 414             proto=None,
 415             flags=FibPathFlags.FIB_PATH_FLAG_NONE,
 416             type=FibPathType.FIB_PATH_TYPE_NORMAL):
 417         self.nh_itf = nh_sw_if_index
 418         self.nh_table_id = nh_table_id
 419         self.nh_labels = labels
 420         self.weight = 1
 421         self.rpf_id = rpf_id
 422         self.proto = proto
 423         self.flags = flags
 424         self.type = type
 425         self.nh = VppFibPathNextHop(nh_addr, nh_via_label, next_hop_id)
 426         if proto is None:
 427             self.proto = self.nh.proto()
 428         else:
 429             self.proto = proto
 430         self.next_hop_id = next_hop_id
 431
 432     def encode_labels(self):
 433         lstack = []
 434         for l in self.nh_labels:
 435             if type(l) == VppMplsLabel:
 436                 lstack.append(l.encode())
 437             else:
 438                 lstack.append({'label': l,
 439                                'ttl': 255})
 440         while (len(lstack) < 16):
 441             lstack.append({})
 442
 443         return lstack
 444
 445     def encode(self):
 446         return {'weight': 1,
 447                 'preference': 0,
 448                 'table_id': self.nh_table_id,
 449                 'nh': self.nh.encode(),
 450                 'next_hop_id': self.next_hop_id,
 451                 'sw_if_index': self.nh_itf,
 452                 'rpf_id': self.rpf_id,
 453                 'proto': self.proto,
 454                 'type': self.type,
 455                 'flags': self.flags,
 456                 'n_labels': len(self.nh_labels),
 457                 'label_stack': self.encode_labels()}
 458
 459     def __eq__(self, other):
 460         if isinstance(other, self.__class__):
 461             return self.nh == other.nh
 462         elif hasattr(other, 'sw_if_index'):
 463             # vl_api_fib_path_t
 464             if (len(self.nh_labels) != other.n_labels):
 465                 return False
 466             for i in range(len(self.nh_labels)):
 467                 if (self.nh_labels[i] != other.label_stack[i]):
 468                     return False
 469             return self.nh_itf == other.sw_if_index
 470         else:
 471             return False
 472
 473     def __ne__(self, other):
 474         return not (self == other)
 475
 476
 477 class VppMRoutePath(VppRoutePath):
 478
 479     def __init__(self, nh_sw_if_index, flags,
 480                  nh=None,
 481                  proto=FibPathProto.FIB_PATH_NH_PROTO_IP4,
 482                  type=FibPathType.FIB_PATH_TYPE_NORMAL,
 483                  bier_imp=INVALID_INDEX):
 484         if not nh:
 485             nh = "::" if proto is FibPathProto.FIB_PATH_NH_PROTO_IP6 \
 486                  else "0.0.0.0"
 487         super(VppMRoutePath, self).__init__(nh,
 488                                             nh_sw_if_index,
 489                                             proto=proto,
 490                                             type=type,
 491                                             next_hop_id=bier_imp)
 492         self.nh_i_flags = flags
 493         self.bier_imp = bier_imp
 494
 495     def encode(self):
 496         return {'path': super(VppMRoutePath, self).encode(),
 497                 'itf_flags': self.nh_i_flags}
 498
 499
 500 class VppIpRoute(VppObject):
 501     """
 502     IP Route
 503     """
 504
 505     def __init__(self, test, dest_addr,
 506                  dest_addr_len, paths, table_id=0, register=True):
 507         self._test = test
 508         self.paths = paths
 509         self.table_id = table_id
 510         self.prefix = mk_network(dest_addr, dest_addr_len)
 511         self.register = register
 512         self.stats_index = None
 513         self.modified = False
 514
 515         self.encoded_paths = []
 516         for path in self.paths:
 517             self.encoded_paths.append(path.encode())
 518
 519     def __eq__(self, other):
 520         if self.table_id == other.table_id and \
 521            self.prefix == other.prefix:
 522             return True
 523         return False
 524
 525     def modify(self, paths):
 526         self.paths = paths
 527         self.encoded_paths = []
 528         for path in self.paths:
 529             self.encoded_paths.append(path.encode())
 530         self.modified = True
 531
 532         self._test.vapi.ip_route_add_del(route={'table_id': self.table_id,
 533                                                 'prefix': self.prefix,
 534                                                 'n_paths': len(
 535                                                     self.encoded_paths),
 536                                                 'paths': self.encoded_paths,
 537                                                 },
 538                                          is_add=1,
 539                                          is_multipath=0)
 540
 541     def add_vpp_config(self):
 542         r = self._test.vapi.ip_route_add_del(
 543             route={'table_id': self.table_id,
 544                    'prefix': self.prefix,
 545                    'n_paths': len(self.encoded_paths),
 546                    'paths': self.encoded_paths,
 547                    },
 548             is_add=1,
 549             is_multipath=0)
 550         self.stats_index = r.stats_index
 551         if self.register:
 552             self._test.registry.register(self, self._test.logger)
 553         return self
 554
 555     def remove_vpp_config(self):
 556         # there's no need to issue different deletes for modified routes
 557         # we do this only to test the two different ways to delete routes
 558         # eiter by passing all the paths to remove and mutlipath=1 or
 559         # passing no paths and multipath=0
 560         if self.modified:
 561             self._test.vapi.ip_route_add_del(
 562                 route={'table_id': self.table_id,
 563                        'prefix': self.prefix,
 564                        'n_paths': len(
 565                            self.encoded_paths),
 566                        'paths': self.encoded_paths},
 567                 is_add=0,
 568                 is_multipath=1)
 569         else:
 570             self._test.vapi.ip_route_add_del(
 571                 route={'table_id': self.table_id,
 572                        'prefix': self.prefix,
 573                        'n_paths': 0},
 574                 is_add=0,
 575                 is_multipath=0)
 576
 577     def query_vpp_config(self):
 578         return find_route(self._test,
 579                           self.prefix.network_address,
 580                           self.prefix.prefixlen,
 581                           self.table_id)
 582
 583     def object_id(self):
 584         return ("%s:table-%d-%s" % (
 585             'ip6-route' if self.prefix.version == 6 else 'ip-route',
 586                 self.table_id,
 587                 self.prefix))
 588
 589     def get_stats_to(self):
 590         c = self._test.statistics.get_counter("/net/route/to")
 591         return c[0][self.stats_index]
 592
 593     def get_stats_via(self):
 594         c = self._test.statistics.get_counter("/net/route/via")
 595         return c[0][self.stats_index]
 596
 597
 598 class VppIpMRoute(VppObject):
 599     """
 600     IP Multicast Route
 601     """
 602
 603     def __init__(self, test, src_addr, grp_addr,
 604                  grp_addr_len, e_flags, paths, table_id=0,
 605                  rpf_id=0):
 606         self._test = test
 607         self.paths = paths
 608         self.table_id = table_id
 609         self.e_flags = e_flags
 610         self.rpf_id = rpf_id
 611
 612         self.prefix = VppIpMPrefix(src_addr, grp_addr, grp_addr_len)
 613         self.encoded_paths = []
 614         for path in self.paths:
 615             self.encoded_paths.append(path.encode())
 616
 617     def add_vpp_config(self):
 618         r = self._test.vapi.ip_mroute_add_del(self.table_id,
 619                                               self.prefix.encode(),
 620                                               self.e_flags,
 621                                               self.rpf_id,
 622                                               self.encoded_paths,
 623                                               is_add=1)
 624         self.stats_index = r.stats_index
 625         self._test.registry.register(self, self._test.logger)
 626         return self
 627
 628     def remove_vpp_config(self):
 629         self._test.vapi.ip_mroute_add_del(self.table_id,
 630                                           self.prefix.encode(),
 631                                           self.e_flags,
 632                                           self.rpf_id,
 633                                           self.encoded_paths,
 634                                           is_add=0)
 635
 636     def update_entry_flags(self, flags):
 637         self.e_flags = flags
 638         self._test.vapi.ip_mroute_add_del(self.table_id,
 639                                           self.prefix.encode(),
 640                                           self.e_flags,
 641                                           self.rpf_id,
 642                                           [],
 643                                           is_add=1)
 644
 645     def update_rpf_id(self, rpf_id):
 646         self.rpf_id = rpf_id
 647         self._test.vapi.ip_mroute_add_del(self.table_id,
 648                                           self.prefix.encode(),
 649                                           self.e_flags,
 650                                           self.rpf_id,
 651                                           [],
 652                                           is_add=1)
 653
 654     def update_path_flags(self, itf, flags):
 655         for p in range(len(self.paths)):
 656             if self.paths[p].nh_itf == itf:
 657                 self.paths[p].nh_i_flags = flags
 658             self.encoded_paths[p] = self.paths[p].encode()
 659             break
 660
 661         self._test.vapi.ip_mroute_add_del(self.table_id,
 662                                           self.prefix.encode(),
 663                                           self.e_flags,
 664                                           self.rpf_id,
 665                                           [self.encoded_paths[p]],
 666                                           is_add=1,
 667                                           is_multipath=0)
 668
 669     def query_vpp_config(self):
 670         return find_mroute(self._test,
 671                            self.prefix.gaddr,
 672                            self.prefix.saddr,
 673                            self.prefix.length,
 674                            self.table_id)
 675
 676     def object_id(self):
 677         return ("%d:(%s,%s/%d)" % (self.table_id,
 678                                    self.prefix.saddr,
 679                                    self.prefix.gaddr,
 680                                    self.prefix.length))
 681
 682     def get_stats(self):
 683         c = self._test.statistics.get_counter("/net/mroute")
 684         return c[0][self.stats_index]
 685
 686
 687 class VppMFibSignal(object):
 688     def __init__(self, test, route, interface, packet):
 689         self.route = route
 690         self.interface = interface
 691         self.packet = packet
 692         self.test = test
 693
 694     def compare(self, signal):
 695         self.test.assertEqual(self.interface, signal.sw_if_index)
 696         self.test.assertEqual(self.route.table_id, signal.table_id)
 697         self.test.assertEqual(self.route.prefix, signal.prefix)
 698
 699
 700 class VppMplsIpBind(VppObject):
 701     """
 702     MPLS to IP Binding
 703     """
 704
 705     def __init__(self, test, local_label, dest_addr, dest_addr_len,
 706                  table_id=0, ip_table_id=0, is_ip6=0):
 707         self._test = test
 708         self.dest_addr_len = dest_addr_len
 709         self.dest_addr = dest_addr
 710         self.ip_addr = ip_address(text_type(dest_addr))
 711         self.local_label = local_label
 712         self.table_id = table_id
 713         self.ip_table_id = ip_table_id
 714         self.prefix = mk_network(dest_addr, dest_addr_len)
 715
 716     def add_vpp_config(self):
 717         self._test.vapi.mpls_ip_bind_unbind(self.local_label,
 718                                             self.prefix,
 719                                             table_id=self.table_id,
 720                                             ip_table_id=self.ip_table_id)
 721         self._test.registry.register(self, self._test.logger)
 722
 723     def remove_vpp_config(self):
 724         self._test.vapi.mpls_ip_bind_unbind(self.local_label,
 725                                             self.prefix,
 726                                             table_id=self.table_id,
 727                                             ip_table_id=self.ip_table_id,
 728                                             is_bind=0)
 729
 730     def query_vpp_config(self):
 731         dump = self._test.vapi.mpls_route_dump(self.table_id)
 732         for e in dump:
 733             if self.local_label == e.mr_route.mr_label \
 734                and self.table_id == e.mr_route.mr_table_id:
 735                 return True
 736         return False
 737
 738     def object_id(self):
 739         return ("%d:%s binds %d:%s/%d"
 740                 % (self.table_id,
 741                    self.local_label,
 742                    self.ip_table_id,
 743                    self.dest_addr,
 744                    self.dest_addr_len))
 745
 746
 747 class VppMplsTable(VppObject):
 748
 749     def __init__(self,
 750                  test,
 751                  table_id):
 752         self._test = test
 753         self.table_id = table_id
 754
 755     def add_vpp_config(self):
 756         self._test.vapi.mpls_table_add_del(
 757             self.table_id,
 758             is_add=1)
 759         self._test.registry.register(self, self._test.logger)
 760
 761     def remove_vpp_config(self):
 762         self._test.vapi.mpls_table_add_del(
 763             self.table_id,
 764             is_add=0)
 765
 766     def query_vpp_config(self):
 767         dump = self._test.vapi.mpls_table_dump()
 768         for d in dump:
 769             if d.mt_table.mt_table_id == self.table_id:
 770                 return True
 771         return False
 772
 773     def object_id(self):
 774         return ("table-mpls-%d" % (self.table_id))
 775
 776
 777 class VppMplsRoute(VppObject):
 778     """
 779     MPLS Route/LSP
 780     """
 781
 782     def __init__(self, test, local_label, eos_bit, paths, table_id=0,
 783                  is_multicast=0,
 784                  eos_proto=FibPathProto.FIB_PATH_NH_PROTO_IP4):
 785         self._test = test
 786         self.paths = paths
 787         self.local_label = local_label
 788         self.eos_bit = eos_bit
 789         self.eos_proto = eos_proto
 790         self.table_id = table_id
 791         self.is_multicast = is_multicast
 792
 793     def add_vpp_config(self):
 794         paths = []
 795         for path in self.paths:
 796             paths.append(path.encode())
 797
 798         r = self._test.vapi.mpls_route_add_del(self.table_id,
 799                                                self.local_label,
 800                                                self.eos_bit,
 801                                                self.eos_proto,
 802                                                self.is_multicast,
 803                                                paths, 1, 0)
 804         self.stats_index = r.stats_index
 805         self._test.registry.register(self, self._test.logger)
 806
 807     def remove_vpp_config(self):
 808         paths = []
 809         for path in self.paths:
 810             paths.append(path.encode())
 811
 812         self._test.vapi.mpls_route_add_del(self.table_id,
 813                                            self.local_label,
 814                                            self.eos_bit,
 815                                            self.eos_proto,
 816                                            self.is_multicast,
 817                                            paths, 0, 0)
 818
 819     def query_vpp_config(self):
 820         return find_mpls_route(self._test, self.table_id,
 821                                self.local_label, self.eos_bit)
 822
 823     def object_id(self):
 824         return ("mpls-route-%d:%s/%d"
 825                 % (self.table_id,
 826                    self.local_label,
 827                    20 + self.eos_bit))
 828
 829     def get_stats_to(self):
 830         c = self._test.statistics.get_counter("/net/route/to")
 831         return c[0][self.stats_index]
 832
 833     def get_stats_via(self):
 834         c = self._test.statistics.get_counter("/net/route/via")
 835         return c[0][self.stats_index]