X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=test%2Ftest_ip4.py;h=a428db339f40d53f300c22df145091a0df562740;hb=f2984bbb0;hp=5c268a8be2c1e5c3499eb1ca7fd7be7a2abd7dcb;hpb=efd7bc2b1c8db160933ed3e9ab3cde0d07aaf863;p=vpp.git diff --git a/test/test_ip4.py b/test/test_ip4.py index 5c268a8be2c..a428db339f4 100644 --- a/test/test_ip4.py +++ b/test/test_ip4.py @@ -14,12 +14,15 @@ from six import moves from framework import VppTestCase, VppTestRunner from util import ppp from vpp_ip_route import VppIpRoute, VppRoutePath, VppIpMRoute, \ - VppMRoutePath, MRouteItfFlags, MRouteEntryFlags, VppMplsIpBind, \ + VppMRoutePath, VppMplsIpBind, \ VppMplsTable, VppIpTable, FibPathType, find_route, \ - VppIpInterfaceAddress + VppIpInterfaceAddress, find_route_in_dump, find_mroute_in_dump +from vpp_ip import VppIpPuntPolicer, VppIpPuntRedirect from vpp_sub_interface import VppSubInterface, VppDot1QSubint, VppDot1ADSubint from vpp_papi import VppEnum from vpp_neighbor import VppNeighbor +from vpp_lo_interface import VppLoInterface +from vpp_policer import VppPolicer NUM_PKTS = 67 @@ -88,7 +91,7 @@ class TestIPv4(VppTestCase): super(TestIPv4, self).tearDown() def show_commands_at_teardown(self): - self.logger.info(self.vapi.cli("show ip arp")) + self.logger.info(self.vapi.cli("show ip4 neighbors")) # info(self.vapi.cli("show ip fib")) # many entries def modify_packet(self, src_if, packet_size, pkt): @@ -212,6 +215,80 @@ class TestIPv4(VppTestCase): self.verify_capture(i, pkts) +class TestIPv4RouteLookup(VppTestCase): + """ IPv4 Route Lookup Test Case """ + routes = [] + + def route_lookup(self, prefix, exact): + return self.vapi.api(self.vapi.papi.ip_route_lookup, + { + 'table_id': 0, + 'exact': exact, + 'prefix': prefix, + }) + + @classmethod + def setUpClass(cls): + super(TestIPv4RouteLookup, cls).setUpClass() + + @classmethod + def tearDownClass(cls): + super(TestIPv4RouteLookup, cls).tearDownClass() + + def setUp(self): + super(TestIPv4RouteLookup, self).setUp() + + drop_nh = VppRoutePath("127.0.0.1", 0xffffffff, + type=FibPathType.FIB_PATH_TYPE_DROP) + + # Add 3 routes + r = VppIpRoute(self, "1.1.0.0", 16, [drop_nh]) + r.add_vpp_config() + self.routes.append(r) + + r = VppIpRoute(self, "1.1.1.0", 24, [drop_nh]) + r.add_vpp_config() + self.routes.append(r) + + r = VppIpRoute(self, "1.1.1.1", 32, [drop_nh]) + r.add_vpp_config() + self.routes.append(r) + + def tearDown(self): + # Remove the routes we added + for r in self.routes: + r.remove_vpp_config() + + super(TestIPv4RouteLookup, self).tearDown() + + def test_exact_match(self): + # Verify we find the host route + prefix = "1.1.1.1/32" + result = self.route_lookup(prefix, True) + assert (prefix == str(result.route.prefix)) + + # Verify we find a middle prefix route + prefix = "1.1.1.0/24" + result = self.route_lookup(prefix, True) + assert (prefix == str(result.route.prefix)) + + # Verify we do not find an available LPM. + with self.vapi.assert_negative_api_retval(): + self.route_lookup("1.1.1.2/32", True) + + def test_longest_prefix_match(self): + # verify we find lpm + lpm_prefix = "1.1.1.0/24" + result = self.route_lookup("1.1.1.2/32", False) + assert (lpm_prefix == str(result.route.prefix)) + + # Verify we find the exact when not requested + result = self.route_lookup(lpm_prefix, False) + assert (lpm_prefix == str(result.route.prefix)) + + # Can't seem to delete the default route so no negative LPM test. + + class TestIPv4IfAddrRoute(VppTestCase): """ IPv4 Interface Addr Route Test Case """ @@ -335,6 +412,24 @@ class TestIPv4IfAddrRoute(VppTestCase): fib4_dump = self.vapi.ip_route_dump(0) self.assertTrue(lo_if.is_ip4_entry_in_fib_dump(fib4_dump)) + def test_ipv4_ifaddr_del(self): + """ Delete an interface address that does not exist """ + + loopbacks = self.create_loopback_interfaces(1) + lo = self.lo_interfaces[0] + + lo.config_ip4() + lo.admin_up() + + # + # try and remove pg0's subnet from lo + # + with self.vapi.assert_negative_api_retval(): + self.vapi.sw_interface_add_del_address( + sw_if_index=lo.sw_if_index, + prefix=self.pg0.local_ip4_prefix, + is_add=0) + class TestICMPEcho(VppTestCase): """ ICMP Echo Test Case """ @@ -802,6 +897,9 @@ class TestIPDisabled(VppTestCase): def test_ip_disabled(self): """ IP Disabled """ + MRouteItfFlags = VppEnum.vl_api_mfib_itf_flags_t + MRouteEntryFlags = VppEnum.vl_api_mfib_entry_flags_t + # # An (S,G). # one accepting interface, pg0, 2 forwarding interfaces @@ -810,11 +908,11 @@ class TestIPDisabled(VppTestCase): self, "0.0.0.0", "232.1.1.1", 32, - MRouteEntryFlags.MFIB_ENTRY_FLAG_NONE, + MRouteEntryFlags.MFIB_API_ENTRY_FLAG_NONE, [VppMRoutePath(self.pg1.sw_if_index, - MRouteItfFlags.MFIB_ITF_FLAG_ACCEPT), + MRouteItfFlags.MFIB_API_ITF_FLAG_ACCEPT), VppMRoutePath(self.pg0.sw_if_index, - MRouteItfFlags.MFIB_ITF_FLAG_FORWARD)]) + MRouteItfFlags.MFIB_API_ITF_FLAG_FORWARD)]) route_232_1_1_1.add_vpp_config() pu = (Ether(src=self.pg1.remote_mac, @@ -1040,6 +1138,9 @@ class TestIPLoadBalance(VppTestCase): def test_ip_load_balance(self): """ IP Load-Balancing """ + fhc = VppEnum.vl_api_ip_flow_hash_config_t + af = VppEnum.vl_api_address_family_t + # # An array of packets that differ only in the destination port # @@ -1108,7 +1209,12 @@ class TestIPLoadBalance(VppTestCase): # - now only the stream with differing source address will # load-balance # - self.vapi.set_ip_flow_hash(vrf_id=0, src=1, dst=1, sport=0, dport=0) + self.vapi.set_ip_flow_hash_v2( + af=af.ADDRESS_IP4, + table_id=0, + flow_hash_config=(fhc.IP_API_FLOW_HASH_SRC_IP | + fhc.IP_API_FLOW_HASH_DST_IP | + fhc.IP_API_FLOW_HASH_PROTO)) self.send_and_expect_load_balancing(self.pg0, src_ip_pkts, [self.pg1, self.pg2]) @@ -1120,7 +1226,8 @@ class TestIPLoadBalance(VppTestCase): # # change the flow hash config back to defaults # - self.vapi.set_ip_flow_hash(vrf_id=0, src=1, dst=1, sport=1, dport=1) + self.vapi.set_ip_flow_hash(vrf_id=0, src=1, dst=1, + proto=1, sport=1, dport=1) # # Recursive prefixes @@ -1380,18 +1487,19 @@ class TestIPPunt(VppTestCase): # Configure a punt redirect via pg1. # nh_addr = self.pg1.remote_ip4 - self.vapi.ip_punt_redirect(self.pg0.sw_if_index, - self.pg1.sw_if_index, - nh_addr) + ip_punt_redirect = VppIpPuntRedirect(self, self.pg0.sw_if_index, + self.pg1.sw_if_index, nh_addr) + ip_punt_redirect.add_vpp_config() self.send_and_expect(self.pg0, pkts, self.pg1) # # add a policer # - policer = self.vapi.policer_add_del(b"ip4-punt", 400, 0, 10, 0, - rate_type=1) - self.vapi.ip_punt_police(policer.policer_index) + policer = VppPolicer(self, "ip4-punt", 400, 0, 10, 0, rate_type=1) + policer.add_vpp_config() + ip_punt_policer = VppIpPuntPolicer(self, policer.policer_index) + ip_punt_policer.add_vpp_config() self.vapi.cli("clear trace") self.pg0.add_stream(pkts) @@ -1409,33 +1517,25 @@ class TestIPPunt(VppTestCase): # # remove the policer. back to full rx # - self.vapi.ip_punt_police(policer.policer_index, is_add=0) - self.vapi.policer_add_del(b"ip4-punt", 400, 0, 10, 0, - rate_type=1, is_add=0) + ip_punt_policer.remove_vpp_config() + policer.remove_vpp_config() self.send_and_expect(self.pg0, pkts, self.pg1) # # remove the redirect. expect full drop. # - self.vapi.ip_punt_redirect(self.pg0.sw_if_index, - self.pg1.sw_if_index, - nh_addr, - is_add=0) + ip_punt_redirect.remove_vpp_config() self.send_and_assert_no_replies(self.pg0, pkts, "IP no punt config") # # Add a redirect that is not input port selective # - self.vapi.ip_punt_redirect(0xffffffff, - self.pg1.sw_if_index, - nh_addr) + ip_punt_redirect = VppIpPuntRedirect(self, 0xffffffff, + self.pg1.sw_if_index, nh_addr) + ip_punt_redirect.add_vpp_config() self.send_and_expect(self.pg0, pkts, self.pg1) - - self.vapi.ip_punt_redirect(0xffffffff, - self.pg1.sw_if_index, - nh_addr, - is_add=0) + ip_punt_redirect.remove_vpp_config() def test_ip_punt_dump(self): """ IP4 punt redirect dump""" @@ -1444,22 +1544,22 @@ class TestIPPunt(VppTestCase): # Configure a punt redirects # nh_address = self.pg3.remote_ip4 - self.vapi.ip_punt_redirect(self.pg0.sw_if_index, - self.pg3.sw_if_index, - nh_address) - self.vapi.ip_punt_redirect(self.pg1.sw_if_index, - self.pg3.sw_if_index, - nh_address) - self.vapi.ip_punt_redirect(self.pg2.sw_if_index, - self.pg3.sw_if_index, - '0.0.0.0') + ipr_03 = VppIpPuntRedirect(self, self.pg0.sw_if_index, + self.pg3.sw_if_index, nh_address) + ipr_13 = VppIpPuntRedirect(self, self.pg1.sw_if_index, + self.pg3.sw_if_index, nh_address) + ipr_23 = VppIpPuntRedirect(self, self.pg2.sw_if_index, + self.pg3.sw_if_index, "0.0.0.0") + ipr_03.add_vpp_config() + ipr_13.add_vpp_config() + ipr_23.add_vpp_config() # # Dump pg0 punt redirects # - punts = self.vapi.ip_punt_redirect_dump(self.pg0.sw_if_index) - for p in punts: - self.assertEqual(p.punt.rx_sw_if_index, self.pg0.sw_if_index) + self.assertTrue(ipr_03.query_vpp_config()) + self.assertTrue(ipr_13.query_vpp_config()) + self.assertTrue(ipr_23.query_vpp_config()) # # Dump punt redirects for all interfaces @@ -1961,5 +2061,366 @@ class TestIPv4Frag(VppTestCase): self.assert_equal(payload, saved_payload, "payload") +class TestIPReplace(VppTestCase): + """ IPv4 Table Replace """ + + @classmethod + def setUpClass(cls): + super(TestIPReplace, cls).setUpClass() + + @classmethod + def tearDownClass(cls): + super(TestIPReplace, cls).tearDownClass() + + def setUp(self): + super(TestIPReplace, self).setUp() + + self.create_pg_interfaces(range(4)) + + table_id = 1 + self.tables = [] + + for i in self.pg_interfaces: + i.admin_up() + i.config_ip4() + i.resolve_arp() + i.generate_remote_hosts(2) + self.tables.append(VppIpTable(self, table_id).add_vpp_config()) + table_id += 1 + + def tearDown(self): + super(TestIPReplace, self).tearDown() + for i in self.pg_interfaces: + i.admin_down() + i.unconfig_ip4() + + def test_replace(self): + """ IP Table Replace """ + + MRouteItfFlags = VppEnum.vl_api_mfib_itf_flags_t + MRouteEntryFlags = VppEnum.vl_api_mfib_entry_flags_t + N_ROUTES = 20 + links = [self.pg0, self.pg1, self.pg2, self.pg3] + routes = [[], [], [], []] + + # load up the tables with some routes + for ii, t in enumerate(self.tables): + for jj in range(N_ROUTES): + uni = VppIpRoute( + self, "10.0.0.%d" % jj, 32, + [VppRoutePath(links[ii].remote_hosts[0].ip4, + links[ii].sw_if_index), + VppRoutePath(links[ii].remote_hosts[1].ip4, + links[ii].sw_if_index)], + table_id=t.table_id).add_vpp_config() + multi = VppIpMRoute( + self, "0.0.0.0", + "239.0.0.%d" % jj, 32, + MRouteEntryFlags.MFIB_API_ENTRY_FLAG_NONE, + [VppMRoutePath(self.pg0.sw_if_index, + MRouteItfFlags.MFIB_API_ITF_FLAG_ACCEPT), + VppMRoutePath(self.pg1.sw_if_index, + MRouteItfFlags.MFIB_API_ITF_FLAG_FORWARD), + VppMRoutePath(self.pg2.sw_if_index, + MRouteItfFlags.MFIB_API_ITF_FLAG_FORWARD), + VppMRoutePath(self.pg3.sw_if_index, + MRouteItfFlags.MFIB_API_ITF_FLAG_FORWARD)], + table_id=t.table_id).add_vpp_config() + routes[ii].append({'uni': uni, + 'multi': multi}) + + # + # replace the tables a few times + # + for kk in range(3): + # replace_begin each table + for t in self.tables: + t.replace_begin() + + # all the routes are still there + for ii, t in enumerate(self.tables): + dump = t.dump() + mdump = t.mdump() + for r in routes[ii]: + self.assertTrue(find_route_in_dump(dump, r['uni'], t)) + self.assertTrue(find_mroute_in_dump(mdump, r['multi'], t)) + + # redownload the even numbered routes + for ii, t in enumerate(self.tables): + for jj in range(0, N_ROUTES, 2): + routes[ii][jj]['uni'].add_vpp_config() + routes[ii][jj]['multi'].add_vpp_config() + + # signal each table replace_end + for t in self.tables: + t.replace_end() + + # we should find the even routes, but not the odd + for ii, t in enumerate(self.tables): + dump = t.dump() + mdump = t.mdump() + for jj in range(0, N_ROUTES, 2): + self.assertTrue(find_route_in_dump( + dump, routes[ii][jj]['uni'], t)) + self.assertTrue(find_mroute_in_dump( + mdump, routes[ii][jj]['multi'], t)) + for jj in range(1, N_ROUTES - 1, 2): + self.assertFalse(find_route_in_dump( + dump, routes[ii][jj]['uni'], t)) + self.assertFalse(find_mroute_in_dump( + mdump, routes[ii][jj]['multi'], t)) + + # reload all the routes + for ii, t in enumerate(self.tables): + for r in routes[ii]: + r['uni'].add_vpp_config() + r['multi'].add_vpp_config() + + # all the routes are still there + for ii, t in enumerate(self.tables): + dump = t.dump() + mdump = t.mdump() + for r in routes[ii]: + self.assertTrue(find_route_in_dump(dump, r['uni'], t)) + self.assertTrue(find_mroute_in_dump(mdump, r['multi'], t)) + + # + # finally flush the tables for good measure + # + for t in self.tables: + t.flush() + self.assertEqual(len(t.dump()), 5) + self.assertEqual(len(t.mdump()), 3) + + +class TestIPCover(VppTestCase): + """ IPv4 Table Cover """ + + @classmethod + def setUpClass(cls): + super(TestIPCover, cls).setUpClass() + + @classmethod + def tearDownClass(cls): + super(TestIPCover, cls).tearDownClass() + + def setUp(self): + super(TestIPCover, self).setUp() + + self.create_pg_interfaces(range(4)) + + table_id = 1 + self.tables = [] + + for i in self.pg_interfaces: + i.admin_up() + i.config_ip4() + i.resolve_arp() + i.generate_remote_hosts(2) + self.tables.append(VppIpTable(self, table_id).add_vpp_config()) + table_id += 1 + + def tearDown(self): + super(TestIPCover, self).tearDown() + for i in self.pg_interfaces: + i.admin_down() + i.unconfig_ip4() + + def test_cover(self): + """ IP Table Cover """ + + # add a loop back with a /32 prefix + lo = VppLoInterface(self) + lo.admin_up() + a = VppIpInterfaceAddress(self, lo, "127.0.0.1", 32).add_vpp_config() + + # add a neighbour that matches the loopback's /32 + nbr = VppNeighbor(self, + lo.sw_if_index, + lo.remote_mac, + "127.0.0.1").add_vpp_config() + + # add the default route which will be the cover for /32 + r = VppIpRoute(self, "0.0.0.0", 0, + [VppRoutePath("127.0.0.1", + lo.sw_if_index)], + register=False).add_vpp_config() + + # add/remove/add a longer mask cover + r8 = VppIpRoute(self, "127.0.0.0", 8, + [VppRoutePath("127.0.0.1", + lo.sw_if_index)]).add_vpp_config() + r8.remove_vpp_config() + r8.add_vpp_config() + r8.remove_vpp_config() + + # remove the default route + r.remove_vpp_config() + + # remove the interface prefix + a.remove_vpp_config() + + +class TestIP4Replace(VppTestCase): + """ IPv4 Interface Address Replace """ + + @classmethod + def setUpClass(cls): + super(TestIP4Replace, cls).setUpClass() + + @classmethod + def tearDownClass(cls): + super(TestIP4Replace, cls).tearDownClass() + + def setUp(self): + super(TestIP4Replace, self).setUp() + + self.create_pg_interfaces(range(4)) + + for i in self.pg_interfaces: + i.admin_up() + + def tearDown(self): + super(TestIP4Replace, self).tearDown() + for i in self.pg_interfaces: + i.admin_down() + + def get_n_pfxs(self, intf): + return len(self.vapi.ip_address_dump(intf.sw_if_index)) + + def test_replace(self): + """ IP interface address replace """ + + intf_pfxs = [[], [], [], []] + + # add prefixes to each of the interfaces + for i in range(len(self.pg_interfaces)): + intf = self.pg_interfaces[i] + + # 172.16.x.1/24 + addr = "172.16.%d.1" % intf.sw_if_index + a = VppIpInterfaceAddress(self, intf, addr, 24).add_vpp_config() + intf_pfxs[i].append(a) + + # 172.16.x.2/24 - a different address in the same subnet as above + addr = "172.16.%d.2" % intf.sw_if_index + a = VppIpInterfaceAddress(self, intf, addr, 24).add_vpp_config() + intf_pfxs[i].append(a) + + # 172.15.x.2/24 - a different address and subnet + addr = "172.15.%d.2" % intf.sw_if_index + a = VppIpInterfaceAddress(self, intf, addr, 24).add_vpp_config() + intf_pfxs[i].append(a) + + # a dump should n_address in it + for intf in self.pg_interfaces: + self.assertEqual(self.get_n_pfxs(intf), 3) + + # + # remove all the address thru a replace + # + self.vapi.sw_interface_address_replace_begin() + self.vapi.sw_interface_address_replace_end() + for intf in self.pg_interfaces: + self.assertEqual(self.get_n_pfxs(intf), 0) + + # + # add all the interface addresses back + # + for p in intf_pfxs: + for v in p: + v.add_vpp_config() + for intf in self.pg_interfaces: + self.assertEqual(self.get_n_pfxs(intf), 3) + + # + # replace again, but this time update/re-add the address on the first + # two interfaces + # + self.vapi.sw_interface_address_replace_begin() + + for p in intf_pfxs[:2]: + for v in p: + v.add_vpp_config() + + self.vapi.sw_interface_address_replace_end() + + # on the first two the address still exist, + # on the other two they do not + for intf in self.pg_interfaces[:2]: + self.assertEqual(self.get_n_pfxs(intf), 3) + for p in intf_pfxs[:2]: + for v in p: + self.assertTrue(v.query_vpp_config()) + for intf in self.pg_interfaces[2:]: + self.assertEqual(self.get_n_pfxs(intf), 0) + + # + # add all the interface addresses back on the last two + # + for p in intf_pfxs[2:]: + for v in p: + v.add_vpp_config() + for intf in self.pg_interfaces: + self.assertEqual(self.get_n_pfxs(intf), 3) + + # + # replace again, this time add different prefixes on all the interfaces + # + self.vapi.sw_interface_address_replace_begin() + + pfxs = [] + for intf in self.pg_interfaces: + # 172.18.x.1/24 + addr = "172.18.%d.1" % intf.sw_if_index + pfxs.append(VppIpInterfaceAddress(self, intf, addr, + 24).add_vpp_config()) + + self.vapi.sw_interface_address_replace_end() + + # only .18 should exist on each interface + for intf in self.pg_interfaces: + self.assertEqual(self.get_n_pfxs(intf), 1) + for pfx in pfxs: + self.assertTrue(pfx.query_vpp_config()) + + # + # remove everything + # + self.vapi.sw_interface_address_replace_begin() + self.vapi.sw_interface_address_replace_end() + for intf in self.pg_interfaces: + self.assertEqual(self.get_n_pfxs(intf), 0) + + # + # add prefixes to each interface. post-begin add the prefix from + # interface X onto interface Y. this would normally be an error + # since it would generate a 'duplicate address' warning. but in + # this case, since what is newly downloaded is sane, it's ok + # + for intf in self.pg_interfaces: + # 172.18.x.1/24 + addr = "172.18.%d.1" % intf.sw_if_index + VppIpInterfaceAddress(self, intf, addr, 24).add_vpp_config() + + self.vapi.sw_interface_address_replace_begin() + + pfxs = [] + for intf in self.pg_interfaces: + # 172.18.x.1/24 + addr = "172.18.%d.1" % (intf.sw_if_index + 1) + pfxs.append(VppIpInterfaceAddress(self, intf, + addr, 24).add_vpp_config()) + + self.vapi.sw_interface_address_replace_end() + + self.logger.info(self.vapi.cli("sh int addr")) + + for intf in self.pg_interfaces: + self.assertEqual(self.get_n_pfxs(intf), 1) + for pfx in pfxs: + self.assertTrue(pfx.query_vpp_config()) + + if __name__ == '__main__': unittest.main(testRunner=VppTestRunner)