docs: describe clib_time monotonic timebase support
[vpp.git] / test / test_ip_ecmp.py
1 #!/usr/bin/env python3
2
3 import unittest
4 import random
5 import socket
6 from ipaddress import IPv4Address, IPv6Address, AddressValueError
7
8 from framework import VppTestCase, VppTestRunner
9 from util import ppp
10
11 from scapy.packet import Raw
12 from scapy.layers.l2 import Ether
13 from scapy.layers.inet import IP, UDP
14 from scapy.layers.inet6 import IPv6
15 from vpp_ip_route import VppIpRoute, VppRoutePath
16
17 try:
18     text_type = unicode
19 except NameError:
20     text_type = str
21
22 #
23 # The number of packets to sent.
24 #
25 N_PKTS_IN_STREAM = 300
26
27
28 class TestECMP(VppTestCase):
29     """ Equal-cost multi-path routing Test Case """
30
31     @classmethod
32     def setUpClass(cls):
33         """
34         Perform standard class setup (defined by class method setUpClass in
35         class VppTestCase) before running the test case, set test case related
36         variables and configure VPP.
37         """
38         super(TestECMP, cls).setUpClass()
39
40         # create 4 pg interfaces
41         cls.create_pg_interfaces(range(4))
42
43         # packet sizes to test
44         cls.pg_if_packet_sizes = [64, 1500, 9018]
45
46         # setup interfaces
47         for i in cls.pg_interfaces:
48             i.admin_up()
49             i.generate_remote_hosts(5)
50             i.config_ip4()
51             i.resolve_arp()
52             i.configure_ipv4_neighbors()
53             i.config_ip6()
54             i.resolve_ndp()
55             i.configure_ipv6_neighbors()
56
57     @classmethod
58     def tearDownClass(cls):
59         if not cls.vpp_dead:
60             for i in cls.pg_interfaces:
61                 i.unconfig_ip4()
62                 i.unconfig_ip6()
63                 i.admin_down()
64
65         super(TestECMP, cls).tearDownClass()
66
67     def setUp(self):
68         super(TestECMP, self).setUp()
69         self.reset_packet_infos()
70
71     def tearDown(self):
72         """
73         Show various debug prints after each test.
74         """
75         super(TestECMP, self).tearDown()
76
77     def show_commands_at_teardown(self):
78         self.logger.info(self.vapi.ppcli("show ip4 neighbors"))
79         self.logger.info(self.vapi.ppcli("show ip6 neighbors"))
80
81     def get_ip_address(self, ip_addr_start, ip_prefix_len):
82         """
83
84         :param str ip_addr_start: Starting IPv4 or IPv6 address.
85         :param int ip_prefix_len: IP address prefix length.
86         :return: Random IPv4 or IPv6 address from required range.
87         """
88         try:
89             ip_addr = IPv4Address(text_type(ip_addr_start))
90             ip_max_len = 32
91         except (AttributeError, AddressValueError):
92             ip_addr = IPv6Address(text_type(ip_addr_start))
93             ip_max_len = 128
94
95         return str(ip_addr +
96                    random.randint(0, 2 ** (ip_max_len - ip_prefix_len) - 2))
97
98     def create_stream(self, src_if, src_ip_start, dst_ip_start,
99                       ip_prefix_len, packet_sizes, ip_l=IP):
100         """Create input packet stream for defined interfaces.
101
102         :param VppInterface src_if: Source Interface for packet stream.
103         :param str src_ip_start: Starting source IPv4 or IPv6 address.
104         :param str dst_ip_start: Starting destination IPv4 or IPv6 address.
105         :param int ip_prefix_len: IP address prefix length.
106         :param list packet_sizes: packet size to test.
107         :param Scapy ip_l: Required IP layer - IP or IPv6. (Default is IP.)
108         """
109         pkts = []
110         for i in range(0, N_PKTS_IN_STREAM):
111             info = self.create_packet_info(src_if, src_if)
112             payload = self.info_to_payload(info)
113             src_ip = self.get_ip_address(src_ip_start, ip_prefix_len)
114             dst_ip = self.get_ip_address(dst_ip_start, ip_prefix_len)
115             p = (Ether(dst=src_if.local_mac, src=src_if.remote_mac) /
116                  ip_l(src=src_ip, dst=dst_ip) /
117                  UDP(sport=1234, dport=1234) /
118                  Raw(payload))
119             info.data = p.copy()
120             size = random.choice(packet_sizes)
121             self.extend_packet(p, size)
122             pkts.append(p)
123         return pkts
124
125     def verify_capture(self, rx_if, capture, ip_l=IP):
126         """Verify captured input packet stream for defined interface.
127
128         :param VppInterface rx_if: Interface to verify captured packet stream.
129         :param list capture: Captured packet stream.
130         :param Scapy ip_l: Required IP layer - IP or IPv6. (Default is IP.)
131         """
132         self.logger.info("Verifying capture on interface %s" % rx_if.name)
133
134         count = 0
135         host_counters = {}
136         for host_mac in rx_if._hosts_by_mac:
137             host_counters[host_mac] = 0
138
139         for packet in capture:
140             try:
141                 ip_received = packet[ip_l]
142                 payload_info = self.payload_to_info(packet[Raw])
143                 packet_index = payload_info.index
144                 ip_sent = self._packet_infos[packet_index].data[ip_l]
145                 self.logger.debug("Got packet on port %s: src=%u (id=%u)" %
146                                   (rx_if.name, payload_info.src, packet_index))
147                 # Check standard fields
148                 self.assertIn(packet.dst, rx_if._hosts_by_mac,
149                               "Destination MAC address %s shouldn't be routed "
150                               "via interface %s" % (packet.dst, rx_if.name))
151                 self.assertEqual(packet.src, rx_if.local_mac)
152                 self.assertEqual(ip_received.src, ip_sent.src)
153                 self.assertEqual(ip_received.dst, ip_sent.dst)
154                 host_counters[packet.dst] += 1
155                 self._packet_infos.pop(packet_index)
156
157             except:
158                 self.logger.error(ppp("Unexpected or invalid packet:", packet))
159                 raise
160
161         # We expect packet routed via all host of pg interface
162         for host_mac in host_counters:
163             nr = host_counters[host_mac]
164             self.assertNotEqual(
165                 nr, 0, "No packet routed via host %s" % host_mac)
166             self.logger.info("%u packets routed via host %s of %s interface" %
167                              (nr, host_mac, rx_if.name))
168             count += nr
169         self.logger.info("Total amount of %u packets routed via %s interface" %
170                          (count, rx_if.name))
171
172         return count
173
174     def create_ip_routes(self, dst_ip_net, dst_prefix_len, is_ipv6=0):
175         """
176         Create IP routes for defined destination IP network.
177
178         :param str dst_ip_net: Destination IP network.
179         :param int dst_prefix_len: IP address prefix length.
180         :param int is_ipv6: 0 if an ip4 route, else ip6
181         """
182
183         paths = []
184         for pg_if in self.pg_interfaces[1:]:
185             for nh_host in pg_if.remote_hosts:
186                 nh_host_ip = nh_host.ip4 if is_ipv6 == 0 else nh_host.ip6
187                 paths.append(VppRoutePath(nh_host_ip,
188                                           pg_if.sw_if_index))
189
190         rip = VppIpRoute(self, dst_ip_net, dst_prefix_len, paths)
191         rip.add_vpp_config()
192         self.logger.info("Route via %s on %s created" %
193                          (nh_host_ip, pg_if.name))
194
195         self.logger.debug(self.vapi.ppcli("show ip fib"))
196         self.logger.debug(self.vapi.ppcli("show ip6 fib"))
197
198     def test_ip_ecmp(self):
199         """ IP equal-cost multi-path routing test """
200
201         src_ip_net = '16.0.0.1'
202         dst_ip_net = '32.0.0.1'
203         ip_prefix_len = 24
204
205         self.create_ip_routes(dst_ip_net, ip_prefix_len)
206
207         pkts = self.create_stream(self.pg0, src_ip_net, dst_ip_net,
208                                   ip_prefix_len, self.pg_if_packet_sizes)
209         self.pg0.add_stream(pkts)
210
211         self.pg_enable_capture(self.pg_interfaces)
212         self.pg_start()
213
214         # We expect packets on pg1, pg2 and pg3, but not on pg0
215         rx_count = 0
216         for pg_if in self.pg_interfaces[1:]:
217             capture = pg_if._get_capture(timeout=1)
218             self.assertNotEqual(
219                 len(capture), 0, msg="No packets captured on %s" % pg_if.name)
220             rx_count += self.verify_capture(pg_if, capture)
221         self.pg0.assert_nothing_captured(remark="IP packets forwarded on pg0")
222
223         # Check that all packets were forwarded via pg1, pg2 and pg3
224         self.assertEqual(rx_count, len(pkts))
225
226     def test_ip6_ecmp(self):
227         """ IPv6 equal-cost multi-path routing test """
228
229         src_ip_net = '3ffe:51::1'
230         dst_ip_net = '3ffe:71::1'
231         ip_prefix_len = 64
232
233         self.create_ip_routes(dst_ip_net, ip_prefix_len, is_ipv6=1)
234
235         pkts = self.create_stream(
236             self.pg0, src_ip_net, dst_ip_net,
237             ip_prefix_len, self.pg_if_packet_sizes, ip_l=IPv6)
238         self.pg0.add_stream(pkts)
239
240         self.pg_enable_capture(self.pg_interfaces)
241         self.pg_start()
242
243         # We expect packets on pg1, pg2 and pg3, but not on pg0
244         rx_count = 0
245         for pg_if in self.pg_interfaces[1:]:
246             capture = pg_if._get_capture(timeout=1)
247             self.assertNotEqual(
248                 len(capture), 0, msg="No packets captured on %s" % pg_if.name)
249             rx_count += self.verify_capture(pg_if, capture, ip_l=IPv6)
250         self.pg0.assert_nothing_captured(remark="IP packets forwarded on pg0")
251
252         # Check that all packets were forwarded via pg1, pg2 and pg3
253         self.assertEqual(rx_count, len(pkts))
254
255
256 if __name__ == '__main__':
257     unittest.main(testRunner=VppTestRunner)