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