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, address=self.prefix.bytes,
 165             address_length=self.prefix.length, is_ipv6=self.prefix.is_ip6,
 166             is_add=1)
 167         self._test.registry.register(self, self._test.logger)
 168
 169     def remove_vpp_config(self):
 170         self._test.vapi.sw_interface_add_del_address(
 171             sw_if_index=self.intf.sw_if_index, address=self.prefix.bytes,
 172             address_length=self.prefix.length, is_ipv6=self.prefix.is_ip6,
 173             is_add=0)
 174
 175     def query_vpp_config(self):
 176         return fib_interface_ip_prefix(self._test,
 177                                        self.prefix.address,
 178                                        self.prefix.length,
 179                                        self.intf.sw_if_index)
 180
 181     def __str__(self):
 182         return self.object_id()
 183
 184     def object_id(self):
 185         return "interface-ip-%s-%s" % (self.intf, self.prefix)
 186
 187
 188 class VppIpInterfaceBind(VppObject):
 189
 190     def __init__(self, test, intf, table):
 191         self._test = test
 192         self.intf = intf
 193         self.table = table
 194
 195     def add_vpp_config(self):
 196         if self.table.is_ip6:
 197             self.intf.set_table_ip6(self.table.table_id)
 198         else:
 199             self.intf.set_table_ip4(self.table.table_id)
 200         self._test.registry.register(self, self._test.logger)
 201
 202     def remove_vpp_config(self):
 203         if 0 == self.table.table_id:
 204             return
 205         if self.table.is_ip6:
 206             self.intf.set_table_ip6(0)
 207         else:
 208             self.intf.set_table_ip4(0)
 209
 210     def query_vpp_config(self):
 211         if 0 == self.table.table_id:
 212             return False
 213         return self._test.vapi.sw_interface_get_table(
 214             self.intf.sw_if_index,
 215             self.table.is_ip6).vrf_id == self.table.table_id
 216
 217     def __str__(self):
 218         return self.object_id()
 219
 220     def object_id(self):
 221         return "interface-bind-%s-%s" % (self.intf, self.table)
 222
 223
 224 class VppMplsLabel(object):
 225     def __init__(self, value, mode=MplsLspMode.PIPE, ttl=64, exp=0):
 226         self.value = value
 227         self.mode = mode
 228         self.ttl = ttl
 229         self.exp = exp
 230
 231     def encode(self):
 232         is_uniform = 0 if self.mode is MplsLspMode.PIPE else 1
 233         return {'label': self.value,
 234                 'ttl': self.ttl,
 235                 'exp': self.exp,
 236                 'is_uniform': is_uniform}
 237
 238     def __eq__(self, other):
 239         if isinstance(other, self.__class__):
 240             return (self.value == other.value and
 241                     self.ttl == other.ttl and
 242                     self.exp == other.exp and
 243                     self.mode == other.mode)
 244         elif hasattr(other, 'label'):
 245             return (self.value == other.label and
 246                     self.ttl == other.ttl and
 247                     self.exp == other.exp and
 248                     (self.mode == MplsLspMode.UNIFORM) == other.is_uniform)
 249         else:
 250             return False
 251
 252     def __ne__(self, other):
 253         return not (self == other)
 254
 255
 256 class VppRoutePath(object):
 257
 258     def __init__(
 259             self,
 260             nh_addr,
 261             nh_sw_if_index,
 262             nh_table_id=0,
 263             labels=[],
 264             nh_via_label=MPLS_LABEL_INVALID,
 265             rpf_id=0,
 266             is_interface_rx=0,
 267             is_resolve_host=0,
 268             is_resolve_attached=0,
 269             is_source_lookup=0,
 270             is_udp_encap=0,
 271             is_dvr=0,
 272             next_hop_id=0xffffffff,
 273             proto=DpoProto.DPO_PROTO_IP4):
 274         self.proto = proto
 275         self.nh_itf = nh_sw_if_index
 276         self.nh_table_id = nh_table_id
 277         self.nh_via_label = nh_via_label
 278         self.nh_labels = labels
 279         self.weight = 1
 280         self.rpf_id = rpf_id
 281         if self.proto is DpoProto.DPO_PROTO_IP6:
 282             self.nh_addr = inet_pton(AF_INET6, nh_addr)
 283         elif self.proto is DpoProto.DPO_PROTO_IP4:
 284             self.nh_addr = inet_pton(AF_INET, nh_addr)
 285         else:
 286             self.nh_addr = inet_pton(AF_INET6, "::")
 287         self.is_resolve_host = is_resolve_host
 288         self.is_resolve_attached = is_resolve_attached
 289         self.is_interface_rx = is_interface_rx
 290         self.is_source_lookup = is_source_lookup
 291         self.is_rpf_id = 0
 292         if rpf_id != 0:
 293             self.is_rpf_id = 1
 294             self.nh_itf = rpf_id
 295         self.is_udp_encap = is_udp_encap
 296         self.next_hop_id = next_hop_id
 297         self.is_dvr = is_dvr
 298
 299     def encode_labels(self):
 300         lstack = []
 301         for l in self.nh_labels:
 302             if type(l) == VppMplsLabel:
 303                 lstack.append(l.encode())
 304             else:
 305                 lstack.append({'label': l,
 306                                'ttl': 255})
 307         return lstack
 308
 309     def encode(self):
 310         return {'next_hop': self.nh_addr,
 311                 'weight': 1,
 312                 'preference': 0,
 313                 'table_id': self.nh_table_id,
 314                 'next_hop_id': self.next_hop_id,
 315                 'sw_if_index': self.nh_itf,
 316                 'afi': self.proto,
 317                 'is_udp_encap': self.is_udp_encap,
 318                 'n_labels': len(self.nh_labels),
 319                 'label_stack': self.encode_labels()}
 320
 321     def __eq__(self, other):
 322         if isinstance(other, self.__class__):
 323             return self.nh_addr == other.nh_addr
 324         elif hasattr(other, 'sw_if_index'):
 325             # vl_api_fib_path_t
 326             if (len(self.nh_labels) != other.n_labels):
 327                 return False
 328             for i in range(len(self.nh_labels)):
 329                 if (self.nh_labels[i] != other.label_stack[i]):
 330                     return False
 331             return self.nh_itf == other.sw_if_index
 332         else:
 333             return False
 334
 335     def __ne__(self, other):
 336         return not (self == other)
 337
 338
 339 class VppMRoutePath(VppRoutePath):
 340
 341     def __init__(self, nh_sw_if_index, flags,
 342                  nh=None,
 343                  proto=DpoProto.DPO_PROTO_IP4,
 344                  bier_imp=0):
 345         if not nh:
 346             nh = "::" if proto is DpoProto.DPO_PROTO_IP6 else "0.0.0.0"
 347         super(VppMRoutePath, self).__init__(nh,
 348                                             nh_sw_if_index,
 349                                             proto=proto)
 350         self.nh_i_flags = flags
 351         self.bier_imp = bier_imp
 352
 353
 354 class VppIpRoute(VppObject):
 355     """
 356     IP Route
 357     """
 358
 359     def __init__(self, test, dest_addr,
 360                  dest_addr_len, paths, table_id=0, is_ip6=0, is_local=0,
 361                  is_unreach=0, is_prohibit=0, is_drop=0):
 362         self._test = test
 363         self.paths = paths
 364         self.dest_addr_len = dest_addr_len
 365         self.table_id = table_id
 366         self.is_ip6 = is_ip6
 367         self.is_local = is_local
 368         self.is_unreach = is_unreach
 369         self.is_prohibit = is_prohibit
 370         self.is_drop = is_drop
 371         self.dest_addr_p = dest_addr
 372         if is_ip6:
 373             self.dest_addr = inet_pton(AF_INET6, dest_addr)
 374         else:
 375             self.dest_addr = inet_pton(AF_INET, dest_addr)
 376
 377     def modify(self, paths, is_local=0,
 378                is_unreach=0, is_prohibit=0):
 379         self.paths = paths
 380         self.is_local = is_local
 381         self.is_unreach = is_unreach
 382         self.is_prohibit = is_prohibit
 383
 384     def add_vpp_config(self):
 385         if self.is_unreach or self.is_prohibit or self.is_drop:
 386             r = self._test.vapi.ip_add_del_route(
 387                 self.dest_addr,
 388                 self.dest_addr_len,
 389                 inet_pton(AF_INET6, "::"),
 390                 0xffffffff,
 391                 is_local=self.is_local,
 392                 is_unreach=self.is_unreach,
 393                 is_prohibit=self.is_prohibit,
 394                 is_drop=self.is_drop,
 395                 table_id=self.table_id,
 396                 is_ipv6=self.is_ip6)
 397         else:
 398             for path in self.paths:
 399                 lstack = path.encode_labels()
 400
 401                 r = self._test.vapi.ip_add_del_route(
 402                     self.dest_addr,
 403                     self.dest_addr_len,
 404                     path.nh_addr,
 405                     path.nh_itf,
 406                     table_id=self.table_id,
 407                     next_hop_out_label_stack=lstack,
 408                     next_hop_n_out_labels=len(lstack),
 409                     next_hop_via_label=path.nh_via_label,
 410                     next_hop_table_id=path.nh_table_id,
 411                     next_hop_id=path.next_hop_id,
 412                     is_ipv6=self.is_ip6,
 413                     is_dvr=path.is_dvr,
 414                     is_local=self.is_local,
 415                     is_resolve_host=path.is_resolve_host,
 416                     is_resolve_attached=path.is_resolve_attached,
 417                     is_source_lookup=path.is_source_lookup,
 418                     is_udp_encap=path.is_udp_encap,
 419                     is_multipath=1 if len(self.paths) > 1 else 0)
 420         self.stats_index = r.stats_index
 421         self._test.registry.register(self, self._test.logger)
 422
 423     def remove_vpp_config(self):
 424         if self.is_unreach or self.is_prohibit or self.is_drop:
 425             self._test.vapi.ip_add_del_route(
 426                 self.dest_addr,
 427                 self.dest_addr_len,
 428                 inet_pton(AF_INET6, "::"),
 429                 0xffffffff,
 430                 is_local=self.is_local,
 431                 is_unreach=self.is_unreach,
 432                 is_prohibit=self.is_prohibit,
 433                 is_add=0,
 434                 table_id=self.table_id,
 435                 is_ipv6=self.is_ip6)
 436         else:
 437             for path in self.paths:
 438                 self._test.vapi.ip_add_del_route(
 439                     self.dest_addr,
 440                     self.dest_addr_len,
 441                     path.nh_addr,
 442                     path.nh_itf,
 443                     table_id=self.table_id,
 444                     next_hop_table_id=path.nh_table_id,
 445                     next_hop_via_label=path.nh_via_label,
 446                     next_hop_id=path.next_hop_id,
 447                     is_add=0,
 448                     is_udp_encap=path.is_udp_encap,
 449                     is_ipv6=self.is_ip6,
 450                     is_dvr=path.is_dvr)
 451
 452     def query_vpp_config(self):
 453         return find_route(self._test,
 454                           self.dest_addr_p,
 455                           self.dest_addr_len,
 456                           self.table_id,
 457                           inet=AF_INET6 if self.is_ip6 == 1 else AF_INET)
 458
 459     def __str__(self):
 460         return self.object_id()
 461
 462     def object_id(self):
 463         return ("%d:%s/%d"
 464                 % (self.table_id,
 465                    self.dest_addr_p,
 466                    self.dest_addr_len))
 467
 468     def get_stats_to(self):
 469         c = self._test.statistics.get_counter("/net/route/to")
 470         return c[0][self.stats_index]
 471
 472     def get_stats_via(self):
 473         c = self._test.statistics.get_counter("/net/route/via")
 474         return c[0][self.stats_index]
 475
 476
 477 class VppIpMRoute(VppObject):
 478     """
 479     IP Multicast Route
 480     """
 481
 482     def __init__(self, test, src_addr, grp_addr,
 483                  grp_addr_len, e_flags, paths, table_id=0,
 484                  rpf_id=0, is_ip6=0):
 485         self._test = test
 486         self.paths = paths
 487         self.grp_addr_len = grp_addr_len
 488         self.table_id = table_id
 489         self.e_flags = e_flags
 490         self.is_ip6 = is_ip6
 491         self.rpf_id = rpf_id
 492
 493         self.grp_addr_p = grp_addr
 494         self.src_addr_p = src_addr
 495         if is_ip6:
 496             self.grp_addr = inet_pton(AF_INET6, grp_addr)
 497             self.src_addr = inet_pton(AF_INET6, src_addr)
 498         else:
 499             self.grp_addr = inet_pton(AF_INET, grp_addr)
 500             self.src_addr = inet_pton(AF_INET, src_addr)
 501
 502     def add_vpp_config(self):
 503         for path in self.paths:
 504             r = self._test.vapi.ip_mroute_add_del(self.src_addr,
 505                                                   self.grp_addr,
 506                                                   self.grp_addr_len,
 507                                                   self.e_flags,
 508                                                   path.proto,
 509                                                   path.nh_itf,
 510                                                   path.nh_addr,
 511                                                   path.nh_i_flags,
 512                                                   bier_imp=path.bier_imp,
 513                                                   rpf_id=self.rpf_id,
 514                                                   table_id=self.table_id,
 515                                                   is_ipv6=self.is_ip6)
 516             self.stats_index = r.stats_index
 517         self._test.registry.register(self, self._test.logger)
 518
 519     def remove_vpp_config(self):
 520         for path in self.paths:
 521             self._test.vapi.ip_mroute_add_del(self.src_addr,
 522                                               self.grp_addr,
 523                                               self.grp_addr_len,
 524                                               self.e_flags,
 525                                               path.proto,
 526                                               path.nh_itf,
 527                                               path.nh_addr,
 528                                               path.nh_i_flags,
 529                                               table_id=self.table_id,
 530                                               bier_imp=path.bier_imp,
 531                                               is_add=0,
 532                                               is_ipv6=self.is_ip6)
 533
 534     def update_entry_flags(self, flags):
 535         self.e_flags = flags
 536         self._test.vapi.ip_mroute_add_del(self.src_addr,
 537                                           self.grp_addr,
 538                                           self.grp_addr_len,
 539                                           self.e_flags,
 540                                           0,
 541                                           0xffffffff,
 542                                           "",
 543                                           0,
 544                                           table_id=self.table_id,
 545                                           is_ipv6=self.is_ip6)
 546
 547     def update_rpf_id(self, rpf_id):
 548         self.rpf_id = rpf_id
 549         self._test.vapi.ip_mroute_add_del(self.src_addr,
 550                                           self.grp_addr,
 551                                           self.grp_addr_len,
 552                                           self.e_flags,
 553                                           0,
 554                                           0xffffffff,
 555                                           "",
 556                                           0,
 557                                           rpf_id=self.rpf_id,
 558                                           table_id=self.table_id,
 559                                           is_ipv6=self.is_ip6)
 560
 561     def update_path_flags(self, itf, flags):
 562         for path in self.paths:
 563             if path.nh_itf == itf:
 564                 path.nh_i_flags = flags
 565                 break
 566         self._test.vapi.ip_mroute_add_del(self.src_addr,
 567                                           self.grp_addr,
 568                                           self.grp_addr_len,
 569                                           self.e_flags,
 570                                           path.proto,
 571                                           path.nh_itf,
 572                                           path.nh_addr,
 573                                           path.nh_i_flags,
 574                                           table_id=self.table_id,
 575                                           is_ipv6=self.is_ip6)
 576
 577     def query_vpp_config(self):
 578         return find_mroute(self._test,
 579                            self.grp_addr_p,
 580                            self.src_addr_p,
 581                            self.grp_addr_len,
 582                            self.table_id,
 583                            inet=AF_INET6 if self.is_ip6 == 1 else AF_INET)
 584
 585     def __str__(self):
 586         return self.object_id()
 587
 588     def object_id(self):
 589         if self.is_ip6:
 590             return ("%d:(%s,%s/%d)"
 591                     % (self.table_id,
 592                        inet_ntop(AF_INET6, self.src_addr),
 593                        inet_ntop(AF_INET6, self.grp_addr),
 594                        self.grp_addr_len))
 595         else:
 596             return ("%d:(%s,%s/%d)"
 597                     % (self.table_id,
 598                        inet_ntop(AF_INET, self.src_addr),
 599                        inet_ntop(AF_INET, self.grp_addr),
 600                        self.grp_addr_len))
 601
 602     def get_stats(self):
 603         c = self._test.statistics.get_counter("/net/mroute")
 604         return c[0][self.stats_index]
 605
 606
 607 class VppMFibSignal(object):
 608     def __init__(self, test, route, interface, packet):
 609         self.route = route
 610         self.interface = interface
 611         self.packet = packet
 612         self.test = test
 613
 614     def compare(self, signal):
 615         self.test.assertEqual(self.interface, signal.sw_if_index)
 616         self.test.assertEqual(self.route.table_id, signal.table_id)
 617         self.test.assertEqual(self.route.grp_addr_len,
 618                               signal.grp_address_len)
 619         for i in range(self.route.grp_addr_len / 8):
 620             self.test.assertEqual(self.route.grp_addr[i],
 621                                   signal.grp_address[i])
 622         if (self.route.grp_addr_len > 32):
 623             for i in range(4):
 624                 self.test.assertEqual(self.route.src_addr[i],
 625                                       signal.src_address[i])
 626
 627
 628 class VppMplsIpBind(VppObject):
 629     """
 630     MPLS to IP Binding
 631     """
 632
 633     def __init__(self, test, local_label, dest_addr, dest_addr_len,
 634                  table_id=0, ip_table_id=0, is_ip6=0):
 635         self._test = test
 636         self.dest_addr_len = dest_addr_len
 637         self.dest_addr = dest_addr
 638         self.local_label = local_label
 639         self.table_id = table_id
 640         self.ip_table_id = ip_table_id
 641         self.is_ip6 = is_ip6
 642         if is_ip6:
 643             self.dest_addrn = inet_pton(AF_INET6, dest_addr)
 644         else:
 645             self.dest_addrn = inet_pton(AF_INET, dest_addr)
 646
 647     def add_vpp_config(self):
 648         self._test.vapi.mpls_ip_bind_unbind(self.local_label,
 649                                             self.dest_addrn,
 650                                             self.dest_addr_len,
 651                                             table_id=self.table_id,
 652                                             ip_table_id=self.ip_table_id,
 653                                             is_ip4=(self.is_ip6 == 0))
 654         self._test.registry.register(self, self._test.logger)
 655
 656     def remove_vpp_config(self):
 657         self._test.vapi.mpls_ip_bind_unbind(self.local_label,
 658                                             self.dest_addrn,
 659                                             self.dest_addr_len,
 660                                             table_id=self.table_id,
 661                                             ip_table_id=self.ip_table_id,
 662                                             is_bind=0,
 663                                             is_ip4=(self.is_ip6 == 0))
 664
 665     def query_vpp_config(self):
 666         dump = self._test.vapi.mpls_fib_dump()
 667         for e in dump:
 668             if self.local_label == e.label \
 669                     and self.table_id == e.table_id:
 670                 return True
 671         return False
 672
 673     def __str__(self):
 674         return self.object_id()
 675
 676     def object_id(self):
 677         return ("%d:%s binds %d:%s/%d"
 678                 % (self.table_id,
 679                    self.local_label,
 680                    self.ip_table_id,
 681                    self.dest_addr,
 682                    self.dest_addr_len))
 683
 684
 685 class VppMplsTable(VppObject):
 686
 687     def __init__(self,
 688                  test,
 689                  table_id):
 690         self._test = test
 691         self.table_id = table_id
 692
 693     def add_vpp_config(self):
 694         self._test.vapi.mpls_table_add_del(
 695             self.table_id,
 696             is_add=1)
 697         self._test.registry.register(self, self._test.logger)
 698
 699     def remove_vpp_config(self):
 700         self._test.vapi.mpls_table_add_del(
 701             self.table_id,
 702             is_add=0)
 703
 704     def query_vpp_config(self):
 705         # find the default route
 706         dump = self._test.vapi.mpls_fib_dump()
 707         if len(dump):
 708             return True
 709         return False
 710
 711     def __str__(self):
 712         return self.object_id()
 713
 714     def object_id(self):
 715         return ("table-mpls-%d" % (self.table_id))
 716
 717
 718 class VppMplsRoute(VppObject):
 719     """
 720     MPLS Route/LSP
 721     """
 722
 723     def __init__(self, test, local_label, eos_bit, paths, table_id=0,
 724                  is_multicast=0):
 725         self._test = test
 726         self.paths = paths
 727         self.local_label = local_label
 728         self.eos_bit = eos_bit
 729         self.table_id = table_id
 730         self.is_multicast = is_multicast
 731
 732     def add_vpp_config(self):
 733         is_multipath = len(self.paths) > 1
 734         for path in self.paths:
 735             lstack = path.encode_labels()
 736
 737             r = self._test.vapi.mpls_route_add_del(
 738                 self.local_label,
 739                 self.eos_bit,
 740                 path.proto,
 741                 path.nh_addr,
 742                 path.nh_itf,
 743                 is_multicast=self.is_multicast,
 744                 is_multipath=is_multipath,
 745                 table_id=self.table_id,
 746                 is_interface_rx=path.is_interface_rx,
 747                 is_rpf_id=path.is_rpf_id,
 748                 next_hop_out_label_stack=lstack,
 749                 next_hop_n_out_labels=len(lstack),
 750                 next_hop_via_label=path.nh_via_label,
 751                 next_hop_table_id=path.nh_table_id)
 752         self.stats_index = r.stats_index
 753         self._test.registry.register(self, self._test.logger)
 754
 755     def remove_vpp_config(self):
 756         for path in self.paths:
 757             self._test.vapi.mpls_route_add_del(self.local_label,
 758                                                self.eos_bit,
 759                                                path.proto,
 760                                                path.nh_addr,
 761                                                path.nh_itf,
 762                                                is_rpf_id=path.is_rpf_id,
 763                                                table_id=self.table_id,
 764                                                is_add=0)
 765
 766     def query_vpp_config(self):
 767         return find_mpls_route(self._test, self.table_id,
 768                                self.local_label, self.eos_bit)
 769
 770     def __str__(self):
 771         return self.object_id()
 772
 773     def object_id(self):
 774         return ("%d:%s/%d"
 775                 % (self.table_id,
 776                    self.local_label,
 777                    20 + self.eos_bit))
 778
 779     def get_stats_to(self):
 780         c = self._test.statistics.get_counter("/net/route/to")
 781         return c[0][self.stats_index]
 782
 783     def get_stats_via(self):
 784         c = self._test.statistics.get_counter("/net/route/via")
 785         return c[0][self.stats_index]