2 """IP6 VRF Multi-instance Test Case HLD:
5 - higher number of pg-ip6 interfaces causes problems => only 15 pg-ip6 \
6 interfaces in 5 VRFs are tested
7 - jumbo packets in configuration with 15 pg-ip6 interfaces leads to \
11 - add 15 pg-ip6 interfaces
12 - configure 5 hosts per pg-ip6 interface
14 - add 3 pg-ip6 interfaces per VRF
17 - send IP6 packets between all pg-ip6 interfaces in all VRF groups
20 - check VRF data by parsing output of ip_route_dump API command
21 - all packets received correctly in case of pg-ip6 interfaces in the
23 - no packet received in case of pg-ip6 interfaces not in VRF
24 - no packet received in case of pg-ip6 interfaces in different VRFs
30 - send IP6 packets between all pg-ip6 interfaces in all VRF groups
33 - check VRF data by parsing output of ip_route_dump API command
34 - all packets received correctly in case of pg-ip6 interfaces in the
36 - no packet received in case of pg-ip6 interfaces not in VRF
37 - no packet received in case of pg-ip6 interfaces in different VRFs
40 - add 1 of reset VRFs and 1 new VRF
43 - send IP6 packets between all pg-ip6 interfaces in all VRF groups
46 - check VRF data by parsing output of ip_route_dump API command
47 - all packets received correctly in case of pg-ip6 interfaces in the
49 - no packet received in case of pg-ip6 interfaces not in VRF
50 - no packet received in case of pg-ip6 interfaces in different VRFs
53 - reset all VRFs (i.e. no VRF except VRF=0 created)
56 - send IP6 packets between all pg-ip6 interfaces in all VRF groups
59 - check VRF data by parsing output of ip_route_dump API command
60 - all packets received correctly in case of pg-ip6 interfaces in the
62 - no packet received in case of pg-ip6 interfaces not in VRF
63 - no packet received in case of pg-ip6 interfaces in different VRFs
70 from scapy.packet import Raw
71 from scapy.layers.l2 import Ether
72 from scapy.layers.inet6 import UDP, IPv6, ICMPv6ND_NS, ICMPv6ND_RA, \
73 RouterAlert, IPv6ExtHdrHopByHop
74 from scapy.utils6 import in6_ismaddr, in6_isllsnmaddr, in6_getAddrType
75 from scapy.pton_ntop import inet_ntop
77 from framework import VppTestCase, VppTestRunner
79 from vrf import VRFState
82 def is_ipv6_misc_ext(p):
83 """ Is packet one of uninteresting IPv6 broadcasts (extended to filter out
84 ICMPv6 Neighbor Discovery - Neighbor Advertisement packets too)? """
85 if p.haslayer(ICMPv6ND_RA):
86 if in6_ismaddr(p[IPv6].dst):
88 if p.haslayer(ICMPv6ND_NS):
89 if in6_isllsnmaddr(p[IPv6].dst):
91 if p.haslayer(IPv6ExtHdrHopByHop):
92 for o in p[IPv6ExtHdrHopByHop].options:
93 if isinstance(o, RouterAlert):
98 class TestIP6VrfMultiInst(VppTestCase):
99 """ IP6 VRF Multi-instance Test Case """
104 Perform standard class setup (defined by class method setUpClass in
105 class VppTestCase) before running the test case, set test case related
106 variables and configure VPP.
108 super(TestIP6VrfMultiInst, cls).setUpClass()
113 cls.pg_ifs_per_vrf = 3
116 # Create pg interfaces
117 cls.create_pg_interfaces(
118 range(cls.nr_of_vrfs * cls.pg_ifs_per_vrf))
120 # Packet flows mapping pg0 -> pg1, pg2 etc.
122 for i in range(len(cls.pg_interfaces)):
123 multiplicand = i // cls.pg_ifs_per_vrf
125 cls.pg_interfaces[multiplicand * cls.pg_ifs_per_vrf + j]
126 for j in range(cls.pg_ifs_per_vrf)
127 if (multiplicand * cls.pg_ifs_per_vrf + j) != i]
128 cls.flows[cls.pg_interfaces[i]] = pg_list
130 # Packet sizes - jumbo packet (9018 bytes) skipped
131 cls.pg_if_packet_sizes = [64, 512, 1518]
133 # Set up all interfaces
134 for pg_if in cls.pg_interfaces:
136 pg_if.generate_remote_hosts(cls.hosts_per_pg)
138 # Create list of VRFs
139 cls.vrf_list = list()
141 # Create list of reset VRFs
142 cls.vrf_reset_list = list()
144 # Create list of pg_interfaces in VRFs
145 cls.pg_in_vrf = list()
147 # Create list of pg_interfaces not in VRFs
148 cls.pg_not_in_vrf = [pg_if for pg_if in cls.pg_interfaces]
150 # Create mapping of pg_interfaces to VRF IDs
151 cls.pg_if_sets = dict()
152 for i in range(cls.nr_of_vrfs):
155 cls.pg_interfaces[i * cls.pg_ifs_per_vrf + j]
156 for j in range(cls.pg_ifs_per_vrf)]
157 cls.pg_if_sets[set_id] = pg_list
160 super(TestIP6VrfMultiInst, cls).tearDownClass()
164 def tearDownClass(cls):
165 super(TestIP6VrfMultiInst, cls).tearDownClass()
169 Clear trace and packet infos before running each test.
171 super(TestIP6VrfMultiInst, self).setUp()
172 self.reset_packet_infos()
176 Show various debug prints after each test.
178 super(TestIP6VrfMultiInst, self).tearDown()
180 def show_commands_at_teardown(self):
181 self.logger.info(self.vapi.ppcli("show ip6 fib"))
182 self.logger.info(self.vapi.ppcli("show ip6 neighbors"))
184 def _assign_interfaces(self, vrf_id, if_set_id):
185 for i in range(self.pg_ifs_per_vrf):
186 pg_if = self.pg_if_sets[if_set_id][i]
187 pg_if.set_table_ip6(vrf_id)
188 self.logger.info("pg-interface %s added to IPv6 VRF ID %d"
189 % (pg_if.name, vrf_id))
190 if pg_if not in self.pg_in_vrf:
191 self.pg_in_vrf.append(pg_if)
192 if pg_if in self.pg_not_in_vrf:
193 self.pg_not_in_vrf.remove(pg_if)
195 pg_if.disable_ipv6_ra()
196 pg_if.configure_ipv6_neighbors()
198 def create_vrf_and_assign_interfaces(self, count, start=1):
200 Create required number of FIB tables / VRFs, put 3 pg-ip6 interfaces
201 to every FIB table / VRF.
203 :param int count: Number of FIB tables / VRFs to be created.
204 :param int start: Starting number of the FIB table / VRF ID. \
207 for i in range(count):
209 self.vapi.ip_table_add_del(is_add=1,
210 table={'table_id': vrf_id, 'is_ip6': 1})
211 self.logger.info("IPv6 VRF ID %d created" % vrf_id)
212 if vrf_id not in self.vrf_list:
213 self.vrf_list.append(vrf_id)
214 if vrf_id in self.vrf_reset_list:
215 self.vrf_reset_list.remove(vrf_id)
216 self._assign_interfaces(vrf_id, vrf_id)
217 self.logger.debug(self.vapi.ppcli("show ip6 fib"))
218 self.logger.debug(self.vapi.ppcli("show ip6 neighbors"))
220 def create_vrf_by_id_and_assign_interfaces(self, set_id,
223 Create a FIB table / VRF by vrf_id, put 3 pg-ip6 interfaces
226 :param int vrf_id: Required table ID / VRF ID. \
227 (Default value = 0xffffffff, ID will be selected automatically)
229 ret = self.vapi.ip_table_allocate(table={'table_id': vrf_id,
231 vrf_id = ret.table.table_id
232 self.logger.info("IPv6 VRF ID %d created" % vrf_id)
233 if vrf_id not in self.vrf_list:
234 self.vrf_list.append(vrf_id)
235 if vrf_id in self.vrf_reset_list:
236 self.vrf_reset_list.remove(vrf_id)
237 self._assign_interfaces(vrf_id, set_id)
238 self.logger.debug(self.vapi.ppcli("show ip6 fib"))
239 self.logger.debug(self.vapi.ppcli("show ip6 neighbors"))
243 def reset_vrf_and_remove_from_vrf_list(self, vrf_id, if_set_id=None):
245 Reset required FIB table / VRF and remove it from VRF list.
247 :param int vrf_id: The FIB table / VRF ID to be reset.
249 if if_set_id is None:
251 self.vapi.ip_table_flush(table={'table_id': vrf_id, 'is_ip6': 1})
252 if vrf_id in self.vrf_list:
253 self.vrf_list.remove(vrf_id)
254 if vrf_id not in self.vrf_reset_list:
255 self.vrf_reset_list.append(vrf_id)
256 for j in range(self.pg_ifs_per_vrf):
257 pg_if = self.pg_if_sets[if_set_id][j]
259 if pg_if in self.pg_in_vrf:
260 self.pg_in_vrf.remove(pg_if)
261 if pg_if not in self.pg_not_in_vrf:
262 self.pg_not_in_vrf.append(pg_if)
263 self.logger.info("IPv6 VRF ID %d reset finished" % vrf_id)
264 self.logger.debug(self.vapi.ppcli("show ip6 fib"))
265 self.logger.debug(self.vapi.ppcli("show ip6 neighbors"))
266 self.vapi.ip_table_add_del(is_add=0,
267 table={'table_id': vrf_id, 'is_ip6': 1})
269 def create_stream(self, src_if, packet_sizes):
271 Create input packet stream for defined interface using hosts list.
273 :param object src_if: Interface to create packet stream for.
274 :param list packet_sizes: List of required packet sizes.
275 :return: Stream of packets.
278 src_hosts = src_if.remote_hosts
279 for dst_if in self.flows[src_if]:
280 for dst_host in dst_if.remote_hosts:
281 src_host = random.choice(src_hosts)
282 pkt_info = self.create_packet_info(src_if, dst_if)
283 payload = self.info_to_payload(pkt_info)
284 p = (Ether(dst=src_if.local_mac, src=src_host.mac) /
285 IPv6(src=src_host.ip6, dst=dst_host.ip6) /
286 UDP(sport=1234, dport=1234) /
288 pkt_info.data = p.copy()
289 size = random.choice(packet_sizes)
290 self.extend_packet(p, size)
292 self.logger.debug("Input stream created for port %s. Length: %u pkt(s)"
293 % (src_if.name, len(pkts)))
296 def create_stream_crosswise_vrf(self, src_if, vrf_id, packet_sizes):
298 Create input packet stream for negative test for leaking across
299 different VRFs for defined interface using hosts list.
301 :param object src_if: Interface to create packet stream for.
302 :param int vrf_id: The FIB table / VRF ID where src_if is assigned.
303 :param list packet_sizes: List of required packet sizes.
304 :return: Stream of packets.
307 src_hosts = src_if.remote_hosts
308 vrf_lst = list(self.vrf_list)
309 vrf_lst.remove(vrf_id)
311 for dst_if in self.pg_if_sets[vrf]:
312 for dst_host in dst_if.remote_hosts:
313 src_host = random.choice(src_hosts)
314 pkt_info = self.create_packet_info(src_if, dst_if)
315 payload = self.info_to_payload(pkt_info)
316 p = (Ether(dst=src_if.local_mac, src=src_host.mac) /
317 IPv6(src=src_host.ip6, dst=dst_host.ip6) /
318 UDP(sport=1234, dport=1234) /
320 pkt_info.data = p.copy()
321 size = random.choice(packet_sizes)
322 self.extend_packet(p, size)
324 self.logger.debug("Input stream created for port %s. Length: %u pkt(s)"
325 % (src_if.name, len(pkts)))
328 def verify_capture(self, pg_if, capture):
330 Verify captured input packet stream for defined interface.
332 :param object pg_if: Interface to verify captured packet stream for.
333 :param list capture: Captured packet stream.
336 for i in self.pg_interfaces:
337 last_info[i.sw_if_index] = None
338 dst_sw_if_index = pg_if.sw_if_index
339 for packet in capture:
343 payload_info = self.payload_to_info(packet[Raw])
344 packet_index = payload_info.index
345 self.assertEqual(payload_info.dst, dst_sw_if_index)
346 self.logger.debug("Got packet on port %s: src=%u (id=%u)" %
347 (pg_if.name, payload_info.src, packet_index))
348 next_info = self.get_next_packet_info_for_interface2(
349 payload_info.src, dst_sw_if_index,
350 last_info[payload_info.src])
351 last_info[payload_info.src] = next_info
352 self.assertIsNotNone(next_info)
353 self.assertEqual(packet_index, next_info.index)
354 saved_packet = next_info.data
355 # Check standard fields
356 self.assertEqual(ip.src, saved_packet[IPv6].src)
357 self.assertEqual(ip.dst, saved_packet[IPv6].dst)
358 self.assertEqual(udp.sport, saved_packet[UDP].sport)
359 self.assertEqual(udp.dport, saved_packet[UDP].dport)
361 self.logger.error(ppp("Unexpected or invalid packet:", packet))
363 for i in self.pg_interfaces:
364 remaining_packet = self.get_next_packet_info_for_interface2(
365 i, dst_sw_if_index, last_info[i.sw_if_index])
368 "Port %u: Packet expected from source %u didn't arrive" %
369 (dst_sw_if_index, i.sw_if_index))
371 def verify_vrf(self, vrf_id, if_set_id=None):
373 Check if the FIB table / VRF ID is configured.
375 :param int vrf_id: The FIB table / VRF ID to be verified.
376 :return: 1 if the FIB table / VRF ID is configured, otherwise return 0.
378 if if_set_id is None:
380 ip6_fib_dump = self.vapi.ip_route_dump(vrf_id, True)
381 vrf_exist = len(ip6_fib_dump)
383 for ip6_fib_details in ip6_fib_dump:
384 addr = ip6_fib_details.route.prefix.network_address
386 for pg_if in self.pg_if_sets[if_set_id]:
389 for host in pg_if.remote_hosts:
390 if str(addr) == host.ip6:
394 if not vrf_exist and vrf_count == 0:
395 self.logger.info("IPv6 VRF ID %d is not configured" % vrf_id)
396 return VRFState.not_configured
397 elif vrf_exist and vrf_count == 0:
398 self.logger.info("IPv6 VRF ID %d has been reset" % vrf_id)
399 return VRFState.reset
401 self.logger.info("IPv6 VRF ID %d is configured" % vrf_id)
402 return VRFState.configured
404 def run_verify_test(self):
406 Create packet streams for all configured pg interfaces, send all \
407 prepared packet streams and verify that:
408 - all packets received correctly on all pg-ip6 interfaces assigned
410 - no packet received on all pg-ip6 interfaces not assigned to VRFs
412 :raise RuntimeError: If no packet captured on pg-ip6 interface assigned
413 to VRF or if any packet is captured on pg-ip6 interface not
417 # Create incoming packet streams for packet-generator interfaces
418 for pg_if in self.pg_interfaces:
419 pkts = self.create_stream(pg_if, self.pg_if_packet_sizes)
420 pg_if.add_stream(pkts)
422 # Enable packet capture and start packet sending
423 self.pg_enable_capture(self.pg_interfaces)
427 # Verify outgoing packet streams per packet-generator interface
428 for pg_if in self.pg_interfaces:
429 if pg_if in self.pg_in_vrf:
430 capture = pg_if.get_capture(remark="interface is in VRF")
431 self.verify_capture(pg_if, capture)
432 elif pg_if in self.pg_not_in_vrf:
433 pg_if.assert_nothing_captured(remark="interface is not in VRF",
434 filter_out_fn=is_ipv6_misc_ext)
435 self.logger.debug("No capture for interface %s" % pg_if.name)
437 raise Exception("Unknown interface: %s" % pg_if.name)
439 def run_crosswise_vrf_test(self):
441 Create packet streams for every pg-ip6 interface in VRF towards all
442 pg-ip6 interfaces in other VRFs, send all prepared packet streams and
445 - no packet received on all configured pg-ip6 interfaces
447 :raise RuntimeError: If any packet is captured on any pg-ip6 interface.
450 # Create incoming packet streams for packet-generator interfaces
451 for vrf_id in self.vrf_list:
452 for pg_if in self.pg_if_sets[vrf_id]:
453 pkts = self.create_stream_crosswise_vrf(
454 pg_if, vrf_id, self.pg_if_packet_sizes)
455 pg_if.add_stream(pkts)
457 # Enable packet capture and start packet sending
458 self.pg_enable_capture(self.pg_interfaces)
462 # Verify outgoing packet streams per packet-generator interface
463 for pg_if in self.pg_interfaces:
464 pg_if.assert_nothing_captured(remark="interface is in other VRF",
465 filter_out_fn=is_ipv6_misc_ext)
466 self.logger.debug("No capture for interface %s" % pg_if.name)
468 def test_ip6_vrf_01(self):
469 """ IP6 VRF Multi-instance test 1 - create 4 VRFs
473 self.create_vrf_and_assign_interfaces(4)
476 for vrf_id in self.vrf_list:
477 self.assert_equal(self.verify_vrf(vrf_id),
478 VRFState.configured, VRFState)
481 self.run_verify_test()
482 self.run_crosswise_vrf_test()
484 def test_ip6_vrf_02(self):
485 """ IP6 VRF Multi-instance test 2 - reset 2 VRFs
489 self.reset_vrf_and_remove_from_vrf_list(1)
490 self.reset_vrf_and_remove_from_vrf_list(2)
493 for vrf_id in self.vrf_reset_list:
494 self.assert_equal(self.verify_vrf(vrf_id),
495 VRFState.reset, VRFState)
496 for vrf_id in self.vrf_list:
497 self.assert_equal(self.verify_vrf(vrf_id),
498 VRFState.configured, VRFState)
501 self.run_verify_test()
502 self.run_crosswise_vrf_test()
504 # Reset routes learned from ICMPv6 Neighbor Discovery
505 # for vrf_id in self.vrf_reset_list:
506 # self.reset_vrf_and_remove_from_vrf_list(vrf_id)
508 def test_ip6_vrf_03(self):
509 """ IP6 VRF Multi-instance 3 - add 2 VRFs
512 # Add 1 of reset VRFs and 1 new VRF
513 self.create_vrf_and_assign_interfaces(1)
514 self.create_vrf_and_assign_interfaces(1, start=5)
517 for vrf_id in self.vrf_reset_list:
518 self.assert_equal(self.verify_vrf(vrf_id),
519 VRFState.reset, VRFState)
520 for vrf_id in self.vrf_list:
521 self.assert_equal(self.verify_vrf(vrf_id),
522 VRFState.configured, VRFState)
525 self.run_verify_test()
526 self.run_crosswise_vrf_test()
528 # Reset routes learned from ICMPv6 Neighbor Discovery
529 # for vrf_id in self.vrf_reset_list:
530 # self.reset_vrf_and_remove_from_vrf_list(vrf_id)
532 def test_ip6_vrf_04(self):
533 """ IP6 VRF Multi-instance test 4 - reset 4 VRFs
536 # Reset all VRFs (i.e. no VRF except VRF=0 configured)
537 for i in range(len(self.vrf_list)):
538 # This call removes the first item of vrf_list as a side effect
539 self.reset_vrf_and_remove_from_vrf_list(self.vrf_list[0])
542 for vrf_id in self.vrf_reset_list:
543 self.assert_equal(self.verify_vrf(vrf_id),
544 VRFState.reset, VRFState)
545 vrf_list_length = len(self.vrf_list)
548 "List of configured VRFs is not empty: %s != 0" % vrf_list_length)
551 self.run_verify_test()
552 self.run_crosswise_vrf_test()
554 @unittest.skip('VPP crashes after running this test. \
555 There seems to be an issue with the way fib locks are managed')
556 def test_ip6_vrf_05(self):
557 """ IP6 VRF Multi-instance test 5 - auto allocate vrf id
560 # Create several VRFs
561 # Set vrf_id manually first
562 self.create_vrf_by_id_and_assign_interfaces(1, 10)
563 # Set vrf_id automatically a few times
565 self.create_vrf_by_id_and_assign_interfaces(i) for i in range(2, 5)
569 self.assert_equal(self.verify_vrf(10, 1), VRFState.configured,
571 for i, vrf in enumerate(auto_vrf_id):
572 self.assert_equal(self.verify_vrf(vrf, i+2),
573 VRFState.configured, VRFState)
576 self.run_verify_test()
580 self.reset_vrf_and_remove_from_vrf_list(10, 1)
581 for i, vrf in enumerate(auto_vrf_id):
582 self.reset_vrf_and_remove_from_vrf_list(vrf, i+2)
585 self.assert_equal(self.verify_vrf(10, 1), VRFState.reset, VRFState)
586 for i, vrf in enumerate(auto_vrf_id):
587 self.assert_equal(self.verify_vrf(vrf, i+2),
588 VRFState.reset, VRFState)
590 vrf_list_length = len(self.vrf_list)
593 "List of configured VRFs is not empty: %s != 0" % vrf_list_length)
595 def test_ip6_vrf_06(self):
596 """ IP6 VRF Multi-instance test 6 - recreate 4 VRFs
598 # Reconfigure all the VRFs
599 self.create_vrf_and_assign_interfaces(4)
601 for vrf_id in self.vrf_list:
602 self.assert_equal(self.verify_vrf(vrf_id),
603 VRFState.configured, VRFState)
605 self.run_verify_test()
606 self.run_crosswise_vrf_test()
608 for i in range(len(self.vrf_list)):
609 self.reset_vrf_and_remove_from_vrf_list(self.vrf_list[0])
611 for vrf_id in self.vrf_reset_list:
612 self.assert_equal(self.verify_vrf(vrf_id),
613 VRFState.reset, VRFState)
614 vrf_list_length = len(self.vrf_list)
617 "List of configured VRFs is not empty: %s != 0" % vrf_list_length)
619 self.run_verify_test()
620 self.run_crosswise_vrf_test()
623 if __name__ == '__main__':
624 unittest.main(testRunner=VppTestRunner)