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