def do_task(ctl, hosts, ifaces, aliases):
m1, m2, sw = hosts
m1_if1, m2_if1, sw_if1, sw_if2 = ifaces
m1_if1_10 = m1.create_vlan(m1_if1, 10, ip=test_ip(1,1))
m2_if1_20 = m2.create_vlan(m2_if1, 20, ip=test_ip(1,2))
sw_if1_10 = sw.create_vlan(sw_if1, 10)
sw_if2_20 = sw.create_vlan(sw_if2, 20)
# Ageing time is 10 seconds.
br_options = {"vlan_filtering": 0, "ageing_time": 1000}
sw_br = sw.create_bridge(slaves = [sw_if1_10, sw_if2_20], options=br_options)
sleep(15)
tl = TestLib(ctl, aliases)
tl.ping_simple(m1_if1_10, m2_if1_20)
tl.check_fdb(sw_if1_10, m1_if1_10.get_hwaddr(), 0, "software")
tl.check_fdb(sw_if1_10, m1_if1_10.get_hwaddr(), 0, "hardware")
sleep(20)
tl.check_fdb(sw_if1_10, m1_if1_10.get_hwaddr(), 0, "software", False)
tl.check_fdb(sw_if1_10, m1_if1_10.get_hwaddr(), 0, "hardware", False)
# Disable learning and make sure FDB is not populated.
sw_if1_10.set_br_learning(on=False, self=True)
tl.ping_simple(m1_if1_10, m2_if1_20)
tl.check_fdb(sw_if1_10, m1_if1_10.get_hwaddr(), 0, "software", False)
tl.check_fdb(sw_if1_10, m1_if1_10.get_hwaddr(), 0, "hardware", False)
# Disable flooding and make sure ping fails.
sw_if1_10.set_br_flooding(on=False, self=True)
tl.ping_simple(m1_if1_10, m2_if1_20, fail_expected=True)
# Set a static FDB entry and make sure ping works again.
sw_if1_10.add_br_fdb(str(m1_if1_10.get_hwaddr()), self=True)
tl.ping_simple(m1_if1_10, m2_if1_20)
tl.check_fdb(sw_if1_10, m1_if1_10.get_hwaddr(), 0, "software", False)
tl.check_fdb(sw_if1_10, m1_if1_10.get_hwaddr(), 0, "hardware")
# Remove static FDB entry. Ping should fail.
sw_if1_10.del_br_fdb(str(m1_if1_10.get_hwaddr()), self=True)
tl.ping_simple(m1_if1_10, m2_if1_20, fail_expected=True)
tl.check_fdb(sw_if1_10, m1_if1_10.get_hwaddr(), 0, "software", False)
tl.check_fdb(sw_if1_10, m1_if1_10.get_hwaddr(), 0, "hardware", False)
# Enable learning_sync and make sure both FDBs are populated.
sw_if1_10.set_br_learning(on=True, self=True)
sw_if1_10.set_br_flooding(on=True, self=True)
sw_if1_10.set_br_learning_sync(on=True, self=True)
tl.ping_simple(m1_if1_10, m2_if1_20)
tl.check_fdb(sw_if1_10, m1_if1_10.get_hwaddr(), 0, "software")
tl.check_fdb(sw_if1_10, m1_if1_10.get_hwaddr(), 0, "hardware")
sleep(20)
tl.check_fdb(sw_if1_10, m1_if1_10.get_hwaddr(), 0, "software", False)
tl.check_fdb(sw_if1_10, m1_if1_10.get_hwaddr(), 0, "hardware", False)
# Disable learning_sync and make sure only hardware FDB is populated.
sw_if1_10.set_br_learning_sync(on=False, self=True)
tl.ping_simple(m1_if1_10, m2_if1_20)
tl.check_fdb(sw_if1_10, m1_if1_10.get_hwaddr(), 0, "software", False)
tl.check_fdb(sw_if1_10, m1_if1_10.get_hwaddr(), 0, "hardware")
# Remove port from bridge and add it back. Disable flooding and learning
# and make sure ping doesn't work. Note that port must be removed from
# bridge when the FDB entry exists only in the hardware table. Otherwise,
# bridge code will flush it himself, instead of driver.
sw_br.slave_del(sw_if1_10.get_id())
sw_br.slave_add(sw_if1_10.get_id()) # Enables learning sync by default.
sw_if1_10.set_br_learning(on=False, self=True)
sw_if1_10.set_br_flooding(on=False, self=True)
tl.ping_simple(m1_if1_10, m2_if1_20, fail_expected=True)
# Enable learning and make sure ping works again.
sw_if1_10.set_br_learning(on=True, self=True)
tl.ping_simple(m1_if1_10, m2_if1_20)
tl.check_fdb(sw_if1_10, m1_if1_10.get_hwaddr(), 0, "software")
tl.check_fdb(sw_if1_10, m1_if1_10.get_hwaddr(), 0, "hardware")
sleep(20)
tl.check_fdb(sw_if1_10, m1_if1_10.get_hwaddr(), 0, "software", False)
tl.check_fdb(sw_if1_10, m1_if1_10.get_hwaddr(), 0, "hardware", False)
# Insert a static FDB entry and disable learning sync. Ping should work.
sw_if1_10.add_br_fdb(str(m1_if1_10.get_hwaddr()), self=True)
sw_if1_10.set_br_learning_sync(on=False, self=True)
tl.ping_simple(m1_if1_10, m2_if1_20)
tl.check_fdb(sw_if1_10, m1_if1_10.get_hwaddr(), 0, "software", False)
tl.check_fdb(sw_if1_10, m1_if1_10.get_hwaddr(), 0, "hardware")
sleep(20)
# Make sure static entry is not aged out.
tl.check_fdb(sw_if1_10, m1_if1_10.get_hwaddr(), 0, "software", False)
tl.check_fdb(sw_if1_10, m1_if1_10.get_hwaddr(), 0, "hardware")
# Remove port from bridge and add it back. Disable flooding and learning
# and make sure ping doesn't work. Note that port must be removed from
# bridge when the FDB entry exists only in the hardware table. Otherwise,
# bridge code will flush it himself, instead of driver. Unlike the
# previous case, here we check if the driver correctly removes the static
# entry.
sw_br.slave_del(sw_if1_10.get_id())
sw_br.slave_add(sw_if1_10.get_id())
sw_if1_10.set_br_learning(on=False, self=True)
sw_if1_10.set_br_flooding(on=False, self=True)
tl.ping_simple(m1_if1_10, m2_if1_20, fail_expected=True)
def do_task(ctl, hosts, ifaces, aliases):
m1, m2, sw = hosts
m1_if1, m2_if1, sw_if1, sw_if2 = ifaces
m1_if1_10 = m1.create_vlan(m1_if1, 10, ip=test_ip(1,1))
m2_if1_20 = m2.create_vlan(m2_if1, 20, ip=test_ip(1,2))
sw_if1_10 = sw.create_vlan(sw_if1, 10)
sw_if2_20 = sw.create_vlan(sw_if2, 20)
# Ageing time is 10 seconds.
br_options = {"vlan_filtering": 0, "ageing_time": 1000}
sw_br = sw.create_bridge(slaves = [sw_if1_10, sw_if2_20], options=br_options)
sleep(30)
tl = TestLib(ctl, aliases)
tl.ping_simple(m1_if1_10, m2_if1_20)
tl.check_fdb(sw_if1_10, m1_if1_10.get_hwaddr(), 0, "software")
tl.check_fdb(sw_if1_10, m1_if1_10.get_hwaddr(), 0, "hardware")
sw_if1_10.set_br_learning(on=False, self=True)
sleep(30)
tl.check_fdb(sw_if1_10, m1_if1_10.get_hwaddr(), 0, "software", False)
tl.check_fdb(sw_if1_10, m1_if1_10.get_hwaddr(), 0, "hardware", False)
# Make sure FDB is not populated when learning is disabled.
sw_if1_10.set_br_learning(on=False, self=True)
tl.ping_simple(m1_if1_10, m2_if1_20)
tl.check_fdb(sw_if1_10, m1_if1_10.get_hwaddr(), 0, "software", False)
tl.check_fdb(sw_if1_10, m1_if1_10.get_hwaddr(), 0, "hardware", False)
# Disable flooding and make sure ping fails.
sw_if1_10.set_br_flooding(on=False, self=True)
tl.ping_simple(m1_if1_10, m2_if1_20, fail_expected=True)
# Set a static FDB entry and make sure ping works again.
sw_if1_10.add_br_fdb(str(m1_if1_10.get_hwaddr()), self=True)
tl.ping_simple(m1_if1_10, m2_if1_20)
tl.check_fdb(sw_if1_10, m1_if1_10.get_hwaddr(), 0, "software", False)
tl.check_fdb(sw_if1_10, m1_if1_10.get_hwaddr(), 0, "hardware")
# Remove static FDB entry. Ping should fail.
sw_if1_10.del_br_fdb(str(m1_if1_10.get_hwaddr()), self=True)
tl.ping_simple(m1_if1_10, m2_if1_20, fail_expected=True)
tl.check_fdb(sw_if1_10, m1_if1_10.get_hwaddr(), 0, "software", False)
tl.check_fdb(sw_if1_10, m1_if1_10.get_hwaddr(), 0, "hardware", False)
# Enable learning_sync and make sure both FDBs are populated.
sw_if1_10.set_br_learning(on=True, self=True)
sw_if1_10.set_br_flooding(on=True, self=True)
sw_if1_10.set_br_learning_sync(on=True, self=True)
tl.ping_simple(m1_if1_10, m2_if1_20)
tl.check_fdb(sw_if1_10, m1_if1_10.get_hwaddr(), 0, "software")
tl.check_fdb(sw_if1_10, m1_if1_10.get_hwaddr(), 0, "hardware")
sw_if1_10.set_br_learning(on=False, self=True)
sleep(20)
tl.check_fdb(sw_if1_10, m1_if1_10.get_hwaddr(), 0, "software", False)
tl.check_fdb(sw_if1_10, m1_if1_10.get_hwaddr(), 0, "hardware", False)
# Disable learning_sync and make sure only hardware FDB is populated.
sw_if1_10.set_br_learning(on=True, self=True)
sw_if1_10.set_br_learning_sync(on=False, self=True)
tl.ping_simple(m1_if1_10, m2_if1_20)
tl.check_fdb(sw_if1_10, m1_if1_10.get_hwaddr(), 0, "software", False)
tl.check_fdb(sw_if1_10, m1_if1_10.get_hwaddr(), 0, "hardware")
# Remove port from bridge and add it back. Disable flooding and learning
# and make sure ping doesn't work. Note that port must be removed from
# bridge when the FDB entry exists only in the hardware table. Otherwise,
# bridge code will flush it himself, instead of driver.
sw_br.slave_del(sw_if1_10.get_id())
sw_br.slave_add(sw_if1_10.get_id()) # Enables learning sync by default.
sw_if1_10.set_br_learning(on=False, self=True)
sw_if1_10.set_br_flooding(on=False, self=True)
tl.ping_simple(m1_if1_10, m2_if1_20, fail_expected=True)
# Enable learning and make sure ping works again.
sw_if1_10.set_br_learning(on=True, self=True)
tl.ping_simple(m1_if1_10, m2_if1_20)
tl.check_fdb(sw_if1_10, m1_if1_10.get_hwaddr(), 0, "software")
tl.check_fdb(sw_if1_10, m1_if1_10.get_hwaddr(), 0, "hardware")
sw_if1_10.set_br_learning(on=False, self=True)
sleep(20)
tl.check_fdb(sw_if1_10, m1_if1_10.get_hwaddr(), 0, "software", False)
tl.check_fdb(sw_if1_10, m1_if1_10.get_hwaddr(), 0, "hardware", False)
# Insert a static FDB entry and disable learning sync. Ping should work.
sw_if1_10.add_br_fdb(str(m1_if1_10.get_hwaddr()), self=True)
sw_if1_10.set_br_learning_sync(on=False, self=True)
tl.ping_simple(m1_if1_10, m2_if1_20)
tl.check_fdb(sw_if1_10, m1_if1_10.get_hwaddr(), 0, "software", False)
tl.check_fdb(sw_if1_10, m1_if1_10.get_hwaddr(), 0, "hardware")
sleep(20)
# Make sure static entry is not aged out.
tl.check_fdb(sw_if1_10, m1_if1_10.get_hwaddr(), 0, "software", False)
tl.check_fdb(sw_if1_10, m1_if1_10.get_hwaddr(), 0, "hardware")
# Remove port from bridge and add it back. Disable flooding and learning
# and make sure ping doesn't work. Note that port must be removed from
# bridge when the FDB entry exists only in the hardware table. Otherwise,
# bridge code will flush it himself, instead of driver. Unlike the
# previous case, here we check if the driver correctly removes the static
# entry.
sw_br.slave_del(sw_if1_10.get_id())
sw_br.slave_add(sw_if1_10.get_id())
sw_if1_10.set_br_learning(on=False, self=True)
sw_if1_10.set_br_flooding(on=False, self=True)
tl.ping_simple(m1_if1_10, m2_if1_20, fail_expected=True)
def do_task(ctl, hosts, ifaces, aliases):
m1, m2, sw = hosts
m1_if1, m1_if2, m2_if1, m2_if2, sw_if1, sw_if2, sw_if3, sw_if4 = ifaces
team_config = '{"runner" : {"name" : "lacp"}}'
m1_lag1 = m1.create_team(slaves=[m1_if1, m1_if2],
config=team_config,
ip=["192.168.101.10/24", "2002::1/64"])
m2_lag1 = m2.create_team(slaves=[m2_if1, m2_if2],
config=team_config,
ip=["192.168.101.11/24", "2002::2/64"])
sw_lag1 = sw.create_team(slaves=[sw_if1, sw_if2], config=team_config)
sw_lag2 = sw.create_team(slaves=[sw_if3, sw_if4], config=team_config)
# Ageing time is 10 seconds.
br_options = {
"vlan_filtering": 1,
"ageing_time": 1000,
"multicast_querier": 1
}
sw_br = sw.create_bridge(slaves=[sw_lag1, sw_lag2], options=br_options)
sleep(30)
tl = TestLib(ctl, aliases)
tl.ping_simple(m1_lag1, m2_lag1)
tl.check_fdb(sw_lag1, m1_lag1.get_hwaddr(), 1, True, True)
sw_lag1.set_br_learning(on=False, master=True)
sleep(30)
tl.check_fdb(sw_lag1, m1_lag1.get_hwaddr(), 1, True, True, False)
# Make sure FDB is not populated when learning is disabled.
sw_lag1.set_br_learning(on=False, master=True)
tl.ping_simple(m1_lag1, m2_lag1)
tl.check_fdb(sw_lag1, m1_lag1.get_hwaddr(), 1, True, True, False)
# Disable flooding and make sure ping fails.
sw_lag1.set_br_flooding(on=False, master=True)
tl.ping_simple(m1_lag1, m2_lag1, fail_expected=True)
# Set a static FDB entry and make sure ping works again. Also check
# its offloaded
sw_lag1.add_br_fdb(str(m1_lag1.get_hwaddr()), master=True, vlan_tci=1)
tl.ping_simple(m1_lag1, m2_lag1)
tl.check_fdb(sw_lag1, m1_lag1.get_hwaddr(), 1, True, False)
# Remove static FDB entry. Ping should fail.
sw_lag1.del_br_fdb(str(m1_lag1.get_hwaddr()), master=True, vlan_tci=1)
tl.ping_simple(m1_lag1, m2_lag1, fail_expected=True)
tl.check_fdb(sw_lag1, m1_lag1.get_hwaddr(), 1, True, False, False)
# Enable learning and flooading and make sure ping works again.
sw_lag1.set_br_learning(on=True, master=True)
sw_lag1.set_br_flooding(on=True, master=True)
tl.ping_simple(m1_lag1, m2_lag1)
tl.check_fdb(sw_lag1, m1_lag1.get_hwaddr(), 1, True, True)
sw_lag1.set_br_learning(on=False, master=True)
sleep(30)
tl.check_fdb(sw_lag1, m1_lag1.get_hwaddr(), 1, True, True, False)
# Insert a static FDB entry. Ping should work.
sw_lag1.add_br_fdb(str(m1_lag1.get_hwaddr()), master=True, vlan_tci=1)
tl.ping_simple(m1_lag1, m2_lag1)
tl.check_fdb(sw_lag1, m1_lag1.get_hwaddr(), 1, True, False)
sleep(30)
# Make sure static entry is not aged out.
tl.check_fdb(sw_lag1, m1_lag1.get_hwaddr(), 1, True, False)
# Remove port from bridge and add it back. The static entry added
# before should be flushed. Disable flooding and learning and make
# sure ping doesn't work.
sw_br.slave_del(sw_lag1.get_id())
sw_br.slave_add(sw_lag1.get_id())
sw_lag1.set_br_learning(on=False, master=True)
sw_lag1.set_br_flooding(on=False, master=True)
tl.ping_simple(m1_lag1, m2_lag1, fail_expected=True)
def do_task(ctl, hosts, ifaces, aliases):
m1, m2, sw = hosts
m1_if1, m2_if1, sw_if1, sw_if2 = ifaces
m1_if1_10 = m1.create_vlan(m1_if1, 10, ip=test_ip(1, 1))
m2_if1_20 = m2.create_vlan(m2_if1, 20, ip=test_ip(1, 2))
sw_if1_10 = sw.create_vlan(sw_if1, 10)
sw_if2_20 = sw.create_vlan(sw_if2, 20)
# Ageing time is 10 seconds.
br_options = {
"vlan_filtering": 0,
"ageing_time": 1000,
"multicast_snooping": 0
}
sw_br = sw.create_bridge(slaves=[sw_if1_10, sw_if2_20], options=br_options)
sleep(30)
tl = TestLib(ctl, aliases)
tl.ping_simple(m1_if1_10, m2_if1_20)
tl.check_fdb(sw_if1_10, m1_if1_10.get_hwaddr(), 0, True, True)
sw_if1_10.set_br_learning(on=False, master=True)
sleep(30)
tl.check_fdb(sw_if1_10, m1_if1_10.get_hwaddr(), 0, True, True, False)
# Make sure FDB is not populated when learning is disabled.
sw_if1_10.set_br_learning(on=False, master=True)
tl.ping_simple(m1_if1_10, m2_if1_20)
tl.check_fdb(sw_if1_10, m1_if1_10.get_hwaddr(), 0, True, True, False)
# Disable flooding and make sure ping fails.
sw_if1_10.set_br_flooding(on=False, master=True)
tl.ping_simple(m1_if1_10, m2_if1_20, fail_expected=True)
# Set a static FDB entry and make sure ping works again. Also check
# its offloaded
sw_if1_10.add_br_fdb(str(m1_if1_10.get_hwaddr()), master=True)
tl.ping_simple(m1_if1_10, m2_if1_20)
tl.check_fdb(sw_if1_10, m1_if1_10.get_hwaddr(), 0, True, False)
# Remove static FDB entry. Ping should fail.
sw_if1_10.del_br_fdb(str(m1_if1_10.get_hwaddr()), master=True)
tl.ping_simple(m1_if1_10, m2_if1_20, fail_expected=True)
tl.check_fdb(sw_if1_10, m1_if1_10.get_hwaddr(), 0, True, False, False)
# Enable learning and flooding and make sure ping works again.
sw_if1_10.set_br_learning(on=True, master=True)
sw_if1_10.set_br_flooding(on=True, master=True)
tl.ping_simple(m1_if1_10, m2_if1_20)
tl.check_fdb(sw_if1_10, m1_if1_10.get_hwaddr(), 0, True, True)
sw_if1_10.set_br_learning(on=False, master=True)
sleep(20)
tl.check_fdb(sw_if1_10, m1_if1_10.get_hwaddr(), 0, True, True, False)
# Insert a static FDB entry. Ping should work.
sw_if1_10.add_br_fdb(str(m1_if1_10.get_hwaddr()), master=True)
tl.ping_simple(m1_if1_10, m2_if1_20)
tl.check_fdb(sw_if1_10, m1_if1_10.get_hwaddr(), 0, True, False)
sleep(20)
# Make sure static entry is not aged out.
tl.check_fdb(sw_if1_10, m1_if1_10.get_hwaddr(), 0, True, False)
# Remove port from bridge and add it back. The static entry added
# before should be flushed. Disable flooding and learning and make
# sure ping doesn't work.
sw_br.slave_del(sw_if1_10.get_id())
sw_br.slave_add(sw_if1_10.get_id())
sw_if1_10.set_br_learning(on=False, master=True)
sw_if1_10.set_br_flooding(on=False, master=True)
tl.ping_simple(m1_if1_10, m2_if1_20, fail_expected=True)
def do_task(ctl, hosts, ifaces, aliases):
m1, m2, sw = hosts
m1_if1, m1_if2, m2_if1, m2_if2, sw_if1, sw_if2, sw_if3, sw_if4 = ifaces
team_config = '{"runner" : {"name" : "lacp"}}'
m1_lag1 = m1.create_team(slaves=[m1_if1, m1_if2], config=team_config,
ip=["192.168.101.10/24", "2002::1/64"])
m2_lag1 = m2.create_team(slaves=[m2_if1, m2_if2], config=team_config,
ip=["192.168.101.11/24", "2002::2/64"])
sw_lag1 = sw.create_team(slaves=[sw_if1, sw_if2], config=team_config)
sw_lag2 = sw.create_team(slaves=[sw_if3, sw_if4], config=team_config)
# Ageing time is 10 seconds.
br_options = {"vlan_filtering": 1, "ageing_time": 1000}
sw_br = sw.create_bridge(slaves = [sw_lag1, sw_lag2], options=br_options)
sleep(15)
tl = TestLib(ctl, aliases)
tl.ping_simple(m1_lag1, m2_lag1)
tl.check_fdb(sw_lag1, m1_lag1.get_hwaddr(), 1, "software")
tl.check_fdb(sw_lag1, m1_lag1.get_hwaddr(), 1, "hardware")
sleep(20)
tl.check_fdb(sw_lag1, m1_lag1.get_hwaddr(), 1, "software", False)
tl.check_fdb(sw_lag1, m1_lag1.get_hwaddr(), 1, "hardware", False)
# Disable learning and make sure FDB is not populated.
sw_lag1.set_br_learning(on=False, self=True)
tl.ping_simple(m1_lag1, m2_lag1)
tl.check_fdb(sw_lag1, m1_lag1.get_hwaddr(), 1, "software", False)
tl.check_fdb(sw_lag1, m1_lag1.get_hwaddr(), 1, "hardware", False)
# Disable flooding and make sure ping fails.
sw_lag1.set_br_flooding(on=False, self=True)
tl.ping_simple(m1_lag1, m2_lag1, fail_expected=True)
# Set a static FDB entry and make sure ping works again.
sw_lag1.add_br_fdb(str(m1_lag1.get_hwaddr()), self=True, vlan_tci=1)
tl.ping_simple(m1_lag1, m2_lag1)
tl.check_fdb(sw_lag1, m1_lag1.get_hwaddr(), 1, "software", False)
tl.check_fdb(sw_lag1, m1_lag1.get_hwaddr(), 1, "hardware")
# Remove static FDB entry. Ping should fail.
sw_lag1.del_br_fdb(str(m1_lag1.get_hwaddr()), self=True, vlan_tci=1)
tl.ping_simple(m1_lag1, m2_lag1, fail_expected=True)
tl.check_fdb(sw_lag1, m1_lag1.get_hwaddr(), 1, "software", False)
tl.check_fdb(sw_lag1, m1_lag1.get_hwaddr(), 1, "hardware", False)
# Enable learning_sync and make sure both FDBs are populated.
sw_lag1.set_br_learning(on=True, self=True)
sw_lag1.set_br_flooding(on=True, self=True)
sw_lag1.set_br_learning_sync(on=True, self=True)
tl.ping_simple(m1_lag1, m2_lag1)
tl.check_fdb(sw_lag1, m1_lag1.get_hwaddr(), 1, "software")
tl.check_fdb(sw_lag1, m1_lag1.get_hwaddr(), 1, "hardware")
sleep(20)
tl.check_fdb(sw_lag1, m1_lag1.get_hwaddr(), 1, "software", False)
tl.check_fdb(sw_lag1, m1_lag1.get_hwaddr(), 1, "hardware", False)
# Disable learning_sync and make sure only hardware FDB is populated.
sw_lag1.set_br_learning_sync(on=False, self=True)
tl.ping_simple(m1_lag1, m2_lag1)
tl.check_fdb(sw_lag1, m1_lag1.get_hwaddr(), 1, "software", False)
tl.check_fdb(sw_lag1, m1_lag1.get_hwaddr(), 1, "hardware")
# Remove port from bridge and add it back. Disable flooding and learning
# and make sure ping doesn't work. Note that port must be removed from
# bridge when the FDB entry exists only in the hardware table. Otherwise,
# bridge code will flush it himself, instead of driver.
sw_br.slave_del(sw_lag1.get_id())
sw_br.slave_add(sw_lag1.get_id()) # Enables learning sync by default.
sw_lag1.set_br_learning(on=False, self=True)
sw_lag1.set_br_flooding(on=False, self=True)
tl.ping_simple(m1_lag1, m2_lag1, fail_expected=True)
# Enable learning and make sure ping works again.
sw_lag1.set_br_learning(on=True, self=True)
tl.ping_simple(m1_lag1, m2_lag1)
tl.check_fdb(sw_lag1, m1_lag1.get_hwaddr(), 1, "software")
tl.check_fdb(sw_lag1, m1_lag1.get_hwaddr(), 1, "hardware")
sleep(20)
tl.check_fdb(sw_lag1, m1_lag1.get_hwaddr(), 1, "software", False)
tl.check_fdb(sw_lag1, m1_lag1.get_hwaddr(), 1, "hardware", False)
# Insert a static FDB entry and disable learning sync. Ping should work.
sw_lag1.add_br_fdb(str(m1_lag1.get_hwaddr()), self=True, vlan_tci=1)
sw_lag1.set_br_learning_sync(on=False, self=True)
tl.ping_simple(m1_lag1, m2_lag1)
tl.check_fdb(sw_lag1, m1_lag1.get_hwaddr(), 1, "software", False)
tl.check_fdb(sw_lag1, m1_lag1.get_hwaddr(), 1, "hardware")
sleep(20)
# Make sure static entry is not aged out.
tl.check_fdb(sw_lag1, m1_lag1.get_hwaddr(), 1, "software", False)
tl.check_fdb(sw_lag1, m1_lag1.get_hwaddr(), 1, "hardware")
# Remove port from bridge and add it back. Disable flooding and learning
# and make sure ping doesn't work. Note that port must be removed from
# bridge when the FDB entry exists only in the hardware table. Otherwise,
# bridge code will flush it himself, instead of driver. Unlike the
# previous case, here we check if the driver correctly removes the static
# entry.
sw_br.slave_del(sw_lag1.get_id())
sw_br.slave_add(sw_lag1.get_id())
sw_lag1.set_br_learning(on=False, self=True)
sw_lag1.set_br_flooding(on=False, self=True)
tl.ping_simple(m1_lag1, m2_lag1, fail_expected=True)
def do_task(ctl, hosts, ifaces, aliases):
m1, m2, sw = hosts
m1_if1, m2_if1, sw_if1, sw_if2 = ifaces
m1_if1.reset(ip=test_ip(1,1))
m2_if1.reset(ip=test_ip(1,2))
# Ageing time is 10 seconds.
br_options = {"vlan_filtering": 1, "ageing_time": 1000,
"multicast_querier": 1}
sw_br = sw.create_bridge(slaves = [sw_if1, sw_if2], options=br_options)
sleep(30)
tl = TestLib(ctl, aliases)
tl.ping_simple(m1_if1, m2_if1)
tl.check_fdb(sw_if1, m1_if1.get_hwaddr(), 1, True, True)
sw_if1.set_br_learning(on=False, master=True)
sleep(30)
tl.check_fdb(sw_if1, m1_if1.get_hwaddr(), 1, True, True, False)
# Make sure FDB is not populated when learning is disabled.
sw_if1.set_br_learning(on=False, master=True)
tl.ping_simple(m1_if1, m2_if1)
tl.check_fdb(sw_if1, m1_if1.get_hwaddr(), 1, True, True, False)
# Disable flooding and make sure ping fails.
sw_if1.set_br_flooding(on=False, master=True)
tl.ping_simple(m1_if1, m2_if1, fail_expected=True)
# Set a static FDB entry and make sure ping works again. Also check
# its offloaded
sw_if1.add_br_fdb(str(m1_if1.get_hwaddr()), master=True, vlan_tci=1)
tl.ping_simple(m1_if1, m2_if1)
tl.check_fdb(sw_if1, m1_if1.get_hwaddr(), 1, True, False)
# Remove static FDB entry. Ping should fail.
sw_if1.del_br_fdb(str(m1_if1.get_hwaddr()), master=True, vlan_tci=1)
tl.ping_simple(m1_if1, m2_if1, fail_expected=True)
tl.check_fdb(sw_if1, m1_if1.get_hwaddr(), 1, True, False, False)
# Enable learning and flooding and make sure ping works again.
sw_if1.set_br_learning(on=True, master=True)
sw_if1.set_br_flooding(on=True, master=True)
tl.ping_simple(m1_if1, m2_if1)
tl.check_fdb(sw_if1, m1_if1.get_hwaddr(), 1, True, True)
sw_if1.set_br_learning(on=False, master=True)
sleep(20)
tl.check_fdb(sw_if1, m1_if1.get_hwaddr(), 1, True, True, False)
# Insert a static FDB entry. Ping should work.
sw_if1.add_br_fdb(str(m1_if1.get_hwaddr()), master=True, vlan_tci=1)
tl.ping_simple(m1_if1, m2_if1)
tl.check_fdb(sw_if1, m1_if1.get_hwaddr(), 1, True, False)
sleep(20)
# Make sure static entry is not aged out.
tl.check_fdb(sw_if1, m1_if1.get_hwaddr(), 1, True, False)
# Remove port from bridge and add it back. The static entry added
# before should be flushed. Disable flooding and learning and make
# sure ping doesn't work.
sw_br.slave_del(sw_if1.get_id())
sw_br.slave_add(sw_if1.get_id())
sw_if1.set_br_learning(on=False, master=True)
sw_if1.set_br_flooding(on=False, master=True)
tl.ping_simple(m1_if1, m2_if1, fail_expected=True)
def do_task(ctl, hosts, ifaces, aliases):
m1, m2, sw = hosts
m1_if1, m1_if2, m2_if1, m2_if2, sw_if1, sw_if2, sw_if3, sw_if4 = ifaces
team_config = '{"runner" : {"name" : "lacp"}}'
m1_lag1 = m1.create_team(slaves=[m1_if1, m1_if2], config=team_config,
ip=["192.168.101.10/24", "2002::1/64"])
m2_lag1 = m2.create_team(slaves=[m2_if1, m2_if2], config=team_config,
ip=["192.168.101.11/24", "2002::2/64"])
sw_lag1 = sw.create_team(slaves=[sw_if1, sw_if2], config=team_config)
sw_lag2 = sw.create_team(slaves=[sw_if3, sw_if4], config=team_config)
# Ageing time is 10 seconds.
br_options = {"vlan_filtering": 1, "ageing_time": 1000}
sw_br = sw.create_bridge(slaves = [sw_lag1, sw_lag2], options=br_options)
sleep(30)
tl = TestLib(ctl, aliases)
tl.ping_simple(m1_lag1, m2_lag1)
tl.check_fdb(sw_lag1, m1_lag1.get_hwaddr(), 1, "software")
tl.check_fdb(sw_lag1, m1_lag1.get_hwaddr(), 1, "hardware")
sw_lag1.set_br_learning(on=False, self=True)
sleep(30)
tl.check_fdb(sw_lag1, m1_lag1.get_hwaddr(), 1, "software", False)
tl.check_fdb(sw_lag1, m1_lag1.get_hwaddr(), 1, "hardware", False)
# Make sure FDB is not populated when learning is disabled.
sw_lag1.set_br_learning(on=False, self=True)
tl.ping_simple(m1_lag1, m2_lag1)
tl.check_fdb(sw_lag1, m1_lag1.get_hwaddr(), 1, "software", False)
tl.check_fdb(sw_lag1, m1_lag1.get_hwaddr(), 1, "hardware", False)
# Disable flooding and make sure ping fails.
sw_lag1.set_br_flooding(on=False, self=True)
tl.ping_simple(m1_lag1, m2_lag1, fail_expected=True)
# Set a static FDB entry and make sure ping works again.
sw_lag1.add_br_fdb(str(m1_lag1.get_hwaddr()), self=True, vlan_tci=1)
tl.ping_simple(m1_lag1, m2_lag1)
tl.check_fdb(sw_lag1, m1_lag1.get_hwaddr(), 1, "software", False)
tl.check_fdb(sw_lag1, m1_lag1.get_hwaddr(), 1, "hardware")
# Remove static FDB entry. Ping should fail.
sw_lag1.del_br_fdb(str(m1_lag1.get_hwaddr()), self=True, vlan_tci=1)
tl.ping_simple(m1_lag1, m2_lag1, fail_expected=True)
tl.check_fdb(sw_lag1, m1_lag1.get_hwaddr(), 1, "software", False)
tl.check_fdb(sw_lag1, m1_lag1.get_hwaddr(), 1, "hardware", False)
# Enable learning_sync and make sure both FDBs are populated.
sw_lag1.set_br_learning(on=True, self=True)
sw_lag1.set_br_flooding(on=True, self=True)
sw_lag1.set_br_learning_sync(on=True, self=True)
tl.ping_simple(m1_lag1, m2_lag1)
tl.check_fdb(sw_lag1, m1_lag1.get_hwaddr(), 1, "software")
tl.check_fdb(sw_lag1, m1_lag1.get_hwaddr(), 1, "hardware")
sw_lag1.set_br_learning(on=False, self=True)
sleep(30)
tl.check_fdb(sw_lag1, m1_lag1.get_hwaddr(), 1, "software", False)
tl.check_fdb(sw_lag1, m1_lag1.get_hwaddr(), 1, "hardware", False)
# Disable learning_sync and make sure only hardware FDB is populated.
sw_lag1.set_br_learning(on=True, self=True)
sw_lag1.set_br_learning_sync(on=False, self=True)
tl.ping_simple(m1_lag1, m2_lag1)
tl.check_fdb(sw_lag1, m1_lag1.get_hwaddr(), 1, "software", False)
tl.check_fdb(sw_lag1, m1_lag1.get_hwaddr(), 1, "hardware")
# Remove port from bridge and add it back. Disable flooding and learning
# and make sure ping doesn't work. Note that port must be removed from
# bridge when the FDB entry exists only in the hardware table. Otherwise,
# bridge code will flush it himself, instead of driver.
sw_br.slave_del(sw_lag1.get_id())
sw_br.slave_add(sw_lag1.get_id()) # Enables learning sync by default.
sw_lag1.set_br_learning(on=False, self=True)
sw_lag1.set_br_flooding(on=False, self=True)
tl.ping_simple(m1_lag1, m2_lag1, fail_expected=True)
# Enable learning and make sure ping works again.
sw_lag1.set_br_learning(on=True, self=True)
tl.ping_simple(m1_lag1, m2_lag1)
tl.check_fdb(sw_lag1, m1_lag1.get_hwaddr(), 1, "software")
tl.check_fdb(sw_lag1, m1_lag1.get_hwaddr(), 1, "hardware")
sw_lag1.set_br_learning(on=False, self=True)
sleep(30)
tl.check_fdb(sw_lag1, m1_lag1.get_hwaddr(), 1, "software", False)
tl.check_fdb(sw_lag1, m1_lag1.get_hwaddr(), 1, "hardware", False)
# Insert a static FDB entry and disable learning sync. Ping should work.
sw_lag1.add_br_fdb(str(m1_lag1.get_hwaddr()), self=True, vlan_tci=1)
sw_lag1.set_br_learning_sync(on=False, self=True)
tl.ping_simple(m1_lag1, m2_lag1)
tl.check_fdb(sw_lag1, m1_lag1.get_hwaddr(), 1, "software", False)
tl.check_fdb(sw_lag1, m1_lag1.get_hwaddr(), 1, "hardware")
sleep(30)
# Make sure static entry is not aged out.
tl.check_fdb(sw_lag1, m1_lag1.get_hwaddr(), 1, "software", False)
tl.check_fdb(sw_lag1, m1_lag1.get_hwaddr(), 1, "hardware")
# Remove port from bridge and add it back. Disable flooding and learning
# and make sure ping doesn't work. Note that port must be removed from
# bridge when the FDB entry exists only in the hardware table. Otherwise,
# bridge code will flush it himself, instead of driver. Unlike the
# previous case, here we check if the driver correctly removes the static
# entry.
sw_br.slave_del(sw_lag1.get_id())
sw_br.slave_add(sw_lag1.get_id())
sw_lag1.set_br_learning(on=False, self=True)
sw_lag1.set_br_flooding(on=False, self=True)
tl.ping_simple(m1_lag1, m2_lag1, fail_expected=True)
def do_task(ctl, hosts, ifaces, aliases):
m1, m2, sw = hosts
m1_if1, m2_if1, sw_if1, sw_if2 = ifaces
# We can't set STP state if kernel's STP is running.
br_options = {"stp_state": 0, "vlan_filtering": 1, "ageing_time": 1000}
sw.create_bridge(slaves=[sw_if1, sw_if2], options=br_options)
m1_if1.reset(ip=test_ip(1, 1))
m2_if1.reset(ip=test_ip(1, 2))
sleep(40)
tl = TestLib(ctl, aliases)
# Set STP state to DISABLED and make sure ping fails and FDB is not
# populated.
sw_if1.set_br_state(0)
tl.ping_simple(m1_if1, m2_if1, fail_expected=True)
tl.check_fdb(sw_if1, m1_if1.get_hwaddr(), 1, "software", False)
tl.check_fdb(sw_if1, m1_if1.get_hwaddr(), 1, "hardware", False)
# Set STP state to LISTENING and make sure ping fails and FDB is not
# populated.
sw_if1.set_br_state(1)
tl.ping_simple(m1_if1, m2_if1, fail_expected=True)
tl.check_fdb(sw_if1, m1_if1.get_hwaddr(), 1, "software", False)
tl.check_fdb(sw_if1, m1_if1.get_hwaddr(), 1, "hardware", False)
# Set STP state to LEARNING and make sure ping fails, but FDB *is*
# populated.
sw_if1.set_br_state(2)
tl.ping_simple(m1_if1, m2_if1, fail_expected=True)
tl.check_fdb(sw_if1, m1_if1.get_hwaddr(), 1, "software")
tl.check_fdb(sw_if1, m1_if1.get_hwaddr(), 1, "hardware")
sleep(20)
tl.check_fdb(sw_if1, m1_if1.get_hwaddr(), 1, "software", False)
tl.check_fdb(sw_if1, m1_if1.get_hwaddr(), 1, "hardware", False)
# Set STP state to FORWARDING and make sure ping works and FDB is
# populated.
sw_if1.set_br_state(3)
tl.ping_simple(m1_if1, m2_if1)
tl.check_fdb(sw_if1, m1_if1.get_hwaddr(), 1, "software")
tl.check_fdb(sw_if1, m1_if1.get_hwaddr(), 1, "hardware")
sleep(20)
tl.check_fdb(sw_if1, m1_if1.get_hwaddr(), 1, "software", False)
tl.check_fdb(sw_if1, m1_if1.get_hwaddr(), 1, "hardware", False)
# Make sure that even with a static FDB record we don't get traffic
# when state is DISABLED, LEARNING or LISTENING.
sw_if2.add_br_fdb(str(m2_if1.get_hwaddr()), self=True, vlan_tci=1)
sw_if1.set_br_state(0)
tl.ping_simple(m1_if1, m2_if1, fail_expected=True)
sw_if1.set_br_state(1)
tl.ping_simple(m1_if1, m2_if1, fail_expected=True)
sw_if1.set_br_state(2)
tl.ping_simple(m1_if1, m2_if1, fail_expected=True)
# Cleanup
sw_if2.del_br_fdb(str(m2_if1.get_hwaddr()), self=True, vlan_tci=1)
def do_task(ctl, hosts, ifaces, aliases):
m1, m2, sw = hosts
m1_if1, m2_if1, sw_if1, sw_if2 = ifaces
# We can't set STP state if kernel's STP is running.
br_options = {
"stp_state": 0,
"vlan_filtering": 1,
"ageing_time": 1000,
"multicast_querier": 1
}
sw.create_bridge(slaves=[sw_if1, sw_if2], options=br_options)
m1_if1.reset(ip=test_ip(1, 1))
m2_if1.reset(ip=test_ip(1, 2))
sleep(40)
tl = TestLib(ctl, aliases)
# Set STP state to DISABLED and make sure ping fails and FDB is not
# populated.
sw_if1.set_br_state(0)
tl.ping_simple(m1_if1, m2_if1, fail_expected=True)
tl.check_fdb(sw_if1, m1_if1.get_hwaddr(), 1, True, True, False)
# Set STP state to LISTENING and make sure ping fails and FDB is not
# populated.
sw_if1.set_br_state(1)
tl.ping_simple(m1_if1, m2_if1, fail_expected=True)
tl.check_fdb(sw_if1, m1_if1.get_hwaddr(), 1, True, True, False)
# Set STP state to LEARNING and make sure ping fails, but FDB *is*
# populated.
sw_if1.set_br_state(2)
tl.ping_simple(m1_if1, m2_if1, fail_expected=True)
tl.check_fdb(sw_if1, m1_if1.get_hwaddr(), 1, True, True)
sleep(30)
tl.check_fdb(sw_if1, m1_if1.get_hwaddr(), 1, True, True, False)
# Set STP state to FORWARDING and make sure ping works and FDB is
# populated.
sw_if1.set_br_state(3)
tl.ping_simple(m1_if1, m2_if1)
tl.check_fdb(sw_if1, m1_if1.get_hwaddr(), 1, True, True)
sleep(30)
tl.check_fdb(sw_if1, m1_if1.get_hwaddr(), 1, True, True, False)
# Make sure that even with a static FDB record we don't get traffic
# when state is DISABLED, LEARNING or LISTENING.
sw_if2.add_br_fdb(str(m2_if1.get_hwaddr()), master=True, vlan_tci=1)
sw_if1.set_br_state(0)
tl.ping_simple(m1_if1, m2_if1, fail_expected=True)
sw_if1.set_br_state(1)
tl.ping_simple(m1_if1, m2_if1, fail_expected=True)
sw_if1.set_br_state(2)
tl.ping_simple(m1_if1, m2_if1, fail_expected=True)
# Cleanup
sw_if2.del_br_fdb(str(m2_if1.get_hwaddr()), master=True, vlan_tci=1)
def do_task(ctl, hosts, ifaces, aliases):
m1, m2, sw = hosts
m1_if1, m1_if2, m2_if1, m2_if2, sw_if1, sw_if2, sw_if3, sw_if4 = ifaces
team_config = '{"runner" : {"name" : "lacp"}}'
m1_lag1 = m1.create_team(slaves=[m1_if1, m1_if2], config=team_config,
ip=["192.168.101.10/24", "2002::1/64"])
m2_lag1 = m2.create_team(slaves=[m2_if1, m2_if2], config=team_config,
ip=["192.168.101.11/24", "2002::2/64"])
sw_lag1 = sw.create_team(slaves=[sw_if1, sw_if2], config=team_config)
sw_lag2 = sw.create_team(slaves=[sw_if3, sw_if4], config=team_config)
# Ageing time is 10 seconds.
br_options = {"vlan_filtering": 1, "ageing_time": 1000, "multicast_querier": 1}
sw_br = sw.create_bridge(slaves = [sw_lag1, sw_lag2], options=br_options)
sleep(30)
tl = TestLib(ctl, aliases)
tl.ping_simple(m1_lag1, m2_lag1)
tl.check_fdb(sw_lag1, m1_lag1.get_hwaddr(), 1, True, True)
sw_lag1.set_br_learning(on=False, master=True)
sleep(30)
tl.check_fdb(sw_lag1, m1_lag1.get_hwaddr(), 1, True, True, False)
# Make sure FDB is not populated when learning is disabled.
sw_lag1.set_br_learning(on=False, master=True)
tl.ping_simple(m1_lag1, m2_lag1)
tl.check_fdb(sw_lag1, m1_lag1.get_hwaddr(), 1, True, True, False)
# Disable flooding and make sure ping fails.
sw_lag1.set_br_flooding(on=False, master=True)
tl.ping_simple(m1_lag1, m2_lag1, fail_expected=True)
# Set a static FDB entry and make sure ping works again. Also check
# its offloaded
sw_lag1.add_br_fdb(str(m1_lag1.get_hwaddr()), master=True, vlan_tci=1)
tl.ping_simple(m1_lag1, m2_lag1)
tl.check_fdb(sw_lag1, m1_lag1.get_hwaddr(), 1, True, False)
# Remove static FDB entry. Ping should fail.
sw_lag1.del_br_fdb(str(m1_lag1.get_hwaddr()), master=True, vlan_tci=1)
tl.ping_simple(m1_lag1, m2_lag1, fail_expected=True)
tl.check_fdb(sw_lag1, m1_lag1.get_hwaddr(), 1, True, False, False)
# Enable learning and flooading and make sure ping works again.
sw_lag1.set_br_learning(on=True, master=True)
sw_lag1.set_br_flooding(on=True, master=True)
tl.ping_simple(m1_lag1, m2_lag1)
tl.check_fdb(sw_lag1, m1_lag1.get_hwaddr(), 1, True, True)
sw_lag1.set_br_learning(on=False, master=True)
sleep(30)
tl.check_fdb(sw_lag1, m1_lag1.get_hwaddr(), 1, True, True, False)
# Insert a static FDB entry. Ping should work.
sw_lag1.add_br_fdb(str(m1_lag1.get_hwaddr()), master=True, vlan_tci=1)
tl.ping_simple(m1_lag1, m2_lag1)
tl.check_fdb(sw_lag1, m1_lag1.get_hwaddr(), 1, True, False)
sleep(30)
# Make sure static entry is not aged out.
tl.check_fdb(sw_lag1, m1_lag1.get_hwaddr(), 1, True, False)
# Remove port from bridge and add it back. The static entry added
# before should be flushed. Disable flooding and learning and make
# sure ping doesn't work.
sw_br.slave_del(sw_lag1.get_id())
sw_br.slave_add(sw_lag1.get_id())
sw_lag1.set_br_learning(on=False, master=True)
sw_lag1.set_br_flooding(on=False, master=True)
tl.ping_simple(m1_lag1, m2_lag1, fail_expected=True)
