1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
|
#!/usr/bin/env python3
import unittest
import random
from scapy.packet import Raw
from scapy.layers.l2 import Ether
from scapy.layers.inet import IP, UDP
from framework import VppTestCase, VppTestRunner
from util import Host, ppp
class TestL2LearnLimitEnable(VppTestCase):
""" L2 Global Learn limit Test Case """
@classmethod
def setUpClass(self):
super(TestL2LearnLimitEnable, self).setUpClass()
self.create_pg_interfaces(range(3))
@classmethod
def tearDownClass(cls):
super(TestL2LearnLimitEnable, cls).tearDownClass()
def create_hosts(self, pg_if, n_hosts_per_if, subnet):
"""
Create required number of host MAC addresses and distribute them among
interfaces. Create host IPv4 address for every host MAC address.
:param int n_hosts_per_if: Number of per interface hosts to
create MAC/IPv4 addresses for.
"""
hosts = dict()
swif = pg_if.sw_if_index
def mac(j): return "00:00:%02x:ff:%02x:%02x" % (subnet, swif, j)
def ip(j): return "172.%02u.1%02x.%u" % (subnet, swif, j)
def h(j): return Host(mac(j), ip(j))
hosts[swif] = [h(j) for j in range(n_hosts_per_if)]
return hosts
def learn_hosts(self, pg_if, bd_id, hosts):
"""
Create and send per interface L2 MAC broadcast packet stream to
let the bridge domain learn these MAC addresses.
:param int bd_id: BD to teach
:param dict hosts: dict of hosts per interface
"""
self.vapi.bridge_flags(bd_id=bd_id, is_set=1, flags=1)
swif = pg_if.sw_if_index
packets = [Ether(dst="ff:ff:ff:ff:ff:ff", src=host.mac)
for host in hosts[swif]]
pg_if.add_stream(packets)
self.logger.info("Sending broadcast eth frames for MAC learning")
self.pg_start()
def test_l2bd_learnlimit01(self):
""" L2BD test with learn Limit
"""
self.vapi.want_l2_macs_events(enable_disable=1, learn_limit=10)
hosts = self.create_hosts(self.pg_interfaces[0], 20, 1)
fhosts = self.create_hosts(self.pg_interfaces[1], 1, 2)
# inject 20 mac addresses on bd1
self.learn_hosts(self.pg_interfaces[0], 1, hosts)
# inject 1 mac address on bd2
self.learn_hosts(self.pg_interfaces[1], 2, fhosts)
lfs1 = self.vapi.l2_fib_table_dump(1)
lfs2 = self.vapi.l2_fib_table_dump(2)
# check that only 10 macs are learned.
self.assertEqual(len(lfs1), 10)
# check that bd2 was not able to learn
self.assertEqual(len(lfs2), 0)
def setUp(self):
super(TestL2LearnLimitEnable, self).setUp()
self.vapi.bridge_domain_add_del(bd_id=1)
self.vapi.bridge_domain_add_del(bd_id=2)
self.vapi.sw_interface_set_l2_bridge(
self.pg_interfaces[0].sw_if_index, bd_id=1)
self.vapi.sw_interface_set_l2_bridge(
self.pg_interfaces[1].sw_if_index, bd_id=2)
def tearDown(self):
super(TestL2LearnLimitEnable, self).tearDown()
self.vapi.sw_interface_set_l2_bridge(
rx_sw_if_index=self.pg_interfaces[0].sw_if_index,
bd_id=1, enable=0)
self.vapi.sw_interface_set_l2_bridge(
rx_sw_if_index=self.pg_interfaces[1].sw_if_index,
bd_id=2, enable=0)
self.vapi.bridge_domain_add_del(bd_id=1, is_add=0)
self.vapi.bridge_domain_add_del(bd_id=2, is_add=0)
if __name__ == '__main__':
unittest.main(testRunner=VppTestRunner)
|
