def lacp_aggregation_key_packet_validation(topology):
"""
Aggregation Key packet validation:
Capture LACPDUs packets and validate the aggregation
key is set correctly for both switches
"""
sw1 = topology.get('sw1')
sw2 = topology.get('sw2')
sw1_lag_id = '100'
sw2_lag_id = '200'
p11 = sw1.ports['1']
p12 = sw1.ports['2']
p21 = sw2.ports['1']
p22 = sw2.ports['2']
print("Turning on all interfaces used in this test")
ports_sw1 = [p11, p12]
for port in ports_sw1:
turn_on_interface(sw1, port)
ports_sw2 = [p21, p22]
for port in ports_sw2:
turn_on_interface(sw2, port)
print("Wait for interfaces to turn on")
time.sleep(60)
validate_turn_on_interfaces(sw1, ports_sw1)
validate_turn_on_interfaces(sw2, ports_sw2)
print("Create LAG in both switches")
create_lag_active(sw1, sw1_lag_id)
create_lag_passive(sw2, sw2_lag_id)
set_lacp_rate_fast(sw1, sw1_lag_id)
set_lacp_rate_fast(sw2, sw2_lag_id)
print("Associate interfaces [1,2] to lag in both switches")
associate_interface_to_lag(sw1, p11, sw1_lag_id)
associate_interface_to_lag(sw1, p12, sw1_lag_id)
associate_interface_to_lag(sw2, p21, sw2_lag_id)
associate_interface_to_lag(sw2, p22, sw2_lag_id)
sw1_mac = get_device_mac_address(sw1, p11)
print("Take capture from interface 1 in switch 1")
capture = tcpdump_capture_interface(sw1, p11, 80)
tcpdump_capture_interface(sw1, p12, 80)
print("Validate actor and partner key from sw1 packets")
sw1_actor = get_info_from_packet_capture(capture, ACTOR, sw1_mac)
assert sw1_actor['key'] == sw1_lag_id,\
'Packet is not sending the correct actor key in sw1'
sw1_partner = get_info_from_packet_capture(capture, PARTNER, sw1_mac)
assert sw1_partner['key'] == sw2_lag_id,\
'Packet is not sending the correct partner key in sw1'
def change_lacp_mode(sw_list, sw_real_ports, step):
step('Change LAGs to dynamic')
create_lag_active(sw_list[0], LAG_ID)
create_lag_passive(sw_list[1], LAG_ID)
# Verify configuration was successfully applied
for sw, mode in zip(sw_list, ['active', 'passive']):
verify_lag_config(sw,
LAG_ID,
sw_real_ports[sw][0:2],
heartbeat_rate='fast',
mode=mode)
check_func = retry_wrapper('Verify LACP status on both devices',
'Retry to make sure negotiation took place', 5,
15)(verify_lacp_state)
check_func(sw_list[0],
sw_list[1],
sw_real_ports,
sw1_lacp_mode='active',
sw2_lacp_mode='passive')
def test_lag_shutdown_disabled(topology, step):
"""Test LAG with shutdown enabled.
By default a new LAG is configured as 'no shutdown', so this case will
test to execute 'no shutdown' on both switches and connectivity must
remain working and IPv4 pings between both clients must be successful.
"""
sw1 = topology.get('sw1')
sw2 = topology.get('sw2')
hs1 = topology.get('hs1')
hs2 = topology.get('hs2')
sw1_lag_id = '100'
sw2_lag_id = '200'
h1_ip_address = '10.0.0.1'
h2_ip_address = '10.0.0.2'
vlan = '100'
mask = '/24'
ports_sw1 = list()
ports_sw2 = list()
port_labels = ['1', '2', '3']
assert sw1 is not None
assert sw2 is not None
assert hs1 is not None
assert hs2 is not None
print("Configure IP and bring UP in host 1")
hs1.libs.ip.interface('1', addr=(h1_ip_address + mask), up=True)
print("Configure IP and bring UP in host 2")
hs2.libs.ip.interface('1', addr=(h2_ip_address + mask), up=True)
step("Mapping interfaces")
for port in port_labels:
ports_sw1.append(sw1.ports[port])
ports_sw2.append(sw2.ports[port])
step("Turning on all interfaces used in this test")
for port in ports_sw1:
turn_on_interface(sw1, port)
for port in ports_sw2:
turn_on_interface(sw2, port)
step("Validate interfaces are turn on")
verify_turn_on_interfaces(sw1, ports_sw1)
verify_turn_on_interfaces(sw2, ports_sw2)
print("Create LAG in both switches")
create_lag_active(sw1, sw1_lag_id)
create_lag_active(sw2, sw2_lag_id)
print("Configure vlan and switch interfaces")
create_vlan(sw1, vlan)
create_vlan(sw2, vlan)
print("Associate vlan with lag in both switches")
associate_vlan_to_lag(sw1, vlan, sw1_lag_id)
associate_vlan_to_lag(sw2, vlan, sw2_lag_id)
print("Associate vlan with l2 interfaces in both switches")
associate_vlan_to_l2_interface(sw1, vlan, ports_sw1[0])
associate_vlan_to_l2_interface(sw2, vlan, ports_sw2[0])
step("Associate interfaces [2,3] to lag in both switches")
for port in ports_sw1[1:3]:
associate_interface_to_lag(sw1, port, sw1_lag_id)
for port in ports_sw2[1:3]:
associate_interface_to_lag(sw2, port, sw2_lag_id)
step("Verify LAG configuration")
verify_lag_config(sw1, sw1_lag_id, ports_sw1[1:3], mode='active')
verify_lag_config(sw2, sw2_lag_id, ports_sw2[1:3], mode='active')
step("Verify if LAG is synchronized")
verify_state_sync_lag(sw1, ports_sw1[1:3], LOCAL_STATE, 'active')
verify_state_sync_lag(sw1, ports_sw1[1:3], REMOTE_STATE, 'active')
step("Validate interfaces are turn on")
verify_turn_on_interfaces(sw1, ports_sw1[1:3])
verify_turn_on_interfaces(sw2, ports_sw2[1:3])
step("Test connectivity between hosts")
check_connectivity_between_hosts(hs1, h1_ip_address, hs2, h2_ip_address,
10, True)
step("Turn on LAG SW1")
lag_no_shutdown(sw1, sw1_lag_id)
step("Test connectivity between hosts")
check_connectivity_between_hosts(hs1, h1_ip_address, hs2, h2_ip_address,
10, True)
step("Turn on LAG SW2")
lag_no_shutdown(sw2, sw2_lag_id)
step("Test connectivity between hosts")
check_connectivity_between_hosts(hs1, h1_ip_address, hs2, h2_ip_address,
10, True)
step("Validate interfaces are turn on")
verify_turn_on_interfaces(sw1, ports_sw1[1:3])
verify_turn_on_interfaces(sw2, ports_sw2[1:3])
def main_setup(request, topology):
"""Test Case common configuration."""
sw1 = topology.get('sw1')
sw2 = topology.get('sw2')
hs1 = topology.get('hs1')
hs2 = topology.get('hs2')
print('Verifying switches are not None')
assert sw1 is not None, 'Topology failed getting object sw1'
assert sw2 is not None, 'Topology failed getting object sw2'
print('Verifying hosts are not None')
assert hs1 is not None, 'Topology failed getting object hs1'
assert hs2 is not None, 'Topology failed getting object hs2'
ports_sw1 = list()
ports_sw2 = list()
print("Mapping interfaces")
for port in port_labels:
ports_sw1.append(sw1.ports[port])
ports_sw2.append(sw2.ports[port])
print("Turning on all interfaces used in this test")
for port in ports_sw1:
turn_on_interface(sw1, port)
for port in ports_sw2:
turn_on_interface(sw2, port)
print("Validate interfaces are turn on")
verify_turn_on_interfaces(sw1, ports_sw1)
verify_turn_on_interfaces(sw2, ports_sw2)
print('Creating VLAN (%s) on Switch 1' % test_vlan)
create_vlan(sw1, test_vlan)
print('Creating VLAN (%s) on Switch 2' % test_vlan)
create_vlan(sw2, test_vlan)
print('Creating LAG (%s) active on Switch 1' % test_lag)
create_lag_active(sw1, test_lag)
print('Executing "show lacp aggregates" on Switch 1')
verify_show_lacp_aggregates(sw1, test_lag_if, 'active')
print('Associating VLAN (%s) to LAG (%s)' % (test_vlan, test_lag))
associate_vlan_to_lag(sw1, test_vlan, test_lag)
print('Creating LAG (%s) passive on Switch 2' % test_lag)
create_lag_passive(sw2, test_lag)
print('Executing "show lacp aggregates" on Switch 2')
verify_show_lacp_aggregates(sw2, test_lag_if, 'passive')
print('Associating VLAN (%s) to LAG (%s)' % (test_vlan, test_lag))
associate_vlan_to_lag(sw2, test_vlan, test_lag)
print('Configuring IP address to Host 1')
hs1.libs.ip.interface('1',
addr='%s/24' % hs1_addr,
up=True)
print('Configuring IP address to Host 2')
hs2.libs.ip.interface('1',
addr='%s/24' % hs2_addr,
up=True)
print("Associate interfaces to LAG in both switches")
for port in ports_sw1[0:2]:
associate_interface_to_lag(sw1, port, test_lag)
for port in ports_sw2[0:2]:
associate_interface_to_lag(sw2, port, test_lag)
for switch in [sw1, sw2]:
# Interface 4 is connected to one host
associate_vlan_to_l2_interface(switch, test_vlan, switch.ports['3'])
# Adding small delay to compensate for framework delay
sleep(10)
print('Verify connectivity between hosts')
verify_connectivity_between_hosts(hs1, hs1_addr, hs2, hs2_addr, True)
def test_lacp_aggregation_key_with_hosts(topology):
"""
Case 1:
A single switch should form LAGs to 2 different
other switches as long as the aggregation key is
the same through members of a single LAG, but
ports should be blocked if 1 of the members is
configured to be a member of the LAG going to a different switch
"""
sw1 = topology.get('sw1')
sw2 = topology.get('sw2')
sw3 = topology.get('sw3')
hs1 = topology.get('hs1')
hs2 = topology.get('hs2')
hs3 = topology.get('hs3')
assert sw1 is not None
assert sw2 is not None
sw1_lag_id = '10'
sw2_lag_id = '20'
sw3_lag_id = '310' # With switch 1
sw3_lag_id_2 = '320' # With switch 2
sw1_vlan = '100'
sw2_vlan = '200'
sw3_sw1_vlan = '100'
sw3_sw2_vlan = '200'
hs1_ip = '10.0.10.1'
hs2_ip = '10.0.20.1'
hs3_ip_1 = '10.0.10.2'
hs3_ip_2 = '10.0.20.2'
mask = '/24'
ports_sw1 = list()
ports_sw2 = list()
ports_sw3 = list()
print("Mapping interfaces")
for port in port_labels[0:3]:
ports_sw1.append(sw1.ports[port])
for port in port_labels[0:2]:
ports_sw2.append(sw2.ports[port])
for port in port_labels:
ports_sw3.append(sw3.ports[port])
step("Sorting the port list")
ports_sw1.sort()
ports_sw2.sort()
ports_sw3.sort()
p13h = ports_sw1[2]
p22h = ports_sw2[1]
p32 = ports_sw3[1]
p34h = ports_sw3[3]
print("Turning on all interfaces used in this test")
for port in ports_sw1:
turn_on_interface(sw1, port)
for port in ports_sw2:
turn_on_interface(sw2, port)
for port in ports_sw3:
turn_on_interface(sw3, port)
print("Verify all interface are up")
verify_turn_on_interfaces(sw1, ports_sw1)
verify_turn_on_interfaces(sw2, ports_sw2)
verify_turn_on_interfaces(sw3, ports_sw3)
step("Create LAG in all switches")
create_lag_active(sw1, sw1_lag_id)
create_lag_active(sw2, sw2_lag_id)
create_lag_active(sw3, sw3_lag_id)
create_lag_active(sw3, sw3_lag_id_2)
set_lacp_rate_fast(sw1, sw1_lag_id)
set_lacp_rate_fast(sw2, sw2_lag_id)
set_lacp_rate_fast(sw3, sw3_lag_id)
set_lacp_rate_fast(sw3, sw3_lag_id_2)
step("Associate interfaces with LAG")
for intf in ports_sw1[0:2]:
associate_interface_to_lag(sw1, intf, sw1_lag_id)
associate_interface_to_lag(sw2, ports_sw2[0], sw2_lag_id)
for intf in ports_sw3[0:2]:
associate_interface_to_lag(sw3, intf, sw3_lag_id)
associate_interface_to_lag(sw3, ports_sw3[2], sw3_lag_id_2)
step("Configure IP and bring UP in host 1")
hs1.libs.ip.interface('1', addr=(hs1_ip + mask), up=True)
step("Configure IP and bring UP in host 2")
hs2.libs.ip.interface('1', addr=(hs2_ip + mask), up=True)
step("Configure IP and bring UP in host 3")
hs3.libs.ip.interface('1', addr=(hs3_ip_1 + mask), up=True)
create_vlan(sw1, sw1_vlan)
create_vlan(sw2, sw2_vlan)
create_vlan(sw3, sw3_sw1_vlan)
create_vlan(sw3, sw3_sw2_vlan)
associate_vlan_to_lag(sw1, sw1_vlan, sw1_lag_id)
associate_vlan_to_lag(sw2, sw2_vlan, sw2_lag_id)
associate_vlan_to_lag(sw3, sw3_sw1_vlan, sw3_lag_id)
associate_vlan_to_lag(sw3, sw3_sw2_vlan, sw3_lag_id_2)
# First associate Host 3 with Vlan from Switch 1
step("Configure connection between Host 1 and 3")
associate_vlan_to_l2_interface(sw1, sw1_vlan, p13h)
associate_vlan_to_l2_interface(sw3, sw3_sw1_vlan, p34h)
validate_vlan_state(sw1, sw1_vlan, "up")
validate_vlan_state(sw3, sw3_sw1_vlan, "up")
step("#### Test ping between clients work ####")
verify_connectivity_between_hosts(hs1, hs1_ip, hs3, hs3_ip_1)
# Then associate Host 3 with Vlan from Switch 2
step("Configure connection between Host 2 and 3")
associate_vlan_to_l2_interface(sw2, sw2_vlan, p22h)
associate_vlan_to_l2_interface(sw3, sw3_sw2_vlan, p34h)
validate_vlan_state(sw2, sw2_vlan, "up")
validate_vlan_state(sw3, sw3_sw2_vlan, "up")
hs3.libs.ip.remove_ip('1', addr=(hs3_ip_1 + mask))
hs3.libs.ip.interface('1', addr=(hs3_ip_2 + mask), up=True)
step("Check connectivty between Host 2 and 3")
verify_connectivity_between_hosts(hs2, hs2_ip, hs3, hs3_ip_2)
step("Setting up priorities")
with sw1.libs.vtysh.ConfigInterface(ports_sw1[0]) as ctx:
ctx.lacp_port_priority(1)
with sw1.libs.vtysh.ConfigInterface(ports_sw1[1]) as ctx:
ctx.lacp_port_priority(10)
with sw3.libs.vtysh.ConfigInterface(ports_sw3[0]) as ctx:
ctx.lacp_port_priority(1)
with sw3.libs.vtysh.ConfigInterface(ports_sw3[1]) as ctx:
ctx.lacp_port_priority(10)
step("Changing interface 2 from Switch 3 to LAG with Switch 2")
associate_interface_to_lag(sw3, p32, sw3_lag_id_2)
# This should get the interface Out of Sync because that
# interface is linked with Switch 1
# Only the link 2 should be get out of sync
verify_state_out_of_sync_lag(sw1, [ports_sw1[1]], LOCAL_STATE)
verify_state_out_of_sync_lag(sw3, [ports_sw3[1]], LOCAL_STATE)
verify_state_sync_lag(sw1, [ports_sw1[0]], LOCAL_STATE, 'active')
verify_state_sync_lag(sw2, [ports_sw2[0]], LOCAL_STATE, 'active')
verify_state_sync_lag(sw3, [ports_sw3[0]], LOCAL_STATE, 'active')
verify_state_sync_lag(sw3, [ports_sw3[2]], LOCAL_STATE, 'active')
step("Check connectivity between Host 2 and 3 again")
verify_connectivity_between_hosts(hs2, hs2_ip, hs3, hs3_ip_2)
step("Change configuration to connect Host 1 and 3 again")
associate_vlan_to_l2_interface(sw3, sw3_sw1_vlan, p34h)
validate_vlan_state(sw3, sw3_sw1_vlan, "up")
hs3.libs.ip.remove_ip('1', addr=(hs3_ip_2 + mask))
hs3.libs.ip.interface('1', addr=(hs3_ip_1 + mask), up=True)
step("Check connectivity between Host 1 and Host 3")
verify_connectivity_between_hosts(hs1, hs1_ip, hs3, hs3_ip_1)
def main_setup(request, topology):
"""Test Suite Common Topology."""
sw1 = topology.get('sw1')
sw2 = topology.get('sw2')
print('Verifying switches are not None')
assert sw1 is not None
assert sw2 is not None
for port in port_labels:
ports_sw1.append(sw1.ports[port])
ports_sw2.append(sw2.ports[port])
print("Sorting the port list")
ports_sw1.sort()
ports_sw2.sort()
print("#### Turning on interfaces in sw1 ###")
for port in ports_sw1:
turn_on_interface(sw1, port)
print("#### Turning on interfaces in sw2 ###")
for port in ports_sw2:
turn_on_interface(sw2, port)
print('Verifying interfaces of Switch 1')
verify_turn_on_interfaces(sw1, ports_sw1)
print('Verifying interfaces of Switch 2')
verify_turn_on_interfaces(sw2, ports_sw2)
mac_addr_sw1 = sw1.libs.vtysh.show_interface('1')['mac_address']
mac_addr_sw2 = sw2.libs.vtysh.show_interface('1')['mac_address']
assert mac_addr_sw1 != mac_addr_sw2, \
'Mac address of interfaces in sw1 is equal to mac address of ' + \
'interfaces in sw2. This is a test framework problem. Dynamic ' + \
'LAGs cannot work properly under this condition. Refer to Taiga ' + \
'issue #1251.'
print('Creating LAG %s on Switch 1' % sw1_lag_id)
create_lag_active(sw1, sw1_lag_id)
print('Creating LAG %s on Switch 2' % sw2_lag_id)
create_lag_active(sw2, sw2_lag_id)
print('Setting LAG %s to "fast" on Switch 1' % sw1_lag_id)
set_lag_rate(sw1, sw1_lag_id, 'fast')
print('Setting LAG %s to "fast" on Switch 2' % sw2_lag_id)
set_lag_rate(sw2, sw2_lag_id, 'fast')
for port in ports_sw1:
print('Associate interfaces %s to lag on Switch 1' % port)
associate_interface_to_lag(sw1, port, sw1_lag_id)
for port in ports_sw2:
print('Associate interfaces %s to lag on Switch 2' % port)
associate_interface_to_lag(sw2, port, sw2_lag_id)
print("Verify state machines in all switches")
"""
The interface 1 and 2 of sw1 must be collecting and distributing
"""
verify_actor_state('asfncd', [sw1], ports_sw1)
verify_actor_state('asfncd', [sw2], ports_sw2)
def test_lacp_agg_key_move_interface(topology):
"""
Case 1:
Verify aggregation key functionality when
interface is moved to another LAG in one of
the switches from the topology
Initial Topology:
SW1>
LAG100 -> Interfaces: 1,2
SW2>
LAG100 -> Interfaces: 1,2
Final Topology:
SW1>
LAG200 -> Interfaces: 1,3
LAG100 -> Interfaces: 2,4
SW2>
LAG100 -> Interfaces: 1,2
Expected behaviour:
Interface 1 should not be in Collecting/Distributing
state in neither switch.
"""
sw1 = topology.get('sw1')
sw2 = topology.get('sw2')
sw1_lag_id = '100'
sw1_lag_id_2 = '200'
sw2_lag_id = '100'
assert sw1 is not None
assert sw2 is not None
p11 = sw1.ports['1']
p12 = sw1.ports['2']
p13 = sw1.ports['3']
p14 = sw1.ports['4']
p21 = sw2.ports['1']
p22 = sw2.ports['2']
p23 = sw2.ports['3']
p24 = sw2.ports['4']
print("Turning on all interfaces used in this test")
ports_sw1 = [p11, p12, p13, p14]
for port in ports_sw1:
turn_on_interface(sw1, port)
ports_sw2 = [p21, p22, p23, p24]
for port in ports_sw2:
turn_on_interface(sw2, port)
print("Waiting for interfaces to turn on")
time.sleep(60)
print("Validate interfaces are turn on")
validate_turn_on_interfaces(sw1, ports_sw1)
validate_turn_on_interfaces(sw2, ports_sw2)
print("Create LAG in both switches")
create_lag_active(sw1, sw1_lag_id)
create_lag_active(sw2, sw2_lag_id)
set_lacp_rate_fast(sw1, sw1_lag_id)
set_lacp_rate_fast(sw2, sw2_lag_id)
print("Associate interfaces [1,2] to lag in both switches")
associate_interface_to_lag(sw1, p11, sw1_lag_id)
associate_interface_to_lag(sw1, p12, sw1_lag_id)
associate_interface_to_lag(sw2, p21, sw2_lag_id)
associate_interface_to_lag(sw2, p22, sw2_lag_id)
# Without this sleep time, we are validating temporary
# states in state machines
print("Waiting for LAG negotations between switches")
time.sleep(80)
print("Get information for LAG in interface 1 with both switches")
map_lacp_sw1 = sw1.libs.vtysh.show_lacp_interface(p11)
map_lacp_sw2 = sw2.libs.vtysh.show_lacp_interface(p21)
print("Get the state of LAGs using diag-dump lacp basic in both switches")
sw1_lacp_state = get_diagdump_lacp_state(sw1)
sw2_lacp_state = get_diagdump_lacp_state(sw2)
map_diagdump_lacp_sw1_p11 = sw1_lacp_state[str(sw1_lag_id)][int(p11)]
map_diagdump_lacp_sw2_p21 = sw2_lacp_state[str(sw2_lag_id)][int(p21)]
print("Get the configured interfaces for each LAG using diag-dump " +
"lacp basic in both switches")
sw1_lacp_interfaces = get_diagdump_lacp_interfaces(sw1)
sw2_lacp_interfaces = get_diagdump_lacp_interfaces(sw2)
validate_diagdump_lacp_interfaces(sw1_lacp_interfaces, sw1_lag_id,
[p11, p12], [p11, p12], [p11, p12])
validate_diagdump_lacp_interfaces(sw2_lacp_interfaces, sw2_lag_id,
[p21, p22], [p21, p22], [p21, p22])
print("Validate the LAG was created in both switches")
validate_lag_name(map_lacp_sw1, sw1_lag_id)
validate_local_key(map_lacp_sw1, sw1_lag_id)
validate_remote_key(map_lacp_sw1, sw2_lag_id)
validate_lag_state_sync(map_lacp_sw1, LOCAL_STATE)
validate_lag_state_sync(map_lacp_sw1, REMOTE_STATE)
# Validate diag-dump results
validate_diagdump_lag_state_sync(map_diagdump_lacp_sw1_p11,
DIAG_DUMP_LOCAL_STATE)
validate_diagdump_lag_state_sync(map_diagdump_lacp_sw1_p11,
DIAG_DUMP_REMOTE_STATE)
validate_lag_name(map_lacp_sw2, sw2_lag_id)
validate_local_key(map_lacp_sw2, sw2_lag_id)
validate_remote_key(map_lacp_sw2, sw1_lag_id)
validate_lag_state_sync(map_lacp_sw2, LOCAL_STATE)
validate_lag_state_sync(map_lacp_sw2, REMOTE_STATE)
# Validate diag-dump results
validate_diagdump_lag_state_sync(map_diagdump_lacp_sw2_p21,
DIAG_DUMP_LOCAL_STATE)
validate_diagdump_lag_state_sync(map_diagdump_lacp_sw2_p21,
DIAG_DUMP_REMOTE_STATE)
print("Changing interface 1 to lag 200 in switch 1")
create_lag_active(sw1, sw1_lag_id_2)
set_lacp_rate_fast(sw1, sw1_lag_id_2)
associate_interface_to_lag(sw1, p11, sw1_lag_id_2)
associate_interface_to_lag(sw1, p13, sw1_lag_id_2)
associate_interface_to_lag(sw1, p14, sw1_lag_id)
# Waiting for switch 1 to update LAG status with newest configuration
print("Waiting for LAG update withe new configuration")
time.sleep(30)
print("Get information from LAG in interface 1 with both switches")
map_lacp_sw1_p11 = sw1.libs.vtysh.show_lacp_interface(p11)
map_lacp_sw1_p12 = sw1.libs.vtysh.show_lacp_interface(p12)
map_lacp_sw1_p13 = sw1.libs.vtysh.show_lacp_interface(p13)
map_lacp_sw1_p14 = sw1.libs.vtysh.show_lacp_interface(p14)
map_lacp_sw2_p21 = sw2.libs.vtysh.show_lacp_interface(p21)
map_lacp_sw2_p22 = sw2.libs.vtysh.show_lacp_interface(p22)
print("Get the state of LAGs using diag-dump lacp basic in both switches")
sw1_lacp_state = get_diagdump_lacp_state(sw1)
sw2_lacp_state = get_diagdump_lacp_state(sw2)
map_diagdump_lacp_sw1_p11 = sw1_lacp_state[str(sw1_lag_id_2)][int(p11)]
map_diagdump_lacp_sw1_p12 = sw1_lacp_state[str(sw1_lag_id)][int(p12)]
map_diagdump_lacp_sw2_p21 = sw2_lacp_state[str(sw2_lag_id)][int(p21)]
map_diagdump_lacp_sw2_p22 = sw2_lacp_state[str(sw2_lag_id)][int(p22)]
print("Get the configured interfaces for each LAG using diagdump " +
"getlacpinterfaces in both switches")
sw1_lacp_interfaces = get_diagdump_lacp_interfaces(sw1)
sw2_lacp_interfaces = get_diagdump_lacp_interfaces(sw2)
validate_diagdump_lacp_interfaces(sw1_lacp_interfaces, sw1_lag_id,
[p12, p24], [p12, p24], [p12])
validate_diagdump_lacp_interfaces(sw1_lacp_interfaces, sw1_lag_id_2,
[p11, p13], [p11, p13], [])
validate_diagdump_lacp_interfaces(sw2_lacp_interfaces, sw2_lag_id,
[p21, p22], [p21, p22], [p22])
print("Validate lag is out of sync in interface 1 in both switches")
validate_lag_name(map_lacp_sw1_p11, sw1_lag_id_2)
validate_local_key(map_lacp_sw1_p11, sw1_lag_id_2)
validate_remote_key(map_lacp_sw1_p11, sw2_lag_id)
validate_lag_state_afn(map_lacp_sw1_p11, LOCAL_STATE)
validate_lag_state_sync(map_lacp_sw1_p12, LOCAL_STATE)
validate_lag_state_default_neighbor(map_lacp_sw1_p13, LOCAL_STATE)
validate_lag_state_default_neighbor(map_lacp_sw1_p14, LOCAL_STATE)
# Validate diag-dump results
validate_diagdump_lag_state_afn(map_diagdump_lacp_sw1_p11,
DIAG_DUMP_LOCAL_STATE)
validate_diagdump_lag_state_sync(map_diagdump_lacp_sw1_p12,
DIAG_DUMP_LOCAL_STATE)
validate_lag_name(map_lacp_sw2_p21, sw2_lag_id)
validate_local_key(map_lacp_sw2_p21, sw2_lag_id)
validate_remote_key(map_lacp_sw2_p21, sw1_lag_id_2)
validate_lag_state_out_of_sync(map_lacp_sw2_p21, LOCAL_STATE)
validate_lag_state_sync(map_lacp_sw2_p22, LOCAL_STATE)
# Validate diag-dump results
validate_diagdump_lag_state_out_sync(map_diagdump_lacp_sw2_p21,
DIAG_DUMP_LOCAL_STATE)
validate_diagdump_lag_state_sync(map_diagdump_lacp_sw2_p22,
DIAG_DUMP_LOCAL_STATE)
def test_lacp_agg_key_more_than_one_lag_connected(topology):
"""
Case 2:
Verify only interfaces associated with the same
aggregation key get to Collecting/Distributing state
Initial Topology:
SW1>
LAG150 -> Interfaces: 1,2,3,4
SW2>
LAG150 -> Interfaces: 1,2
LAG400 -> Interfaces: 3,4
Expected behaviour:
Interfaces 1 and 2 in both switches get state Active, InSync,
Collecting and Distributing. Interfaces 3 and 4 should get state
Active, OutOfSync, Collecting and Distributing
"""
sw1 = topology.get('sw1')
sw2 = topology.get('sw2')
sw1_lag_id = '150'
sw2_lag_id = '150'
sw2_lag_id_2 = '400'
assert sw1 is not None
assert sw2 is not None
ports_sw1 = list()
ports_sw2 = list()
port_labels = ['1', '2', '3', '4']
step("Mapping interfaces")
for port in port_labels:
ports_sw1.append(sw1.ports[port])
ports_sw2.append(sw2.ports[port])
step("Sorting the port list")
ports_sw1.sort()
ports_sw2.sort()
step("Turning on all interfaces used in this test")
for port in ports_sw1:
turn_on_interface(sw1, port)
for port in ports_sw2:
turn_on_interface(sw2, port)
step("Verify interfaces to turn on")
verify_turn_on_interfaces(sw1, ports_sw1)
verify_turn_on_interfaces(sw2, ports_sw2)
mac_addr_sw1 = sw1.libs.vtysh.show_interface('1')['mac_address']
mac_addr_sw2 = sw2.libs.vtysh.show_interface('1')['mac_address']
assert mac_addr_sw1 != mac_addr_sw2, \
'Mac address of interfaces in sw1 is equal to mac address of ' + \
'interfaces in sw2. This is a test framework problem. Dynamic ' + \
'LAGs cannot work properly under this condition. Refer to Taiga ' + \
'issue #1251.'
step("Create LAG in both switches")
create_lag_active(sw1, sw1_lag_id)
create_lag_active(sw2, sw2_lag_id)
create_lag_active(sw2, sw2_lag_id_2)
set_lacp_rate_fast(sw1, sw1_lag_id)
set_lacp_rate_fast(sw2, sw2_lag_id)
set_lacp_rate_fast(sw2, sw2_lag_id_2)
step("Associate interfaces to lag in both switches")
for interface in ports_sw1:
associate_interface_to_lag(sw1, interface, sw1_lag_id)
for interface in ports_sw2[0:2]:
associate_interface_to_lag(sw2, interface, sw2_lag_id)
for interface in ports_sw2[2:4]:
associate_interface_to_lag(sw2, interface, sw2_lag_id_2)
step("#### Verify LAG configuration ####")
verify_lag_config(sw1, sw1_lag_id, ports_sw1, 'fast', mode='active')
verify_lag_config(sw2, sw2_lag_id, ports_sw2[0:2], 'fast', mode='active')
verify_lag_config(sw2, sw2_lag_id_2, ports_sw2[2:4], 'fast', mode='active')
step("Get the configured interfaces for each LAG using diag-dump " +
"lacp basic in both switches")
time.sleep(60)
sw1_lacp_interfaces = get_diagdump_lacp_interfaces(sw1)
sw2_lacp_interfaces = get_diagdump_lacp_interfaces(sw2)
validate_diagdump_lacp_interfaces(sw1_lacp_interfaces, sw1_lag_id,
ports_sw1, ports_sw1,
[ports_sw1[0], ports_sw1[1]])
validate_diagdump_lacp_interfaces(sw2_lacp_interfaces, sw2_lag_id,
[ports_sw2[0], ports_sw2[1]],
[ports_sw2[0], ports_sw2[1]],
[ports_sw2[0], ports_sw2[1]])
validate_diagdump_lacp_interfaces(sw2_lacp_interfaces, sw2_lag_id_2,
[ports_sw2[2], ports_sw2[3]],
[ports_sw2[2], ports_sw2[3]], [])
step("Get information for LAG in interface 1 with both switches")
map_lacp_sw1_p11 = sw1.libs.vtysh.show_lacp_interface(ports_sw1[0])
map_lacp_sw1_p12 = sw1.libs.vtysh.show_lacp_interface(ports_sw1[1])
map_lacp_sw1_p13 = sw1.libs.vtysh.show_lacp_interface(ports_sw1[2])
map_lacp_sw1_p14 = sw1.libs.vtysh.show_lacp_interface(ports_sw1[3])
map_lacp_sw2_p21 = sw2.libs.vtysh.show_lacp_interface(ports_sw2[0])
map_lacp_sw2_p22 = sw2.libs.vtysh.show_lacp_interface(ports_sw2[1])
map_lacp_sw2_p23 = sw2.libs.vtysh.show_lacp_interface(ports_sw2[2])
map_lacp_sw2_p24 = sw2.libs.vtysh.show_lacp_interface(ports_sw2[3])
step("Get the state of LAGs using diag-dump lacp basic in both switches")
sw1_lacp_state = get_diagdump_lacp_state(sw1)
sw2_lacp_state = get_diagdump_lacp_state(sw2)
# Recast labels to work with the library output
ports_sw1[:] = [int(x) if x.isdigit() else x for x in ports_sw1]
ports_sw2[:] = [int(x) if x.isdigit() else x for x in ports_sw2]
map_diagdump_lacp_sw1_p11 = sw1_lacp_state[str(sw1_lag_id)][ports_sw1[0]]
map_diagdump_lacp_sw1_p12 = sw1_lacp_state[str(sw1_lag_id)][ports_sw1[1]]
map_diagdump_lacp_sw1_p13 = sw1_lacp_state[str(sw1_lag_id)][ports_sw1[2]]
map_diagdump_lacp_sw1_p14 = sw1_lacp_state[str(sw1_lag_id)][ports_sw1[3]]
map_diagdump_lacp_sw2_p21 = sw2_lacp_state[str(sw2_lag_id)][ports_sw2[0]]
map_diagdump_lacp_sw2_p22 = sw2_lacp_state[str(sw2_lag_id)][ports_sw2[1]]
map_diagdump_lacp_sw2_p23 = sw2_lacp_state[str(sw2_lag_id_2)][ports_sw2[2]]
map_diagdump_lacp_sw2_p24 = sw2_lacp_state[str(sw2_lag_id_2)][ports_sw2[3]]
step("Validate the LAG was created in both switches")
validate_lag_state_sync(map_lacp_sw1_p11, LOCAL_STATE)
validate_lag_state_sync(map_lacp_sw1_p12, LOCAL_STATE)
validate_lag_state_out_of_sync(map_lacp_sw1_p13, LOCAL_STATE)
validate_lag_state_out_of_sync(map_lacp_sw1_p14, LOCAL_STATE)
validate_lag_state_sync(map_lacp_sw2_p21, LOCAL_STATE)
validate_lag_state_sync(map_lacp_sw2_p22, LOCAL_STATE)
validate_lag_state_afn(map_lacp_sw2_p23, LOCAL_STATE)
validate_lag_state_afn(map_lacp_sw2_p24, LOCAL_STATE)
# Validate diag-dump results
validate_diagdump_lag_state_sync(map_diagdump_lacp_sw1_p11,
DIAG_DUMP_LOCAL_STATE)
validate_diagdump_lag_state_sync(map_diagdump_lacp_sw1_p12,
DIAG_DUMP_LOCAL_STATE)
validate_diagdump_lag_state_out_sync(map_diagdump_lacp_sw1_p13,
DIAG_DUMP_LOCAL_STATE)
validate_diagdump_lag_state_out_sync(map_diagdump_lacp_sw1_p14,
DIAG_DUMP_LOCAL_STATE)
validate_diagdump_lag_state_sync(map_diagdump_lacp_sw2_p21,
DIAG_DUMP_LOCAL_STATE)
validate_diagdump_lag_state_sync(map_diagdump_lacp_sw2_p22,
DIAG_DUMP_LOCAL_STATE)
validate_diagdump_lag_state_afn(map_diagdump_lacp_sw2_p23,
DIAG_DUMP_LOCAL_STATE)
validate_diagdump_lag_state_afn(map_diagdump_lacp_sw2_p24,
DIAG_DUMP_LOCAL_STATE)
def test_lag_shutdown_enabled(topology, step):
"""Test LAG with shutdown enabled.
When lag shutdown is enabled IPv4 ping must be unsuccessful, after
configuring LAGs as no shutdown IPv4 ping must be successful
"""
sw1 = topology.get('sw1')
sw2 = topology.get('sw2')
hs1 = topology.get('hs1')
hs2 = topology.get('hs2')
sw1_lag_id = '100'
sw2_lag_id = '200'
h1_ip_address = '10.0.0.1'
h2_ip_address = '10.0.0.2'
vlan = '100'
mask = '/24'
ports_sw1 = list()
ports_sw2 = list()
port_labels = ['1', '2', '3']
assert sw1 is not None
assert sw2 is not None
assert hs1 is not None
assert hs2 is not None
step("Configure IP and bring UP in host 1")
hs1.libs.ip.interface('1', addr=h1_ip_address + mask, up=True)
step("Configure IP and bring UP in host 2")
hs2.libs.ip.interface('1', addr=h2_ip_address + mask, up=True)
step("Mapping interfaces")
for port in port_labels:
ports_sw1.append(sw1.ports[port])
ports_sw2.append(sw2.ports[port])
step("Turning on all interfaces used in this test")
for port in ports_sw1:
turn_on_interface(sw1, port)
for port in ports_sw2:
turn_on_interface(sw2, port)
step("Validate interfaces are turn on")
verify_turn_on_interfaces(sw1, ports_sw1)
verify_turn_on_interfaces(sw2, ports_sw2)
step("Create LAG in both switches")
create_lag_passive(sw1, sw1_lag_id)
create_lag_active(sw2, sw2_lag_id)
step("Configure vlan and switch interfaces")
create_vlan(sw1, vlan)
create_vlan(sw2, vlan)
step("Associate vlan with lag in both switches")
associate_vlan_to_lag(sw1, vlan, sw1_lag_id)
associate_vlan_to_lag(sw2, vlan, sw2_lag_id)
step("Associate vlan with l2 interfaces in both switches")
associate_vlan_to_l2_interface(sw1, vlan, ports_sw1[0])
associate_vlan_to_l2_interface(sw2, vlan, ports_sw2[0])
step("Associate interfaces [2,3] to lag in both switches")
for port in ports_sw1[1:3]:
associate_interface_to_lag(sw1, port, sw1_lag_id)
for port in ports_sw2[1:3]:
associate_interface_to_lag(sw2, port, sw2_lag_id)
step("Verify LAG configuration")
verify_lag_config(sw1, sw1_lag_id, ports_sw1[1:3], mode='passive')
verify_lag_config(sw2, sw2_lag_id, ports_sw2[1:3], mode='active')
step("Verify if LAG is synchronized")
verify_state_sync_lag(sw1, ports_sw1[1:3], LOCAL_STATE, 'passive')
verify_state_sync_lag(sw1, ports_sw1[1:3], REMOTE_STATE, 'active')
step("Test connectivity between hosts")
check_connectivity_between_hosts(hs1, h1_ip_address, hs2, h2_ip_address,
10, True)
step("Turn off LAG in SW1")
lag_shutdown(sw1, sw1_lag_id)
step("Negative test connectivity between hosts")
check_connectivity_between_hosts(hs1, h1_ip_address, hs2, h2_ip_address,
10, False)
step("Turn off LAG in SW2")
lag_shutdown(sw2, sw2_lag_id)
step("Negative test connectivity between hosts")
check_connectivity_between_hosts(hs1, h1_ip_address, hs2, h2_ip_address,
10, False)
step("Verify all interface are down")
verify_turn_off_interfaces(sw1, ports_sw1[1:3])
verify_turn_off_interfaces(sw2, ports_sw2[1:3])
step("Turn on LAG")
lag_no_shutdown(sw1, sw1_lag_id)
lag_no_shutdown(sw2, sw2_lag_id)
step("Verify all interface are up")
verify_turn_on_interfaces(sw1, ports_sw1[1:3])
verify_turn_on_interfaces(sw2, ports_sw2[1:3])
step("Verify if LAG is synchronized")
verify_state_sync_lag(sw1, ports_sw1[1:3], LOCAL_STATE, 'passive')
verify_state_sync_lag(sw1, ports_sw1[1:3], REMOTE_STATE, 'active')
step("Test connectivity between hosts")
check_connectivity_between_hosts(hs1, h1_ip_address, hs2, h2_ip_address,
10, True)
def test_lacp_agg_key_cross_links(topology, step):
"""
Case 3:
Verify LAGs should be formed independent of port ids as long
as aggregation key is the same
Initial Topology:
SW1>
LAG150 -> Interfaces: 1,5
LAG250 -> Interfaces: 2,6
LAG350 -> Interfaces: 3,7
SW2>
LAG150 -> Interfaces: 1,6
LAG250 -> Interfaces: 2,7
LAG350 -> Interfaces: 3,5
Expected behaviour:
All interfaces in all LAGs should be InSync, Collecting
and Distributing state
"""
sw1 = topology.get('sw1')
sw2 = topology.get('sw2')
lag_id_1 = '150'
lag_id_2 = '250'
lag_id_3 = '350'
sw_lag_id = [lag_id_1, lag_id_2, lag_id_3]
assert sw1 is not None
assert sw2 is not None
ports_sw1 = list()
ports_sw2 = list()
port_labels = ['1', '2', '3', '4', '5', '6', '7']
step("### Mapping interfaces from Docker ###")
for port in port_labels:
ports_sw1.append(sw1.ports[port])
ports_sw2.append(sw2.ports[port])
step("#### Turning on interfaces in sw1 ###")
for port in ports_sw1:
turn_on_interface(sw1, port)
step("#### Turning on interfaces in sw2 ###")
for port in ports_sw2:
turn_on_interface(sw2, port)
step("#### Validate interfaces are turn on ####")
verify_turn_on_interfaces(sw1, ports_sw1)
verify_turn_on_interfaces(sw2, ports_sw2)
mac_addr_sw1 = sw1.libs.vtysh.show_interface(1)['mac_address']
mac_addr_sw2 = sw2.libs.vtysh.show_interface(1)['mac_address']
assert mac_addr_sw1 != mac_addr_sw2, \
'Mac address of interfaces in sw1 is equal to mac address of ' + \
'interfaces in sw2. This is a test framework problem. Dynamic ' + \
'LAGs cannot work properly under this condition. Refer to Taiga ' + \
'issue #1251.'
step("Create LAGs (150, 250 and 350) in both switches")
for lag in sw_lag_id:
create_lag_active(sw1, lag)
create_lag_active(sw2, lag)
set_lacp_rate_fast(sw1, lag)
set_lacp_rate_fast(sw2, lag)
p11 = sw1.ports['1']
p12 = sw1.ports['2']
p13 = sw1.ports['3']
p15 = sw1.ports['5']
p16 = sw1.ports['6']
p17 = sw1.ports['7']
p21 = sw2.ports['1']
p22 = sw2.ports['2']
p23 = sw2.ports['3']
p25 = sw2.ports['5']
p26 = sw2.ports['6']
p27 = sw2.ports['7']
step("#### Associate Interfaces to LAG ####")
step("Associate interfaces with LAG in switch1")
associate_interface_to_lag(sw1, p11, lag_id_1)
associate_interface_to_lag(sw1, p15, lag_id_1)
associate_interface_to_lag(sw1, p12, lag_id_2)
associate_interface_to_lag(sw1, p16, lag_id_2)
associate_interface_to_lag(sw1, p13, lag_id_3)
associate_interface_to_lag(sw1, p17, lag_id_3)
step("Associate interfaces with LAG in switch2")
associate_interface_to_lag(sw2, p21, lag_id_1)
associate_interface_to_lag(sw2, p26, lag_id_1)
associate_interface_to_lag(sw2, p22, lag_id_2)
associate_interface_to_lag(sw2, p27, lag_id_2)
associate_interface_to_lag(sw2, p23, lag_id_3)
associate_interface_to_lag(sw2, p25, lag_id_3)
step("#### Verify LAG configuration ####")
verify_lag_config(sw1,
lag_id_1, [p11, p15],
mode='active',
heartbeat_rate='fast')
verify_lag_config(sw1,
lag_id_2, [p12, p16],
mode='active',
heartbeat_rate='fast')
verify_lag_config(sw1,
lag_id_3, [p13, p17],
mode='active',
heartbeat_rate='fast')
verify_lag_config(sw2,
lag_id_1, [p21, p26],
mode='active',
heartbeat_rate='fast')
verify_lag_config(sw2,
lag_id_2, [p22, p27],
mode='active',
heartbeat_rate='fast')
verify_lag_config(sw2,
lag_id_3, [p23, p25],
mode='active',
heartbeat_rate='fast')
ports_sw1.remove('4')
ports_sw2.remove('4')
step("Validate correct state in switch1 for interfaces")
verify_state_sync_lag(sw1, ports_sw1, LOCAL_STATE, 'active')
step("Validate correct state in switch2 for interfaces")
verify_state_sync_lag(sw2, ports_sw2, LOCAL_STATE, 'active')
def test_lacp_different_aggregation_keys(topology):
"""
Case 4:
Verify LAGs with different names from switches can
get connected as long as all interfaces connected have
same aggregation key
Initial Topology:
SW1>
LAG10 -> Interfaces: 1,2
SW2>
LAG20 -> Interfaces: 1,2
Expected behaviour:
All interfaces in all LAGs should be InSync, Collecting
and Distributing state
"""
sw1 = topology.get('sw1')
sw2 = topology.get('sw2')
sw1_lag_id = '10'
sw2_lag_id = '20'
assert sw1 is not None
assert sw2 is not None
ports_sw1 = list()
ports_sw2 = list()
port_labels = ['1', '2']
step("Mapping interfaces")
for port in port_labels:
ports_sw1.append(sw1.ports[port])
ports_sw2.append(sw2.ports[port])
step("Sorting the port list")
ports_sw1.sort()
ports_sw2.sort()
step("Turning on all interfaces used in this test")
for port in ports_sw1:
turn_on_interface(sw1, port)
for port in ports_sw2:
turn_on_interface(sw2, port)
step("Validate interfaces are turn on")
verify_turn_on_interfaces(sw1, ports_sw1)
verify_turn_on_interfaces(sw2, ports_sw2)
step("Create LAG in both switches")
create_lag_active(sw1, sw1_lag_id)
create_lag_active(sw2, sw2_lag_id)
set_lacp_rate_fast(sw1, sw1_lag_id)
set_lacp_rate_fast(sw2, sw2_lag_id)
step("Associate interfaces 1,2 to the lag in both switches")
for port in ports_sw1:
associate_interface_to_lag(sw1, port, sw1_lag_id)
for port in ports_sw2:
associate_interface_to_lag(sw2, port, sw2_lag_id)
step("#### Verify LAG configuration ####")
verify_lag_config(sw1, sw1_lag_id, ports_sw1, 'fast', mode='active')
verify_lag_config(sw2, sw2_lag_id, ports_sw2, 'fast', mode='active')
step("Verify if LAG is synchronized")
verify_state_sync_lag(sw1, ports_sw1, LOCAL_STATE, 'active')
verify_state_sync_lag(sw1, ports_sw1, REMOTE_STATE, 'active')
def test_lag_shutdown_by_default(topology, step):
"""Test LAG with shutdown by default ('no shutdown').
By default a new LAG will be configured with 'no shutdown'. IPv4 pings
from both clients must be successful.
"""
step('\n############################################')
step('Test lag shutdown (By default)')
step('############################################')
sw1 = topology.get('sw1')
sw2 = topology.get('sw2')
hs1 = topology.get('hs1')
hs2 = topology.get('hs2')
step('### Verifying switches are not None ###')
assert sw1 is not None, 'Topology failed getting object sw1'
assert sw2 is not None, 'Topology failed getting object sw2'
step('### Verifying hosts are not None ###')
assert hs1 is not None, 'Topology failed getting object hs1'
assert hs2 is not None, 'Topology failed getting object hs2'
sw1_lag_id = '100'
sw2_lag_id = '200'
h1_ip_address = '10.0.0.1'
h2_ip_address = '10.0.0.2'
vlan = '100'
mask = '/24'
ports_sw1 = list()
ports_sw2 = list()
port_labels = ['1', '2', '3']
step("### Mapping interfaces from Docker ###")
for port in port_labels:
ports_sw1.append(sw1.ports[port])
ports_sw2.append(sw2.ports[port])
step("Sorting the port list")
ports_sw1.sort()
ports_sw2.sort()
step("### Turning on all interfaces used in this test ###")
for port in ports_sw1:
turn_on_interface(sw1, port)
for port in ports_sw2:
turn_on_interface(sw2, port)
step("#### Validate interfaces are turned on ####")
verify_turn_on_interfaces(sw1, ports_sw1)
verify_turn_on_interfaces(sw2, ports_sw2)
# Changing hardcoded interfaces for dynamic assignation
mac_addr_sw1 = sw1.libs.vtysh.show_interface('1')['mac_address']
mac_addr_sw2 = sw2.libs.vtysh.show_interface('1')['mac_address']
assert mac_addr_sw1 != mac_addr_sw2,\
'Mac address of interfaces in sw1 is equal to mac address of ' +\
'interfaces in sw2. This is a test framework problem. Dynamic ' +\
'LAGs cannot work properly under this condition. Refer to Taiga ' +\
'issue #1251.'
step("### Create LAG in both switches ###")
create_lag_active(sw1, sw1_lag_id)
create_lag_active(sw2, sw2_lag_id)
step("### Set LACP rate to fast ###")
set_lacp_rate_fast(sw1, sw1_lag_id)
set_lacp_rate_fast(sw2, sw2_lag_id)
step("### Configure vlan and switch interfaces ###")
create_vlan(sw1, vlan)
create_vlan(sw2, vlan)
step("### Associate vlan with lag in both switches ###")
associate_vlan_to_lag(sw1, vlan, sw1_lag_id)
associate_vlan_to_lag(sw2, vlan, sw2_lag_id)
step("### Associate vlan with l2 interfaces in both switches ###")
associate_vlan_to_l2_interface(sw1, vlan, ports_sw1[2])
associate_vlan_to_l2_interface(sw2, vlan, ports_sw2[2])
step("### Associate interfaces [1,2] to lag in both switches ###")
for intf in ports_sw1[0:2]:
associate_interface_to_lag(sw1, intf, sw1_lag_id)
for intf in ports_sw2[0:2]:
associate_interface_to_lag(sw2, intf, sw2_lag_id)
step("### Verify if LAG is synchronized ###")
verify_state_sync_lag(sw1, ports_sw1[0:2], LOCAL_STATE, 'active')
verify_state_sync_lag(sw1, ports_sw1[0:2], REMOTE_STATE, 'active')
step("### Configure IP and bring UP in host 1 ###")
hs1.libs.ip.interface('1', addr=(h1_ip_address + mask), up=True)
step("### Configure IP and bring UP in host 2 ###")
hs2.libs.ip.interface('1', addr=(h2_ip_address + mask), up=True)
verify_connectivity_between_hosts(hs1, h1_ip_address, hs2, h2_ip_address,
True)
step('\n############################################')
step('Test lag shutdown (By default) DONE')
step('############################################')