def test_ft_bgp_unnumbered_bfd():
utils_obj.banner_log('FtOtSoRtBgpUnFn006')
# ################ Author Details ################
# Name: Kiran Vedula
# Email: [email protected]
# ################################################
result = 0
st.log('######------Enable BFD on unnumbered BGP peers------######')
dict1 = {
'config': 'yes',
'local_asn': data.d1_local_as,
'neighbor_ip': vars.D1D2P1,
'interface': vars.D1D2P1
}
dict2 = {
'config': 'yes',
'local_asn': data.d2_local_as,
'neighbor_ip': vars.D2D1P1,
'interface': vars.D2D1P1
}
parallel.exec_parallel(True, [vars.D1, vars.D2], bfd_obj.configure_bfd,
[dict1, dict2])
if not utils.poll_wait(bfd_obj.verify_bfd_peers_brief,
data.wait_timer,
vars.D2,
peeraddress=d1_prt_link_local[0],
ouraddress=d2_prt_link_local[0],
status="UP"):
st.log("Failed to get BFD status Up")
result += 1
if result == 0:
st.report_pass("test_case_passed")
else:
st.log("BGP unnumbered neighborship failure")
st.report_fail("test_case_failed")
def fixture_test_warm_reboot(request, prologue_epilogue):
yield
reboot_obj.config_warm_restart(data.dut2, oper="disable")
reboot_obj.config_warm_restart(data.dut2,
oper="disable",
tasks=["bgp", "swss", "teamd", "system"])
dict1 = {'local_asn': dut1_as, 'config': 'del', 'preserve_state': '1'}
dict2 = {'local_asn': dut2_as, 'config': 'del', 'preserve_state': '1'}
dict3 = {'local_asn': dut3_as, 'config': 'del', 'preserve_state': '1'}
parallel.exec_parallel(True, [data.dut1, data.dut2, data.dut3],
bgp_obj.config_bgp_graceful_restart,
[dict1, dict2, dict3])
def verify_udld_interface(udld_int,mode):
'''
Verify UDLD interface local port state
:param udld_int: dictionary of UDLD global attributes to be verified
:param mode: normal/aggressive/normal_udld_block/aggressive_udld_block
:return:
'''
ver_flag = True
int_local_list1 = udld_int[dut1]['udld_int']
if mode == "normal" or mode == "aggressive":
st.log("mode inside {}".format(mode))
int_mode_list1 = udld_int[dut1]['neighbor_state']
elif mode == "loopnormal":
st.log("mode inside {}".format(mode))
int_mode_list1 = udld_int[dut1]['neighbor_state_norm']
elif mode == "loopaggressive":
int_mode_list1 = udld_int[dut1]['neighbor_state_agg']
st.log("Before output......................")
st.log("mode {}".format(mode))
st.log("int_local_list1 {}".format(int_local_list1))
st.log("int_mode_list1 {}".format(int_mode_list1))
st.log("After output......................")
for int_local1,int_mode1 in zip(int_local_list1,int_mode_list1):
dict1 = {'udld_intf': int_local1, 'udld_status': int_mode1}
[result, exceptions] = pll.exec_parallel(True, [dut1], udld.verify_udld_interface, [dict1])
if not all(i is None for i in exceptions):
print_log(exceptions)
if False in result:
print_log('UDLD Local port states FAILED','ERROR')
ver_flag = False
return ver_flag
def test_ft_bgp_rst001():
# """
# Validate the BGP IPv4 neighborship when configured through REST
# :return:
# """
[out, exceptions] = exec_all(True, [[config_bgp_router_rst, vars.D1, bgp_rst_data.dut1_asn, "add"], \
[config_bgp_router_rst, vars.D2, bgp_rst_data.dut2_asn, "add"]])
ensure_no_exception(exceptions)
for each in out:
if not each:
st.report_fail("bgp_router_create_delete", "Creation", "REST",
"FAILED")
st.wait(5)
dut1_data = {
'neigh_ip': bgp_rst_data.dut2_ip_l[0],
'local_asn': bgp_rst_data.dut1_asn,
'remote_asn': bgp_rst_data.dut2_asn,
'peer_type': "EXTERNAL",
'family': "ipv4",
'config': "add"
}
dut2_data = {
'neigh_ip': bgp_rst_data.dut1_ip_l[0],
'local_asn': bgp_rst_data.dut2_asn,
'remote_asn': bgp_rst_data.dut1_asn,
'peer_type': "EXTERNAL",
'family': "ipv4",
'config': "add"
}
exec_parallel(True, [vars.D1, vars.D2], config_bgp_neighbor_rst,
[dut1_data, dut2_data])
for each in out:
if not each:
st.report_fail("bgp_neighbor_create_delete", "v4", "Creation",
"REST", "FAILED")
if not poll_wait(verify_bgp_neighbor_rst, 60, vars.D1,
bgp_rst_data.dut2_ip_l[0]):
st.report_fail("bgp_neighbor_create_delete", "v4", "Creation", "REST",
"FAILED")
[out, exceptions] = exec_all(True, [[bgp_neighbor_del_rst, vars.D1, bgp_rst_data.dut2_ip_l[0]] , \
[bgp_neighbor_del_rst, vars.D2, bgp_rst_data.dut1_ip_l[0]]])
ensure_no_exception(exceptions)
for each in out:
if not each:
st.report_fail("bgp_neighbor_create_delete", "v4", "Delrtion",
"REST", "FAILED")
st.report_pass("bgp_neighbor_status", "v4", "Successful", "REST")
def static_port_channel_dut_config():
static_data.dut1_rt_int_mac = get_ifconfig_ether(vars.D1, vars.D1T1P1)
static_data.members_dut1 = [
vars.D1D2P1, vars.D1D2P2, vars.D1D2P3, vars.D1D2P4
]
static_data.members_dut2 = [
vars.D2D1P1, vars.D2D1P2, vars.D2D1P3, vars.D2D1P4
]
st.log('Creating port-channel and adding members in both DUTs')
dict1 = {
'portchannel_list': [static_data.portchannel_name],
'static': True
}
dict2 = {
'portchannel_list': [static_data.portchannel_name],
'static': True
}
exceptions = exec_parallel(True, [vars.D1, vars.D2],
portchannelobj.create_portchannel,
[dict1, dict2])[1]
ensure_no_exception(exceptions)
dict1 = {
'portchannel': static_data.portchannel_name,
'members': static_data.members_dut1
}
dict2 = {
'portchannel': static_data.portchannel_name,
'members': static_data.members_dut2
}
exceptions = exec_parallel(True, [vars.D1, vars.D2],
portchannelobj.add_del_portchannel_member,
[dict1, dict2])[1]
ensure_no_exception(exceptions)
st.log('Creating random VLAN in both the DUTs')
exceptions = exec_all(True, [[create_vlan, vars.D1, static_data.vid],
[create_vlan, vars.D2, static_data.vid]])[1]
ensure_no_exception(exceptions)
st.log(
'Adding Port-Channel and TGen connected ports as tagged members to the random VLAN'
)
exceptions = \
exec_all(True, [[add_vlan_member, vars.D1, static_data.vid, [static_data.portchannel_name, vars.D1T1P1], True],
[add_vlan_member, vars.D2, static_data.vid, [static_data.portchannel_name, vars.D2T1P1], True]])[1]
ensure_no_exception(exceptions)
def retry_parallel(func, dict_list=[], dut_list=[], retry_count=3, delay=5):
for i in range(retry_count):
st.log("Attempt %s of %s" % ((i + 1), retry_count))
result = pll.exec_parallel(True, dut_list, func, dict_list)
if False not in result[0]:
return True
if retry_count != (i + 1):
st.log("waiting for %s seconds before retyring again" % delay)
st.wait(delay)
return False
def udld_module_config():
'''
- Configure vlans 10 on DUT1 to DUT2 to DUT3
- Configure the ports to add in acess vlan 10
- Configure UDLD global and interface
'''
ver_flag = True
print_log("Starting UDLD Module Configurations...\n\
STEPS:\n\
- Configure vlans 10 on DUT1 to DUT2 to DUT3\n\
- Configure the ports to add in acess vlan 10\n\
- Configure UDLD global and interface.", "HIGH")
### Create Access VLAN on all DUTs
utils.exec_all(True,[[vlan.create_vlan, dut, trunk_base_vlan] for dut in dut_list])
### Add Access ports between DUT1<->DUT2<->DUT3<->DUT1 in vlan 10
api_list = []
api_list.append([vlan.add_vlan_member, dut1, trunk_base_vlan, [vars.D1D2P1]])
api_list.append([vlan.add_vlan_member, dut2, trunk_base_vlan, [vars.D2D1P1,vars.D2D3P1,vars.D2D3P2]])
api_list.append([vlan.add_vlan_member, dut3, trunk_base_vlan, [vars.D3D2P1,vars.D3D2P2]])
utils.exec_all(True, api_list)
[result, exceptions] = pll.exec_parallel(True, [dut2, dut3], udld.udld_cfg_ebtables_rule, [{'add': False}, {'add': False}])
if not all(i is None for i in exceptions):
result.append(False)
print_log(exceptions)
if False in result:
print_log('UDLD Delete ebtables rule FAILED','ERROR')
ver_flag = False
###Enable UDLD global
dict1 = {'udld_enable': udld_global[dut1]['udld_enable'], 'config': udld_global[dut1]['config']}
pll.exec_parallel(True,[dut1],udld.config_udld_global, [dict1])
###Enable UDLD on Interfaces
dict1 = {'intf': udld_int[dut1]['udld_int'],'udld_enable': udld_int[dut1]['udld_enable'], 'config': udld_int[dut1]['config']}
pll.exec_parallel(True,[dut1],udld.config_intf_udld, [dict1])
return ver_flag
def config_ipunnumbered(config='yes'):
if config == 'yes':
hdrMsg(
'Configure IP unnumbered on Physical interfaces between DUT1 and DUT3'
)
dict1 = {
'family': 'ipv4',
'action': 'add',
'interface': 'PortChannel14',
'loop_back': 'Loopback1'
}
dict2 = {
'family': 'ipv4',
'action': 'add',
'interface': 'PortChannel14',
'loop_back': 'Loopback1'
}
parallel.exec_parallel(True, [data.dut1, data.dut3],
ip_api.config_unnumbered_interface,
[dict1, dict2])
else:
hdrMsg(
'UnConfig IP unnumbered on Physical interfaces between DUT1 and DUT3'
)
dict1 = {
'family': 'ipv4',
'action': 'del',
'interface': 'PortChannel14',
'loop_back': 'Loopback1'
}
dict2 = {
'family': 'ipv4',
'action': 'del',
'interface': 'PortChannel14',
'loop_back': 'Loopback1'
}
parallel.exec_parallel(True, [data.dut1, data.dut3],
ip_api.config_unnumbered_interface,
[dict1, dict2])
def verify_udld_mode(udld_mode_def ='Normal'):
'''
Verify UDLD mode and other attributes
:param udld_global: dictionary of UDLD global attributes to be verified
:return:
'''
ver_flag = True
print_log("Verify the UDLD modes", 'MED')
dict1 = {'udld_mode': udld_mode_def}
[result, exceptions] = pll.exec_parallel(True, [dut1], udld.verify_udld_global, [dict1])
if not all(i is None for i in exceptions):
print_log(exceptions)
if False in result:
print_log('UDLD modes verification FAILED','ERROR')
ver_flag = False
return ver_flag
def verify_udld_global(udld_global):
'''
Verify UDLD state and other attributes
:param udld_global: dictionary of UDLD global attributes to be verified
:return:
'''
ver_flag = True
print_log("Verify the UDLD state and other attributes", 'MED')
dict1 = {'udld_admin_state': udld_global[dut1]['udld_admin_state'], 'udld_mode': udld_global[dut1]['udld_mode'],\
'udld_message_time': udld_global[dut1]['udld_message_time'], 'udld_multiplier': udld_global[dut1]['udld_multiplier']}
[result, exceptions] = pll.exec_parallel(True, [dut1], udld.verify_udld_global, [dict1])
if not all(i is None for i in exceptions):
print_log(exceptions)
if False in result:
print_log('UDLD state and other attributes verification FAILED','ERROR')
ver_flag = False
return ver_flag
def verify_udld_neighbor(udld_neighbor):
'''
Verify UDLD neighbor state and other attributes
:param udld_neighbor: dictionary of UDLD neighbor attributes to be verified
:return:
'''
ver_flag = True
print_log("Verify the UDLD neighbor state and other attributes", 'MED')
dict1 = {'local_port': udld_neighbor[dut1]['local_port'], 'device_name': udld_neighbor[dut1]['device_name'],\
'remote_port': udld_neighbor[dut1]['remote_port'], 'neighbor_state': udld_neighbor[dut1]['neighbor_state']}
dict2 = {'local_port': udld_neighbor[dut2]['local_port'], 'device_name': udld_neighbor[dut2]['device_name'],\
'remote_port': udld_neighbor[dut2]['remote_port'], 'neighbor_state': udld_neighbor[dut2]['neighbor_state']}
[result, exceptions] = pll.exec_parallel(True, dut_list, udld.verify_udld_neighbors, [dict1, dict2])
if not all(i is None for i in exceptions):
print_log(exceptions)
if False in result:
print_log('UDLD neighbor state and other attributes verification FAILED','ERROR')
ver_flag = False
return ver_flag
def udld_module_unconfig():
ver_flag = True
print_log("Starting UDLD Module UnConfigurations...", "HIGH")
### Remove the trunk ports between DUT1<->DUT2<->DUT3 in vlan 10
api_list = []
api_list.append([vlan.delete_vlan_member, dut1, trunk_base_vlan, [vars.D1D2P1]])
api_list.append([vlan.delete_vlan_member, dut2, trunk_base_vlan, [vars.D2D1P1]])
utils.exec_all(True, api_list)
### delete Access VLAN on all DUTs
utils.exec_all(True,[[vlan.delete_vlan, dut, trunk_base_vlan] for dut in dut_list])
[result, exceptions] = pll.exec_parallel(True, [dut2, dut3], udld.udld_cfg_ebtables_rule, [{'add': True}, {'add': True}])
if not all(i is None for i in exceptions):
result.append(False)
print_log(exceptions)
if False in result:
print_log('UDLD Add ebtables rule FAILED','ERROR')
ver_flag = False
return ver_flag
def test_ft_bgp_rst003():
[_, exceptions] = exec_all(True, [
[config_interface_ip6_link_local, vars.D1, [vars.D1D2P1]], \
[config_interface_ip6_link_local, vars.D2, [vars.D2D1P1]]])
ensure_no_exception(exceptions)
dut1_data = {
'neigh_ip': vars.D1D2P1,
'local_asn': bgp_rst_data.dut1_asn,
'remote_asn': bgp_rst_data.dut2_asn,
'peer_type': "EXTERNAL",
'family': "ipv6",
'config': "add"
}
dut2_data = {
'neigh_ip': vars.D2D1P1,
'local_asn': bgp_rst_data.dut2_asn,
'remote_asn': bgp_rst_data.dut1_asn,
'peer_type': "EXTERNAL",
'family': "ipv6",
'config': "add"
}
[out, exceptions] = exec_parallel(True, [vars.D1, vars.D2],
config_bgp_neighbor_rst,
[dut1_data, dut2_data])
ensure_no_exception(exceptions)
for each in out:
if not each:
st.report_fail("bgp_neighbor_create_delete", "v6", "Creation",
"REST", "FAILED")
if not poll_wait(verify_bgp_neighbor_rst, 60, vars.D1, vars.D1D2P1):
st.report_fail("bgp_neighbor_create_delete", "v6", "Creation", "REST",
"FAILED")
[out, exceptions] = exec_all(True, [[bgp_neighbor_del_rst, vars.D1, vars.D2D1P1], \
[bgp_neighbor_del_rst, vars.D2, vars.D1D2P1]])
ensure_no_exception(exceptions)
for each in out:
if not each:
st.report_fail("bgp_neighbor_create_delete", "v6", "Delrtion",
"REST", "FAILED")
st.report_pass("bgp_neighbor_status", "v6", "Successful", "REST")
def fixture_unnumvrf_test_bfd(request, prologue_epilogue):
yield
dict1 = {
"interface": data.d1_d2_ports[0],
'neighbor_ip': data.dut2_loopback_ip[0],
'config': 'no',
'noshut': 'yes',
'vrf_name': data.dut1_vrf[0]
}
dict2 = {
"interface": data.d1_d2_ports[0],
'neighbor_ip': data.dut1_loopback_ip[0],
'config': 'no',
'noshut': 'yes'
}
parallel.exec_parallel(True, [data.dut1, data.dut2], bfd_obj.configure_bfd,
[dict1, dict2])
dict1 = {
"interface": data.portchannel,
'neighbor_ip': data.dut2_loopback_ip[2],
'config': 'no',
'noshut': 'yes',
'vrf_name': data.dut1_vrf[0]
}
dict2 = {
"interface": data.portchannel,
'neighbor_ip': data.dut1_loopback_ip[2],
'config': 'no',
'noshut': 'yes'
}
parallel.exec_parallel(True, [data.dut1, data.dut2], bfd_obj.configure_bfd,
[dict1, dict2])
dict1 = {
"interface": 'Vlan' + data.dut1_dut2_vlan[0],
'neighbor_ip': data.dut2_loopback_ip[1],
'config': 'no',
'noshut': 'yes',
'vrf_name': data.dut1_vrf[0]
}
dict2 = {
"interface": 'Vlan' + data.dut1_dut2_vlan[0],
'neighbor_ip': data.dut1_loopback_ip[1],
'config': 'no',
'noshut': 'yes'
}
parallel.exec_parallel(True, [data.dut1, data.dut2], bfd_obj.configure_bfd,
[dict1, dict2])
def dut_vrf_bgp(**kwargs):
vars = st.get_testbed_vars()
dut1 = st.get_dut_names()[0]
dut2 = st.get_dut_names()[1]
if 'config' in kwargs:
config = kwargs['config']
else:
config = ''
if config == '':
st.log('######------Configure BGP in vrf for virtual interface ------######')
for i in range(0,3):
dict1 = {'vrf_name':data.vrf_name[i],'router_id':data.dut1_router_id,'local_as':data.dut1_as[i],'neighbor':data.dut2_dut1_vrf_ip[i],'remote_as':data.dut2_as[i],'config_type_list':['neighbor']}
dict2 = {'vrf_name':data.vrf_name[i],'router_id':data.dut2_router_id,'local_as':data.dut2_as[i],'neighbor':data.dut1_dut2_vrf_ip[i],'remote_as':data.dut1_as[i],'config_type_list':['neighbor']}
parallel.exec_parallel(True, [vars.D1, vars.D2], bgp_obj.config_bgp, [dict1, dict2])
dict1 = {'vrf_name':data.vrf_name[i],'router_id':data.dut1_router_id,'local_as':data.dut1_as[i],'neighbor':data.dut2_dut1_vrf_ip[i],'remote_as':data.dut2_as[i],'config_type_list':['activate','nexthop_self']}
dict2 = {'vrf_name':data.vrf_name[i],'router_id':data.dut2_router_id,'local_as':data.dut2_as[i],'neighbor':data.dut1_dut2_vrf_ip[i],'remote_as':data.dut1_as[i],'config_type_list':['activate','nexthop_self']}
parallel.exec_parallel(True, [vars.D1, vars.D2], bgp_obj.config_bgp, [dict1, dict2])
st.log('######------Configure BGPv4+ in vrf for virtual interface ------######')
dict1 = {'vrf_name':data.vrf_name[i],'router_id':data.dut1_router_id,'local_as':data.dut1_as[i],'addr_family':'ipv6','neighbor':data.dut2_dut1_vrf_ipv6[i],'remote_as':data.dut2_as[i],'config_type_list':['neighbor']}
dict2 = {'vrf_name':data.vrf_name[i],'router_id':data.dut2_router_id,'local_as':data.dut2_as[i],'addr_family':'ipv6','neighbor':data.dut1_dut2_vrf_ipv6[i],'remote_as':data.dut1_as[i],'config_type_list':['neighbor']}
parallel.exec_parallel(True, [vars.D1, vars.D2], bgp_obj.config_bgp, [dict1, dict2])
dict1 = {'vrf_name':data.vrf_name[i],'router_id':data.dut1_router_id,'local_as':data.dut1_as[i],'addr_family':'ipv6','neighbor':data.dut2_dut1_vrf_ipv6[i],'remote_as':data.dut2_as[i],'config_type_list':['activate','nexthop_self']}
dict2 = {'vrf_name':data.vrf_name[i],'router_id':data.dut2_router_id,'local_as':data.dut2_as[i],'addr_family':'ipv6','neighbor':data.dut1_dut2_vrf_ipv6[i],'remote_as':data.dut1_as[i],'config_type_list':['activate','nexthop_self']}
parallel.exec_parallel(True, [vars.D1, vars.D2], bgp_obj.config_bgp, [dict1, dict2])
bgp_obj.config_bgp(dut = dut2, vrf_name = data.vrf_name[i], local_as = data.dut2_as[i], addr_family ='ipv6', config_type_list=["routeMap"], routeMap='UseGlobal', diRection='in', neighbor=data.dut1_dut2_vrf_ipv6[i])
bgp_obj.config_bgp(dut = dut1, vrf_name = data.vrf_name[i], local_as = data.dut1_as[i], addr_family ='ipv6', config_type_list=["routeMap"], routeMap='UseGlobal', diRection='in', neighbor=data.dut2_dut1_vrf_ipv6[i])
elif config == 'no':
for i in range(0,3):
bgp_obj.config_bgp(dut = dut1, local_as = data.dut1_as[i], vrf_name = data.vrf_name[i] ,config = 'no', removeBGP = 'yes', config_type_list = ["removeBGP"])
bgp_obj.config_bgp(dut = dut2, local_as = data.dut2_as[i], vrf_name = data.vrf_name[i] ,config = 'no', removeBGP = 'yes', config_type_list = ["removeBGP"])
def test_ft_bgp_rst004():
dut1_data = {
'neigh_ip': "Vlan{}".format(bgp_rst_data.vlan_id[0]),
'local_asn': bgp_rst_data.dut1_asn,
'remote_asn': bgp_rst_data.dut2_asn,
'peer_type': "EXTERNAL",
'family': "ipv6",
'config': "add"
}
dut2_data = {
'neigh_ip': "Vlan{}".format(bgp_rst_data.vlan_id[0]),
'local_asn': bgp_rst_data.dut2_asn,
'remote_asn': bgp_rst_data.dut1_asn,
'peer_type': "EXTERNAL",
'family': "ipv6",
'config': "add"
}
[out, exceptions] = exec_parallel(True, [vars.D1, vars.D2],
config_bgp_neighbor_rst,
[dut1_data, dut2_data])
ensure_no_exception(exceptions)
for each in out:
if not each:
st.report_fail("bgp_neighbor_create_delete", "v6", "Creation",
"REST", "FAILED")
if not poll_wait(verify_bgp_neighbor_rst, 60, vars.D1, "Vlan{}".format(
bgp_rst_data.vlan_id[0])):
st.report_fail("bgp_neighbor_create_delete", "v6", "Creation", "REST",
"FAILED")
[out, exceptions] = exec_all(True, [[bgp_neighbor_del_rst, vars.D1, "Vlan{}".format(bgp_rst_data.vlan_id[0])], \
[bgp_neighbor_del_rst, vars.D2, "Vlan{}".format(bgp_rst_data.vlan_id[0])]])
ensure_no_exception(exceptions)
for each in out:
if not each:
st.report_fail("bgp_neighbor_create_delete", "v6", "Delrtion",
"REST", "FAILED")
st.report_pass("bgp_neighbor_status", "v6", "Successful", "REST")
def bgp_unnumbered_neighbour_config():
"""
This proc is for the BGP peering with Port-Based, Vlan-Based, Lag interfaces.
:return:
"""
st.log(
'######------Configure Unnumbered BGP peers on port based------######')
dict1 = {
'peergroup': 'peer_v6',
'router_id': data.d1_rid,
'addr_family': 'ipv6',
'local_as': data.d1_local_as,
'remote_as': 'external',
'config_type_list': ['peergroup', "activate"],
'neighbor': vars.D1D2P1,
'interface': vars.D2D1P1
}
dict2 = {
'peergroup': 'peer_v6',
'router_id': data.d2_rid,
'addr_family': 'ipv6',
'local_as': data.d2_local_as,
'remote_as': 'external',
'config_type_list': ['peergroup', "activate"],
'neighbor': vars.D2D1P1,
'interface': vars.D2D1P1
}
parallel.exec_parallel(True, [vars.D1, vars.D2], bgp_obj.config_bgp,
[dict1, dict2])
st.log('######------Configure Unnumbered BGP peers on PC------######')
dict1 = {
'router_id': data.d1_rid,
'addr_family': 'ipv6',
'local_as': data.d1_local_as,
'remote_as': 'external',
'config_type_list': ["remote-as", "activate"],
'interface': data.portchannel_name,
'neighbor': data.portchannel_name
}
dict2 = {
'router_id': data.d2_rid,
'addr_family': 'ipv6',
'local_as': data.d2_local_as,
'remote_as': 'external',
'config_type_list': ["remote-as", "activate"],
'interface': data.portchannel_name,
'neighbor': data.portchannel_name
}
parallel.exec_parallel(True, [vars.D1, vars.D2], bgp_obj.config_bgp,
[dict1, dict2])
st.log('######------Configure Unnumbered BGP peers on VLAN------######')
dict1 = {
'router_id': data.d1_rid,
'addr_family': 'ipv6',
'local_as': data.d1_local_as,
'remote_as': 'external',
'config_type_list': ["remote-as", "activate"],
'interface': data.vlan_in_1,
'neighbor': data.vlan_in_1
}
dict2 = {
'router_id': data.d2_rid,
'addr_family': 'ipv6',
'local_as': data.d2_local_as,
'remote_as': 'external',
'config_type_list': ["remote-as", "activate"],
'interface': data.vlan_in_1,
'neighbor': data.vlan_in_1
}
parallel.exec_parallel(True, [vars.D1, vars.D2], bgp_obj.config_bgp,
[dict1, dict2])
def dut_vrf_bind(**kwargs):
vars = st.get_testbed_vars()
dut1 = st.get_dut_names()[0]
dut2 = st.get_dut_names()[1]
if 'config' in kwargs:
config = kwargs['config']
else:
config = ''
if config == '':
st.log(
'######------Configure vlans on the PE--PE side - DUT1 -- DUT2------######'
)
for vlan in data.dut1_dut2_vlan[0:3]:
vlan_obj.create_vlan(dut1, vlan)
vlan_obj.add_vlan_member(dut1, vlan, vars.D1D2P1, True, True)
for vlan in data.dut2_dut1_vlan[0:3]:
vlan_obj.create_vlan(dut2, vlan)
vlan_obj.add_vlan_member(dut2, vlan, vars.D2D1P1, True, True)
st.log(
'######------Bind DUT1 <--> DUT2 vlans to vrf, assign v4 and v6 address------######'
)
for vlan, ip, ip2, ipv6, ipv6_2, vrf in zip(
data.dut1_dut2_vlan[0:3], data.dut1_dut2_vrf_ip[0:3],
data.dut2_dut1_vrf_ip[0:3], data.dut1_dut2_vrf_ipv6[0:3],
data.dut2_dut1_vrf_ipv6[0:3], data.vrf_name[0:3]):
dict1 = {
'vrf_name': vrf,
'intf_name': 'Vlan' + vlan,
'skip_error': True
}
dict2 = {
'vrf_name': vrf,
'intf_name': 'Vlan' + vlan,
'skip_error': True
}
parallel.exec_parallel(True, [dut1, dut2],
vrf_api.bind_vrf_interface, [dict1, dict2])
parallel.exec_all(
True,
[[
ipfeature.config_ip_addr_interface, dut1, 'Vlan' + vlan,
ip, data.dut1_dut2_vrf_ip_subnet, 'ipv4'
],
[
ipfeature.config_ip_addr_interface, dut2, 'Vlan' + vlan,
ip2, data.dut2_dut1_vrf_ip_subnet, 'ipv4'
]])
parallel.exec_all(
True,
[[
ipfeature.config_ip_addr_interface, dut1, 'Vlan' + vlan,
ipv6, data.dut1_dut2_vrf_ipv6_subnet, 'ipv6'
],
[
ipfeature.config_ip_addr_interface, dut2, 'Vlan' + vlan,
ipv6_2, data.dut2_dut1_vrf_ipv6_subnet, 'ipv6'
]])
'''
vrf_api.bind_vrf_interface(dut = dut1, vrf_name = vrf, intf_name = 'Vlan'+vlan, skip_error = True)
ipfeature.config_ip_addr_interface(dut1, 'Vlan'+vlan, ip, data.dut1_dut2_vrf_ip_subnet, 'ipv4')
ipfeature.config_ip_addr_interface(dut1, 'Vlan'+vlan, ipv6, data.dut1_dut2_vrf_ipv6_subnet, 'ipv6')
'''
'''
st.log('######------Bind DUT2 <--> DUT1 virtual interfaces to vrf and config IP addresses------######')
for vlan, ip, ipv6, vrf in zip(data.dut2_dut1_vlan[0:3], data.dut2_dut1_vrf_ip[0:3], data.dut2_dut1_vrf_ipv6[0:3],data.vrf_name[0:3]):
vrf_api.bind_vrf_interface(dut = dut2, vrf_name = vrf, intf_name = 'Vlan'+vlan, skip_error = True)
ipfeature.config_ip_addr_interface(dut2, 'Vlan'+vlan, ip, data.dut2_dut1_vrf_ip_subnet, 'ipv4')
ipfeature.config_ip_addr_interface(dut2, 'Vlan'+vlan, ipv6, data.dut2_dut1_vrf_ipv6_subnet, 'ipv6')
'''
elif config == 'no':
'''
st.log('######------Unbind DUT1 <--> DUT2 vlans to vrf, assign v4 and v6 address------######')
for vlan, ip, ipv6, vrf in zip(data.dut1_dut2_vlan[0:3], data.dut1_dut2_vrf_ip[0:3], data.dut1_dut2_vrf_ipv6[0:3],data.vrf_name[0:3]):
vrf_api.bind_vrf_interface(dut = dut1, vrf_name = vrf, intf_name = 'Vlan'+vlan, skip_error = True, config = 'no')
ipfeature.delete_ip_interface(dut1, 'Vlan'+vlan, ip, data.dut1_dut2_vrf_ip_subnet, 'ipv4')
ipfeature.delete_ip_interface(dut1, 'Vlan'+vlan, ipv6, data.dut1_dut2_vrf_ipv6_subnet, 'ipv6')
st.log('######------Unbind DUT2 <--> DUT1 physical interfaces to vrf and config IP addresses------######')
for vlan, ip, ipv6, vrf in zip(data.dut2_dut1_vlan[0:3], data.dut2_dut1_vrf_ip[0:3], data.dut2_dut1_vrf_ipv6[0:3],data.vrf_name[0:3]):
vrf_api.bind_vrf_interface(dut = dut2, vrf_name = vrf, intf_name = 'Vlan'+vlan, skip_error = True, config = 'no')
ipfeature.delete_ip_interface(dut2, 'Vlan'+vlan, ip, data.dut2_dut1_vrf_ip_subnet, 'ipv4')
ipfeature.delete_ip_interface(dut2, 'Vlan'+vlan, ipv6, data.dut2_dut1_vrf_ipv6_subnet, 'ipv6')
'''
st.log(
'######------Delete vlans on the PE--PE side - DUT1 -- DUT2------######'
)
for vlan in data.dut1_dut2_vlan[0:3]:
vlan_obj.delete_vlan_member(dut1,
vlan,
vars.D1D2P1,
tagging_mode=True)
vlan_obj.delete_vlan(dut1, vlan)
for vlan in data.dut2_dut1_vlan[0:3]:
vlan_obj.delete_vlan_member(dut2,
vlan,
vars.D2D1P1,
tagging_mode=True)
vlan_obj.delete_vlan(dut2, vlan)
def test_udld_loops_normal_aggressive():
'''
Verify UDLD Tx/Rx loops in normal mode with out PVST/RPVST
Verify UDLD Tx/Rx loops in aggressive mode with out PVST/RPVST
'''
tc_list = ['FtOpSoSwudldloopnormal001', 'FtOpSoSwudldloopaggressive001']
print_log("START of TC:test_pvst_udld_normal_aggressive ==>Sub-Test:Verify UDLD functionality with PVST\n TCs:<{}>".format(tc_list), "HIGH")
final_result = True
tc_result1 = 0
tc_result2 = 0
#udld_global_fail = 0
udld_mode_fail = 0
udld_interface_normal_loop_fail = 0
udld_interface_no_normal_loop_fail = 0
udld_interface_aggressive_loop_fail = 0
udld_interface_no_aggressive_loop_fail = 0
udld_neighbor_fail = 0
udld_neighbor_warm_reboot_norm_fail = 0
##########################################NORMAL MODE UDLD RX/TX loop TESTS START#######################################
st.wait(5)
print_log("Verify that the port from DUT1 to DUT2 should go down in Normal Mode with UDLD TX/RX loop...",'MED')
udld_interfaces = [vars.D1D2P1]
state = 'down'
if verify_udld_port_status(udld_interfaces,dut1,state):
print_log("The ports from DUT1 to DUT3 is going to down state verification PASSED", "HIGH")
else:
print_log("The ports from DUT1 to DUT3 is not going to down state verification FAILED", "HIGH")
udld_interface_normal_loop_fail += 1
tc_result1 += 1
final_result = False
###Disable UDLD on Interfaces
dict1 = {'intf': udld_int[dut1]['udld_int'],'udld_enable': 'no', 'config': 'no'}
pll.exec_parallel(True,[dut1],udld.config_intf_udld, [dict1])
###Disable UDLD global
dict1 = {'udld_enable': 'no', 'config': 'no'}
pll.exec_parallel(True,[dut1],udld.config_udld_global, [dict1])
###do shut and no shut on DUt1 to DUT2
udld_interfaces = [vars.D1D2P1]
for udld_interface in udld_interfaces:
intf.interface_operation(dut1, udld_interface , "shutdown")
intf.interface_operation(dut1, udld_interface , "startup")
st.wait(5)
print_log("Verify that the port from DUT1 to DUT2 should go up in Normal Mode with UDLD TX/RX loop...",'MED')
udld_interfaces = [vars.D1D2P1]
state = 'up'
if verify_udld_port_status(udld_interfaces,dut1,state):
print_log("The ports from DUT1 to DUT2 is going to up state verification PASSED", "HIGH")
else:
print_log("The ports from DUT1 to DUT2 is not going to up state verification FAILED", "HIGH")
udld_interface_no_normal_loop_fail += 1
tc_result1 += 1
final_result = False
if tc_result1 > 0:
st.report_tc_fail("FtOpSoSwudldloopnormal001", "UDLD_TX_RX_loop_Normal_Failed", "test_udld_loops_normal_aggressive")
else:
st.report_tc_pass("FtOpSoSwudldloopnormal001", "UDLD_TX_RX_loop_Normal_Passed", "test_udld_loops_normal_aggressive")
###Enable UDLD global
dict1 = {'udld_enable': udld_global[dut1]['udld_enable'], 'config': udld_global[dut1]['config']}
pll.exec_parallel(True,[dut1],udld.config_udld_global, [dict1])
###Enable UDLD on Interfaces
dict1 = {'intf': udld_int[dut1]['udld_int'],'udld_enable': udld_int[dut1]['udld_enable'], 'config': udld_int[dut1]['config']}
pll.exec_parallel(True,[dut1],udld.config_intf_udld, [dict1])
###Enable UDLD mode Aggressive
print_log("Enable the UDLD Mode Agrgressive on All DUTs...", 'MED')
dict1 = {'udld_mode': udld_global[dut1]['udld_enable'], 'config': udld_global[dut1]['config']}
pll.exec_parallel(True,[dut1],udld.config_udld_mode, [dict1])
### Verify UDLD mode
if verify_udld_mode('Aggressive'):
print_log("UDLD Mode Aggressive verification PASSED", "HIGH")
else:
print_log("UDLD Mode Aggressive verification FAILED", "HIGH")
udld_mode_fail += 1
tc_result2 += 1
final_result = False
st.wait(2)
print_log("Verify that the port from DUT1 to DUT2 should go down in Aggressive Mode with UDLD TX/RX loop...",'MED')
udld_interfaces = [vars.D1D2P1]
state = 'down'
if verify_udld_port_status(udld_interfaces,dut1,state):
print_log("The ports from DUT1 to DUT2 is going to down state verification PASSED", "HIGH")
else:
print_log("The ports from DUT1 to DUT2 is not going to down state verification FAILED", "HIGH")
udld_interface_aggressive_loop_fail += 1
tc_result2 += 1
final_result = False
###Disable UDLD on Interfaces
dict1 = {'intf': udld_int[dut1]['udld_int'],'udld_enable': 'no', 'config': 'no'}
pll.exec_parallel(True,[dut1],udld.config_intf_udld, [dict1])
###Disable UDLD global
dict1 = {'udld_enable': 'no', 'config': 'no'}
pll.exec_parallel(True,[dut1],udld.config_udld_global, [dict1])
###do shut and no shut on DUt1 to DUT2
udld_interfaces = [vars.D1D2P1]
for udld_interface in udld_interfaces:
intf.interface_operation(dut1, udld_interface , "shutdown")
intf.interface_operation(dut1, udld_interface , "startup")
st.wait(5)
print_log("Verify that the port from DUT1 to DUT2 should go up in Aggressive Mode with UDLD TX/RX loop...",'MED')
udld_interfaces = [vars.D1D2P1]
state = 'up'
if verify_udld_port_status(udld_interfaces,dut1,state):
print_log("The ports from DUT1 to DUT2 is going to up state verification PASSED", "HIGH")
else:
print_log("The ports from DUT1 to DUT2 is not going to up state verification FAILED", "HIGH")
udld_interface_no_aggressive_loop_fail += 1
tc_result2 += 1
final_result = False
api_list = []
api_list.append([vlan.delete_vlan_member, dut2, trunk_base_vlan, [vars.D2D3P1,vars.D2D3P2]])
api_list.append([vlan.delete_vlan_member, dut3, trunk_base_vlan, [vars.D3D2P1,vars.D3D2P2]])
utils.exec_all(True, api_list)
###Enable UDLD global
dict1 = {'udld_enable': udld_global[dut1]['udld_enable'], 'config': udld_global[dut1]['config']}
dict2 = {'udld_enable': udld_global[dut2]['udld_enable'], 'config': udld_global[dut2]['config']}
pll.exec_parallel(True,dut_list,udld.config_udld_global, [dict1, dict2])
###Enable UDLD on Interfaces
dict1 = {'intf': udld_int[dut1]['udld_int'],'udld_enable': udld_int[dut1]['udld_enable'], 'config': udld_int[dut1]['config']}
dict2 = {'intf': udld_int[dut2]['udld_int'],'udld_enable': udld_int[dut2]['udld_enable'], 'config': udld_int[dut2]['config']}
pll.exec_parallel(True,dut_list,udld.config_intf_udld, [dict1, dict2])
st.wait(2)
####################PDB will REMOVE after suite completion
#import pdb;pdb.set_trace()
if verify_udld_neighbor(udld_neighbor):
print_log("UDLD neighbor verification PASSED", "HIGH")
else:
print_log("UDLD neighbor verification FAILED", "HIGH")
udld_neighbor_fail += 1
tc_result2 += 1
final_result = False
print_log("Do Warm Reboot in Aggressive Mode...", 'MED')
utils.exec_foreach(True, dut_reload, reboot_api.config_warm_restart, oper="enable")
utils.exec_all(True, [[st.reboot, dut, "warm"] for dut in dut_reload])
st.wait(10)
if verify_udld_neighbor(udld_neighbor):
print_log("UDLD neighbor in normal mode after cold reboot verification PASSED", "HIGH")
else:
print_log("UDLD neighbor in normal mode after cold reboot verification FAILED", "HIGH")
udld_neighbor_warm_reboot_norm_fail += 1
tc_result2 += 1
final_result = False
###Disable UDLD on Interfaces
dict1 = {'intf': udld_int[dut1]['udld_int'],'udld_enable': 'no', 'config': 'no'}
dict2 = {'intf': udld_int[dut2]['udld_int'],'udld_enable': 'no', 'config': 'no'}
pll.exec_parallel(True,dut_list,udld.config_intf_udld, [dict1, dict2])
###Disable UDLD global
dict1 = {'udld_enable': 'no', 'config': 'no'}
dict2 = {'udld_enable': 'no', 'config': 'no'}
pll.exec_parallel(True,dut_list,udld.config_udld_global, [dict1, dict2])
if tc_result2 > 0:
st.report_tc_fail("FtOpSoSwudldloopaggressive001", "UDLD_TX_RX_loop_Aggressive_Failed", "test_udld_loops_normal_aggressive")
else:
st.report_tc_pass("FtOpSoSwudldloopaggressive001", "UDLD_TX_RX_loop_Aggressive_Passed", "test_udld_loops_normal_aggressive")
if final_result:
st.report_pass("test_case_passed")
else:
fail_msg = ''
if udld_interface_normal_loop_fail > 0:
fail_msg += 'UDLD loop port down Failed in Normal mode:'
if udld_interface_no_normal_loop_fail > 0:
fail_msg += 'UDLD no loop port up Failed in Normal mode:'
if udld_mode_fail > 0:
fail_msg += 'UDLD mode Aggressive config Failed:'
if udld_interface_aggressive_loop_fail > 0:
fail_msg += 'UDLD loop port down Failed in Aggressive mode:'
if udld_interface_no_aggressive_loop_fail > 0:
fail_msg += 'UDLD no loop port up Failed in Aggressive mode:'
if udld_neighbor_fail > 0:
fail_msg += 'UDLD neighbor Failed:'
if udld_neighbor_warm_reboot_norm_fail > 0:
fail_msg += 'UDLD neighbor Failed after warm reboot:'
st.report_fail("test_case_failure_message", fail_msg.strip(':'))
def config_ip_address(oper='add'):
st.log("Configuring ipv4 address on D1 and D2 connected port")
dict1 = {
'interface_name': vars.D1D2P1,
'ip_address': ssh_data.ipv4_address_D1D2P1,
'subnet': ssh_data.ipv4_mask,
'family': "ipv4",
'config': oper
}
dict2 = {
'interface_name': vars.D2D1P1,
'ip_address': ssh_data.ipv4_address_D2D1P1,
'subnet': ssh_data.ipv4_mask,
'family': "ipv4",
'config': oper
}
parallel.exec_parallel(True, [vars.D1, vars.D2],
ip_obj.config_ip_addr_interface, [dict1, dict2])
dict1 = {
'interface_name': vars.D1D2P2,
'ip_address': ssh_data.ipv4_address_D1D2P2,
'subnet': ssh_data.ipv4_mask,
'family': "ipv4",
'config': oper
}
dict2 = {
'interface_name': vars.D2D1P2,
'ip_address': ssh_data.ipv4_address_D2D1P2,
'subnet': ssh_data.ipv4_mask,
'family': "ipv4",
'config': oper
}
parallel.exec_parallel(True, [vars.D1, vars.D2],
ip_obj.config_ip_addr_interface, [dict1, dict2])
st.log("Configuring ipv6 address on D1 and D2 connected port")
dict1 = {
'interface_name': vars.D1D2P1,
'ip_address': ssh_data.ipv6_address_D1D2P1,
'subnet': ssh_data.ipv6_mask,
'family': "ipv6",
'config': oper
}
dict2 = {
'interface_name': vars.D2D1P1,
'ip_address': ssh_data.ipv6_address_D2D1P1,
'subnet': ssh_data.ipv6_mask,
'family': "ipv6",
'config': oper
}
parallel.exec_parallel(True, [vars.D1, vars.D2],
ip_obj.config_ip_addr_interface, [dict1, dict2])
dict1 = {
'interface_name': vars.D1D2P2,
'ip_address': ssh_data.ipv6_address_D1D2P2,
'subnet': ssh_data.ipv6_mask,
'family': "ipv6",
'config': oper
}
dict2 = {
'interface_name': vars.D2D1P2,
'ip_address': ssh_data.ipv6_address_D2D1P2,
'subnet': ssh_data.ipv6_mask,
'family': "ipv6",
'config': oper
}
parallel.exec_parallel(True, [vars.D1, vars.D2],
ip_obj.config_ip_addr_interface, [dict1, dict2])
def cleanup_evpn_5549():
make_global_vars()
global vars
vars = st.get_testbed_vars()
############################################################################################
hdrMsg("Delete router bgp on dut1 and dut2")
############################################################################################
dict1 = {'config_type_list': ["removeBGP"], 'removeBGP': 'yes', 'config': 'no'}
parallel.exec_parallel(True, data.spine_nodes_list, bgp_obj.config_bgp, [dict1,dict1])
parallel.exec_parallel(True, data.leaf_nodes_list, bgp_obj.config_bgp, [dict1,dict1,dict1,dict1])
############################################################################################
hdrMsg("\n####### Unconfigure IP address on link1 of all the DUTs ##############\n")
############################################################################################
utils.exec_all(True, [[ipfeature.config_interface_ip6_link_local, vars.D1, data.spine1_port_list1, 'disable'], [ipfeature.config_interface_ip6_link_local, vars.D2, data.spine2_port_list1, 'disable']])
utils.exec_all(True, [[ipfeature.config_interface_ip6_link_local, vars.D3, data.leafs_spine1_port_lst1[0], 'disable'], [ipfeature.config_interface_ip6_link_local, vars.D4, data.leafs_spine1_port_lst1[1], 'disable'], [ipfeature.config_interface_ip6_link_local, vars.D5, data.leafs_spine1_port_lst1[2], 'disable'],[ipfeature.config_interface_ip6_link_local, vars.D6, data.leafs_spine1_port_lst1[3], 'disable']])
utils.exec_all(True, [[ipfeature.config_interface_ip6_link_local, vars.D3, data.leafs_spine2_port_lst1[0], 'disable'], [ipfeature.config_interface_ip6_link_local, vars.D4, data.leafs_spine2_port_lst1[1],'disable'], [ipfeature.config_interface_ip6_link_local, vars.D5, data.leafs_spine2_port_lst1[2],'disable'],[ipfeature.config_interface_ip6_link_local, vars.D6, data.leafs_spine2_port_lst1[3],'disable']])
############################################################################################
hdrMsg("\n########## Unconfigure IP address on link2 (LAG) of all the DUTs ##############\n")
############################################################################################
utils.exec_all(True, [[ipfeature.config_interface_ip6_link_local, vars.D1, data.spine1_po_list, 'disable'], [ipfeature.config_interface_ip6_link_local, vars.D2, data.spine2_po_list, 'disable']])
utils.exec_all(True, [[ipfeature.config_interface_ip6_link_local, vars.D3, data.leaf1_po_list[0], 'disable'], [ipfeature.config_interface_ip6_link_local, vars.D4, data.leaf2_po_list[0], 'disable'], [ipfeature.config_interface_ip6_link_local, vars.D5, data.leaf3_po_list[0], 'disable'],[ipfeature.config_interface_ip6_link_local, vars.D6, data.leaf4_po_list[0], 'disable']])
utils.exec_all(True, [[ipfeature.config_interface_ip6_link_local, vars.D3, data.leaf1_po_list[1], 'disable'], [ipfeature.config_interface_ip6_link_local, vars.D4, data.leaf2_po_list[1], 'disable'], [ipfeature.config_interface_ip6_link_local, vars.D5, data.leaf3_po_list[1], 'disable'],[ipfeature.config_interface_ip6_link_local, vars.D6, data.leaf4_po_list[1], 'disable']])
############################################################################################
hdrMsg("\n####### Unconfigure IP address on link3 of all the DUTs ##############\n")
############################################################################################
for ipv6_1,ipv6_2,po1,po2 in zip(data.spine1_ipv6_list, data.spine2_ipv6_list,data.spine1_port_list4, data.spine2_port_list4):
utils.exec_all(True,[[ipfeature.delete_ip_interface,vars.D1, po1, ipv6_1 , data.maskv6,'ipv6'],[ipfeature.delete_ip_interface,vars.D2, po2, ipv6_2, data.maskv6,'ipv6']])
utils.exec_all(True,[[ipfeature.delete_ip_interface,vars.D3, data.leafs_spine1_port_lst4[0], data.leaf_spine1_ipv6_list[0], data.maskv6,'ipv6'],[ipfeature.delete_ip_interface,vars.D4, data.leafs_spine1_port_lst4[1], data.leaf_spine1_ipv6_list[1], data.maskv6,'ipv6'], [ipfeature.delete_ip_interface,vars.D5, data.leafs_spine1_port_lst4[2], data.leaf_spine1_ipv6_list[2] , data.maskv6,'ipv6'], [ipfeature.delete_ip_interface,vars.D6, data.leafs_spine1_port_lst4[3], data.leaf_spine1_ipv6_list[3] , data.maskv6,'ipv6']])
utils.exec_all(True,[[ipfeature.delete_ip_interface,vars.D3, data.leafs_spine2_port_lst4[0], data.leaf_spine2_ipv6_list[0], data.maskv6,'ipv6'],[ipfeature.delete_ip_interface,vars.D4, data.leafs_spine2_port_lst4[1], data.leaf_spine2_ipv6_list[1], data.maskv6,'ipv6'], [ipfeature.delete_ip_interface,vars.D5, data.leafs_spine2_port_lst4[2], data.leaf_spine2_ipv6_list[2], data.maskv6,'ipv6'], [ipfeature.delete_ip_interface,vars.D6, data.leafs_spine2_port_lst4[3], data.leaf_spine2_ipv6_list[3], data.maskv6,'ipv6']])
############################################################################################
hdrMsg("\n########## Delete Port-channel and portchannel members ############\n")
############################################################################################
st.log("Add members to port channel created b/w leaf and spine nodes")
utils.exec_all(True, [[pch.delete_portchannel_member, data.leaf_nodes_list[0], data.leaf1_po_list[0], data.leaf1_spine1_po_intf_list],
[pch.delete_portchannel_member, data.leaf_nodes_list[1], data.leaf2_po_list[0], data.leaf2_spine1_po_intf_list],
[pch.delete_portchannel_member, data.leaf_nodes_list[2], data.leaf3_po_list[0], data.leaf3_spine1_po_intf_list],
[pch.delete_portchannel_member, data.leaf_nodes_list[3], data.leaf4_po_list[0], data.leaf4_spine1_po_intf_list]])
utils.exec_all(True, [[pch.delete_portchannel_member, data.leaf_nodes_list[0], data.leaf1_po_list[1], data.leaf1_spine2_po_intf_list],
[pch.delete_portchannel_member, data.leaf_nodes_list[1], data.leaf2_po_list[1], data.leaf2_spine2_po_intf_list],
[pch.delete_portchannel_member, data.leaf_nodes_list[2], data.leaf3_po_list[1], data.leaf3_spine2_po_intf_list],
[pch.delete_portchannel_member, data.leaf_nodes_list[3], data.leaf4_po_list[1], data.leaf4_spine2_po_intf_list]])
for po1,po2,intf_list1,intf_list2 in zip(data.spine1_po_list,data.spine2_po_list,data.spine1_all_lfs_po_intf_list,data.spine2_all_lfs_po_intf_list):
utils.exec_all(True, [[pch.delete_portchannel_member, data.spine_nodes_list[0], po1, intf_list1],
[pch.delete_portchannel_member, data.spine_nodes_list[1], po2, intf_list2]])
for i in range(0,2):
utils.exec_all(True, [[pch.delete_portchannel, data.leaf_nodes_list[0], data.leaf1_po_list[i]],
[pch.delete_portchannel, data.leaf_nodes_list[1], data.leaf2_po_list[i]],
[pch.delete_portchannel, data.leaf_nodes_list[2], data.leaf3_po_list[i]],
[pch.delete_portchannel, data.leaf_nodes_list[3], data.leaf4_po_list[i]]])
for i in range(0,4):
utils.exec_all(True,
[[pch.delete_portchannel, data.spine_nodes_list[0], data.spine1_po_list[i]],
[pch.delete_portchannel, data.spine_nodes_list[1], data.spine2_po_list[i]]])
############################################################################################
hdrMsg(" \n########### Unconfigure loopback interface ##############\n")
############################################################################################
utils.exec_all(True,[[ipfeature.delete_ip_interface, vars.D1, 'Loopback1', data.spine_loopback_list[0], 32, 'ipv4'], [ipfeature.delete_ip_interface, vars.D2, 'Loopback1', data.spine_loopback_list[1], 32, 'ipv4'], [ipfeature.delete_ip_interface, vars.D3, 'Loopback1', data.leaf_loopback_list[0], 32, 'ipv4'], [ipfeature.delete_ip_interface, vars.D4, 'Loopback1', data.leaf_loopback_list[1], 32, 'ipv4'], [ipfeature.delete_ip_interface, vars.D5, 'Loopback1', data.leaf_loopback_list[2], 32, 'ipv4'], [ipfeature.delete_ip_interface, vars.D6, 'Loopback1', data.leaf_loopback_list[3], 32, 'ipv4']])
dict={}
for i in range(0,6):
dict[i] = {'loopback_name':'Loopback1', 'config':'no'}
dict_lst = [dict[x] for x in range(0,6)]
parallel.exec_parallel(True,data.spine_nodes_list+data.leaf_nodes_list,ipfeature.configure_loopback,dict_lst)
############################################################################################
hdrMsg("\n########## Disable debugs ############\n")
############################################################################################
disable_debugs()
def setup_evpn_5549():
global vars
vars = st.get_testbed_vars()
make_global_vars()
############################################################################################
hdrMsg("\n########## BASE CONFIGS ############\n")
############################################################################################
############################################################################################
hdrMsg("\n########## Enable debugs ############\n")
############################################################################################
enable_debugs()
############################################################################################
hdrMsg("\n########## Configure Port-channel and portchannel members ############\n")
############################################################################################
st.log("create port channel interface b/w leaf and spine nodes")
utils.exec_all(True, [[pch.create_portchannel, data.leaf_nodes_list[0], data.leaf1_po_list],
[pch.create_portchannel, data.leaf_nodes_list[1], data.leaf2_po_list],
[pch.create_portchannel, data.leaf_nodes_list[2], data.leaf3_po_list],
[pch.create_portchannel, data.leaf_nodes_list[3], data.leaf4_po_list],
[pch.create_portchannel, data.spine_nodes_list[0], data.spine1_po_list],
[pch.create_portchannel, data.spine_nodes_list[1], data.spine2_po_list]])
st.log("Add members to port channel created b/w leaf and spine nodes")
utils.exec_all(True, [[pch.add_portchannel_member, data.leaf_nodes_list[0], data.leaf1_po_list[0], data.leaf1_spine1_po_intf_list],
[pch.add_portchannel_member, data.leaf_nodes_list[1], data.leaf2_po_list[0], data.leaf2_spine1_po_intf_list],
[pch.add_portchannel_member, data.leaf_nodes_list[2], data.leaf3_po_list[0], data.leaf3_spine1_po_intf_list],
[pch.add_portchannel_member, data.leaf_nodes_list[3], data.leaf4_po_list[0], data.leaf4_spine1_po_intf_list]])
utils.exec_all(True, [[pch.add_portchannel_member, data.leaf_nodes_list[0], data.leaf1_po_list[1], data.leaf1_spine2_po_intf_list],
[pch.add_portchannel_member, data.leaf_nodes_list[1], data.leaf2_po_list[1], data.leaf2_spine2_po_intf_list],
[pch.add_portchannel_member, data.leaf_nodes_list[2], data.leaf3_po_list[1], data.leaf3_spine2_po_intf_list],
[pch.add_portchannel_member, data.leaf_nodes_list[3], data.leaf4_po_list[1], data.leaf4_spine2_po_intf_list]])
for po1,po2,intf_list1,intf_list2 in zip(data.spine1_po_list,data.spine2_po_list,data.spine1_all_lfs_po_intf_list,data.spine2_all_lfs_po_intf_list):
utils.exec_all(True, [[pch.add_portchannel_member,data.spine_nodes_list[0], po1, intf_list1],
[pch.add_portchannel_member, data.spine_nodes_list[1], po2, intf_list2]])
st.log("Enable portchannel interface on all leaf and spine nodes")
utils.exec_all(True, [[Intf.interface_operation, data.leaf_nodes_list[0], data.leaf1_po_list, "startup"],
[Intf.interface_operation, data.leaf_nodes_list[1], data.leaf2_po_list, "startup"],
[Intf.interface_operation, data.leaf_nodes_list[2], data.leaf3_po_list, "startup"],
[Intf.interface_operation, data.leaf_nodes_list[3], data.leaf4_po_list, "startup"],
[Intf.interface_operation, data.spine_nodes_list[0], data.spine1_po_list, "startup"],
[Intf.interface_operation, data.spine_nodes_list[1], data.spine2_po_list, "startup"]])
############################################################################################
hdrMsg("\n####### Configure IP address on link1 of all the DUTs ##############\n")
############################################################################################
utils.exec_all(True, [[ipfeature.config_interface_ip6_link_local, vars.D1, data.spine1_port_list1], [ipfeature.config_interface_ip6_link_local, vars.D2, data.spine2_port_list1]])
utils.exec_all(True, [[ipfeature.config_interface_ip6_link_local, vars.D3, data.leafs_spine1_port_lst1[0]], [ipfeature.config_interface_ip6_link_local, vars.D4, data.leafs_spine1_port_lst1[1]], [ipfeature.config_interface_ip6_link_local, vars.D5, data.leafs_spine1_port_lst1[2]],[ipfeature.config_interface_ip6_link_local, vars.D6, data.leafs_spine1_port_lst1[3]]])
utils.exec_all(True, [[ipfeature.config_interface_ip6_link_local, vars.D3, data.leafs_spine2_port_lst1[0]], [ipfeature.config_interface_ip6_link_local, vars.D4, data.leafs_spine2_port_lst1[1]], [ipfeature.config_interface_ip6_link_local, vars.D5, data.leafs_spine2_port_lst1[2]],[ipfeature.config_interface_ip6_link_local, vars.D6, data.leafs_spine2_port_lst1[3]]])
############################################################################################
hdrMsg("\n########## Configure IP address on link2 (LAG) of all the DUTs ##############\n")
############################################################################################
utils.exec_all(True, [[ipfeature.config_interface_ip6_link_local, vars.D1, data.spine1_po_list], [ipfeature.config_interface_ip6_link_local, vars.D2, data.spine2_po_list]])
utils.exec_all(True, [[ipfeature.config_interface_ip6_link_local, vars.D3, data.leaf1_po_list[0]], [ipfeature.config_interface_ip6_link_local, vars.D4, data.leaf2_po_list[0]], [ipfeature.config_interface_ip6_link_local, vars.D5, data.leaf3_po_list[0]], [ipfeature.config_interface_ip6_link_local, vars.D6, data.leaf4_po_list[0]]])
utils.exec_all(True, [[ipfeature.config_interface_ip6_link_local, vars.D3, data.leaf1_po_list[1]], [ipfeature.config_interface_ip6_link_local, vars.D4, data.leaf2_po_list[1]], [ipfeature.config_interface_ip6_link_local, vars.D5, data.leaf3_po_list[1]], [ipfeature.config_interface_ip6_link_local, vars.D6, data.leaf4_po_list[1]]])
############################################################################################
hdrMsg("\n####### Configure IP address on link3 of all the DUTs ##############\n")
############################################################################################
for ipv6_1,ipv6_2,po1,po2 in zip(data.spine1_ipv6_list, data.spine2_ipv6_list,data.spine1_port_list4, data.spine2_port_list4):
utils.exec_all(True,[[ipfeature.config_ip_addr_interface,vars.D1, po1, ipv6_1 , data.maskv6,'ipv6'],[ipfeature.config_ip_addr_interface,vars.D2, po2, ipv6_2, data.maskv6,'ipv6']])
utils.exec_all(True,[[ipfeature.config_ip_addr_interface,vars.D3, data.leafs_spine1_port_lst4[0], data.leaf_spine1_ipv6_list[0], data.maskv6,'ipv6'],[ipfeature.config_ip_addr_interface,vars.D4, data.leafs_spine1_port_lst4[1], data.leaf_spine1_ipv6_list[1], data.maskv6,'ipv6'], [ipfeature.config_ip_addr_interface,vars.D5, data.leafs_spine1_port_lst4[2], data.leaf_spine1_ipv6_list[2] , data.maskv6,'ipv6'], [ipfeature.config_ip_addr_interface,vars.D6, data.leafs_spine1_port_lst4[3], data.leaf_spine1_ipv6_list[3] , data.maskv6,'ipv6']])
utils.exec_all(True,[[ipfeature.config_ip_addr_interface,vars.D3, data.leafs_spine2_port_lst4[0], data.leaf_spine2_ipv6_list[0], data.maskv6,'ipv6'],[ipfeature.config_ip_addr_interface,vars.D4, data.leafs_spine2_port_lst4[1], data.leaf_spine2_ipv6_list[1], data.maskv6,'ipv6'], [ipfeature.config_ip_addr_interface,vars.D5, data.leafs_spine2_port_lst4[2], data.leaf_spine2_ipv6_list[2], data.maskv6,'ipv6'], [ipfeature.config_ip_addr_interface,vars.D6, data.leafs_spine2_port_lst4[3], data.leaf_spine2_ipv6_list[3], data.maskv6,'ipv6']])
############################################################################################
hdrMsg("\n########## Enable router bgp and configure router id ##############\n")
############################################################################################
dict1 = {'local_as': data.bgp_leaf_local_as[0],'router_id':data.leaf_loopback_list[0],'config_type_list':['router_id']}
dict2 = {'local_as': data.bgp_leaf_local_as[1],'router_id':data.leaf_loopback_list[1],'config_type_list':['router_id']}
dict3 = {'local_as': data.bgp_leaf_local_as[2],'router_id':data.leaf_loopback_list[2],'config_type_list':['router_id']}
dict4 = {'local_as': data.bgp_leaf_local_as[3],'router_id':data.leaf_loopback_list[3],'config_type_list':['router_id']}
parallel.exec_parallel(True, data.leaf_nodes_list, bgp_obj.config_bgp, [dict1,dict2,dict3,dict4])
dict1 = {'local_as':data.bgp_spine_local_as[0],'router_id':data.spine_loopback_list[0], 'config_type_list':['router_id']}
dict2 = {'local_as':data.bgp_spine_local_as[1],'router_id':data.spine_loopback_list[1],'config_type_list':['router_id']}
parallel.exec_parallel(True, data.spine_nodes_list, bgp_obj.config_bgp, [dict1,dict2])
############################################################################################
hdrMsg(" \n######### Configure BGP neighbor for link1 on all spines and leafs ##########\n")
############################################################################################
dict1 = {'local_as':data.bgp_spine_local_as[0], 'config': 'yes', 'config_type_list':["multipath-relax"]}
dict2 = {'local_as':data.bgp_spine_local_as[1], 'config': 'yes', 'config_type_list':["multipath-relax"]}
parallel.exec_parallel(True,data.spine_nodes_list,bgp_obj.config_bgp,[dict1,dict2])
dict = {}
for i in range(0,4):
dict[i] = {'local_as':data.bgp_leaf_local_as[i], 'config': 'yes', 'config_type_list':["multipath-relax"]}
dict_lst = [dict[x] for x in range(0,4)]
parallel.exec_parallel(True,data.leaf_nodes_list,bgp_obj.config_bgp,dict_lst)
for intf1,intf2 in zip(data.spine1_port_list1,data.spine2_port_list1):
if evpn_dict['cli_mode'] == 'click':
dict1 = {'local_as':data.bgp_spine_local_as[0],'config':'yes','config_type_list':["remote-as"],'remote_as':'external','interface':intf1}
dict2 = {'local_as':data.bgp_spine_local_as[1],'config':'yes','config_type_list':["remote-as"],'remote_as':'external','interface':intf2}
parallel.exec_parallel(True,data.spine_nodes_list,bgp_obj.config_bgp,[dict1,dict2])
dict1 = {'local_as':data.bgp_spine_local_as[0],'config':'yes','config_type_list':["connect"],'neighbor':intf1,'connect':"1"}
dict2 = {'local_as':data.bgp_spine_local_as[1],'config':'yes','config_type_list':["connect"],'neighbor':intf2,'connect':"1"}
parallel.exec_parallel(True,data.spine_nodes_list,bgp_obj.config_bgp,[dict1,dict2])
elif evpn_dict['cli_mode'] == 'klish':
dict1 = {'local_as':data.bgp_spine_local_as[0],'config':'yes','config_type_list':["neighbor","connect"],'remote_as':'external','neighbor':intf1, \
'addr_family':"ipv6",'connect':"1"}
dict2 = {'local_as':data.bgp_spine_local_as[1],'config':'yes','config_type_list':["neighbor","connect"],'remote_as':'external','neighbor':intf2,'connect':"1"}
parallel.exec_parallel(True,data.spine_nodes_list,bgp_obj.config_bgp,[dict1,dict2])
dict1 = {'local_as':data.bgp_spine_local_as[0], 'config': 'yes', 'config_type_list':["activate"], 'neighbor':intf1,'remote_as':'external'}
dict2 = {'local_as':data.bgp_spine_local_as[1], 'config': 'yes', 'config_type_list':["activate"], 'neighbor':intf2,'remote_as':'external'}
parallel.exec_parallel(True,data.spine_nodes_list,evpn_api.config_bgp_evpn,[dict1,dict2])
for port_lst1 in [data.leafs_spine1_port_lst1, data.leafs_spine2_port_lst1]:
if evpn_dict['cli_mode'] == 'click':
dict = {}
for i in range(0,4):
dict[i] ={'local_as':data.bgp_leaf_local_as[i],'config':'yes','config_type_list':["remote-as"],'remote_as':'external','interface':port_lst1[i]}
dict_lst = [dict[x] for x in range(0,4)]
parallel.exec_parallel(True,data.leaf_nodes_list,bgp_obj.config_bgp,dict_lst)
dict = {}
for i in range(0,4):
dict[i] ={'local_as':data.bgp_leaf_local_as[i],'config':'yes','config_type_list':["connect"],'neighbor':port_lst1[i],'connect':"1"}
dict_lst = [dict[x] for x in range(0,4)]
parallel.exec_parallel(True,data.leaf_nodes_list,bgp_obj.config_bgp,dict_lst)
elif evpn_dict['cli_mode'] == 'klish':
for i in range(0,4):
dict[i] ={'local_as':data.bgp_leaf_local_as[i],'config':'yes','config_type_list':["neighbor","connect"],'remote_as':'external', \
'addr_family':"ipv6",'neighbor':port_lst1[i],'connect':"1"}
dict_lst = [dict[x] for x in range(0,4)]
parallel.exec_parallel(True,data.leaf_nodes_list,bgp_obj.config_bgp,dict_lst)
dict = {}
for i in range(0,4):
dict[i] = {'local_as':data.bgp_leaf_local_as[i], 'config': 'yes', 'config_type_list':["activate"], 'neighbor':port_lst1[i],'remote_as':'external'}
dict_lst = [dict[x] for x in range(0,4)]
parallel.exec_parallel(True,data.leaf_nodes_list,evpn_api.config_bgp_evpn,dict_lst)
############################################################################################
hdrMsg(" \n######### Configure BGP neighbor for link2 on all spines and leafs ##########\n")
############################################################################################
for intf1,intf2,j in zip(data.spine1_po_list,data.spine2_po_list,range(0,4)):
if evpn_dict['cli_mode'] == 'click':
dict1 = {'local_as':data.bgp_spine_local_as[0],'config':'yes','config_type_list':["remote-as"],'remote_as':data.bgp_leaf_local_as[j],'interface' :intf1}
dict2 = {'local_as':data.bgp_spine_local_as[1],'config':'yes','config_type_list':["remote-as"],'remote_as':data.bgp_leaf_local_as[j],'interface' :intf2}
parallel.exec_parallel(True,data.spine_nodes_list,bgp_obj.config_bgp,[dict1,dict2])
dict1 = {'local_as':data.bgp_spine_local_as[0],'config':'yes','config_type_list':["connect"],'neighbor' :intf1,'connect':"1"}
dict2 = {'local_as':data.bgp_spine_local_as[1],'config':'yes','config_type_list':["connect"],'neighbor' :intf2,'connect':"1"}
parallel.exec_parallel(True,data.spine_nodes_list,bgp_obj.config_bgp,[dict1,dict2])
elif evpn_dict['cli_mode'] == 'klish':
dict1 = {'local_as':data.bgp_spine_local_as[0],'config':'yes','config_type_list':["neighbor","connect"],'remote_as':data.bgp_leaf_local_as[j], \
'addr_family':"ipv6",'neighbor' :intf1,'connect':"1"}
dict2 = {'local_as':data.bgp_spine_local_as[1],'config':'yes','config_type_list':["neighbor","connect"],'remote_as':data.bgp_leaf_local_as[j], \
'addr_family':"ipv6",'neighbor' :intf2,'connect':"1"}
parallel.exec_parallel(True,data.spine_nodes_list,bgp_obj.config_bgp,[dict1,dict2])
dict1 = {'local_as':data.bgp_spine_local_as[0], 'config': 'yes', 'config_type_list':["activate"], 'neighbor':intf1,'remote_as':data.bgp_leaf_local_as[j]}
dict2 = {'local_as':data.bgp_spine_local_as[1], 'config': 'yes', 'config_type_list':["activate"], 'neighbor':intf2,'remote_as':data.bgp_leaf_local_as[j]}
parallel.exec_parallel(True,data.spine_nodes_list,evpn_api.config_bgp_evpn,[dict1,dict2])
for j,port_lst1 in zip(range(0,2),[data.leafs_spine1_po_lst1, data.leafs_spine2_po_lst1]):
if evpn_dict['cli_mode'] == 'click':
dict = {}
for i in range(0,4):
dict[i] = {'local_as':data.bgp_leaf_local_as[i],'config':'yes','config_type_list':["remote-as"],'remote_as':data.bgp_spine_local_as[j],'interface':port_lst1[i]}
dict_lst = [dict[x] for x in range(0,4)]
parallel.exec_parallel(True,data.leaf_nodes_list,bgp_obj.config_bgp,dict_lst)
dict = {}
for i in range(0,4):
dict[i] = {'local_as':data.bgp_leaf_local_as[i],'config':'yes','config_type_list':["connect"],'neighbor':port_lst1[i],'connect':"1"}
dict_lst = [dict[x] for x in range(0,4)]
parallel.exec_parallel(True,data.leaf_nodes_list,bgp_obj.config_bgp,dict_lst)
elif evpn_dict['cli_mode'] == 'klish':
dict = {}
for i in range(0,4):
dict[i] = {'local_as':data.bgp_leaf_local_as[i], 'config': 'yes', 'config_type_list':["neighbor","connect"], 'remote_as': data.bgp_spine_local_as[j], 'neighbor' : port_lst1[i],'addr_family':"ipv6",'connect':"1"}
dict_lst = [dict[x] for x in range(0,4)]
parallel.exec_parallel(True,data.leaf_nodes_list,bgp_obj.config_bgp,dict_lst)
dict = {}
for i in range(0,4):
dict[i] = {'local_as':data.bgp_leaf_local_as[i], 'config': 'yes', 'config_type_list':["activate"],'neighbor':port_lst1[i],'remote_as': data.bgp_spine_local_as[j]}
dict_lst = [dict[x] for x in range(0,4)]
parallel.exec_parallel(True,data.leaf_nodes_list,evpn_api.config_bgp_evpn,dict_lst)
############################################################################################
hdrMsg(" \n######### Configure BGP neighbor for link3 on all spines and leafs ##########\n")
############################################################################################
for ipv6_1,ipv6_2,j in zip(data.leaf_spine1_ipv6_list, data.leaf_spine2_ipv6_list,range(0,4)):
dict1 = {'local_as':data.bgp_spine_local_as[0], 'config': 'yes', 'config_type_list':["neighbor","connect"], 'remote_as':data.bgp_leaf_local_as[j], 'neighbor' : ipv6_1,'addr_family':"ipv6",'connect':"1"}
dict2 = {'local_as':data.bgp_spine_local_as[1], 'config': 'yes', 'config_type_list':["neighbor","connect"], 'remote_as':data.bgp_leaf_local_as[j], 'neighbor' : ipv6_2,'addr_family':"ipv6",'connect':"1"}
parallel.exec_parallel(True,data.spine_nodes_list,bgp_obj.config_bgp,[dict1,dict2])
dict1 = {'local_as':data.bgp_spine_local_as[0], 'config': 'yes', 'config_type_list':["activate"], 'neighbor':ipv6_1,'remote_as':data.bgp_leaf_local_as[j]}
dict2 = {'local_as':data.bgp_spine_local_as[1], 'config': 'yes', 'config_type_list':["activate"], 'neighbor':ipv6_2,'remote_as':data.bgp_leaf_local_as[j]}
parallel.exec_parallel(True,data.spine_nodes_list,evpn_api.config_bgp_evpn,[dict1,dict2])
for ipv6_lst1,j in zip([data.spine1_ipv6_list,data.spine2_ipv6_list],range(0,2)):
dict = {}
for i in range(0,4):
dict[i] = {'local_as':data.bgp_leaf_local_as[i], 'config': 'yes', 'config_type_list':["neighbor","connect"], 'remote_as':data.bgp_spine_local_as[j], 'neighbor' : ipv6_lst1[i],'addr_family':"ipv6",'connect':"1"}
dict_lst = [dict[x] for x in range(0,4)]
parallel.exec_parallel(True,data.leaf_nodes_list,bgp_obj.config_bgp,dict_lst)
dict = {}
for i in range(0,4):
dict[i] = {'local_as':data.bgp_leaf_local_as[i], 'config': 'yes', 'config_type_list':["activate"], 'neighbor':ipv6_lst1[i],'remote_as':data.bgp_spine_local_as[j]}
dict_lst = [dict[x] for x in range(0,4)]
parallel.exec_parallel(True,data.leaf_nodes_list,evpn_api.config_bgp_evpn,dict_lst)
dict1 = {'local_as':data.bgp_spine_local_as[0], 'config': 'yes', 'config_type_list':["advertise_all_vni"]}
dict2 = {'local_as':data.bgp_spine_local_as[1], 'config': 'yes', 'config_type_list':["advertise_all_vni"]}
parallel.exec_parallel(True,data.spine_nodes_list,evpn_api.config_bgp_evpn,[dict1,dict2])
dict = {}
for i in range(0,4):
dict[i] = {'local_as':data.bgp_leaf_local_as[i], 'config': 'yes', 'config_type_list':["advertise_all_vni"]}
dict_lst = [dict[x] for x in range(0,4)]
parallel.exec_parallel(True,data.leaf_nodes_list,evpn_api.config_bgp_evpn,dict_lst)
############################################################################################
hdrMsg(" \n####### Verify BGP neighborship on Spine1 and Spine2 ##############\n")
############################################################################################
if not retry_api(ip_bgp.check_bgp_session,vars.D1,nbr_list=data.spine1_port_list1,state_list=['Established']*4,retry_count=9,delay=5):
st.error("########## BGP neighborship between Spine 1 towards Leafs is not Up ##########")
if not retry_api(ip_bgp.check_bgp_session,vars.D2,nbr_list=data.spine2_port_list1,state_list=['Established']*4,retry_count=9,delay=5):
st.error("########## BGP neighborship between Spine 2 towards Leaf is not Up ##########")
evpn_verify1 = { "neighbor": data.leaf_spine1_ipv6_list+data.spine1_port_list1+data.spine1_po_list, "updown": ["up"]*12}
evpn_verify2 = { "neighbor": data.leaf_spine2_ipv6_list+data.spine2_port_list1+data.spine2_po_list, "updown": ["up"]*12}
st.log("verify BGP EVPN neighborship for ipv6 global address, router port & L3 PortChannel b/w Spine towards Leaf ndoes")
parallel.exec_parallel(True, data.spine_nodes_list, evpn_api.verify_bgp_l2vpn_evpn_summary,[evpn_verify1,evpn_verify2])
############################################################################################
hdrMsg(" \n####### Configure loopback interface ##############\n")
############################################################################################
dict={}
for i in range(0,6):
dict[i] = {'loopback_name':'Loopback1', 'config':'yes'}
dict_lst = [dict[x] for x in range(0,6)]
parallel.exec_parallel(True,data.spine_nodes_list+data.leaf_nodes_list,ipfeature.configure_loopback,dict_lst)
utils.exec_all(True,[[ipfeature.config_ip_addr_interface, vars.D1, 'Loopback1', data.spine_loopback_list[0], 32, 'ipv4'], [ipfeature.config_ip_addr_interface, vars.D2, 'Loopback1', data.spine_loopback_list[1], 32, 'ipv4'], [ipfeature.config_ip_addr_interface, vars.D3, 'Loopback1', data.leaf_loopback_list[0], 32, 'ipv4'], [ipfeature.config_ip_addr_interface, vars.D4, 'Loopback1', data.leaf_loopback_list[1], 32, 'ipv4'], [ipfeature.config_ip_addr_interface, vars.D5, 'Loopback1', data.leaf_loopback_list[2], 32, 'ipv4'], [ipfeature.config_ip_addr_interface, vars.D6, 'Loopback1', data.leaf_loopback_list[3], 32, 'ipv4']])
############################################################################################
hdrMsg(" \n####### Redistribute connected route in to bgp ##############\n")
############################################################################################
dict = {}
for i,as1 in zip(range(0,6),data.bgp_spine_local_as+data.bgp_leaf_local_as):
dict[i] = {'local_as':as1, 'config_type_list':['redist'],'redistribute':'connected'}
dict_lst = [dict[x] for x in range(0,6)]
parallel.exec_parallel(True,data.spine_nodes_list+data.leaf_nodes_list,bgp_obj.config_bgp,dict_lst)
############################################################################################
hdrMsg(" \n####### Verify ip route shows IPv6 NH ##############\n")
############################################################################################
x={}
for i, dut, port in zip(range(0,4), data.leaf_nodes_list, data.leafs_spine1_port_lst1):
x[i]=basic_obj.get_ifconfig_inet6(dut, port)
for i,ip in zip(range(0,4),data.leaf_loopback_list):
if not retry_api(ipfeature.verify_ip_route,vars.D1, type='B', nexthop = x[i][0].strip(), ip_address = ip+'/32',retry_count=9,delay=1):
st.report_fail("ip_routing_int_create_fail", ip)
############################################################################################
hdrMsg(" \n####### Configure BFD on BGP unnumbered sessions ##############\n")
############################################################################################
for intf1,intf2 in zip(data.spine1_port_list1,data.spine2_port_list1):
dict1 = {'local_as':data.bgp_spine_local_as[0], 'config': 'yes', 'config_type_list':["bfd"], 'interface' : intf1,'remote_as':'external'}
dict2 = {'local_as':data.bgp_spine_local_as[1], 'config': 'yes', 'config_type_list':["bfd"], 'interface' : intf2,'remote_as':'external'}
parallel.exec_parallel(True,data.spine_nodes_list,bgp_obj.config_bgp,[dict1,dict2])
for port_lst1 in [data.leafs_spine1_port_lst1, data.leafs_spine2_port_lst1]:
dict = {}
for i in range(0,4):
dict[i] = {'local_as':data.bgp_leaf_local_as[i], 'config': 'yes', 'config_type_list':["bfd"], 'remote_as':'external', 'interface' : port_lst1[i]}
dict_lst = [dict[x] for x in range(0,4)]
parallel.exec_parallel(True,data.leaf_nodes_list,bgp_obj.config_bgp, dict_lst)
for intf1,intf2,j in zip(data.spine1_po_list,data.spine2_po_list,range(0,4)):
dict1 = {'local_as':data.bgp_spine_local_as[0], 'config': 'yes', 'config_type_list':["bfd"], 'remote_as':data.bgp_leaf_local_as[j], 'interface' : intf1}
dict2 = {'local_as':data.bgp_spine_local_as[1], 'config': 'yes', 'config_type_list':["bfd"], 'remote_as':data.bgp_leaf_local_as[j], 'interface' : intf2}
parallel.exec_parallel(True,data.spine_nodes_list,bgp_obj.config_bgp,[dict1,dict2])
for j,port_lst1 in zip(range(0,2),[data.leafs_spine1_po_lst1, data.leafs_spine2_po_lst1]):
dict = {}
for i in range(0,4):
dict[i] = {'local_as':data.bgp_leaf_local_as[i], 'config': 'yes', 'config_type_list':["bfd"], 'remote_as': data.bgp_spine_local_as[j], 'interface' : port_lst1[i]}
dict_lst = [dict[x] for x in range(0,4)]
parallel.exec_parallel(True,data.leaf_nodes_list,bgp_obj.config_bgp,dict_lst)
for ipv6_1,ipv6_2,j in zip(data.leaf_spine1_ipv6_list, data.leaf_spine2_ipv6_list,range(0,4)):
dict1 = {'local_as':data.bgp_spine_local_as[0], 'config': 'yes', 'config_type_list':["bfd"], 'neighbor' : ipv6_1,'remote_as':data.bgp_leaf_local_as[j]}
dict2 = {'local_as':data.bgp_spine_local_as[1], 'config': 'yes', 'config_type_list':["bfd"], 'neighbor' : ipv6_2,'remote_as':data.bgp_leaf_local_as[j]}
parallel.exec_parallel(True,data.spine_nodes_list,bgp_obj.config_bgp,[dict1,dict2])
for ipv6_lst1,j in zip([data.spine1_ipv6_list,data.spine2_ipv6_list],range(0,2)):
dict = {}
for i in range(0,4):
dict[i] = {'local_as':data.bgp_leaf_local_as[i], 'config': 'yes', 'config_type_list':["bfd"], 'remote_as':data.bgp_spine_local_as[j], 'neighbor' : ipv6_lst1[i]}
dict_lst = [dict[x] for x in range(0,4)]
parallel.exec_parallel(True,data.leaf_nodes_list,bgp_obj.config_bgp,dict_lst)
n1 = get_num_of_bfd_sessions_up(vars.D1)
n2 = get_num_of_bfd_sessions_up(vars.D2)
if n1 >= 8 and n2 >= 8:
st.log('PASS: Total number of BFD sesions found is {} so expected min no of BFD session 8 found in Spine 1'.format(n1))
st.log('PASS: Total number of BFD sesions found is {} so expected min no of BFD session 8 found in Spine 2'.format(n2))
else:
st.error('FAIL: Min number of BFD sesions expected 8 but found {} sessions in Spine 1'.format(n1))
st.error('FAIL: Min number of BFD sesions expected 8 but found {} sessions in Spine 2'.format(n2))
st.report_fail("base_config_verification_failed")
def config_ip(config='yes'):
if config == 'yes':
api_name = ip_api.config_ip_addr_interface
config_str = "Configure"
else:
api_name = ip_api.delete_ip_interface
config_str = "Delete"
hdrMsg("Bring-up the port on dut3 which is connected to dhcp server ")
interface_api.interface_operation(data.dut3,
data.dhcp_server_port,
operation="startup")
##########################################################################
hdrMsg(
"IP-config: {} IP address between dut2 interface {} and dut3 interface {}"
.format(config_str, data.d2d3_ports, data.d3d2_ports))
##########################################################################
utils.exec_all(True, [[
api_name, data.dut2, data.d2d3_ports[0], dut2_3_ip_list[0], mask_24
], [api_name, data.dut3, data.d3d2_ports[0], dut3_2_ip_list[0], mask_24]])
if config == 'yes':
st.banner('Install L2 DHCP rules on dhcp client device')
copp_api.bind_class_action_copp_policy(data.dut4,
classifier='copp-system-dhcpl2',
action_group='copp-system-dhcp')
##########################################################################
hdrMsg("Create loopback interfaces on dut1, dut2 and dut3")
##########################################################################
parallel.exec_parallel(True, [data.dut1, data.dut2, data.dut3],
ip_api.configure_loopback,
[{
'loopback_name': 'Loopback1'
}] * 3)
##########################################################################
hdrMsg("Loopback-config: {} IP address on Loopback interface".format(
config_str))
##########################################################################
utils.exec_all(True, [[
api_name, data.dut1, "Loopback1", dut1_loopback_ip_list[0], '32'
], [
api_name, data.dut2, "Loopback1", dut2_loopback_ip_list[0], '32'
], [api_name, data.dut3, "Loopback1", dut3_loopback_ip_list[0], '32']])
##########################################
hdrMsg("config required vlan to test on dut2 and dut4")
##########################################
utils.exec_all(True, [[vlan_api.create_vlan, data.dut2, ['100']],
[vlan_api.create_vlan, data.dut4, ['100']]])
vlan_api.create_vlan(data.dut4, ['200', '300'])
##########################################
hdrMsg("Add vlan members")
##########################################
utils.exec_all(True, [[
vlan_api.add_vlan_member, data.dut2, '100', data.d2d4_ports[0],
True
],
[
vlan_api.add_vlan_member, data.dut4, '100',
data.d4d2_ports[0], True
]])
#########################################################
hdrMsg("LAG-Config: Create portchannel on dut2 and dut4")
#########################################################
utils.exec_all(True,
[[pc.create_portchannel, data.dut2, ['PortChannel12']],
[pc.create_portchannel, data.dut4, ['PortChannel12']]])
#########################################################
hdrMsg("LAG-Config: add member ports to portchannel")
#########################################################
utils.exec_all(True, [[
pc.add_del_portchannel_member, data.dut2, 'PortChannel12',
data.d2d4_ports[2], 'add'
],
[
pc.add_del_portchannel_member, data.dut4,
'PortChannel12', data.d4d2_ports[2], 'add'
]])
#########################################################
hdrMsg("LAG-Config: Create portchannel on dut3 and dut1")
#########################################################
utils.exec_all(True,
[[pc.create_portchannel, data.dut3, ['PortChannel14']],
[pc.create_portchannel, data.dut1, ['PortChannel14']]])
#########################################################
hdrMsg("LAG-Config: add member ports to portchannel")
#########################################################
utils.exec_all(True, [[
pc.add_del_portchannel_member, data.dut3, 'PortChannel14',
data.d3d1_ports[0], 'add'
],
[
pc.add_del_portchannel_member, data.dut1,
'PortChannel14', data.d1d3_ports[0], 'add'
]])
ip_api.config_ip_addr_interface(data.dut2, 'Vlan100',
dut2_4_ip_list[0], mask_24)
ip_api.config_ip_addr_interface(data.dut2, data.d2d4_ports[1],
dut2_4_ip_list[1], mask_24)
ip_api.config_ip_addr_interface(data.dut2, 'PortChannel12',
dut2_4_ip_list[2], mask_24)
ip_api.config_ip_addr_interface(data.dut1,
'PortChannel14',
data.dhcp_server_ipv6,
mask_v6,
family='ipv6')
#########################################
hdrMsg("Add vlan members on DUT4")
#########################################
vlan_api.add_vlan_member(data.dut4, '200', data.d4d2_ports[1])
vlan_api.add_vlan_member(data.dut4, '300', 'PortChannel12')
st.exec_all([[create_static_route_dut2], [create_static_route_dut3]])
else:
st.banner('Remove L2 DHCP rules on dhcp client device')
copp_api.bind_class_action_copp_policy(data.dut4,
classifier='copp-system-dhcpl2',
action_group='copp-system-dhcp',
config='no')
##########################################################################
hdrMsg("Loopback-config: {} IP address on Loopback interface".format(
config_str))
##########################################################################
utils.exec_all(True, [[
api_name, data.dut1, "Loopback1", dut1_loopback_ip_list[0], '32'
], [
api_name, data.dut2, "Loopback1", dut2_loopback_ip_list[0], '32'
], [api_name, data.dut3, "Loopback1", dut3_loopback_ip_list[0], '32']])
##########################################################################
hdrMsg("Delete loopback interfaces on dut1, dut2 and dut3")
##########################################################################
parallel.exec_parallel(True, [data.dut1, data.dut2, data.dut3],
ip_api.configure_loopback, [{
'loopback_name': 'Loopback1',
'config': 'no'
}] * 3)
st.exec_all([[delete_static_route_dut2], [delete_static_route_dut3]])
hdrMsg(" Remove all ip configs on dut2")
ip_api.delete_ip_interface(data.dut2, 'Vlan100', dut2_4_ip_list[0],
mask_24)
ip_api.delete_ip_interface(data.dut2, data.d2d4_ports[1],
dut2_4_ip_list[1], mask_24)
ip_api.delete_ip_interface(data.dut2, 'PortChannel12',
dut2_4_ip_list[2], mask_24)
ip_api.delete_ip_interface(data.dut1,
'PortChannel14',
data.dhcp_server_ipv6,
mask_v6,
family='ipv6')
###########################################################
hdrMsg("LAG-unConfig: delete member ports to portchannel")
###########################################################
utils.exec_all(True, [[
pc.add_del_portchannel_member, data.dut2, 'PortChannel12',
data.d2d4_ports[2], 'del'
],
[
pc.add_del_portchannel_member, data.dut4,
'PortChannel12', data.d4d2_ports[2], 'del'
]])
utils.exec_all(True, [[
pc.add_del_portchannel_member, data.dut3, 'PortChannel14',
data.d3d1_ports[0], 'del'
],
[
pc.add_del_portchannel_member, data.dut1,
'PortChannel14', data.d1d3_ports[0], 'del'
]])
vlan_api.delete_vlan_member(data.dut4, '300', 'PortChannel12')
#######################################################
hdrMsg("LAG-UnConfig: Delete portchannel on dut2 and dut4")
#######################################################
utils.exec_all(True,
[[pc.delete_portchannel, data.dut2, ['PortChannel12']],
[pc.delete_portchannel, data.dut4, ['PortChannel12']]])
utils.exec_all(True,
[[pc.delete_portchannel, data.dut3, ['PortChannel14']],
[pc.delete_portchannel, data.dut1, ['PortChannel14']]])
########################################
hdrMsg("Delete vlan member ports")
########################################
utils.exec_all(True, [[
vlan_api.delete_vlan_member, data.dut2, '100', data.d2d4_ports[0],
True
],
[
vlan_api.delete_vlan_member, data.dut4,
'100', data.d4d2_ports[0], True
]])
vlan_api.delete_vlan_member(data.dut4, '200', data.d4d2_ports[1])
####################################
hdrMsg("Unconfig vlan fron dut2 and dut4")
###################################
utils.exec_all(True, [[vlan_api.delete_vlan, data.dut2, ['100']],
[vlan_api.delete_vlan, data.dut4, ['100']]])
vlan_api.delete_vlan(data.dut4, ['200', '300'])
def test_ft_bgp_unnumbered_rr():
"""
# ################ Author Details ################
# Name: Sesha Reddy Koilkonda
# Email: [email protected]
# ################################################
:return:
"""
utils_obj.banner_log('FtOtSoRtBgpUnFn011,FtOtSoRtBgpUnFn012')
result = 0
bgp_obj.cleanup_router_bgp(st.get_dut_names())
dict1 = {
'config': 'yes',
'router_id': data.d1_rid,
'addr_family': 'ipv6',
'local_as': data.d1_local_as,
'remote_as': 'internal',
'config_type_list': ["remote-as", "activate"],
'interface': vars.D1D2P1,
'neighbor': vars.D1D2P1
}
dict2 = {
'config': 'yes',
'router_id': data.d2_rid,
'addr_family': 'ipv6',
'local_as': data.d1_local_as,
'remote_as': 'internal',
'config_type_list': ["remote-as", "activate"],
'interface': vars.D2D1P1,
'neighbor': vars.D2D1P1
}
parallel.exec_parallel(True, [vars.D1, vars.D2], bgp_obj.config_bgp,
[dict1, dict2])
result_rr = bgp_obj.create_bgp_route_reflector_client(
vars.D1, data.d1_local_as, 'ipv6', vars.D1D2P1, 'yes')
if not result_rr:
st.error(
"BGP SP - Configuring client reflection on {} {} bgp {} Failed".
format(vars.D1, 'ipv6', data.d1_local_as))
result += 1
if not utils.poll_wait(bgp_obj.verify_bgp_summary,
data.wait_timer,
vars.D1,
family='ipv6',
shell=bgp_cli_type,
neighbor=vars.D1D2P1,
state='Established'):
st.error(
"Failed to form iBGP unnumbered peering using IPv6 link local with Route-reflector-client config"
)
result += 1
# Unconfiguration
bgp_obj.create_bgp_route_reflector_client(vars.D1,
data.d1_local_as,
'ipv6',
vars.D1D2P1,
config='no')
bgp_obj.cleanup_router_bgp(st.get_dut_names())
if result == 0:
st.report_pass("test_case_passed")
else:
st.error(
"BGP unnumbered neighborship failed with the Route-reflector-client configuration failed."
)
st.report_fail("test_case_failed")
def test_warm_reboot_dynmaic_neigh(fixture_test_warm_reboot):
#####################################################################################################################################
errs = []
st.banner(
'FtOpSoRoDynReb002 - Verify BGP unnumbererd and listen range on default after a warm reboot'
)
st.log(" Add graceful restart and preserve_state state configuration")
dict1 = {'local_asn': dut1_as, 'config': 'add', 'preserve_state': '1'}
dict2 = {'local_asn': dut2_as, 'config': 'add', 'preserve_state': '1'}
dict3 = {'local_asn': dut3_as, 'config': 'add', 'preserve_state': '1'}
parallel.exec_parallel(True, [data.dut1, data.dut2, data.dut3],
bgp_obj.config_bgp_graceful_restart,
[dict1, dict2, dict3])
st.log('FtOpSoRoDynReb002 - Enable warm restart for dockers')
reboot_obj.config_warm_restart(data.dut2, oper="enable")
reboot_obj.config_warm_restart(data.dut2,
oper="enable",
tasks=["bgp", "swss", "teamd", "system"])
st.log("Verify ping and BGP session before warm reboot")
if not loc_lib.retry_api(bgp_obj.verify_bgp_summary,
data.dut2,
family='ipv4',
shell=bgp_cli_type,
neighbor='Vlan2',
state='Established',
retry_count=10,
delay=15):
errs.append(
st.error(
"Failed to form BGP unnumbered session using IPv6 link local address over vlan"
))
if not loc_lib.retry_api(ip_obj.ping,
data.dut1,
addresses=dut3_tg_ip[0],
retry_count=10,
delay=10,
source_ip=dut1_tg_ip[0]):
errs.append(st.error('IPv4 Ping from DUT1 to DUT3 failed'))
st.log("Save the running config in sonic and vtysh modes")
reboot_obj.config_save(data.dut2)
st.vtysh(data.dut2, "copy running startup")
st.reboot(data.dut2, 'warm')
if not loc_lib.retry_api(ip_obj.ping,
data.dut1,
addresses=dut3_tg_ip[0],
retry_count=10,
delay=10,
source_ip=dut1_tg_ip[0]):
errs.append(st.error('IPv4 Ping from DUT1 to DUT3 failed'))
aggrResult = loc_lib.send_verify_traffic()
if not aggrResult:
errs.append(
st.error(
'IPv4 traffic over default VRF with BGP unnumbered and Dynamic Discovery failed'
))
if not errs:
st.report_tc_pass('FtOpSoRoDynReb002', 'test_case_passed')
else:
st.report_tc_fail('FtOpSoRoDynReb002', 'test_case_failed')
if not errs:
st.report_pass('test_case_passed')
else:
st.report_fail('test_case_failed_msg', ", ".join(errs))
def test_ft_bgp_unnumbered_manual_ll():
"""
# ################ Author Details ################
# Name: Sesha Reddy Koilkonda
# Email: [email protected]
# ################################################
:return:
"""
utils_obj.banner_log(
'FtOtSoRtBgpUnFn013,FtOtSoRtBgpUnFn014,FtOtSoRtBgpUnFn015')
result = 0
# Configure the Link-local manually on Dut1 and auto link-local on DUT2 and verify the neighbourship.
bgp_obj.cleanup_router_bgp(st.get_dut_names())
ip_obj.config_ip_addr_interface(vars.D1,
vars.D1D2P1,
data.ip6_addr_manual_ll[0],
96,
family='ipv6')
dict1 = {
'config': 'yes',
'router_id': data.d1_rid,
'addr_family': 'ipv6',
'local_as': data.d1_local_as,
'remote_as': 'external',
'config_type_list': ["remote-as", "activate"],
'interface': vars.D1D2P1,
'neighbor': vars.D1D2P1
}
dict2 = {
'config': 'yes',
'router_id': data.d2_rid,
'addr_family': 'ipv6',
'local_as': data.d2_local_as,
'remote_as': 'external',
'config_type_list': ["remote-as", "activate"],
'interface': vars.D2D1P1,
'neighbor': vars.D2D1P1
}
parallel.exec_parallel(True, [vars.D1, vars.D2], bgp_obj.config_bgp,
[dict1, dict2])
if not utils.poll_wait(bgp_obj.verify_bgp_summary,
data.wait_timer,
vars.D1,
family='ipv6',
shell=bgp_cli_type,
neighbor=vars.D1D2P1,
state='Established'):
st.error(
"Failed to form BGP unnumbered peering using IPv6 link local with the Manual-Auto link-local address combination."
)
result += 1
# with the manual link-local on Dut1 and configure the link-local on DUT2 also manually and verify the neighbourship.
bgp_obj.cleanup_router_bgp(st.get_dut_names())
ip_obj.config_ip_addr_interface(vars.D2,
vars.D2D1P1,
data.ip6_addr_manual_ll[1],
96,
family='ipv6')
parallel.exec_parallel(True, [vars.D1, vars.D2], bgp_obj.config_bgp,
[dict1, dict2])
if not utils.poll_wait(bgp_obj.verify_bgp_summary,
data.wait_timer,
vars.D1,
family='ipv6',
shell=bgp_cli_type,
neighbor=vars.D1D2P1,
state='Established'):
st.error(
"Failed to form BGP unnumbered peering using IPv6 link local with the manual-manual link-local address combination."
)
result += 1
# update the manual link-local on Dut2 and verify the neighbourship.
bgp_obj.cleanup_router_bgp(st.get_dut_names())
data.ip6_addr_ll3 = 'FE80:0:0:0:204:5FF:FE00:500'
ip_obj.config_ip_addr_interface(vars.D2,
vars.D2D1P1,
data.ip6_addr_manual_ll[2],
96,
family='ipv6')
parallel.exec_parallel(True, [vars.D1, vars.D2], bgp_obj.config_bgp,
[dict1, dict2])
if not utils.poll_wait(bgp_obj.verify_bgp_summary,
data.wait_timer,
vars.D1,
family='ipv6',
shell=bgp_cli_type,
neighbor=vars.D1D2P1,
state='Established'):
st.error(
"Failed to form BGP unnumbered peering using IPv6 link local, after uodating the manual link-local address on peer DUT.."
)
result += 1
bgp_obj.cleanup_router_bgp(st.get_dut_names())
ip_obj.config_ip_addr_interface(vars.D1,
vars.D1D2P1,
data.ip6_addr_manual_ll[0],
96,
family='ipv6',
config='remove')
ip_obj.config_ip_addr_interface(vars.D2,
vars.D2D1P1,
data.ip6_addr_manual_ll[1],
96,
family='ipv6',
config='remove')
ip_obj.config_ip_addr_interface(vars.D2,
vars.D2D1P1,
data.ip6_addr_manual_ll[2],
96,
family='ipv6',
config='remove')
if result == 0:
st.report_pass("test_case_passed")
else:
st.error(
"BGP unnumbered neighborship failed with the manual link-local address configuration."
)
st.report_fail("test_case_failed")
def test_unnumvrf_bfd(fixture_unnumvrf_test_bfd):
tc_list = [
'FtOpSoRoIPnumvrfFun004', 'FtOpSoRoIPnumvrfFun005',
'FtOpSoRoIPnumvrfFun006'
]
final_result = 0
error_list = []
st.banner('FtOpSoRoIPnumvrfFun004 -- to -- FtOpSoRoIPnumvrfFun006')
st.banner(
'Verify OSPF BFD over all the unnumbered interfaces over non-default vrf'
)
tc_result = True
st.log('Verify OSPF is up for all interfaces')
loc_lib.verify_ospf()
st.log('Configure BFD on PortChannel, Physical interface and vlan')
dict1 = {
"interface": data.d1_d2_ports[0],
'neighbor_ip': data.dut2_loopback_ip[0],
'config': 'yes',
'noshut': 'yes',
'vrf_name': data.dut1_vrf[0]
}
dict2 = {
"interface": data.d2_d1_ports[0],
'neighbor_ip': data.dut1_loopback_ip[0],
'config': 'yes',
'noshut': 'yes'
}
parallel.exec_parallel(True, [data.dut1, data.dut2], bfd_obj.configure_bfd,
[dict1, dict2])
result = retry_api(ip_obj.ping,
data.dut1,
addresses=data.dut2_loopback_ip[0],
interface=data.dut1_vrf[0],
retry_count=2,
delay=10)
if result is False:
error = "Ping on IP unnumbered physical interface over non-default vrf failed"
tc_result = False
error_list.append(error)
result = retry_api(bfd_obj.verify_bfd_peer,
data.dut1,
peer=data.dut2_loopback_ip[0],
interface=data.d1_d2_ports[0],
vrf_name=data.dut1_vrf[0],
status='up',
retry_count=3,
delay=2)
if result is False:
error = "BFD on IP unnumbered physical interface over non-default vrf failed"
tc_result = False
error_list.append(error)
if tc_result:
st.report_tc_pass(tc_list[0], 'tc_passed')
else:
final_result += 1
st.report_tc_fail(tc_list[0], 'test_case_failure_message', error)
tc_result = True
dict1 = {
"interface": data.portchannel,
'neighbor_ip': data.dut2_loopback_ip[2],
'config': 'yes',
'noshut': 'yes',
'vrf_name': data.dut1_vrf[0]
}
dict2 = {
"interface": data.portchannel,
'neighbor_ip': data.dut1_loopback_ip[2],
'config': 'yes',
'noshut': 'yes'
}
parallel.exec_parallel(True, [data.dut1, data.dut2], bfd_obj.configure_bfd,
[dict1, dict2])
result = retry_api(ip_obj.ping,
data.dut1,
addresses=data.dut2_loopback_ip[2],
interface=data.dut1_vrf[0],
retry_count=2,
delay=10)
if result is False:
error = "Ping on IP unnumbered portchannel over non-default vrf failed"
tc_result = False
error_list.append(error)
result = retry_api(bfd_obj.verify_bfd_peer,
data.dut1,
peer=data.dut2_loopback_ip[2],
interface=data.portchannel,
status='up',
vrf_name=data.dut1_vrf[0],
retry_count=3,
delay=2)
if result is False:
error = "BFD on IP unnumbered portchannel over non-default vrf failed"
tc_result = False
error_list.append(error)
if tc_result:
st.report_tc_pass(tc_list[1], 'tc_passed')
else:
final_result += 1
st.report_tc_fail(tc_list[1], 'test_case_failure_message', error)
tc_result = True
dict1 = {
"interface": 'Vlan' + data.dut1_dut2_vlan[0],
'neighbor_ip': data.dut2_loopback_ip[1],
'config': 'yes',
'noshut': 'yes',
'vrf_name': data.dut1_vrf[0]
}
dict2 = {
"interface": 'Vlan' + data.dut1_dut2_vlan[0],
'neighbor_ip': data.dut1_loopback_ip[1],
'config': 'yes',
'noshut': 'yes'
}
parallel.exec_parallel(True, [data.dut1, data.dut2], bfd_obj.configure_bfd,
[dict1, dict2])
result = retry_api(ip_obj.ping,
data.dut1,
addresses=data.dut2_loopback_ip[1],
interface=data.dut1_vrf[0],
retry_count=2,
delay=10)
if result is False:
error = "Ping on IP unnumbered vlan over non-default vrf failed"
tc_result = False
error_list.append(error)
result = retry_api(bfd_obj.verify_bfd_peer,
data.dut1,
peer=data.dut2_loopback_ip[1],
interface='Vlan' + data.dut1_dut2_vlan[0],
status='up',
vrf_name=data.dut1_vrf[0],
retry_count=3,
delay=2)
if result is False:
error = "BFD on IP unnumbered vlan over non-default vrf failed"
tc_result = False
error_list.append(error)
if tc_result:
st.report_tc_pass(tc_list[2], 'tc_passed')
else:
final_result += 1
st.report_tc_fail(tc_list[2], 'test_case_failure_message', error)
if final_result != 0:
st.report_fail('test_case_failure_message', error_list)
else:
st.report_pass('test_case_passed')
def test_ft_bgp_unnumbered_nondefault_vrf():
"""
# ################ Author Details ################
# Name: Sesha Reddy Koilkonda
# Email: [email protected]
# ################################################
:return:
"""
utils_obj.banner_log("FtOtSoRtBgpUnFn016,FtOtSoRtBgpUnFn017")
result = 0
bgp_obj.cleanup_router_bgp(st.get_dut_names())
dict1 = {'vrf_name': data.vrf_name, 'skip_error': True}
parallel.exec_parallel(True, [vars.D1, vars.D2], vrf_api.config_vrf,
[dict1, dict1])
utils.exec_all(True, [[
ip_obj.config_interface_ip6_link_local, vars.D1, vars.D1D2P1, "disable"
], [
ip_obj.config_interface_ip6_link_local, vars.D2, vars.D2D1P1, "disable"
]])
dict1 = {
'vrf_name': data.vrf_name,
'intf_name': vars.D1D2P1,
'skip_error': True
}
dict2 = {
'vrf_name': data.vrf_name,
'intf_name': vars.D2D1P1,
'skip_error': True
}
parallel.exec_parallel(True, [vars.D1, vars.D2],
vrf_api.bind_vrf_interface, [dict1, dict2])
utils.exec_all(
True, [[ip_obj.config_interface_ip6_link_local, vars.D1, vars.D1D2P1],
[ip_obj.config_interface_ip6_link_local, vars.D2, vars.D2D1P1]])
utils.exec_all(True,
[[ip_obj.get_interface_ip_address, vars.D1, None, "ipv6"],
[ip_obj.get_interface_ip_address, vars.D2, None, "ipv6"]])
dict1 = {
'vrf_name': data.vrf_name,
'router_id': data.d1_rid,
'local_as': data.d1_local_as,
'addr_family': 'ipv6',
'neighbor': vars.D1D2P1,
'remote_as': 'external',
'config_type_list': ["remote-as", "activate"],
'interface': vars.D1D2P1
}
dict2 = {
'vrf_name': data.vrf_name,
'router_id': data.d2_rid,
'local_as': data.d2_local_as,
'addr_family': 'ipv6',
'neighbor': vars.D2D1P1,
'remote_as': 'external',
'config_type_list': ["remote-as", "activate"],
'interface': vars.D2D1P1
}
parallel.exec_parallel(True, [vars.D1, vars.D2], bgp_obj.config_bgp,
[dict1, dict2])
if not utils.poll_wait(bgp_obj.verify_bgp_summary,
data.wait_timer,
vars.D1,
family='ipv6',
shell=bgp_cli_type,
neighbor=vars.D1D2P1,
vrf=data.vrf_name,
state='Established'):
st.error(
"BGP unnumbered neighbourship with the non-default vrf configuration failed."
)
result += 1
st.log('######------Save and reboot------######')
reboot_obj.config_save(vars.D1, "sonic")
reboot_obj.config_save(vars.D1, "vtysh")
st.reboot(vars.D1)
if not utils.poll_wait(bgp_obj.verify_bgp_summary,
data.wait_timer,
vars.D1,
family='ipv6',
shell=bgp_cli_type,
neighbor=vars.D1D2P1,
vrf=data.vrf_name,
state='Established'):
st.error(
"BGP unnumbered neighbourship with the non-default vrf configuration failed after save and reboot."
)
result += 1
st.log('######------Config reload with BGP unnumbered------######')
st.log("Config reload the DUT")
reboot_obj.config_save_reload(vars.D1)
if not utils.poll_wait(bgp_obj.verify_bgp_summary,
data.wait_timer,
vars.D1,
family='ipv6',
shell=bgp_cli_type,
neighbor=vars.D1D2P1,
vrf=data.vrf_name,
state='Established'):
st.error(
"BGP unnumbered neighbourship with the non-default vrf configuration failed after config reload."
)
result += 1
# unconfig part:
dict1 = {
'vrf_name': data.vrf_name,
'local_as': data.d1_local_as,
'config': 'no',
'removeBGP': 'yes',
'config_type_list': ['removeBGP']
}
dict2 = {
'vrf_name': data.vrf_name,
'local_as': data.d2_local_as,
'config': 'no',
'removeBGP': 'yes',
'config_type_list': ['removeBGP']
}
parallel.exec_parallel(True, [vars.D1, vars.D2], bgp_obj.config_bgp,
[dict1, dict2])
utils.exec_all(True, [[
ip_obj.config_interface_ip6_link_local, vars.D1, vars.D1D2P1, "disable"
], [
ip_obj.config_interface_ip6_link_local, vars.D2, vars.D2D1P1, "disable"
]])
dict1 = {
'vrf_name': data.vrf_name,
'intf_name': vars.D1D2P1,
'skip_error': True,
'config': 'no'
}
dict2 = {
'vrf_name': data.vrf_name,
'intf_name': vars.D2D1P1,
'skip_error': True,
'config': 'no'
}
parallel.exec_parallel(True, [vars.D1, vars.D2],
vrf_api.bind_vrf_interface, [dict1, dict2])
dict1 = {'vrf_name': data.vrf_name, 'skip_error': True, 'config': 'no'}
parallel.exec_parallel(True, [vars.D1, vars.D2], vrf_api.config_vrf,
[dict1, dict1])
bgp_obj.cleanup_router_bgp(st.get_dut_names())
utils.exec_all(
True,
[[ip_obj.config_interface_ip6_link_local, vars.D1, d1_int_ipv6_list],
[ip_obj.config_interface_ip6_link_local, vars.D2, d2_int_ipv6_list]])
if result == 0:
st.report_pass("test_case_passed")
else:
st.error(
"BGP unnumbered neighborship failed with the non-default vrf configuration."
)
st.report_fail("test_case_failed")
def test_scale_ip_unnumbered():
##########################################################################################################################################
result = 0
st.banner('FtOpSoRoIPunScl001 - Verify maximum IPv4 unnumbered interfaces')
st.log(
'Configure IP unnumbered on Physical interfaces between DUT1 and DUT3')
for d1port, d2port in zip(data.d1_d2_ports, data.d2_d1_ports):
dict1 = {
'family': 'ipv4',
'action': 'add',
'interface': d1port,
'loop_back': dut1_loopback[0]
}
dict2 = {
'family': 'ipv4',
'action': 'add',
'interface': d2port,
'loop_back': dut2_loopback[0]
}
parallel.exec_parallel(True, [data.dut1, data.dut2],
ip_obj.config_unnumbered_interface,
[dict1, dict2])
st.log(
'Configure IP unnumbered on Physical interfaces between DUT2 and DUT3')
for d2port, d3port in zip(data.d2_d3_ports, data.d3_d2_ports):
dict2 = {
'family': 'ipv4',
'action': 'add',
'interface': d2port,
'loop_back': dut2_loopback[0]
}
dict3 = {
'family': 'ipv4',
'action': 'add',
'interface': d3port,
'loop_back': dut3_loopback[0]
}
parallel.exec_parallel(True, [data.dut2, data.dut3],
ip_obj.config_unnumbered_interface,
[dict2, dict3])
if not ip_obj.verify_interface_ip_address(
data.dut2, data.d2_d3_ports[0],
dut2_loopback_ip[0] + '/' + ip_loopback_prefix, 'ipv4', '', 'U'):
st.error(
'IP Unnumbered configuration on DUT2-Physical Interface failed')
result += 1
if not loc_lib.retry_api(ip_obj.ping,
data.dut1,
addresses=dut3_loopback_ip[0],
retry_count=5,
delay=10):
st.error('IPv4 Ping from DUT1 to DUT3 failed')
result += 1
if not arp_obj.verify_arp(dut=data.dut2, ipaddress=dut3_loopback_ip[0]):
st.error(
"Failed to resolve ARP for link local address over physical interface"
)
result += 1
aggrResult = loc_lib.send_verify_traffic(type='ipv4')
if not aggrResult:
st.error('IPv4 traffic with IPv4 unnumbered failed')
result += 1
port_obj.shutdown(data.dut2, [
data.d2_d1_ports[0], data.d2_d1_ports[1], data.d2_d1_ports[2],
data.d2_d1_ports[3], data.d2_d3_ports[0], data.d2_d3_ports[1],
data.d2_d3_ports[2], data.d2_d3_ports[3]
])
st.log('Wait for OSFP to go down')
st.wait(10)
port_obj.noshutdown(data.dut2, [
data.d2_d1_ports[0], data.d2_d1_ports[1], data.d2_d1_ports[2],
data.d2_d1_ports[3], data.d2_d3_ports[0], data.d2_d3_ports[1],
data.d2_d3_ports[2], data.d2_d3_ports[3]
])
st.log('Wait for OSFP to come up')
st.wait(10)
if not loc_lib.retry_api(ip_obj.ping,
data.dut1,
addresses=dut3_loopback_ip[0],
retry_count=5,
delay=10):
st.error('IPv4 Ping from DUT1 to DUT2 failed')
result += 1
aggrResult = loc_lib.send_verify_traffic(type='ipv4')
if not aggrResult:
st.error('IPv4 traffic with IPv4 unnumbered failed')
result += 1
if result == 0:
st.report_tc_pass('FtOpSoRoIPunScl001', 'test_case_passed')
else:
st.report_tc_fail('FtOpSoRoIPunScl001', 'test_case_failed')
if result == 0:
st.report_pass('test_case_passed')
else:
st.report_fail('test_case_failed')
def test_vrf_bgp():
result = 0
###############################################################################################################################
st.log('######------Configure BGP on 100 VRFs-----######')
for vrf, dut1_ip, dut2_ip, dut1_as, dut2_as in zip(
vrf_list[899:1000], data.dut1_dut2_ip_list[899:1000],
data.dut2_dut1_ip_list[899:1000], dut1_as_scale[0:100],
dut2_as_scale[0:100]):
dict1 = {
'vrf_name': vrf,
'router_id': dut1_router_id,
'local_as': dut1_as,
'neighbor': dut2_ip,
'remote_as': dut2_as,
'config_type_list': ['neighbor']
}
dict2 = {
'vrf_name': vrf,
'router_id': dut2_router_id,
'local_as': dut2_as,
'neighbor': dut1_ip,
'remote_as': dut1_as,
'config_type_list': ['neighbor']
}
parallel.exec_parallel(True, [data.dut1, data.dut2],
bgp_api.config_bgp, [dict1, dict2])
dict1 = {
'vrf_name': vrf,
'local_as': dut1_as,
'neighbor': dut2_ip,
'remote_as': dut2_as,
'connect': '3',
'config_type_list': ['activate', 'nexthop_self', 'connect']
}
dict2 = {
'vrf_name': vrf,
'local_as': dut2_as,
'neighbor': dut1_ip,
'remote_as': dut1_as,
'connect': '3',
'config_type_list': ['activate', 'nexthop_self', 'connect']
}
parallel.exec_parallel(True, [data.dut1, data.dut2],
bgp_api.config_bgp, [dict1, dict2])
###############################################################################################################################
st.log('######------Verify the BGP neighbors have come up -----######')
if not utils.poll_wait(ip_bgp.verify_bgp_neighbor,
60,
data.dut1,
neighborip=data.dut2_dut1_ip_list[899],
state='Established',
vrf=vrf_list[899]):
st.log('IPv4 BGP session on VRF-899 did not come up')
result += 1
if not utils.poll_wait(ip_bgp.verify_bgp_neighbor,
60,
data.dut1,
neighborip=data.dut2_dut1_ip_list[950],
state='Established',
vrf=vrf_list[950]):
st.log('IPv4 BGP session on VRF-950 did not come up')
result += 1
###############################################################################################################################
st.log('######------Clear BGP and reverify -----######')
bgp_api.clear_ip_bgp_vrf_vtysh(data.dut1, vrf_list[899], family='ipv4')
st.log('######------Time taken for BGP to come up after clear -----######')
st.wait(10)
if not utils.poll_wait(ip_bgp.verify_bgp_neighbor,
60,
data.dut1,
neighborip=data.dut2_dut1_ip_list[899],
state='Established',
vrf=vrf_list[899]):
st.log('IPv4 BGP session on VRF-899 did not come up')
result += 1
###############################################################################################################################
if result == 0:
st.report_pass('test_case_passed')
else:
st.log('BGP neighborship on 100 VRFs failed')
st.report_fail('test_case_failed')
