2 """L2 FIB Test Case HLD:
5 - add 4 pg-l2 interfaces
6 - configure them into l2bd
7 - configure 100 MAC entries in L2 fib - 25 MACs per interface
8 - L2 MAC learning and unknown unicast flooding disabled in l2bd
9 - configure 100 MAC entries in L2 fib - 25 MACs per interface
12 - send L2 MAC frames between all 4 pg-l2 interfaces for all of 100 MAC \
16 - all packets received correctly
19 - delete 12 MAC entries - 3 MACs per interface
22 - send L2 MAC frames between all 4 pg-l2 interfaces for non-deleted MAC \
26 - all packets received correctly
29 - send L2 MAC frames between all 4 pg-l2 interfaces for all of 12 deleted \
33 - no packet received on all 4 pg-l2 interfaces
36 - configure new 100 MAC entries in L2 fib - 25 MACs per interface
39 - send L2 MAC frames between all 4 pg-l2 interfaces for all of 188 MAC \
43 - all packets received correctly
46 - delete 160 MAC entries, 40 MACs per interface
49 - send L2 MAC frames between all 4 pg-l2 interfaces for all of 28 \
50 non-deleted MAC entries
53 - all packets received correctly
56 - try send L2 MAC frames between all 4 pg-l2 interfaces for all of 172 \
60 - no packet received on all 4 pg-l2 interfaces
66 from scapy.packet import Raw
67 from scapy.layers.l2 import Ether
68 from scapy.layers.inet import IP, UDP
70 from framework import VppTestCase, VppTestRunner
71 from util import Host, ppp
73 # from src/vnet/l2/l2_fib.h
74 MAC_EVENT_ACTION_ADD = 0
75 MAC_EVENT_ACTION_DELETE = 1
76 MAC_EVENT_ACTION_MOVE = 2
79 class TestL2fib(VppTestCase):
80 """ L2 FIB Test Case """
83 def bd_ifs(cls, bd_id):
84 return range((bd_id - 1) * cls.n_ifs_per_bd,
85 bd_id * cls.n_ifs_per_bd - 1)
90 Perform standard class setup (defined by class method setUpClass in
91 class VppTestCase) before running the test case, set test case related
92 variables and configure VPP.
94 :var int bd_id: Bridge domain ID.
96 super(TestL2fib, cls).setUpClass()
99 n_brs = cls.n_brs = range(1, 3)
101 n_ifs = range(cls.n_ifs_per_bd * len(cls.n_brs))
102 # Create pg interfaces
103 cls.create_pg_interfaces(n_ifs)
107 # Packet flows mapping pg0 -> pg1, pg2, pg3 etc.
108 ifs = cls.bd_ifs(bd_id)
110 cls.flows[cls.pg_interfaces[j]] = [
111 cls.pg_interfaces[x] for x in ifs if x != j]
114 cls.pg_if_packet_sizes = [64, 512, 1518, 9018]
117 # Create BD with MAC learning and unknown unicast flooding
118 # disabled and put interfaces to this BD
119 cls.vapi.bridge_domain_add_del(
120 bd_id=bd_id, uu_flood=0, learn=0)
121 ifs = [cls.pg_interfaces[i] for i in cls.bd_ifs(bd_id)]
123 cls.vapi.sw_interface_set_l2_bridge(pg_if.sw_if_index,
126 # Set up all interfaces
127 for i in cls.pg_interfaces:
130 super(TestL2fib, cls).tearDownClass()
134 super(TestL2fib, self).setUp()
135 self.reset_packet_infos()
139 Show various debug prints after each test.
141 super(TestL2fib, self).tearDown()
142 if not self.vpp_dead:
143 self.logger.info(self.vapi.ppcli("show l2fib verbose"))
144 for bd_id in self.n_brs:
145 self.logger.info(self.vapi.ppcli("show bridge-domain %s detail"
148 def create_hosts(self, n_hosts_per_if, subnet):
150 Create required number of host MAC addresses and distribute them among
151 interfaces. Create host IPv4 address for every host MAC address.
153 :param int n_hosts_per_if: Number of per interface hosts to
154 create MAC/IPv4 addresses for.
158 for pg_if in self.pg_interfaces:
159 swif = pg_if.sw_if_index
161 def mac(j): return "00:00:%02x:ff:%02x:%02x" % (subnet, swif, j)
163 def ip(j): return "172.%02u.1%02x.%u" % (subnet, swif, j)
165 def h(j): return Host(mac(j), ip(j))
166 hosts[swif] = [h(j) for j in range(n_hosts_per_if)]
169 def split_hosts(self, hosts, n):
171 for pg_if in self.pg_interfaces:
172 swif = pg_if.sw_if_index
173 splits[swif] = hosts[swif][:n]
174 hosts[swif] = hosts[swif][n:]
177 def learn_hosts(self, bd_id, hosts):
179 Create and send per interface L2 MAC broadcast packet stream to
180 let the bridge domain learn these MAC addresses.
182 :param int bd_id: BD to teach
183 :param dict hosts: dict of hosts per interface
185 self.vapi.bridge_flags(bd_id, 1, 1)
186 ifs = [self.pg_interfaces[i] for i in self.bd_ifs(bd_id)]
188 swif = pg_if.sw_if_index
189 packets = [Ether(dst="ff:ff:ff:ff:ff:ff", src=host.mac)
190 for host in hosts[swif]]
191 pg_if.add_stream(packets)
192 self.logger.info("Sending broadcast eth frames for MAC learning")
195 def config_l2_fib_entries(self, bd_id, hosts):
197 Config required number of L2 FIB entries.
199 :param int bd_id: BD's id
200 :param int count: Number of L2 FIB entries to be created.
201 :param int start: Starting index of the host list. (Default value = 0)
203 ifs = [self.pg_interfaces[i] for i in self.bd_ifs(bd_id)]
205 swif = pg_if.sw_if_index
206 for host in hosts[swif]:
207 self.vapi.l2fib_add_del(
208 host.mac, bd_id, swif, static_mac=1)
210 def delete_l2_fib_entry(self, bd_id, hosts):
212 Delete required number of L2 FIB entries.
214 :param int count: Number of L2 FIB entries to be created.
216 ifs = [self.pg_interfaces[i] for i in self.bd_ifs(bd_id)]
218 swif = pg_if.sw_if_index
219 for host in hosts[swif]:
220 self.vapi.l2fib_add_del(
221 host.mac, bd_id, swif, is_add=0)
223 def flush_int(self, swif, learned_hosts):
225 Flush swif L2 FIB entries.
227 :param int swif: sw if index.
230 self.vapi.l2fib_flush_int(swif)
231 flushed[swif] = learned_hosts[swif]
232 learned_hosts[swif] = []
235 def flush_bd(self, bd_id, learned_hosts):
237 Flush bd_id L2 FIB entries.
239 :param int bd_id: Bridge Domain id.
241 self.vapi.l2fib_flush_bd(bd_id)
243 ifs = [self.pg_interfaces[i] for i in self.bd_ifs(bd_id)]
245 swif = pg_if.sw_if_index
246 flushed[swif] = learned_hosts[swif]
247 learned_hosts[swif] = []
252 Flush All L2 FIB entries.
254 self.vapi.l2fib_flush_all()
256 def create_stream(self, src_if, packet_sizes, if_src_hosts, if_dst_hosts):
258 Create input packet stream for defined interface using hosts or
261 :param object src_if: Interface to create packet stream for.
262 :param list packet_sizes: List of required packet sizes.
263 :param boolean deleted: Set to True if deleted_hosts list required.
264 :return: Stream of packets.
266 src_hosts = if_src_hosts[src_if.sw_if_index]
270 for dst_if in self.flows[src_if]:
271 dst_swif = dst_if.sw_if_index
272 if dst_swif not in if_dst_hosts:
274 dst_hosts = if_dst_hosts[dst_swif]
275 for dst_host in dst_hosts:
276 src_host = random.choice(src_hosts)
277 pkt_info = self.create_packet_info(src_if, dst_if)
278 payload = self.info_to_payload(pkt_info)
279 p = (Ether(dst=dst_host.mac, src=src_host.mac) /
280 IP(src=src_host.ip4, dst=dst_host.ip4) /
281 UDP(sport=1234, dport=1234) /
283 pkt_info.data = p.copy()
284 size = random.choice(packet_sizes)
285 self.extend_packet(p, size)
289 def verify_capture(self, pg_if, capture):
291 Verify captured input packet stream for defined interface.
293 :param object pg_if: Interface to verify captured packet stream for.
294 :param list capture: Captured packet stream.
297 for i in self.pg_interfaces:
298 last_info[i.sw_if_index] = None
299 dst_sw_if_index = pg_if.sw_if_index
300 for packet in capture:
301 payload_info = self.payload_to_info(str(packet[Raw]))
305 packet_index = payload_info.index
306 self.assertEqual(payload_info.dst, dst_sw_if_index)
307 self.logger.debug("Got packet on port %s: src=%u (id=%u)" %
308 (pg_if.name, payload_info.src, packet_index))
309 next_info = self.get_next_packet_info_for_interface2(
310 payload_info.src, dst_sw_if_index,
311 last_info[payload_info.src])
312 last_info[payload_info.src] = next_info
313 self.assertTrue(next_info is not None)
314 self.assertEqual(packet_index, next_info.index)
315 saved_packet = next_info.data
316 # Check standard fields
317 self.assertEqual(ip.src, saved_packet[IP].src)
318 self.assertEqual(ip.dst, saved_packet[IP].dst)
319 self.assertEqual(udp.sport, saved_packet[UDP].sport)
320 self.assertEqual(udp.dport, saved_packet[UDP].dport)
322 self.logger.error(ppp("Unexpected or invalid packet:", packet))
324 for i in self.pg_interfaces:
325 remaining_packet = self.get_next_packet_info_for_interface2(
326 i, dst_sw_if_index, last_info[i.sw_if_index])
328 remaining_packet is None,
329 "Port %u: Packet expected from source %u didn't arrive" %
330 (dst_sw_if_index, i.sw_if_index))
332 def run_verify_test(self, bd_id, src_hosts, dst_hosts):
334 # Create incoming packet streams for packet-generator interfaces
335 self.reset_packet_infos()
336 ifs = [self.pg_interfaces[i] for i in self.bd_ifs(bd_id)]
338 pkts = self.create_stream(
339 i, self.pg_if_packet_sizes,
340 if_src_hosts=src_hosts,
341 if_dst_hosts=dst_hosts)
345 self.vapi.bridge_flags(bd_id, 0, 1)
346 # Enable packet capture and start packet sending
347 self.pg_enable_capture(ifs)
351 # Verify outgoing packet streams per packet-generator interface
353 if not dst_hosts[i.sw_if_index]:
355 capture = i.get_capture()
356 self.logger.info("Verifying capture on interface %s" % i.name)
357 self.verify_capture(i, capture)
359 def run_verify_negat_test(self, bd_id, src_hosts, dst_hosts):
361 # Create incoming packet streams for packet-generator interfaces for
362 # deleted MAC addresses
363 self.reset_packet_infos()
364 ifs = [self.pg_interfaces[i] for i in self.bd_ifs(bd_id)]
366 pkts = self.create_stream(
367 i, self.pg_if_packet_sizes,
368 if_src_hosts=src_hosts,
369 if_dst_hosts=dst_hosts)
373 self.vapi.bridge_flags(bd_id, 0, 1)
374 # Enable packet capture and start packet sending
375 self.pg_enable_capture(ifs)
379 # Verify outgoing packet streams per packet-generator interface
382 i.get_capture(0, timeout=timeout)
383 i.assert_nothing_captured(remark="outgoing interface")
386 def test_l2_fib_program100(self):
387 """ L2 FIB - program 100 MACs
390 hosts = self.create_hosts(100, subnet=17)
391 self.config_l2_fib_entries(bd_id, hosts)
392 self.run_verify_test(bd_id, hosts, hosts)
394 def test_l2_fib_program100_delete12(self):
395 """ L2 FIB - program 100, delete 12 MACs
398 hosts = self.create_hosts(100, subnet=17)
399 self.config_l2_fib_entries(bd_id, hosts)
400 del_hosts = self.split_hosts(hosts, 12)
401 self.delete_l2_fib_entry(bd_id, del_hosts)
403 self.run_verify_test(bd_id, hosts, hosts)
404 self.run_verify_negat_test(bd_id, hosts, del_hosts)
406 def test_l2_fib_program100_add100(self):
407 """ L2 FIB - program 100, add 100 MACs
410 hosts = self.create_hosts(100, subnet=17)
411 self.config_l2_fib_entries(bd_id, hosts)
412 hosts2 = self.create_hosts(100, subnet=22)
413 self.config_l2_fib_entries(bd_id, hosts2)
414 self.run_verify_test(bd_id, hosts, hosts2)
416 def test_l2_fib_program10_learn10(self):
417 """ L2 FIB - program 10 MACs, learn 10
419 hosts = self.create_hosts(20, subnet=35)
420 lhosts = self.split_hosts(hosts, 10)
424 self.learn_hosts(bd1, lhosts)
425 self.learn_hosts(bd2, lhosts)
426 self.config_l2_fib_entries(bd1, hosts)
427 self.config_l2_fib_entries(bd2, hosts)
428 self.run_verify_test(bd1, lhosts, hosts)
429 self.run_verify_test(bd2, lhosts, hosts)
431 def test_l2_fib_flush_int(self):
432 """ L2 FIB - flush interface
434 hosts = self.create_hosts(20, subnet=36)
435 lhosts = self.split_hosts(hosts, 10)
438 self.learn_hosts(bd1, lhosts)
439 self.config_l2_fib_entries(bd1, hosts)
440 self.run_verify_test(bd1, lhosts, hosts)
441 flushed = self.flush_int(self.pg_interfaces[0].sw_if_index, lhosts)
442 self.run_verify_test(bd1, hosts, lhosts)
443 self.run_verify_negat_test(bd1, hosts, flushed)
445 def test_l2_fib_flush_bd(self):
446 """ L2 FIB - flush BD
448 hosts = self.create_hosts(20, subnet=37)
449 lhosts = self.split_hosts(hosts, 10)
452 self.learn_hosts(bd1, lhosts)
453 self.config_l2_fib_entries(bd1, hosts)
454 self.run_verify_test(bd1, lhosts, hosts)
455 flushed = self.flush_bd(bd1, lhosts)
456 self.run_verify_negat_test(bd1, hosts, flushed)
458 def test_l2_fib_flush_all(self):
459 """ L2 FIB - flush all
461 hosts = self.create_hosts(20, subnet=38)
462 lhosts = self.split_hosts(hosts, 10)
466 self.learn_hosts(bd1, lhosts)
467 self.learn_hosts(bd2, lhosts)
468 self.config_l2_fib_entries(bd1, hosts)
469 self.config_l2_fib_entries(bd2, hosts)
470 self.run_verify_test(bd1, hosts, lhosts)
471 self.run_verify_test(bd2, hosts, lhosts)
475 self.run_verify_negat_test(bd1, hosts, lhosts)
476 self.run_verify_negat_test(bd2, hosts, lhosts)
478 def test_l2_fib_mac_learn_evs(self):
479 """ L2 FIB - mac learning events
482 hosts = self.create_hosts(10, subnet=39)
484 self.vapi.want_macs_learn_events()
485 self.learn_hosts(bd1, hosts)
488 self.logger.info(self.vapi.ppcli("show l2fib"))
489 evs = self.vapi.collect_events()
491 e.mac[i].mac_addr for e in evs for i in range(e.n_macs)
492 if e.mac[i].action == MAC_EVENT_ACTION_ADD}
493 macs = {h.bin_mac for swif in self.bd_ifs(bd1)
494 for h in hosts[self.pg_interfaces[swif].sw_if_index]}
495 self.vapi.want_macs_learn_events(enable_disable=0)
496 self.assertEqual(len(learned_macs ^ macs), 0)
498 def test_l2_fib_macs_learn_max(self):
499 """ L2 FIB - mac learning max macs in event
502 hosts = self.create_hosts(10, subnet=40)
505 self.vapi.want_macs_learn_events(max_macs_in_event=ev_macs)
506 self.learn_hosts(bd1, hosts)
509 self.logger.info(self.vapi.ppcli("show l2fib"))
510 evs = self.vapi.collect_events()
511 self.vapi.want_macs_learn_events(enable_disable=0)
513 self.assertGreater(len(evs), 0)
515 e.mac[i].mac_addr for e in evs for i in range(e.n_macs)
516 if e.mac[i].action == MAC_EVENT_ACTION_ADD}
517 macs = {h.bin_mac for swif in self.bd_ifs(bd1)
518 for h in hosts[self.pg_interfaces[swif].sw_if_index]}
521 self.assertLess(len(e), ev_macs * 10)
522 self.assertEqual(len(learned_macs ^ macs), 0)
525 if __name__ == '__main__':
526 unittest.main(testRunner=VppTestRunner)