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 VppIp6LinkLocalAddress(VppObject):
 307
 308     def __init__(self, test, intf, addr):
 309         self._test = test
 310         self.intf = intf
 311         self.addr = addr
 312
 313     def add_vpp_config(self):
 314         self._test.vapi.sw_interface_ip6_set_link_local_address(
 315             sw_if_index=self.intf.sw_if_index, ip=self.addr)
 316         self._test.registry.register(self, self._test.logger)
 317         return self
 318
 319     def remove_vpp_config(self):
 320         # link locals can't be removed, only changed
 321         pass
 322
 323     def query_vpp_config(self):
 324         # no API to query
 325         return False
 326
 327     def object_id(self):
 328         return "ip6-link-local-%s-%s" % (self.intf, self.addr)
 329
 330
 331 class VppIpInterfaceBind(VppObject):
 332
 333     def __init__(self, test, intf, table):
 334         self._test = test
 335         self.intf = intf
 336         self.table = table
 337
 338     def add_vpp_config(self):
 339         if self.table.is_ip6:
 340             self.intf.set_table_ip6(self.table.table_id)
 341         else:
 342             self.intf.set_table_ip4(self.table.table_id)
 343         self._test.registry.register(self, self._test.logger)
 344         return self
 345
 346     def remove_vpp_config(self):
 347         if 0 == self.table.table_id:
 348             return
 349         if self.table.is_ip6:
 350             self.intf.set_table_ip6(0)
 351         else:
 352             self.intf.set_table_ip4(0)
 353
 354     def query_vpp_config(self):
 355         if 0 == self.table.table_id:
 356             return False
 357         return self._test.vapi.sw_interface_get_table(
 358             self.intf.sw_if_index,
 359             self.table.is_ip6).vrf_id == self.table.table_id
 360
 361     def object_id(self):
 362         return "interface-bind-%s-%s" % (self.intf, self.table)
 363
 364
 365 class VppMplsLabel(object):
 366     def __init__(self, value, mode=MplsLspMode.PIPE, ttl=64, exp=0):
 367         self.value = value
 368         self.mode = mode
 369         self.ttl = ttl
 370         self.exp = exp
 371
 372     def encode(self):
 373         is_uniform = 0 if self.mode is MplsLspMode.PIPE else 1
 374         return {'label': self.value,
 375                 'ttl': self.ttl,
 376                 'exp': self.exp,
 377                 'is_uniform': is_uniform}
 378
 379     def __eq__(self, other):
 380         if isinstance(other, self.__class__):
 381             return (self.value == other.value and
 382                     self.ttl == other.ttl and
 383                     self.exp == other.exp and
 384                     self.mode == other.mode)
 385         elif hasattr(other, 'label'):
 386             return (self.value == other.label and
 387                     self.ttl == other.ttl and
 388                     self.exp == other.exp and
 389                     (self.mode == MplsLspMode.UNIFORM) == other.is_uniform)
 390         else:
 391             return False
 392
 393     def __ne__(self, other):
 394         return not (self == other)
 395
 396
 397 class VppFibPathNextHop(object):
 398     def __init__(self, addr,
 399                  via_label=MPLS_LABEL_INVALID,
 400                  next_hop_id=INVALID_INDEX):
 401         self.addr = VppIpAddressUnion(addr)
 402         self.via_label = via_label
 403         self.obj_id = next_hop_id
 404
 405     def encode(self):
 406         if self.via_label is not MPLS_LABEL_INVALID:
 407             return {'via_label': self.via_label}
 408         if self.obj_id is not INVALID_INDEX:
 409             return {'obj_id': self.obj_id}
 410         else:
 411             return {'address': self.addr.encode()}
 412
 413     def proto(self):
 414         if self.via_label is MPLS_LABEL_INVALID:
 415             return address_proto(self.addr)
 416         else:
 417             return FibPathProto.FIB_PATH_NH_PROTO_MPLS
 418
 419     def __eq__(self, other):
 420         if not isinstance(other, self.__class__):
 421             # try the other instance's __eq__.
 422             return NotImplemented
 423         return (self.addr == other.addr and
 424                 self.via_label == other.via_label and
 425                 self.obj_id == other.obj_id)
 426
 427
 428 class VppRoutePath(object):
 429
 430     def __init__(
 431             self,
 432             nh_addr,
 433             nh_sw_if_index,
 434             nh_table_id=0,
 435             labels=[],
 436             nh_via_label=MPLS_LABEL_INVALID,
 437             rpf_id=0,
 438             next_hop_id=INVALID_INDEX,
 439             proto=None,
 440             flags=FibPathFlags.FIB_PATH_FLAG_NONE,
 441             type=FibPathType.FIB_PATH_TYPE_NORMAL):
 442         self.nh_itf = nh_sw_if_index
 443         self.nh_table_id = nh_table_id
 444         self.nh_labels = labels
 445         self.weight = 1
 446         self.rpf_id = rpf_id
 447         self.proto = proto
 448         self.flags = flags
 449         self.type = type
 450         self.nh = VppFibPathNextHop(nh_addr, nh_via_label, next_hop_id)
 451         if proto is None:
 452             self.proto = self.nh.proto()
 453         else:
 454             self.proto = proto
 455         self.next_hop_id = next_hop_id
 456
 457     def encode_labels(self):
 458         lstack = []
 459         for l in self.nh_labels:
 460             if type(l) == VppMplsLabel:
 461                 lstack.append(l.encode())
 462             else:
 463                 lstack.append({'label': l,
 464                                'ttl': 255})
 465         while (len(lstack) < 16):
 466             lstack.append({})
 467
 468         return lstack
 469
 470     def encode(self):
 471         return {'weight': 1,
 472                 'preference': 0,
 473                 'table_id': self.nh_table_id,
 474                 'nh': self.nh.encode(),
 475                 'next_hop_id': self.next_hop_id,
 476                 'sw_if_index': self.nh_itf,
 477                 'rpf_id': self.rpf_id,
 478                 'proto': self.proto,
 479                 'type': self.type,
 480                 'flags': self.flags,
 481                 'n_labels': len(self.nh_labels),
 482                 'label_stack': self.encode_labels()}
 483
 484     def __eq__(self, other):
 485         if isinstance(other, self.__class__):
 486             return self.nh == other.nh
 487         elif hasattr(other, 'sw_if_index'):
 488             # vl_api_fib_path_t
 489             if (len(self.nh_labels) != other.n_labels):
 490                 return False
 491             for i in range(len(self.nh_labels)):
 492                 if (self.nh_labels[i] != other.label_stack[i]):
 493                     return False
 494             return self.nh_itf == other.sw_if_index
 495         else:
 496             return False
 497
 498     def __ne__(self, other):
 499         return not (self == other)
 500
 501
 502 class VppMRoutePath(VppRoutePath):
 503
 504     def __init__(self, nh_sw_if_index, flags,
 505                  nh=None,
 506                  proto=FibPathProto.FIB_PATH_NH_PROTO_IP4,
 507                  type=FibPathType.FIB_PATH_TYPE_NORMAL,
 508                  bier_imp=INVALID_INDEX):
 509         if not nh:
 510             nh = "::" if proto is FibPathProto.FIB_PATH_NH_PROTO_IP6 \
 511                  else "0.0.0.0"
 512         super(VppMRoutePath, self).__init__(nh,
 513                                             nh_sw_if_index,
 514                                             proto=proto,
 515                                             type=type,
 516                                             next_hop_id=bier_imp)
 517         self.nh_i_flags = flags
 518         self.bier_imp = bier_imp
 519
 520     def encode(self):
 521         return {'path': super(VppMRoutePath, self).encode(),
 522                 'itf_flags': self.nh_i_flags}
 523
 524
 525 class VppIpRoute(VppObject):
 526     """
 527     IP Route
 528     """
 529
 530     def __init__(self, test, dest_addr,
 531                  dest_addr_len, paths, table_id=0, register=True):
 532         self._test = test
 533         self.paths = paths
 534         self.table_id = table_id
 535         self.prefix = mk_network(dest_addr, dest_addr_len)
 536         self.register = register
 537         self.stats_index = None
 538         self.modified = False
 539
 540         self.encoded_paths = []
 541         for path in self.paths:
 542             self.encoded_paths.append(path.encode())
 543
 544     def __eq__(self, other):
 545         if self.table_id == other.table_id and \
 546            self.prefix == other.prefix:
 547             return True
 548         return False
 549
 550     def modify(self, paths):
 551         self.paths = paths
 552         self.encoded_paths = []
 553         for path in self.paths:
 554             self.encoded_paths.append(path.encode())
 555         self.modified = True
 556
 557         self._test.vapi.ip_route_add_del(route={'table_id': self.table_id,
 558                                                 'prefix': self.prefix,
 559                                                 'n_paths': len(
 560                                                     self.encoded_paths),
 561                                                 'paths': self.encoded_paths,
 562                                                 },
 563                                          is_add=1,
 564                                          is_multipath=0)
 565
 566     def add_vpp_config(self):
 567         r = self._test.vapi.ip_route_add_del(
 568             route={'table_id': self.table_id,
 569                    'prefix': self.prefix,
 570                    'n_paths': len(self.encoded_paths),
 571                    'paths': self.encoded_paths,
 572                    },
 573             is_add=1,
 574             is_multipath=0)
 575         self.stats_index = r.stats_index
 576         if self.register:
 577             self._test.registry.register(self, self._test.logger)
 578         return self
 579
 580     def remove_vpp_config(self):
 581         # there's no need to issue different deletes for modified routes
 582         # we do this only to test the two different ways to delete routes
 583         # eiter by passing all the paths to remove and mutlipath=1 or
 584         # passing no paths and multipath=0
 585         if self.modified:
 586             self._test.vapi.ip_route_add_del(
 587                 route={'table_id': self.table_id,
 588                        'prefix': self.prefix,
 589                        'n_paths': len(
 590                            self.encoded_paths),
 591                        'paths': self.encoded_paths},
 592                 is_add=0,
 593                 is_multipath=1)
 594         else:
 595             self._test.vapi.ip_route_add_del(
 596                 route={'table_id': self.table_id,
 597                        'prefix': self.prefix,
 598                        'n_paths': 0},
 599                 is_add=0,
 600                 is_multipath=0)
 601
 602     def query_vpp_config(self):
 603         return find_route(self._test,
 604                           self.prefix.network_address,
 605                           self.prefix.prefixlen,
 606                           self.table_id)
 607
 608     def object_id(self):
 609         return ("%s:table-%d-%s" % (
 610             'ip6-route' if self.prefix.version == 6 else 'ip-route',
 611                 self.table_id,
 612                 self.prefix))
 613
 614     def get_stats_to(self):
 615         c = self._test.statistics.get_counter("/net/route/to")
 616         return c[0][self.stats_index]
 617
 618     def get_stats_via(self):
 619         c = self._test.statistics.get_counter("/net/route/via")
 620         return c[0][self.stats_index]
 621
 622
 623 class VppIpMRoute(VppObject):
 624     """
 625     IP Multicast Route
 626     """
 627
 628     def __init__(self, test, src_addr, grp_addr,
 629                  grp_addr_len, e_flags, paths, table_id=0,
 630                  rpf_id=0):
 631         self._test = test
 632         self.paths = paths
 633         self.table_id = table_id
 634         self.e_flags = e_flags
 635         self.rpf_id = rpf_id
 636
 637         self.prefix = VppIpMPrefix(src_addr, grp_addr, grp_addr_len)
 638         self.encoded_paths = []
 639         for path in self.paths:
 640             self.encoded_paths.append(path.encode())
 641
 642     def encode(self, paths=None):
 643         _paths = self.encoded_paths if paths is None else paths
 644         return {'table_id': self.table_id,
 645                 'entry_flags': self.e_flags,
 646                 'rpf_id': self.rpf_id,
 647                 'prefix': self.prefix.encode(),
 648                 'n_paths': len(_paths),
 649                 'paths': _paths,
 650                 }
 651
 652     def add_vpp_config(self):
 653         r = self._test.vapi.ip_mroute_add_del(route=self.encode(),
 654                                               is_multipath=1,
 655                                               is_add=1)
 656         self.stats_index = r.stats_index
 657         self._test.registry.register(self, self._test.logger)
 658         return self
 659
 660     def remove_vpp_config(self):
 661         self._test.vapi.ip_mroute_add_del(route=self.encode(),
 662                                           is_multipath=1,
 663                                           is_add=0)
 664
 665     def update_entry_flags(self, flags):
 666         self.e_flags = flags
 667         self._test.vapi.ip_mroute_add_del(route=self.encode(paths=[]),
 668                                           is_multipath=1,
 669                                           is_add=1)
 670
 671     def update_rpf_id(self, rpf_id):
 672         self.rpf_id = rpf_id
 673         self._test.vapi.ip_mroute_add_del(route=self.encode(paths=[]),
 674                                           is_multipath=1,
 675                                           is_add=1)
 676
 677     def update_path_flags(self, itf, flags):
 678         for p in range(len(self.paths)):
 679             if self.paths[p].nh_itf == itf:
 680                 self.paths[p].nh_i_flags = flags
 681             self.encoded_paths[p] = self.paths[p].encode()
 682             break
 683
 684         self._test.vapi.ip_mroute_add_del(
 685             route=self.encode(
 686                 paths=[self.encoded_paths[p]]),
 687             is_add=1,
 688             is_multipath=0)
 689
 690     def query_vpp_config(self):
 691         return find_mroute(self._test,
 692                            self.prefix.gaddr,
 693                            self.prefix.saddr,
 694                            self.prefix.length,
 695                            self.table_id)
 696
 697     def object_id(self):
 698         return ("%d:(%s,%s/%d)" % (self.table_id,
 699                                    self.prefix.saddr,
 700                                    self.prefix.gaddr,
 701                                    self.prefix.length))
 702
 703     def get_stats(self):
 704         c = self._test.statistics.get_counter("/net/mroute")
 705         return c[0][self.stats_index]
 706
 707
 708 class VppMFibSignal(object):
 709     def __init__(self, test, route, interface, packet):
 710         self.route = route
 711         self.interface = interface
 712         self.packet = packet
 713         self.test = test
 714
 715     def compare(self, signal):
 716         self.test.assertEqual(self.interface, signal.sw_if_index)
 717         self.test.assertEqual(self.route.table_id, signal.table_id)
 718         self.test.assertEqual(self.route.prefix, signal.prefix)
 719
 720
 721 class VppMplsIpBind(VppObject):
 722     """
 723     MPLS to IP Binding
 724     """
 725
 726     def __init__(self, test, local_label, dest_addr, dest_addr_len,
 727                  table_id=0, ip_table_id=0, is_ip6=0):
 728         self._test = test
 729         self.dest_addr_len = dest_addr_len
 730         self.dest_addr = dest_addr
 731         self.ip_addr = ip_address(text_type(dest_addr))
 732         self.local_label = local_label
 733         self.table_id = table_id
 734         self.ip_table_id = ip_table_id
 735         self.prefix = mk_network(dest_addr, dest_addr_len)
 736
 737     def add_vpp_config(self):
 738         self._test.vapi.mpls_ip_bind_unbind(self.local_label,
 739                                             self.prefix,
 740                                             table_id=self.table_id,
 741                                             ip_table_id=self.ip_table_id)
 742         self._test.registry.register(self, self._test.logger)
 743
 744     def remove_vpp_config(self):
 745         self._test.vapi.mpls_ip_bind_unbind(self.local_label,
 746                                             self.prefix,
 747                                             table_id=self.table_id,
 748                                             ip_table_id=self.ip_table_id,
 749                                             is_bind=0)
 750
 751     def query_vpp_config(self):
 752         dump = self._test.vapi.mpls_route_dump(self.table_id)
 753         for e in dump:
 754             if self.local_label == e.mr_route.mr_label \
 755                and self.table_id == e.mr_route.mr_table_id:
 756                 return True
 757         return False
 758
 759     def object_id(self):
 760         return ("%d:%s binds %d:%s/%d"
 761                 % (self.table_id,
 762                    self.local_label,
 763                    self.ip_table_id,
 764                    self.dest_addr,
 765                    self.dest_addr_len))
 766
 767
 768 class VppMplsTable(VppObject):
 769
 770     def __init__(self,
 771                  test,
 772                  table_id):
 773         self._test = test
 774         self.table_id = table_id
 775
 776     def add_vpp_config(self):
 777         self._test.vapi.mpls_table_add_del(
 778             self.table_id,
 779             is_add=1)
 780         self._test.registry.register(self, self._test.logger)
 781
 782     def remove_vpp_config(self):
 783         self._test.vapi.mpls_table_add_del(
 784             self.table_id,
 785             is_add=0)
 786
 787     def query_vpp_config(self):
 788         dump = self._test.vapi.mpls_table_dump()
 789         for d in dump:
 790             if d.mt_table.mt_table_id == self.table_id:
 791                 return True
 792         return False
 793
 794     def object_id(self):
 795         return ("table-mpls-%d" % (self.table_id))
 796
 797
 798 class VppMplsRoute(VppObject):
 799     """
 800     MPLS Route/LSP
 801     """
 802
 803     def __init__(self, test, local_label, eos_bit, paths, table_id=0,
 804                  is_multicast=0,
 805                  eos_proto=FibPathProto.FIB_PATH_NH_PROTO_IP4):
 806         self._test = test
 807         self.paths = paths
 808         self.local_label = local_label
 809         self.eos_bit = eos_bit
 810         self.eos_proto = eos_proto
 811         self.table_id = table_id
 812         self.is_multicast = is_multicast
 813
 814     def add_vpp_config(self):
 815         paths = []
 816         for path in self.paths:
 817             paths.append(path.encode())
 818
 819         r = self._test.vapi.mpls_route_add_del(self.table_id,
 820                                                self.local_label,
 821                                                self.eos_bit,
 822                                                self.eos_proto,
 823                                                self.is_multicast,
 824                                                paths, 1, 0)
 825         self.stats_index = r.stats_index
 826         self._test.registry.register(self, self._test.logger)
 827
 828     def remove_vpp_config(self):
 829         paths = []
 830         for path in self.paths:
 831             paths.append(path.encode())
 832
 833         self._test.vapi.mpls_route_add_del(self.table_id,
 834                                            self.local_label,
 835                                            self.eos_bit,
 836                                            self.eos_proto,
 837                                            self.is_multicast,
 838                                            paths, 0, 0)
 839
 840     def query_vpp_config(self):
 841         return find_mpls_route(self._test, self.table_id,
 842                                self.local_label, self.eos_bit)
 843
 844     def object_id(self):
 845         return ("mpls-route-%d:%s/%d"
 846                 % (self.table_id,
 847                    self.local_label,
 848                    20 + self.eos_bit))
 849
 850     def get_stats_to(self):
 851         c = self._test.statistics.get_counter("/net/route/to")
 852         return c[0][self.stats_index]
 853
 854     def get_stats_via(self):
 855         c = self._test.statistics.get_counter("/net/route/via")
 856         return c[0][self.stats_index]