Jan Gelety | 057bb8c | 2016-12-20 17:32:45 +0100 | [diff] [blame] | 1 | #!/usr/bin/env python |
| 2 | """IP6 VRF Multi-instance Test Case HLD: |
| 3 | |
| 4 | **NOTES:** |
| 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 \ |
| 8 | problems too |
Jan Gelety | 057bb8c | 2016-12-20 17:32:45 +0100 | [diff] [blame] | 9 | |
| 10 | **config 1** |
| 11 | - add 15 pg-ip6 interfaces |
| 12 | - configure 5 hosts per pg-ip6 interface |
| 13 | - configure 4 VRFs |
| 14 | - add 3 pg-ip6 interfaces per VRF |
| 15 | |
| 16 | **test 1** |
| 17 | - send IP6 packets between all pg-ip6 interfaces in all VRF groups |
| 18 | |
| 19 | **verify 1** |
Neale Ranns | 097fa66 | 2018-05-01 05:17:55 -0700 | [diff] [blame] | 20 | - check VRF data by parsing output of ip_route_dump API command |
Jan Gelety | d16ba62 | 2018-06-21 16:57:47 +0200 | [diff] [blame] | 21 | - all packets received correctly in case of pg-ip6 interfaces in the same |
| 22 | VRF |
Jan Gelety | 057bb8c | 2016-12-20 17:32:45 +0100 | [diff] [blame] | 23 | - no packet received in case of pg-ip6 interfaces not in VRF |
Jan Gelety | d16ba62 | 2018-06-21 16:57:47 +0200 | [diff] [blame] | 24 | - no packet received in case of pg-ip6 interfaces in different VRFs |
Jan Gelety | 057bb8c | 2016-12-20 17:32:45 +0100 | [diff] [blame] | 25 | |
| 26 | **config 2** |
Jan Gelety | b5b2ef5 | 2017-02-23 15:01:29 +0100 | [diff] [blame] | 27 | - reset 2 VRFs |
Jan Gelety | 057bb8c | 2016-12-20 17:32:45 +0100 | [diff] [blame] | 28 | |
| 29 | **test 2** |
| 30 | - send IP6 packets between all pg-ip6 interfaces in all VRF groups |
| 31 | |
| 32 | **verify 2** |
Neale Ranns | 097fa66 | 2018-05-01 05:17:55 -0700 | [diff] [blame] | 33 | - check VRF data by parsing output of ip_route_dump API command |
Jan Gelety | d16ba62 | 2018-06-21 16:57:47 +0200 | [diff] [blame] | 34 | - all packets received correctly in case of pg-ip6 interfaces in the same |
| 35 | VRF |
Jan Gelety | 057bb8c | 2016-12-20 17:32:45 +0100 | [diff] [blame] | 36 | - no packet received in case of pg-ip6 interfaces not in VRF |
Jan Gelety | d16ba62 | 2018-06-21 16:57:47 +0200 | [diff] [blame] | 37 | - no packet received in case of pg-ip6 interfaces in different VRFs |
Jan Gelety | 057bb8c | 2016-12-20 17:32:45 +0100 | [diff] [blame] | 38 | |
| 39 | **config 3** |
Jan Gelety | b5b2ef5 | 2017-02-23 15:01:29 +0100 | [diff] [blame] | 40 | - add 1 of reset VRFs and 1 new VRF |
Jan Gelety | 057bb8c | 2016-12-20 17:32:45 +0100 | [diff] [blame] | 41 | |
| 42 | **test 3** |
| 43 | - send IP6 packets between all pg-ip6 interfaces in all VRF groups |
| 44 | |
| 45 | **verify 3** |
Neale Ranns | 097fa66 | 2018-05-01 05:17:55 -0700 | [diff] [blame] | 46 | - check VRF data by parsing output of ip_route_dump API command |
Jan Gelety | d16ba62 | 2018-06-21 16:57:47 +0200 | [diff] [blame] | 47 | - all packets received correctly in case of pg-ip6 interfaces in the same |
| 48 | VRF |
Jan Gelety | 057bb8c | 2016-12-20 17:32:45 +0100 | [diff] [blame] | 49 | - no packet received in case of pg-ip6 interfaces not in VRF |
Jan Gelety | d16ba62 | 2018-06-21 16:57:47 +0200 | [diff] [blame] | 50 | - no packet received in case of pg-ip6 interfaces in different VRFs |
Jan Gelety | 057bb8c | 2016-12-20 17:32:45 +0100 | [diff] [blame] | 51 | |
| 52 | **config 4** |
Jan Gelety | b5b2ef5 | 2017-02-23 15:01:29 +0100 | [diff] [blame] | 53 | - reset all VRFs (i.e. no VRF except VRF=0 created) |
Jan Gelety | 057bb8c | 2016-12-20 17:32:45 +0100 | [diff] [blame] | 54 | |
| 55 | **test 4** |
| 56 | - send IP6 packets between all pg-ip6 interfaces in all VRF groups |
| 57 | |
| 58 | **verify 4** |
Neale Ranns | 097fa66 | 2018-05-01 05:17:55 -0700 | [diff] [blame] | 59 | - check VRF data by parsing output of ip_route_dump API command |
Jan Gelety | d16ba62 | 2018-06-21 16:57:47 +0200 | [diff] [blame] | 60 | - all packets received correctly in case of pg-ip6 interfaces in the same |
| 61 | VRF |
Jan Gelety | 057bb8c | 2016-12-20 17:32:45 +0100 | [diff] [blame] | 62 | - no packet received in case of pg-ip6 interfaces not in VRF |
Jan Gelety | d16ba62 | 2018-06-21 16:57:47 +0200 | [diff] [blame] | 63 | - no packet received in case of pg-ip6 interfaces in different VRFs |
Jan Gelety | 057bb8c | 2016-12-20 17:32:45 +0100 | [diff] [blame] | 64 | """ |
| 65 | |
| 66 | import unittest |
| 67 | import random |
Jan Gelety | b5b2ef5 | 2017-02-23 15:01:29 +0100 | [diff] [blame] | 68 | import socket |
Jan Gelety | 057bb8c | 2016-12-20 17:32:45 +0100 | [diff] [blame] | 69 | |
| 70 | from scapy.packet import Raw |
| 71 | from scapy.layers.l2 import Ether |
Jan Gelety | b5b2ef5 | 2017-02-23 15:01:29 +0100 | [diff] [blame] | 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 |
Jan Gelety | 057bb8c | 2016-12-20 17:32:45 +0100 | [diff] [blame] | 76 | |
| 77 | from framework import VppTestCase, VppTestRunner |
| 78 | from util import ppp |
Jan Gelety | 95c87b5 | 2017-02-27 10:46:14 +0100 | [diff] [blame] | 79 | from vrf import VRFState |
Jan Gelety | b5b2ef5 | 2017-02-23 15:01:29 +0100 | [diff] [blame] | 80 | |
| 81 | |
| 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): |
| 87 | return True |
| 88 | if p.haslayer(ICMPv6ND_NS): |
| 89 | if in6_isllsnmaddr(p[IPv6].dst): |
| 90 | return True |
| 91 | if p.haslayer(IPv6ExtHdrHopByHop): |
| 92 | for o in p[IPv6ExtHdrHopByHop].options: |
| 93 | if isinstance(o, RouterAlert): |
| 94 | return True |
| 95 | return False |
| 96 | |
Jan Gelety | 057bb8c | 2016-12-20 17:32:45 +0100 | [diff] [blame] | 97 | |
| 98 | class TestIP6VrfMultiInst(VppTestCase): |
| 99 | """ IP6 VRF Multi-instance Test Case """ |
| 100 | |
| 101 | @classmethod |
| 102 | def setUpClass(cls): |
| 103 | """ |
| 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. |
| 107 | """ |
| 108 | super(TestIP6VrfMultiInst, cls).setUpClass() |
| 109 | |
| 110 | # Test variables |
| 111 | cls.hosts_per_pg = 5 |
| 112 | cls.nr_of_vrfs = 5 |
| 113 | cls.pg_ifs_per_vrf = 3 |
| 114 | |
| 115 | try: |
| 116 | # Create pg interfaces |
| 117 | cls.create_pg_interfaces( |
| 118 | range(cls.nr_of_vrfs * cls.pg_ifs_per_vrf)) |
| 119 | |
| 120 | # Packet flows mapping pg0 -> pg1, pg2 etc. |
| 121 | cls.flows = dict() |
| 122 | for i in range(len(cls.pg_interfaces)): |
Ole Troan | 1975733 | 2019-10-18 14:54:30 +0200 | [diff] [blame] | 123 | multiplicand = i // cls.pg_ifs_per_vrf |
Jan Gelety | 057bb8c | 2016-12-20 17:32:45 +0100 | [diff] [blame] | 124 | pg_list = [ |
| 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 |
| 129 | |
| 130 | # Packet sizes - jumbo packet (9018 bytes) skipped |
| 131 | cls.pg_if_packet_sizes = [64, 512, 1518] |
| 132 | |
| 133 | # Set up all interfaces |
| 134 | for pg_if in cls.pg_interfaces: |
| 135 | pg_if.admin_up() |
| 136 | pg_if.generate_remote_hosts(cls.hosts_per_pg) |
| 137 | |
| 138 | # Create list of VRFs |
| 139 | cls.vrf_list = list() |
| 140 | |
Jan Gelety | b5b2ef5 | 2017-02-23 15:01:29 +0100 | [diff] [blame] | 141 | # Create list of reset VRFs |
| 142 | cls.vrf_reset_list = list() |
Jan Gelety | 057bb8c | 2016-12-20 17:32:45 +0100 | [diff] [blame] | 143 | |
| 144 | # Create list of pg_interfaces in VRFs |
| 145 | cls.pg_in_vrf = list() |
| 146 | |
Jan Gelety | d16ba62 | 2018-06-21 16:57:47 +0200 | [diff] [blame] | 147 | # Create list of pg_interfaces not in VRFs |
Jan Gelety | 057bb8c | 2016-12-20 17:32:45 +0100 | [diff] [blame] | 148 | cls.pg_not_in_vrf = [pg_if for pg_if in cls.pg_interfaces] |
| 149 | |
| 150 | # Create mapping of pg_interfaces to VRF IDs |
| 151 | cls.pg_if_by_vrf_id = dict() |
| 152 | for i in range(cls.nr_of_vrfs): |
| 153 | vrf_id = i + 1 |
| 154 | pg_list = [ |
| 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_by_vrf_id[vrf_id] = pg_list |
| 158 | |
| 159 | except Exception: |
| 160 | super(TestIP6VrfMultiInst, cls).tearDownClass() |
| 161 | raise |
| 162 | |
Paul Vinciguerra | 7f9b7f9 | 2019-03-12 19:23:27 -0700 | [diff] [blame] | 163 | @classmethod |
| 164 | def tearDownClass(cls): |
| 165 | super(TestIP6VrfMultiInst, cls).tearDownClass() |
| 166 | |
Jan Gelety | 057bb8c | 2016-12-20 17:32:45 +0100 | [diff] [blame] | 167 | def setUp(self): |
| 168 | """ |
| 169 | Clear trace and packet infos before running each test. |
| 170 | """ |
| 171 | super(TestIP6VrfMultiInst, self).setUp() |
| 172 | self.reset_packet_infos() |
| 173 | |
| 174 | def tearDown(self): |
| 175 | """ |
| 176 | Show various debug prints after each test. |
| 177 | """ |
| 178 | super(TestIP6VrfMultiInst, self).tearDown() |
Paul Vinciguerra | 90cf21b | 2019-03-13 09:23:05 -0700 | [diff] [blame] | 179 | |
| 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")) |
Jan Gelety | 057bb8c | 2016-12-20 17:32:45 +0100 | [diff] [blame] | 183 | |
| 184 | def create_vrf_and_assign_interfaces(self, count, start=1): |
| 185 | """ |
Jan Gelety | d16ba62 | 2018-06-21 16:57:47 +0200 | [diff] [blame] | 186 | Create required number of FIB tables / VRFs, put 3 pg-ip6 interfaces |
Jan Gelety | 057bb8c | 2016-12-20 17:32:45 +0100 | [diff] [blame] | 187 | to every FIB table / VRF. |
| 188 | |
| 189 | :param int count: Number of FIB tables / VRFs to be created. |
| 190 | :param int start: Starting number of the FIB table / VRF ID. \ |
| 191 | (Default value = 1) |
| 192 | """ |
| 193 | for i in range(count): |
| 194 | vrf_id = i + start |
| 195 | pg_if = self.pg_if_by_vrf_id[vrf_id][0] |
Jan Gelety | 95c87b5 | 2017-02-27 10:46:14 +0100 | [diff] [blame] | 196 | dest_addr = pg_if.local_ip6n |
Jan Gelety | 057bb8c | 2016-12-20 17:32:45 +0100 | [diff] [blame] | 197 | dest_addr_len = 64 |
Ole Troan | 9a47537 | 2019-03-05 16:58:24 +0100 | [diff] [blame] | 198 | self.vapi.ip_table_add_del(is_ipv6=1, is_add=1, table_id=vrf_id) |
Jan Gelety | 057bb8c | 2016-12-20 17:32:45 +0100 | [diff] [blame] | 199 | self.logger.info("IPv6 VRF ID %d created" % vrf_id) |
| 200 | if vrf_id not in self.vrf_list: |
| 201 | self.vrf_list.append(vrf_id) |
Jan Gelety | b5b2ef5 | 2017-02-23 15:01:29 +0100 | [diff] [blame] | 202 | if vrf_id in self.vrf_reset_list: |
| 203 | self.vrf_reset_list.remove(vrf_id) |
Jan Gelety | 057bb8c | 2016-12-20 17:32:45 +0100 | [diff] [blame] | 204 | for j in range(self.pg_ifs_per_vrf): |
| 205 | pg_if = self.pg_if_by_vrf_id[vrf_id][j] |
| 206 | pg_if.set_table_ip6(vrf_id) |
| 207 | self.logger.info("pg-interface %s added to IPv6 VRF ID %d" |
| 208 | % (pg_if.name, vrf_id)) |
| 209 | if pg_if not in self.pg_in_vrf: |
| 210 | self.pg_in_vrf.append(pg_if) |
| 211 | if pg_if in self.pg_not_in_vrf: |
| 212 | self.pg_not_in_vrf.remove(pg_if) |
| 213 | pg_if.config_ip6() |
| 214 | pg_if.disable_ipv6_ra() |
Neale Ranns | baf2e90 | 2017-02-25 04:20:00 -0800 | [diff] [blame] | 215 | pg_if.configure_ipv6_neighbors() |
Jan Gelety | 057bb8c | 2016-12-20 17:32:45 +0100 | [diff] [blame] | 216 | self.logger.debug(self.vapi.ppcli("show ip6 fib")) |
| 217 | self.logger.debug(self.vapi.ppcli("show ip6 neighbors")) |
| 218 | |
Jan Gelety | 95c87b5 | 2017-02-27 10:46:14 +0100 | [diff] [blame] | 219 | def reset_vrf_and_remove_from_vrf_list(self, vrf_id): |
Jan Gelety | 057bb8c | 2016-12-20 17:32:45 +0100 | [diff] [blame] | 220 | """ |
Jan Gelety | 95c87b5 | 2017-02-27 10:46:14 +0100 | [diff] [blame] | 221 | Reset required FIB table / VRF and remove it from VRF list. |
Jan Gelety | 057bb8c | 2016-12-20 17:32:45 +0100 | [diff] [blame] | 222 | |
Jan Gelety | b5b2ef5 | 2017-02-23 15:01:29 +0100 | [diff] [blame] | 223 | :param int vrf_id: The FIB table / VRF ID to be reset. |
Jan Gelety | 057bb8c | 2016-12-20 17:32:45 +0100 | [diff] [blame] | 224 | """ |
| 225 | # self.vapi.reset_vrf(vrf_id, is_ipv6=1) |
| 226 | self.vapi.reset_fib(vrf_id, is_ipv6=1) |
| 227 | if vrf_id in self.vrf_list: |
| 228 | self.vrf_list.remove(vrf_id) |
Jan Gelety | b5b2ef5 | 2017-02-23 15:01:29 +0100 | [diff] [blame] | 229 | if vrf_id not in self.vrf_reset_list: |
| 230 | self.vrf_reset_list.append(vrf_id) |
Jan Gelety | 057bb8c | 2016-12-20 17:32:45 +0100 | [diff] [blame] | 231 | for j in range(self.pg_ifs_per_vrf): |
| 232 | pg_if = self.pg_if_by_vrf_id[vrf_id][j] |
Neale Ranns | 4008ac9 | 2017-02-13 23:20:04 -0800 | [diff] [blame] | 233 | pg_if.unconfig_ip6() |
Jan Gelety | 057bb8c | 2016-12-20 17:32:45 +0100 | [diff] [blame] | 234 | if pg_if in self.pg_in_vrf: |
| 235 | self.pg_in_vrf.remove(pg_if) |
| 236 | if pg_if not in self.pg_not_in_vrf: |
| 237 | self.pg_not_in_vrf.append(pg_if) |
Jan Gelety | 95c87b5 | 2017-02-27 10:46:14 +0100 | [diff] [blame] | 238 | self.logger.info("IPv6 VRF ID %d reset finished" % vrf_id) |
Jan Gelety | 057bb8c | 2016-12-20 17:32:45 +0100 | [diff] [blame] | 239 | self.logger.debug(self.vapi.ppcli("show ip6 fib")) |
| 240 | self.logger.debug(self.vapi.ppcli("show ip6 neighbors")) |
Ole Troan | 9a47537 | 2019-03-05 16:58:24 +0100 | [diff] [blame] | 241 | self.vapi.ip_table_add_del(is_ipv6=1, is_add=0, table_id=vrf_id) |
Jan Gelety | 057bb8c | 2016-12-20 17:32:45 +0100 | [diff] [blame] | 242 | |
| 243 | def create_stream(self, src_if, packet_sizes): |
| 244 | """ |
| 245 | Create input packet stream for defined interface using hosts list. |
| 246 | |
| 247 | :param object src_if: Interface to create packet stream for. |
| 248 | :param list packet_sizes: List of required packet sizes. |
| 249 | :return: Stream of packets. |
| 250 | """ |
| 251 | pkts = [] |
| 252 | src_hosts = src_if.remote_hosts |
| 253 | for dst_if in self.flows[src_if]: |
| 254 | for dst_host in dst_if.remote_hosts: |
| 255 | src_host = random.choice(src_hosts) |
| 256 | pkt_info = self.create_packet_info(src_if, dst_if) |
| 257 | payload = self.info_to_payload(pkt_info) |
| 258 | p = (Ether(dst=src_if.local_mac, src=src_host.mac) / |
| 259 | IPv6(src=src_host.ip6, dst=dst_host.ip6) / |
| 260 | UDP(sport=1234, dport=1234) / |
| 261 | Raw(payload)) |
| 262 | pkt_info.data = p.copy() |
| 263 | size = random.choice(packet_sizes) |
| 264 | self.extend_packet(p, size) |
| 265 | pkts.append(p) |
| 266 | self.logger.debug("Input stream created for port %s. Length: %u pkt(s)" |
| 267 | % (src_if.name, len(pkts))) |
| 268 | return pkts |
| 269 | |
Jan Gelety | d16ba62 | 2018-06-21 16:57:47 +0200 | [diff] [blame] | 270 | def create_stream_crosswise_vrf(self, src_if, vrf_id, packet_sizes): |
| 271 | """ |
| 272 | Create input packet stream for negative test for leaking across |
| 273 | different VRFs for defined interface using hosts list. |
| 274 | |
| 275 | :param object src_if: Interface to create packet stream for. |
| 276 | :param int vrf_id: The FIB table / VRF ID where src_if is assigned. |
| 277 | :param list packet_sizes: List of required packet sizes. |
| 278 | :return: Stream of packets. |
| 279 | """ |
| 280 | pkts = [] |
| 281 | src_hosts = src_if.remote_hosts |
| 282 | vrf_lst = list(self.vrf_list) |
| 283 | vrf_lst.remove(vrf_id) |
| 284 | for vrf in vrf_lst: |
| 285 | for dst_if in self.pg_if_by_vrf_id[vrf]: |
| 286 | for dst_host in dst_if.remote_hosts: |
| 287 | src_host = random.choice(src_hosts) |
| 288 | pkt_info = self.create_packet_info(src_if, dst_if) |
| 289 | payload = self.info_to_payload(pkt_info) |
| 290 | p = (Ether(dst=src_if.local_mac, src=src_host.mac) / |
| 291 | IPv6(src=src_host.ip6, dst=dst_host.ip6) / |
| 292 | UDP(sport=1234, dport=1234) / |
| 293 | Raw(payload)) |
| 294 | pkt_info.data = p.copy() |
| 295 | size = random.choice(packet_sizes) |
| 296 | self.extend_packet(p, size) |
| 297 | pkts.append(p) |
| 298 | self.logger.debug("Input stream created for port %s. Length: %u pkt(s)" |
| 299 | % (src_if.name, len(pkts))) |
| 300 | return pkts |
| 301 | |
Jan Gelety | 057bb8c | 2016-12-20 17:32:45 +0100 | [diff] [blame] | 302 | def verify_capture(self, pg_if, capture): |
| 303 | """ |
| 304 | Verify captured input packet stream for defined interface. |
| 305 | |
| 306 | :param object pg_if: Interface to verify captured packet stream for. |
| 307 | :param list capture: Captured packet stream. |
| 308 | """ |
| 309 | last_info = dict() |
| 310 | for i in self.pg_interfaces: |
| 311 | last_info[i.sw_if_index] = None |
| 312 | dst_sw_if_index = pg_if.sw_if_index |
| 313 | for packet in capture: |
| 314 | try: |
| 315 | ip = packet[IPv6] |
| 316 | udp = packet[UDP] |
Paul Vinciguerra | eaea421 | 2019-03-06 11:58:06 -0800 | [diff] [blame] | 317 | payload_info = self.payload_to_info(packet[Raw]) |
Jan Gelety | 057bb8c | 2016-12-20 17:32:45 +0100 | [diff] [blame] | 318 | packet_index = payload_info.index |
| 319 | self.assertEqual(payload_info.dst, dst_sw_if_index) |
| 320 | self.logger.debug("Got packet on port %s: src=%u (id=%u)" % |
| 321 | (pg_if.name, payload_info.src, packet_index)) |
| 322 | next_info = self.get_next_packet_info_for_interface2( |
| 323 | payload_info.src, dst_sw_if_index, |
| 324 | last_info[payload_info.src]) |
| 325 | last_info[payload_info.src] = next_info |
| 326 | self.assertIsNotNone(next_info) |
| 327 | self.assertEqual(packet_index, next_info.index) |
| 328 | saved_packet = next_info.data |
| 329 | # Check standard fields |
| 330 | self.assertEqual(ip.src, saved_packet[IPv6].src) |
| 331 | self.assertEqual(ip.dst, saved_packet[IPv6].dst) |
| 332 | self.assertEqual(udp.sport, saved_packet[UDP].sport) |
| 333 | self.assertEqual(udp.dport, saved_packet[UDP].dport) |
| 334 | except: |
| 335 | self.logger.error(ppp("Unexpected or invalid packet:", packet)) |
| 336 | raise |
| 337 | for i in self.pg_interfaces: |
| 338 | remaining_packet = self.get_next_packet_info_for_interface2( |
| 339 | i, dst_sw_if_index, last_info[i.sw_if_index]) |
| 340 | self.assertIsNone( |
| 341 | remaining_packet, |
| 342 | "Port %u: Packet expected from source %u didn't arrive" % |
| 343 | (dst_sw_if_index, i.sw_if_index)) |
| 344 | |
| 345 | def verify_vrf(self, vrf_id): |
| 346 | """ |
| 347 | Check if the FIB table / VRF ID is configured. |
| 348 | |
| 349 | :param int vrf_id: The FIB table / VRF ID to be verified. |
| 350 | :return: 1 if the FIB table / VRF ID is configured, otherwise return 0. |
| 351 | """ |
Neale Ranns | 097fa66 | 2018-05-01 05:17:55 -0700 | [diff] [blame] | 352 | ip6_fib_dump = self.vapi.ip_route_dump(vrf_id, True) |
| 353 | vrf_exist = len(ip6_fib_dump) |
Jan Gelety | 057bb8c | 2016-12-20 17:32:45 +0100 | [diff] [blame] | 354 | vrf_count = 0 |
| 355 | for ip6_fib_details in ip6_fib_dump: |
Neale Ranns | 097fa66 | 2018-05-01 05:17:55 -0700 | [diff] [blame] | 356 | addr = ip6_fib_details.route.prefix.network_address |
| 357 | found = False |
| 358 | for pg_if in self.pg_if_by_vrf_id[vrf_id]: |
| 359 | if found: |
| 360 | break |
| 361 | for host in pg_if.remote_hosts: |
| 362 | if str(addr) == host.ip6: |
| 363 | vrf_count += 1 |
| 364 | found = True |
Jan Gelety | 95c87b5 | 2017-02-27 10:46:14 +0100 | [diff] [blame] | 365 | break |
Jan Gelety | b5b2ef5 | 2017-02-23 15:01:29 +0100 | [diff] [blame] | 366 | if not vrf_exist and vrf_count == 0: |
Jan Gelety | 057bb8c | 2016-12-20 17:32:45 +0100 | [diff] [blame] | 367 | self.logger.info("IPv6 VRF ID %d is not configured" % vrf_id) |
Jan Gelety | 95c87b5 | 2017-02-27 10:46:14 +0100 | [diff] [blame] | 368 | return VRFState.not_configured |
Jan Gelety | b5b2ef5 | 2017-02-23 15:01:29 +0100 | [diff] [blame] | 369 | elif vrf_exist and vrf_count == 0: |
| 370 | self.logger.info("IPv6 VRF ID %d has been reset" % vrf_id) |
Jan Gelety | 95c87b5 | 2017-02-27 10:46:14 +0100 | [diff] [blame] | 371 | return VRFState.reset |
Jan Gelety | 057bb8c | 2016-12-20 17:32:45 +0100 | [diff] [blame] | 372 | else: |
| 373 | self.logger.info("IPv6 VRF ID %d is configured" % vrf_id) |
Jan Gelety | 95c87b5 | 2017-02-27 10:46:14 +0100 | [diff] [blame] | 374 | return VRFState.configured |
Jan Gelety | 057bb8c | 2016-12-20 17:32:45 +0100 | [diff] [blame] | 375 | |
| 376 | def run_verify_test(self): |
| 377 | """ |
Jan Gelety | d16ba62 | 2018-06-21 16:57:47 +0200 | [diff] [blame] | 378 | Create packet streams for all configured pg interfaces, send all \ |
Jan Gelety | 057bb8c | 2016-12-20 17:32:45 +0100 | [diff] [blame] | 379 | prepared packet streams and verify that: |
Jan Gelety | d16ba62 | 2018-06-21 16:57:47 +0200 | [diff] [blame] | 380 | - all packets received correctly on all pg-ip6 interfaces assigned |
| 381 | to VRFs |
| 382 | - no packet received on all pg-ip6 interfaces not assigned to VRFs |
Jan Gelety | 057bb8c | 2016-12-20 17:32:45 +0100 | [diff] [blame] | 383 | |
Jan Gelety | d16ba62 | 2018-06-21 16:57:47 +0200 | [diff] [blame] | 384 | :raise RuntimeError: If no packet captured on pg-ip6 interface assigned |
| 385 | to VRF or if any packet is captured on pg-ip6 interface not |
| 386 | assigned to VRF. |
Jan Gelety | 057bb8c | 2016-12-20 17:32:45 +0100 | [diff] [blame] | 387 | """ |
| 388 | # Test |
| 389 | # Create incoming packet streams for packet-generator interfaces |
| 390 | for pg_if in self.pg_interfaces: |
| 391 | pkts = self.create_stream(pg_if, self.pg_if_packet_sizes) |
| 392 | pg_if.add_stream(pkts) |
| 393 | |
| 394 | # Enable packet capture and start packet sending |
| 395 | self.pg_enable_capture(self.pg_interfaces) |
| 396 | self.pg_start() |
| 397 | |
| 398 | # Verify |
| 399 | # Verify outgoing packet streams per packet-generator interface |
| 400 | for pg_if in self.pg_interfaces: |
| 401 | if pg_if in self.pg_in_vrf: |
| 402 | capture = pg_if.get_capture(remark="interface is in VRF") |
| 403 | self.verify_capture(pg_if, capture) |
| 404 | elif pg_if in self.pg_not_in_vrf: |
Jan Gelety | b5b2ef5 | 2017-02-23 15:01:29 +0100 | [diff] [blame] | 405 | pg_if.assert_nothing_captured(remark="interface is not in VRF", |
| 406 | filter_out_fn=is_ipv6_misc_ext) |
Jan Gelety | 057bb8c | 2016-12-20 17:32:45 +0100 | [diff] [blame] | 407 | self.logger.debug("No capture for interface %s" % pg_if.name) |
| 408 | else: |
| 409 | raise Exception("Unknown interface: %s" % pg_if.name) |
| 410 | |
Jan Gelety | d16ba62 | 2018-06-21 16:57:47 +0200 | [diff] [blame] | 411 | def run_crosswise_vrf_test(self): |
| 412 | """ |
| 413 | Create packet streams for every pg-ip6 interface in VRF towards all |
| 414 | pg-ip6 interfaces in other VRFs, send all prepared packet streams and \ |
| 415 | verify that: |
| 416 | - no packet received on all configured pg-ip6 interfaces |
| 417 | |
| 418 | :raise RuntimeError: If any packet is captured on any pg-ip6 interface. |
| 419 | """ |
| 420 | # Test |
| 421 | # Create incoming packet streams for packet-generator interfaces |
| 422 | for vrf_id in self.vrf_list: |
| 423 | for pg_if in self.pg_if_by_vrf_id[vrf_id]: |
| 424 | pkts = self.create_stream_crosswise_vrf( |
| 425 | pg_if, vrf_id, self.pg_if_packet_sizes) |
| 426 | pg_if.add_stream(pkts) |
| 427 | |
| 428 | # Enable packet capture and start packet sending |
| 429 | self.pg_enable_capture(self.pg_interfaces) |
| 430 | self.pg_start() |
| 431 | |
| 432 | # Verify |
| 433 | # Verify outgoing packet streams per packet-generator interface |
| 434 | for pg_if in self.pg_interfaces: |
| 435 | pg_if.assert_nothing_captured(remark="interface is in other VRF", |
| 436 | filter_out_fn=is_ipv6_misc_ext) |
| 437 | self.logger.debug("No capture for interface %s" % pg_if.name) |
| 438 | |
Jan Gelety | 057bb8c | 2016-12-20 17:32:45 +0100 | [diff] [blame] | 439 | def test_ip6_vrf_01(self): |
| 440 | """ IP6 VRF Multi-instance test 1 - create 4 VRFs |
| 441 | """ |
| 442 | # Config 1 |
| 443 | # Create 4 VRFs |
| 444 | self.create_vrf_and_assign_interfaces(4) |
| 445 | |
| 446 | # Verify 1 |
| 447 | for vrf_id in self.vrf_list: |
Jan Gelety | 95c87b5 | 2017-02-27 10:46:14 +0100 | [diff] [blame] | 448 | self.assert_equal(self.verify_vrf(vrf_id), |
| 449 | VRFState.configured, VRFState) |
Jan Gelety | 057bb8c | 2016-12-20 17:32:45 +0100 | [diff] [blame] | 450 | |
| 451 | # Test 1 |
| 452 | self.run_verify_test() |
Jan Gelety | d16ba62 | 2018-06-21 16:57:47 +0200 | [diff] [blame] | 453 | self.run_crosswise_vrf_test() |
Jan Gelety | 057bb8c | 2016-12-20 17:32:45 +0100 | [diff] [blame] | 454 | |
Jan Gelety | 057bb8c | 2016-12-20 17:32:45 +0100 | [diff] [blame] | 455 | def test_ip6_vrf_02(self): |
| 456 | """ IP6 VRF Multi-instance test 2 - reset 2 VRFs |
| 457 | """ |
| 458 | # Config 2 |
| 459 | # Delete 2 VRFs |
Jan Gelety | 95c87b5 | 2017-02-27 10:46:14 +0100 | [diff] [blame] | 460 | self.reset_vrf_and_remove_from_vrf_list(1) |
| 461 | self.reset_vrf_and_remove_from_vrf_list(2) |
Jan Gelety | 057bb8c | 2016-12-20 17:32:45 +0100 | [diff] [blame] | 462 | |
| 463 | # Verify 2 |
Jan Gelety | b5b2ef5 | 2017-02-23 15:01:29 +0100 | [diff] [blame] | 464 | for vrf_id in self.vrf_reset_list: |
Jan Gelety | 95c87b5 | 2017-02-27 10:46:14 +0100 | [diff] [blame] | 465 | self.assert_equal(self.verify_vrf(vrf_id), |
| 466 | VRFState.reset, VRFState) |
Jan Gelety | 057bb8c | 2016-12-20 17:32:45 +0100 | [diff] [blame] | 467 | for vrf_id in self.vrf_list: |
Jan Gelety | 95c87b5 | 2017-02-27 10:46:14 +0100 | [diff] [blame] | 468 | self.assert_equal(self.verify_vrf(vrf_id), |
| 469 | VRFState.configured, VRFState) |
Jan Gelety | 057bb8c | 2016-12-20 17:32:45 +0100 | [diff] [blame] | 470 | |
| 471 | # Test 2 |
| 472 | self.run_verify_test() |
Jan Gelety | d16ba62 | 2018-06-21 16:57:47 +0200 | [diff] [blame] | 473 | self.run_crosswise_vrf_test() |
Jan Gelety | 057bb8c | 2016-12-20 17:32:45 +0100 | [diff] [blame] | 474 | |
Jan Gelety | b5b2ef5 | 2017-02-23 15:01:29 +0100 | [diff] [blame] | 475 | # Reset routes learned from ICMPv6 Neighbor Discovery |
| 476 | for vrf_id in self.vrf_reset_list: |
Jan Gelety | 95c87b5 | 2017-02-27 10:46:14 +0100 | [diff] [blame] | 477 | self.reset_vrf_and_remove_from_vrf_list(vrf_id) |
Jan Gelety | b5b2ef5 | 2017-02-23 15:01:29 +0100 | [diff] [blame] | 478 | |
Jan Gelety | 057bb8c | 2016-12-20 17:32:45 +0100 | [diff] [blame] | 479 | def test_ip6_vrf_03(self): |
| 480 | """ IP6 VRF Multi-instance 3 - add 2 VRFs |
| 481 | """ |
| 482 | # Config 3 |
Jan Gelety | b5b2ef5 | 2017-02-23 15:01:29 +0100 | [diff] [blame] | 483 | # Add 1 of reset VRFs and 1 new VRF |
| 484 | self.create_vrf_and_assign_interfaces(1) |
Jan Gelety | 057bb8c | 2016-12-20 17:32:45 +0100 | [diff] [blame] | 485 | self.create_vrf_and_assign_interfaces(1, start=5) |
| 486 | |
| 487 | # Verify 3 |
Jan Gelety | b5b2ef5 | 2017-02-23 15:01:29 +0100 | [diff] [blame] | 488 | for vrf_id in self.vrf_reset_list: |
Jan Gelety | 95c87b5 | 2017-02-27 10:46:14 +0100 | [diff] [blame] | 489 | self.assert_equal(self.verify_vrf(vrf_id), |
| 490 | VRFState.reset, VRFState) |
Jan Gelety | 057bb8c | 2016-12-20 17:32:45 +0100 | [diff] [blame] | 491 | for vrf_id in self.vrf_list: |
Jan Gelety | 95c87b5 | 2017-02-27 10:46:14 +0100 | [diff] [blame] | 492 | self.assert_equal(self.verify_vrf(vrf_id), |
| 493 | VRFState.configured, VRFState) |
Jan Gelety | 057bb8c | 2016-12-20 17:32:45 +0100 | [diff] [blame] | 494 | |
| 495 | # Test 3 |
| 496 | self.run_verify_test() |
Jan Gelety | d16ba62 | 2018-06-21 16:57:47 +0200 | [diff] [blame] | 497 | self.run_crosswise_vrf_test() |
Jan Gelety | 057bb8c | 2016-12-20 17:32:45 +0100 | [diff] [blame] | 498 | |
Jan Gelety | b5b2ef5 | 2017-02-23 15:01:29 +0100 | [diff] [blame] | 499 | # Reset routes learned from ICMPv6 Neighbor Discovery |
| 500 | for vrf_id in self.vrf_reset_list: |
Jan Gelety | 95c87b5 | 2017-02-27 10:46:14 +0100 | [diff] [blame] | 501 | self.reset_vrf_and_remove_from_vrf_list(vrf_id) |
Jan Gelety | b5b2ef5 | 2017-02-23 15:01:29 +0100 | [diff] [blame] | 502 | |
Jan Gelety | 057bb8c | 2016-12-20 17:32:45 +0100 | [diff] [blame] | 503 | def test_ip6_vrf_04(self): |
| 504 | """ IP6 VRF Multi-instance test 4 - reset 4 VRFs |
| 505 | """ |
| 506 | # Config 4 |
Jan Gelety | 95c87b5 | 2017-02-27 10:46:14 +0100 | [diff] [blame] | 507 | # Reset all VRFs (i.e. no VRF except VRF=0 configured) |
Jan Gelety | 057bb8c | 2016-12-20 17:32:45 +0100 | [diff] [blame] | 508 | for i in range(len(self.vrf_list)): |
Jan Gelety | 95c87b5 | 2017-02-27 10:46:14 +0100 | [diff] [blame] | 509 | self.reset_vrf_and_remove_from_vrf_list(self.vrf_list[0]) |
Jan Gelety | 057bb8c | 2016-12-20 17:32:45 +0100 | [diff] [blame] | 510 | |
| 511 | # Verify 4 |
Jan Gelety | b5b2ef5 | 2017-02-23 15:01:29 +0100 | [diff] [blame] | 512 | for vrf_id in self.vrf_reset_list: |
Jan Gelety | 95c87b5 | 2017-02-27 10:46:14 +0100 | [diff] [blame] | 513 | self.assert_equal(self.verify_vrf(vrf_id), |
| 514 | VRFState.reset, VRFState) |
| 515 | vrf_list_length = len(self.vrf_list) |
| 516 | self.assertEqual( |
| 517 | vrf_list_length, 0, |
| 518 | "List of configured VRFs is not empty: %s != 0" % vrf_list_length) |
Jan Gelety | 057bb8c | 2016-12-20 17:32:45 +0100 | [diff] [blame] | 519 | |
| 520 | # Test 4 |
| 521 | self.run_verify_test() |
Jan Gelety | d16ba62 | 2018-06-21 16:57:47 +0200 | [diff] [blame] | 522 | self.run_crosswise_vrf_test() |
Jan Gelety | 057bb8c | 2016-12-20 17:32:45 +0100 | [diff] [blame] | 523 | |
| 524 | |
| 525 | if __name__ == '__main__': |
| 526 | unittest.main(testRunner=VppTestRunner) |