def get_mac_all_dut(dut_list, thread=True):
st.log("Displaying mac ..in all dut")
dut_li = list([str(e) for e in dut_list]) if isinstance(dut_list, list) else [dut_list]
params = list()
for dut in dut_li:
params.append([get_mac, dut])
if params:
exec_all(thread, params)
def debug_vrrp(dut_list):
"""
Author : Sooriya G
email : [email protected]
:param dut_list:
:return:
"""
st.log("### Start of Debug commands #####")
cmd_list = ['show vrrp','teamshow','show mac','show ip route','show vlan brief','bcmcmd \'l2 show \'', 'bcmcmd \'l3 defip show\'','bcmcmd \'l3 l3table show\'']
arg_list = [[st.apply_script,dut,cmd_list] for dut in dut_list]
utils.exec_all(True,arg_list)
st.log(" End of Dubug commands")
def config_ospf(config='yes'):
if config == 'yes':
hdrMsg('Configure ospf between DUT1 and DUT3')
utils.exec_all(True, [[
ospf_obj.config_ospf_router_id, data.dut1, dut1_ospf_router_id,
'default', '', 'yes'
],
[
ospf_obj.config_ospf_router_id, data.dut3,
dut3_ospf_router_id, 'default', '', 'yes'
]])
utils.exec_all(True, [[
ospf_obj.config_ospf_network, data.dut1, dut1_loopback_ip_list[0] +
'/' + ip_loopback_prefix, 0, 'default', '', 'yes'
],
[
ospf_obj.config_ospf_network, data.dut3,
dut3_loopback_ip_list[0] + '/' +
ip_loopback_prefix, 0, 'default', '', 'yes'
]])
utils.exec_all(
True,
[[
ospf_obj.config_interface_ip_ospf_network_type, data.dut1,
'PortChannel14', 'point-to-point', 'default', 'yes'
],
[
ospf_obj.config_interface_ip_ospf_network_type, data.dut3,
'PortChannel14', 'point-to-point', 'default', 'yes'
]])
ospf_obj.config_ospf_router_redistribute(data.dut3, 'connected')
else:
hdrMsg('UnConfig ospf between DUT1 and DUT3')
utils.exec_all(
True,
[[
ospf_obj.config_interface_ip_ospf_network_type, data.dut1,
'PortChannel14', 'point-to-point', 'default', 'no'
],
[
ospf_obj.config_interface_ip_ospf_network_type, data.dut3,
'PortChannel14', 'point-to-point', 'default', 'no'
]])
utils.exec_all(
True,
[[ospf_obj.config_ospf_router, data.dut1, 'default', '', 'no'],
[ospf_obj.config_ospf_router, data.dut3, 'default', '', 'no']])
def tg_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--CE side-------######')
for i in range(3):
utils.exec_all(True, [[vlan_obj.create_vlan, vars.D1, data.dut1_tg1_vlan[i]], [vlan_obj.create_vlan, vars.D2, data.dut2_tg1_vlan[i]]])
utils.exec_all(True,[[vlan_obj.add_vlan_member,vars.D1,data.dut1_tg1_vlan[i],vars.D1T1P1,True,True], [vlan_obj.add_vlan_member,vars.D2,data.dut2_tg1_vlan[i],vars.D2T1P1,True,True]])
'''
vlan_obj.create_vlan(vars.D1, data.dut1_tg1_vlan[i]) # Vlan-1, VRF-101, port1
vlan_obj.add_vlan_member(vars.D1, data.dut1_tg1_vlan[i], vars.D1T1P1, True, True)
vlan_obj.create_vlan(vars.D2, data.dut2_tg1_vlan[i])
vlan_obj.add_vlan_member(vars.D2, data.dut2_tg1_vlan[i], vars.D2T1P1, True, True)
'''
st.log('######------Bind DUT1 <--> tg1 vlans to vrf, assign v4 and v6 address------######')
for vrf, vlan, ip, ipv6 in zip(data.vrf_name[0:3], data.dut1_tg1_vlan[0:3],data.dut1_tg1_vrf_ip[0:3], data.dut1_tg1_vrf_ipv6[0:3]):
vrf_api.bind_vrf_interface(dut = vars.D1, vrf_name = vrf, intf_name = 'Vlan'+vlan, skip_error = True)
ipfeature.config_ip_addr_interface(vars.D1, 'Vlan'+vlan, ip, data.dut1_tg1_vrf_ip_subnet, 'ipv4')
ipfeature.config_ip_addr_interface(vars.D1, 'Vlan'+vlan, ipv6, data.dut1_tg1_vrf_ipv6_subnet, 'ipv6')
st.log('######------Bind DUT2 <--> tg1 vlans to vrf, assign v4 and v6 address------######')
for vrf, vlan,ip,ipv6 in zip(data.vrf_name[0:3], data.dut2_tg1_vlan[0:3], data.dut2_tg1_vrf_ip[0:3], data.dut2_tg1_vrf_ipv6[0:3]):
vrf_api.bind_vrf_interface(dut = vars.D2, vrf_name = vrf, intf_name = 'Vlan'+vlan, skip_error = True)
ipfeature.config_ip_addr_interface(vars.D2, 'Vlan'+vlan, ip, data.dut2_tg1_vrf_ip_subnet, 'ipv4')
ipfeature.config_ip_addr_interface(vars.D2, 'Vlan'+vlan, ipv6, data.dut2_tg1_vrf_ipv6_subnet, 'ipv6')
else:
st.log('######------Unbind DUT1 <--> tg1port1 vlans to vrf, assign v4 and v6 address------######')
for vrf, vlan, ip, ipv6 in zip(data.vrf_name[0:3], data.dut1_tg1_vlan[0:3],data.dut1_tg1_vrf_ip[0:3], data.dut1_tg1_vrf_ipv6[0:3]):
ipfeature.delete_ip_interface(dut1, 'Vlan'+vlan, ip, data.dut1_tg1_vrf_ip_subnet, 'ipv4')
ipfeature.delete_ip_interface(dut1, 'Vlan'+vlan, ipv6, data.dut1_tg1_vrf_ipv6_subnet, 'ipv6')
vrf_api.bind_vrf_interface(dut = dut1, vrf_name = vrf, intf_name = 'Vlan'+vlan, skip_error = True, config = 'no')
st.log('######------Unbind DUT2 <--> tg1 vlans to vrf, assign v4 and v6 address------######')
for vrf, vlan,ip,ipv6 in zip(data.vrf_name[0:3], data.dut2_tg1_vlan[0:3], data.dut2_tg1_vrf_ip[0:3], data.dut2_tg1_vrf_ipv6[0:3]):
ipfeature.delete_ip_interface(dut2, 'Vlan'+vlan, ip, data.dut2_tg1_vrf_ip_subnet, 'ipv4')
ipfeature.delete_ip_interface(dut2, 'Vlan'+vlan, ipv6, data.dut2_tg1_vrf_ipv6_subnet, 'ipv6')
vrf_api.bind_vrf_interface(dut = dut2, vrf_name = vrf, intf_name = 'Vlan'+vlan, skip_error = True, config = 'no')
st.log('######------Unconfigure vlans on the PE--CE side -------######')
for i in range(3):
vlan_obj.delete_vlan_member(dut1, data.dut1_tg1_vlan[i], vars.D1T1P1, tagging_mode=True)
vlan_obj.delete_vlan(dut1, data.dut1_tg1_vlan[i]) # Vlan-1, VRF-101, port1
vlan_obj.delete_vlan_member(dut2, data.dut2_tg1_vlan[i], vars.D2T1P1, tagging_mode=True)
vlan_obj.delete_vlan(dut2, data.dut2_tg1_vlan[i])
def config_stp_vlan_parameters_parallel(dut_list, thread=True, **kwargs):
"""
Author : chaitanya lohith bollapragada
This will configure the "config_stp_vlan_parameters" in parallel to all DUTs mentioned.
:param dut_list:
:param vlan: list of vlans
:param priority: list of STP priorities
:param thread: True | False
:return:
"""
st.log("Configuring STP vlan parameters in paraller on all DUT's ... ")
dut_li = list(dut_list) if isinstance(dut_list, list) else [dut_list]
vlan_li = list(kwargs['vlan']) if isinstance(kwargs['vlan'],
list) else [kwargs['vlan']]
priority_li = list(kwargs['priority']) if isinstance(
kwargs['priority'], list) else [kwargs['priority']]
if not len(dut_li) == len(vlan_li) == len(priority_li):
return False
params = list()
for i, each in enumerate(dut_list):
params.append(
utility.ExecAllFunc(config_stp_vlan_parameters,
each,
vlan_li[i],
priority=priority_li[i]))
[out, exceptions] = exec_all(thread, params)
st.log(exceptions)
return False if False in out else True
def debug_vrrpv3(dut_list):
"""
Author : Raghukumar Rampur
email : [email protected]
:param dut_list:
:return:
"""
st.log("### Start of Debug commands #####")
cmd_list = [
'show vrrp6', 'teamshow', 'show mac', 'show ip route',
'show ipv6 route', 'show vlan brief', 'bcmcmd \'l2 show \'',
'bcmcmd \'l3 defip show\'', 'bcmcmd \'l3 l3table show\''
]
arg_list = [[st.apply_script, dut, cmd_list] for dut in dut_list]
utils.exec_all(True, arg_list)
st.log(" End of Dubug commands")
def verify_root_bridge_on_stp_instances(dut_list, vlan, bridge_identifier):
"""
API to verify the bridge identifier with root bridge identifier
:param dut_list:
:param vlan:
:param bridge_identifier:
:return:
"""
dut_li = list(dut_list) if isinstance(dut_list, list) else [dut_list]
params = list()
for dut in dut_li:
params.append([get_stp_bridge_param, dut, vlan, "rt_id"])
if params:
[out, exceptions] = exec_all(True, params)
st.log("#########OUTPUT###########")
st.log(out)
st.log(exceptions)
for value in exceptions:
st.log("Exceptions observed {}".format(value))
if value is not None:
return False
for identifier in out:
st.log("Comparing ROOT bridge ID {} with Provided ID {}".format(
identifier, bridge_identifier))
if identifier != bridge_identifier:
st.log("Mismatch in root and bridge identifiers")
return False
else:
st.log(
"Root Bridge Identifier {} is matched with provided identifier {}"
.format(identifier, bridge_identifier))
return True
return False
def ip_config(test_type, vrfname='default'):
D1_ports, D2_ports, max_bfd, ipv4_bgp, ipv6_bgp, dut1_ip, dut2_ip, dut1_ipv6, dut2_ipv6, vlan_list, vlan_intf = \
return_vars(vrfname)
if test_type == 'mix':
############################################################################################
hdrMsg(
"Step-C1: Configure ip address %s on dut1 and %s on dut2 for all Vlans"
% (dut1_ip, dut2_ip))
############################################################################################
for vlan, ip_1, ip_3 in zip(vlan_intf, dut1_ip, dut2_ip):
utils.exec_all(
True,
[[ip_api.config_ip_addr_interface, dut1, vlan, ip_1, ip_mask],
[ip_api.config_ip_addr_interface, dut2, vlan, ip_3, ip_mask]])
############################################################################################
hdrMsg(
"Step-C2: Configure ipv6 address %s on dut1 and %s on dut2 for all Vlans"
% (dut1_ipv6, dut2_ipv6))
############################################################################################
for vlan, ip_1, ip_3 in zip(vlan_intf, dut1_ipv6, dut2_ipv6):
utils.exec_all(True, [[
ip_api.config_ip_addr_interface, dut1, vlan, ip_1, ipv6_mask,
'ipv6'
],
[
ip_api.config_ip_addr_interface, dut2,
vlan, ip_3, ipv6_mask, 'ipv6'
]])
elif test_type == 'ipv4':
############################################################################################
hdrMsg(
"Step-C1: Configure ip address %s on dut1 and %s on dut2 for all Vlans"
% (dut1_ip, dut2_ip))
############################################################################################
for vlan, ip_1, ip_3 in zip(vlan_intf, dut1_ip, dut2_ip):
utils.exec_all(
True,
[[ip_api.config_ip_addr_interface, dut1, vlan, ip_1, ip_mask],
[ip_api.config_ip_addr_interface, dut2, vlan, ip_3, ip_mask]])
else:
############################################################################################
hdrMsg(
"Step-C1: Configure ipv6 address %s on dut1 and %s on dut2 for all Vlans"
% (dut1_ipv6, dut2_ipv6))
############################################################################################
for vlan, ip_1, ip_3 in zip(vlan_intf, dut1_ipv6, dut2_ipv6):
utils.exec_all(True, [[
ip_api.config_ip_addr_interface, dut1, vlan, ip_1, ipv6_mask,
'ipv6'
],
[
ip_api.config_ip_addr_interface, dut2,
vlan, ip_3, ipv6_mask, 'ipv6'
]])
def check_for_single_root_bridge_per_vlan(dut_list,
vlan_list,
dut_vlan_data,
cli_type='click'):
"""
API to check for single root bridge per VLAN
Author: Chaitanya Vella ([email protected])
:param dut:
:param vlanid:
:param cli_type:
:return:
"""
st.log("Verifying the single root bridge per vlan ...")
dut_li = list([str(e) for e in dut_list]) if isinstance(
dut_list, list) else [dut_list]
vlan_li = list([str(e) for e in vlan_list]) if isinstance(
vlan_list, list) else [vlan_list]
if len(vlan_list) != len(dut_list):
st.log("Invalid data provided to check the root bridge per vlan ...")
st.report_fail("invalid_data_for_root_bridge_per_vlan")
for vlan in vlan_li:
root_count = 0
params = list()
for dut in dut_li:
params.append([show_stp_vlan, dut, vlan, cli_type])
stp_output, exceptions = exec_all(True, params)
st.log(stp_output)
st.log(exceptions)
for value in exceptions:
st.log("Exceptions observed {}".format(value))
if value is not None:
st.log("Exception occured {}".format(value))
return False
if not stp_output:
st.log("STP output not found on {} for {} instance".format(
dut_li, vlan))
st.report_fail("stp_output_not_found", dut_li, vlan)
for index, stp_out in enumerate(stp_output):
if len(stp_out) <= 0:
st.log("STP OUTPUT IS NOT OBSERVED --- {}".format(stp_out))
st.report_fail("stp_output_not_found")
root_bridge = stp_out[0]["rt_id"]
dut_bridge_id = stp_out[0]["br_id"]
if root_bridge == dut_bridge_id and stp_out[0]["rt_port"] == "Root":
if dut_vlan_data[dut_li[index]] != int(vlan.strip()):
st.log(
"Expected DUT {} is not root for {} instance".format(
dut_li[index], vlan))
st.report_fail("expected_dut_not_root", dut_li[index],
vlan)
root_count += 1
if root_count > 1:
st.log(
"Observed more than 1 root bridge per {} instance".format(
vlan))
st.report_fail("observed_more_than_1_root_bridge", vlan)
return True
def get_root_bridge_for_vlan(dut_vlan_data, thread=True):
params = list()
result = dict()
for dut, vlan in dut_vlan_data.items():
params.append([check_dut_is_root_bridge_for_vlan, dut, vlan])
if params:
[out, exceptions] = exec_all(thread, params)
utils.banner_log("Getting root bridge details")
for i, response in enumerate(out):
result[params[i][1]] = response
print(result)
return result
def initialize_topology():
# code for ensuring min topology
st.log(
"Initialize............................................................................................................."
)
vars = st.ensure_min_topology("D1D2:4", "D1T1:2", "D2T1:2")
data.dut_list = st.get_dut_names()
data.dut1 = data.dut_list[0]
data.dut2 = data.dut_list[1]
utils.exec_all(True,
[[bgp_api.enable_docker_routing_config_mode, data.dut1],
[bgp_api.enable_docker_routing_config_mode, data.dut2]])
data.d1_dut_ports = [vars.D1D2P1]
data.d2_dut_ports = [vars.D2D1P1]
data.dut1_tg1_ports = [vars.D1T1P1]
data.dut2_tg1_ports = [vars.D2T1P1]
data.tg_dut1_hw_port = vars.T1D1P1
data.tg_dut2_hw_port = vars.T1D2P1
data.tg1 = tgen_obj_dict[vars['tgen_list'][0]]
data.tg2 = tgen_obj_dict[vars['tgen_list'][0]]
data.tg_dut1_p1 = data.tg1.get_port_handle(vars.T1D1P1)
data.tg_dut2_p1 = data.tg2.get_port_handle(vars.T1D2P1)
data.d1_p1_intf_v4 = {}
data.d1_p1_intf_v6 = {}
data.d2_p1_intf_v4 = {}
data.d2_p1_intf_v6 = {}
data.stream_list_scale = {}
data.stream = []
data.dut1_dut2_ip_list = ip_range('5.0.0.1', 2, 1000)
data.dut2_dut1_ip_list = ip_range('5.0.0.2', 2, 1000)
data.dut1_tg_host = '6.0.0.1'
data.tg_dut1_host = '6.0.0.2'
data.dut2_tg_host = '7.0.0.1'
data.tg_dut2_host = '7.0.0.2'
data.tg_dut1_stream_start = ip_range('6.0.0.3', 3, 1000)
data.tg_dut2_stream_start = ip_range('7.0.0.3', 3, 1000)
data.intf_list = []
for vlan in dut1_dut2_vlan_scale:
data.intf_list.append('Vlan' + vlan)
def config_stp_root_bridge_by_vlan(stp_data):
"""
:param stp_data: {dut1: {"vlan":10, "priority": "0"}, dut2: {"vlan":20, "priority": "0"}, dut3: {"vlan":30, "priority": "0"}}
"""
params = list()
for dut, data in stp_data.items():
params.append(
utility.ExecAllFunc(config_stp_vlan_parameters,
dut,
data["vlan"],
priority=data["priority"]))
[out, exceptions] = exec_all(True, params)
ensure_no_exception(exceptions)
def config_stp_in_parallel(dut_list,
feature="pvst",
mode="enable",
vlan=None,
thread=True):
"""
API to configure stp in parallel on all the provided DUT's
Author: Chaitanya Vella ([email protected])
:param dut_list:
:param feature:
:param mode:
:param vlan:
:param thread:
:return:
"""
st.log("Configuring {} on all the DUT's with mode as {}".format(
feature.capitalize(), mode))
dut_li = list([str(e) for e in dut_list]) if isinstance(
dut_list, list) else [dut_list]
params = list()
for dut in dut_li:
params.append([config_spanning_tree, dut, feature, mode, vlan])
if params:
exec_all(thread, params)
def bgp_unnum_post_config():
vars = st.get_testbed_vars()
bgp_obj.cleanup_router_bgp(st.get_dut_names())
ip_obj.clear_ip_configuration(st.get_dut_names(),
family='ipv4',
skip_error_check=True)
ip_obj.clear_ip_configuration(st.get_dut_names(),
family='ipv6',
skip_error_check=True)
utils.exec_all(True, [[
ip_obj.config_interface_ip6_link_local, vars.D1, d1_int_ipv6_list,
"disable"
],
[
ip_obj.config_interface_ip6_link_local, vars.D2,
d2_int_ipv6_list, "disable"
]])
vlan_obj.clear_vlan_configuration(st.get_dut_names())
pc_obj.clear_portchannel_configuration(st.get_dut_names())
st.log("Cleaning up routing interfaces configured on TG")
st.log(
"Stopping the TG traffic again, if in case of any failures in test function misses the stop operation"
)
def debug_cmds2():
global vars
############################################################################################
hdrMsg(" \n######### Debugs ##########\n")
############################################################################################
utils.exec_all(True, [[Bgp.show_bgp_ipv4_summary_vtysh, vars.D1], [Bgp.show_bgp_ipv4_summary_vtysh, vars.D2]])
utils.exec_all(True, [[ip.show_ip_route, vars.D1], [ip.show_ip_route, vars.D2],
[ip.show_ip_route, vars.D3],[ip.show_ip_route, vars.D6]])
utils.exec_all(True, [[ip.show_ip_route, vars.D1, "ipv6"], [ip.show_ip_route, vars.D2, "ipv6"],
[ip.show_ip_route, vars.D3, "ipv6"],[ip.show_ip_route, vars.D6, "ipv6"]])
def base_config(vrfname='default'):
D1_ports, D2_ports, max_bfd, ipv4_bgp, ipv6_bgp, dut1_ip, dut2_ip, dut1_ipv6, dut2_ipv6, vlan_list, vlan_intf = \
return_vars(vrfname)
hdrMsg("##### BASE config Starts ####")
############################################################################################
hdrMsg("Step-C1: Configure %s Vlans on dut1 and dut2" % max_bfd)
############################################################################################
utils.exec_all(True, [[
vlan_api.config_vlan_range, dut1, '{} {}'.format(
vlan_list[0], vlan_list[-1])
],
[
vlan_api.config_vlan_range, dut2, '{} {}'.format(
vlan_list[0], vlan_list[-1])
]])
if vrfname == user_vrf_name:
dict1 = {'vrf_name': user_vrf_name, 'skip_error': True}
parallel.exec_parallel(True, [dut1, dut2], vrf_api.config_vrf,
[dict1, dict1])
dict1 = {
'vrf_name': [vrfname] * len(vlan_intf),
'intf_name': vlan_intf,
'skip_error': True
}
dict2 = {
'vrf_name': [vrfname] * len(vlan_intf),
'intf_name': vlan_intf,
'skip_error': True
}
parallel.exec_parallel(True, [dut1, dut2], vrf_api.bind_vrf_interface,
[dict1, dict2])
############################################################################################
hdrMsg(
"Step-C2: Configure %s as tagged member for vlans %s on dut1 and %s on dut2"
% (D1_ports[0], vlan_list[0:((total_vlans / 2))], D2_ports[0]))
############################################################################################
utils.exec_all(
True, [[
vlan_api.config_vlan_range_members, dut1, '{} {}'.format(
vlan_list[0], vlan_list[total_vlans / 2]), D1_ports[0]
],
[
vlan_api.config_vlan_range_members, dut2, '{} {}'.format(
vlan_list[0], vlan_list[total_vlans / 2]), D2_ports[0]
]])
############################################################################################
hdrMsg(
"Step-C2: Configure %s as tagged member for vlans %s on dut1 and %s on dut2"
% (D1_ports[1], vlan_list[((total_vlans / 2)):], D2_ports[1]))
############################################################################################
utils.exec_all(
True, [[
vlan_api.config_vlan_range_members, dut1, '{} {}'.format(
vlan_list[((total_vlans / 2) + 1)], vlan_list[-1]), D1_ports[1]
],
[
vlan_api.config_vlan_range_members, dut2, '{} {}'.format(
vlan_list[((total_vlans / 2) + 1)], vlan_list[-1]),
D2_ports[1]
]])
ip_config(test_type, vrfname)
dict1 = {
'vrf_name': vrfname,
'local_as': dut1_as,
'router_id': '1.1.1.1',
'config_type_list': ['router_id']
}
dict2 = {
'vrf_name': vrfname,
'local_as': dut2_as,
'router_id': '2.2.2.2',
'config_type_list': ['router_id']
}
parallel.exec_parallel(True, [dut1, dut2], bgp_api.config_bgp,
[dict1, dict2])
bgp_config(test_type, vrfname)
############################################################################################
hdrMsg("Step-C3: Verify all BGP/BGP+ sessions are in Established state")
############################################################################################
if test_type == 'ipv4':
nbr_list = dut2_ip
elif test_type == 'ipv6':
nbr_list = dut2_ipv6
else:
nbr_list = dut2_ip + dut2_ipv6
result = retry_api(ip_bgp.check_bgp_session,
dut1,
nbr_list=nbr_list,
state_list=['Established'] * len(nbr_list),
vrf_name=vrfname,
retry_count=10,
delay=3)
if result is False:
st.error("One or more BGP sessions did not come up")
st.report_fail('module_config_failed',
'One or more BGP sessions did not come up')
hdrMsg("##### BASE config END ####")
def base_unconfig():
###############################################################################################################################
st.log('######------Unconfigure static routes on 900 VRFs-----######')
for vrf, dut1_as, dut2_as in zip(vrf_list[899:1000], dut1_as_scale[0:100],
dut2_as_scale[0:100]):
dict1 = {
'vrf_name': vrf,
'local_as': dut1_as,
'config': 'no',
'removeBGP': 'yes',
'config_type_list': ['removeBGP']
}
dict2 = {
'vrf_name': vrf,
'local_as': dut2_as,
'config': 'no',
'removeBGP': 'yes',
'config_type_list': ['removeBGP']
}
parallel.exec_parallel(True, [data.dut1, data.dut2],
bgp_api.config_bgp, [dict1, dict2])
###############################################################################################################################
st.log('######------Unconfigure static routes on 900 VRFs-----######')
dict1 = {
'dest_list': data.tg_dut2_stream_start[0:425],
'next_hop_list': data.dut2_dut1_ip_list[0:425],
'vrf_list': vrf_list[0:425],
'config': 'no'
}
dict2 = {
'dest_list': data.tg_dut2_stream_start[0:425],
'vrf_list': vrf_list[0:425],
'config': 'no'
}
parallel.exec_parallel(True, [data.dut1, data.dut2], vrf_static_route,
[dict1, dict2])
st.wait(30)
st.log('######----- UnConfigure IP on DUT--TG interface------######')
utils.exec_all(
True,
[[
ip_api.config_ip_addr_interface, data.dut1, data.dut1_tg1_ports[0],
data.dut1_tg_host, '16', 'ipv4', 'remove'
],
[
ip_api.config_ip_addr_interface, data.dut2,
data.dut2_tg1_ports[0], data.dut2_tg_host, '16', 'ipv4', 'remove'
]])
dict1 = {
'dest_list': data.tg_dut2_stream_start[425:899],
'next_hop_list': data.dut2_dut1_ip_list[425:899],
'vrf_list': vrf_list[425:899],
'config': 'no'
}
dict2 = {
'dest_list': data.tg_dut2_stream_start[425:899],
'vrf_list': vrf_list[425:899],
'config': 'no'
}
parallel.exec_parallel(True, [data.dut1, data.dut2], vrf_static_route,
[dict1, dict2])
st.wait(30)
###############################################################################################################################
st.log('###### ----- Laoding back the config_db file ------######')
#cmd = 'cp /etc/sonic/default.json /etc/sonic/config_db.json'
src_path = "/etc/sonic/default.json"
dst_path = "/etc/sonic/config_db.json"
utils.exec_all(
True,
[[basic_obj.copy_file_to_local_path, data.dut1, src_path, dst_path],
[basic_obj.copy_file_to_local_path, data.dut2, src_path, dst_path]])
utils.exec_all(
True, [[st.reboot, data.dut1, 'fast'], [st.reboot, data.dut2, 'fast']])
###############################################################################################################################
host_config(config='no')
def base_config():
###############################################################################################################################
st.log('###### ----- Taking backup for unconfig ------######')
src_path = "/etc/sonic/config_db.json"
dst_path = "/etc/sonic/default.json"
#cmd = 'cp /etc/sonic/config_db.json /etc/sonic/default.json'
utils.exec_all(
True,
[[basic_obj.copy_file_to_local_path, data.dut1, src_path, dst_path],
[basic_obj.copy_file_to_local_path, data.dut2, src_path, dst_path]])
###############################################################################################################################
st.log(
'###### ----- Loading json file with vrf and IP address config ------######'
)
curr_path = os.getcwd()
json_file_dut1 = curr_path + "/routing/VRF/vrf_scale_dut1.json"
st.apply_files(data.dut1, [json_file_dut1])
json_file_dut2 = curr_path + "/routing/VRF/vrf_scale_dut2.json"
st.apply_files(data.dut2, [json_file_dut2])
utils.exec_all(True, [[st.apply_files, data.dut1, [json_file_dut1]],
[st.apply_files, data.dut2, [json_file_dut2]]])
st.log('######------Configure vlans and add members------######')
utils.exec_all(True,
[[vlan_api.config_vlan_range, data.dut1, '1 999', 'add'],
[vlan_api.config_vlan_range, data.dut2, '1 999', 'add']])
utils.exec_all(True, [[
vlan_api.config_vlan_range_members, data.dut1, '1 999',
data.d1_dut_ports[0], 'add'
],
[
vlan_api.config_vlan_range_members, data.dut2,
'1 999', data.d2_dut_ports[0], 'add'
]])
###############################################################################################################################
st.log('######----- Configure IP on DUT--TG interface------######')
utils.exec_all(True,
[[
ip_api.config_ip_addr_interface, data.dut1,
data.dut1_tg1_ports[0], data.dut1_tg_host, '16', 'ipv4'
],
[
ip_api.config_ip_addr_interface, data.dut2,
data.dut2_tg1_ports[0], data.dut2_tg_host, '16', 'ipv4'
]])
###############################################################################################################################
st.log(
'######----- Configure hosts and create traffic streams for all VRFs------######'
)
host_config()
gateway_mac = mac_api.get_sbin_intf_mac(data.dut1, data.dut1_tg1_ports[0])
data.stream = data.tg1.tg_traffic_config(
port_handle=data.tg_dut1_p1,
mode='create',
duration='5',
transmit_mode='continuous',
length_mode='fixed',
port_handle2=data.tg_dut2_p1,
rate_pps=1000,
mac_src='00.00.00.11.12.53',
mac_dst=gateway_mac,
ip_src_addr=data.tg_dut1_stream_start[0],
ip_dst_addr=data.tg_dut2_stream_start[0],
l3_protocol='ipv4',
ip_src_mode='increment',
ip_src_count=1000,
ip_src_step='0.0.0.1')
data.stream_list_scale.update({'pc_v4_stream': data.stream['stream_id']})
st.wait(30)
def test_ft_bgp_unnumbered_peer_basic():
# ################ Author Details ################
# Name: Kiran Vedula
# Email: [email protected]
# ################################################
utils_obj.banner_log(
'FtOtSoRtBgpUnFn001,FtOtSoRtBgpUnFn002,FtOtSoRtBgpUnFn018,FtOtSoRtBgpUnFn019'
)
st.log('######------Configure Unnumbered BGP peers------######')
result = 0
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.log("Failed to form BGP unnumbered peering using IPv6 link local")
result += 1
bgp_obj.config_bgp_neighbor_properties(vars.D1,
data.d1_local_as,
vars.D1D2P1,
family="ipv6",
neighbor_shutdown='',
no_form='')
if utils.poll_wait(bgp_obj.verify_bgp_summary,
data.wait,
vars.D1,
family='ipv6',
shell=bgp_cli_type,
neighbor=vars.D1D2P1,
state='Established'):
st.log("unnumbered BGP peering is established even after shutdown")
result += 1
bgp_obj.config_bgp_neighbor_properties(vars.D1,
data.d1_local_as,
vars.D1D2P1,
family="ipv6",
neighbor_shutdown='',
no_form='no')
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.log(
"Failed to form BGP unnumbered peering using IPv6 link local after no shutdown"
)
result += 1
if not utils.poll_wait(bgp_obj.verify_bgp_summary,
data.wait_timer,
vars.D1,
family='ipv6',
shell=bgp_cli_type,
neighbor=data.vlan_in_1,
state='Established'):
st.log(
"Failed to form BGP unnumbered peering using IPv6 link local on a VLAN"
)
result += 1
# Get show ndp output
st.log('######------shut/no shut link with unnumbered BGP------######')
utils.exec_all(
True,
[[arp_obj.show_ndp, vars.D1, None], [arp_obj.show_ndp, vars.D2, None]])
intf_obj.interface_operation(vars.D1,
vars.D1D2P1,
operation="shutdown",
skip_verify=True)
st.wait(data.wait)
intf_obj.interface_status_show(vars.D1, vars.D1D2P1)
intf_obj.interface_operation(vars.D1,
vars.D1D2P1,
operation="startup",
skip_verify=True)
st.wait(data.wait)
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.log("Failed to form BGP unnumbered peering using IPv6 link local")
result += 1
if result == 0:
st.report_pass("test_case_passed")
else:
st.log("BGP IPv6 unnumbered neighborship failure")
st.report_fail("test_case_failed")
def bgp_unnum_pre_config():
global vars
vars = st.ensure_min_topology("D1D2:4", "D1T1:2", "D2T1:2")
global dut1_rt_int_mac, dut2_rt_int_mac, d1_prt_link_local, \
d2_prt_link_local, d1_int_ipv6_list, d2_int_ipv6_list
# For debugging purpose, checking 'running config' before proceeding for module config
utils.exec_all(True, [[sc_obj.get_running_config, vars.D1],
[sc_obj.get_running_config, vars.D2]])
# For debugging purpose, checking 'routing interfaces' before proceeding for module config
# utils.exec_all(True, [[ip_obj.get_interface_ip_address, vars.D1, None, "ipv6"],
# [ip_obj.get_interface_ip_address, vars.D2, None, "ipv6"]])
pc_obj.config_portchannel(vars.D1,
vars.D2,
data.portchannel_name,
[vars.D1D2P3, vars.D1D2P4],
[vars.D2D1P3, vars.D2D1P4],
config='add',
thread=True)
# vlan config
utils.exec_all(
True,
[[vlan_obj.create_vlan, vars.D1, [data.vlan_li[0], data.vlan_li[1]]],
[vlan_obj.create_vlan, vars.D2, [data.vlan_li[0], data.vlan_li[1]]]])
utils.exec_all(True, [[
vlan_mem_cfg, vars.D1,
[[data.vlan_li[0], vars.D1D2P2, True],
[data.vlan_li[1], vars.D1D2P2, True]]
],
[
vlan_mem_cfg, vars.D2,
[[data.vlan_li[0], vars.D2D1P2, True],
[data.vlan_li[1], vars.D2D1P2, True]]
]])
d1_int_ipv6_list = [
vars.D1D2P1, data.vlan_in_1, data.vlan_in_2, data.portchannel_name
]
d2_int_ipv6_list = [
vars.D2D1P1, data.vlan_in_1, data.vlan_in_2, data.portchannel_name
]
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]])
# TG connected int ipv6 address config
utils.exec_all(
True,
[[
ip_obj.config_ip_addr_interface, vars.D1, vars.D1T1P2,
data.tgd_ip6_addr_l[0], data.tg_ip6_addr_mask_l[0], "ipv6", 'add'
],
[
ip_obj.config_ip_addr_interface, vars.D2, vars.D2T1P2,
data.tgd_ip6_addr_l[1], data.tg_ip6_addr_mask_l[1], "ipv6", 'add'
]])
utils.exec_all(
True,
[[
ip_obj.config_ip_addr_interface, vars.D1, vars.D1T1P1,
data.tgd_ip4_addr_l[0], data.tg_ip4_addr_mask_l[0], "ipv4", 'add'
],
[
ip_obj.config_ip_addr_interface, vars.D2, vars.D2T1P1,
data.tgd_ip4_addr_l[1], data.tg_ip4_addr_mask_l[1], "ipv4", 'add'
]])
# Get DUT mac address
[rt_int_mac, exceptions
] = utils.exec_all(True,
[[basic_obj.get_ifconfig_ether, vars.D1, vars.D1D2P1],
[basic_obj.get_ifconfig_ether, vars.D2, vars.D2D1P1]])
for value in exceptions:
if value is not None:
st.log("Exceptions observed {}".format(value))
st.error(
"Exceptions observed while getting mac address of routing interface"
)
dut1_rt_int_mac = rt_int_mac[0]
dut2_rt_int_mac = rt_int_mac[1]
# Get DUT link local addresses
[rt_link_local_addr, exceptions] = utils.exec_all(
True, [[ip_obj.get_link_local_addresses, vars.D1, vars.D1D2P1],
[ip_obj.get_link_local_addresses, vars.D2, vars.D2D1P1]])
for value in exceptions:
if value is not None:
st.log("Exceptions observed {}".format(value))
st.error(
"Exceptions observed while getting mac address of routing interface"
)
d1_prt_link_local = rt_link_local_addr[0]
d2_prt_link_local = rt_link_local_addr[1]
st.log("######------Get show ndp output------######")
utils.exec_all(
True,
[[arp_obj.show_ndp, vars.D1, None], [arp_obj.show_ndp, vars.D2, None]])
bgp_unnumbered_neighbour_config()
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])
utils.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']])
utils.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 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 test_ft_bgp_unnumbered_clear_bgp_ndp():
# ################ Author Details ################
# Name: Kiran Vedula
# Email: [email protected]
# ################################################
utils_obj.banner_log(
'FtOtSoRtBgpUnFn004,FtOtSoRtBgpUnFn005,FtOtSoRtBgpUnFn007')
result = 0
st.log('######------Clear BGP on both nodes------######')
utils.exec_all(True, [[arp_obj.clear_ndp_table, vars.D1],
[arp_obj.clear_ndp_table, vars.D2]])
utils.exec_all(True,
[[arp_obj.show_ndp, vars.D1], [arp_obj.show_ndp, vars.D2]])
utils.exec_all(True, [[bgp_obj.clear_ip_bgp_vtysh, vars.D1],
[bgp_obj.clear_ip_bgp_vtysh, vars.D2]])
utils.exec_all(True,
[[arp_obj.show_ndp, vars.D1], [arp_obj.show_ndp, vars.D2]])
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.log("Failed to form BGP unnumbered peering after clear NDP/BGP")
result += 1
if not utils.poll_wait(bgp_obj.verify_bgp_summary,
data.wait_timer,
vars.D2,
family='ipv6',
shell=bgp_cli_type,
neighbor=vars.D2D1P1,
state='Established'):
st.log("Failed to form BGP unnumbered peering after clear NDP/BGP")
result += 1
utils.exec_all(True, [[ip_obj.config_ipv6, vars.D1, "disable"],
[ip_obj.config_ipv6, vars.D2, "disable"]])
utils.exec_all(True, [[bgp_obj.clear_ip_bgp_vtysh, vars.D1],
[bgp_obj.clear_ip_bgp_vtysh, vars.D2]])
if not utils.poll_wait(bgp_obj.verify_bgp_summary,
data.wait_timer,
vars.D2,
family='ipv6',
shell=bgp_cli_type,
neighbor=vars.D2D1P1,
state='Active'):
st.log("BGP unnumbered peers established even after disable IPv6")
result += 1
utils.exec_all(True, [[ip_obj.config_ipv6, vars.D1, "enable"],
[ip_obj.config_ipv6, vars.D2, "enable"]])
if not utils.poll_wait(bgp_obj.verify_bgp_summary,
data.wait_timer,
vars.D2,
family='ipv6',
shell=bgp_cli_type,
neighbor=vars.D2D1P1,
state='Established'):
st.log("Failed to form BGP unnumbered peering after enable IPv6")
result += 1
if result == 0:
st.report_pass("test_case_passed")
else:
st.log("BGP unnumbered neighborship failed after config state toggle")
st.report_fail("test_case_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 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 test_ft_bgp_ebgp_multihop_4byteASN():
"""
Verify the functioning of ebgp multihop command with 4 byte ASN
"""
# On DUT1 and DUT3, create BGP with 4byte ASN
dut1_as = 6500001
dut1 = topo['dut_list'][0]
dut3_as = 6500002
dut3 = topo['dut_list'][2]
result = 0
wait_timer = 150
st.banner("Verify the ebgp multihop functionality with 4 byte AS Number")
# Configure bgp on DUT1 and configure DUT3 as neighbor with ebgp-multihop ttl set to 5
st.log(
"Configure eBGP on DUT1 with Neighbor as DUT3 with multihop set to maximum hops of 5"
)
bgpapi.config_bgp(dut1,
local_as=dut1_as,
neighbor=topo['D3D2P1_ipv4'],
remote_as=dut3_as,
config_type_list=["neighbor", "ebgp_mhop"],
ebgp_mhop='5')
# Add static route towards neighbor DUT3
st.log("Add static route towards DUT3")
ipapi.create_static_route(dut1, topo['D1D2P1_neigh_ipv4'],
"{}/24".format(topo['D3D2P1_ipv4']))
# Configure bgp on DUT3 and configure DUT1 as neighbor with ebgp-multihop ttl set to 5
st.log(
"Configure eBGP on DUT3 with DUT1 as Neighbor with multihop set to maximum hops of 5"
)
bgpapi.config_bgp(dut3,
local_as=dut3_as,
neighbor=topo['D1D2P1_ipv4'],
remote_as=dut1_as,
config_type_list=["neighbor", "ebgp_mhop"],
ebgp_mhop='5')
# Add static route towards neighbor DUT1
st.log("Add static route towards DUT1")
ipapi.create_static_route(dut3, topo['D3D2P1_neigh_ipv4'],
"{}/24".format(topo['D1D2P1_ipv4']))
st.log("Verify BGP neighborship on DUT1")
#result = bgpapi.verify_bgp_summary(dut1, family='ipv4', neighbor=topo['D3D2P1_ipv4'], state='Established')
if not utils.poll_wait(bgpapi.verify_bgp_summary,
wait_timer,
dut1,
family='ipv4',
neighbor=topo['D3D2P1_ipv4'],
state='Established'):
st.log("Failed to form BGP eBGP multihop peering with 4byte ASN")
result += 1
if result == 0:
st.log("Pass: BGP neighborship established between DUT1 and DUT3")
else:
st.error(
"Fail: BGP neighborship not established between DUT1 and DUT3")
st.banner("Collecting techsupport")
exec_all(True, [[
st.generate_tech_support, topo['dut_list'][0],
"test_ft_bgp_ebgp_multihop_4byteASN"
],
[
st.generate_tech_support, topo['dut_list'][1],
"test_ft_bgp_ebgp_multihop_4byteASN"
],
[
st.generate_tech_support, topo['dut_list'][2],
"test_ft_bgp_ebgp_multihop_4byteASN"
]])
#Clear applied configs
st.banner("Cleanup for TestFunction")
bgpapi.cleanup_router_bgp(dut1)
bgpapi.cleanup_router_bgp(dut3)
ipapi.delete_static_route(dut1, topo['D1D2P1_neigh_ipv4'],
"{}/24".format(topo['D3D2P1_ipv4']))
ipapi.delete_static_route(dut3, topo['D3D2P1_neigh_ipv4'],
"{}/24".format(topo['D1D2P1_ipv4']))
if result == 0:
st.report_pass("test_case_passed")
else:
st.report_fail("test_case_failed")
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 base_deconfig(vrfname='default'):
D1_ports, D2_ports, max_bfd, ipv4_bgp, ipv6_bgp, dut1_ip, dut2_ip, dut1_ipv6, dut2_ipv6, vlan_list, vlan_intf = \
return_vars(vrfname)
hdrMsg("##### BASE Deconfig Starts ####")
############################################################################################
hdrMsg("Step-DC1: Remove BGP router from dut1 and dut2")
############################################################################################
dict1 = {
'local_as': dut1_as,
'vrf_name': vrfname,
'config_type_list': ["removeBGP"],
'removeBGP': 'yes',
'config': 'no'
}
dict2 = {
'local_as': dut2_as,
'vrf_name': vrfname,
'config_type_list': ["removeBGP"],
'removeBGP': 'yes',
'config': 'no'
}
parallel.exec_parallel(True, [dut1, dut2], bgp_api.config_bgp,
[dict1, dict2])
ip_deconfig(test_type, vrfname)
utils.exec_all(
True,
[[
vlan_api.config_vlan_range_members, dut1, '{} {}'.format(
vlan_list[0], vlan_list[total_vlans / 2]), D1_ports[0], 'del'
],
[
vlan_api.config_vlan_range_members, dut2, '{} {}'.format(
vlan_list[0], vlan_list[total_vlans / 2]), D2_ports[0], 'del'
]])
utils.exec_all(True,
[[
vlan_api.config_vlan_range_members, dut1,
'{} {}'.format(vlan_list[((total_vlans / 2) + 1)],
vlan_list[-1]), D1_ports[1], 'del'
],
[
vlan_api.config_vlan_range_members, dut2,
'{} {}'.format(vlan_list[((total_vlans / 2) + 1)],
vlan_list[-1]), D2_ports[1], 'del'
]])
if vrfname == user_vrf_name:
dict1 = {
'vrf_name': [vrfname] * len(vlan_intf),
'intf_name': vlan_intf,
'skip_error': True,
'config': 'no'
}
dict2 = {
'vrf_name': [vrfname] * len(vlan_intf),
'intf_name': vlan_intf,
'skip_error': True,
'config': 'no'
}
parallel.exec_parallel(True, [dut1, dut2], vrf_api.bind_vrf_interface,
[dict1, dict2])
utils.exec_all(True, [[
vlan_api.config_vlan_range, dut1, '{} {}'.format(
vlan_list[0], vlan_list[-1]), 'del'
],
[
vlan_api.config_vlan_range, dut2, '{} {}'.format(
vlan_list[0], vlan_list[-1]), 'del'
]])
hdrMsg("##### BASE Deconfig End ####")
def test_ft_bgp_unnumbered_warmboot():
# ################ Author Details ################
# Name: Kiran Vedula
# Email: [email protected]
# ################################################
utils_obj.banner_log('FtOtSoRtBgpUnFn009')
utils.exec_all(True, [[bgp_obj.show_bgp_ipv6_summary_vtysh, vars.D1],
[bgp_obj.show_bgp_ipv6_summary_vtysh, vars.D2]])
utils.exec_all(
True,
[[arp_obj.show_ndp, vars.D1, None], [arp_obj.show_ndp, vars.D2, None]])
result = 0
st.log('######------Warm reboot with BGP unnumbered------######')
platform = basic_obj.get_hwsku(vars.D1)
common_constants = st.get_datastore(vars.D1, "constants", "default")
if not platform.lower(
) in common_constants['WARM_REBOOT_SUPPORTED_PLATFORMS']:
st.error("Warm-Reboot is not supported for this platform {}".format(
platform))
st.report_unsupported('Warmboot_unsupported_platform', platform)
reboot_obj.config_save(vars.D1, "sonic")
reboot_obj.config_save(vars.D1, "vtysh")
st.reboot(vars.D1, 'warm')
st.wait(data.wait)
if not utils.poll_wait(bgp_obj.verify_bgp_summary,
data.wait_timer,
vars.D2,
family='ipv6',
shell=bgp_cli_type,
neighbor=vars.D2D1P1,
state='Established'):
st.log("Failed to form BGP unnumbered peering after warm reboot")
result += 1
st.wait(data.wait)
if not utils.poll_wait(bgp_obj.verify_bgp_summary,
data.wait_timer,
vars.D2,
family='ipv6',
shell=bgp_cli_type,
neighbor=data.vlan_in_1,
state='Established'):
st.log("Failed to form BGP unnumbered peering after warm reboot")
result += 1
st.wait(data.wait)
if not utils.poll_wait(bgp_obj.verify_bgp_summary,
data.wait_timer,
vars.D2,
family='ipv6',
shell=bgp_cli_type,
neighbor=data.portchannel_name,
state='Established'):
st.log("Failed to form BGP unnumbered peering after warm reboot")
result += 1
if result == 0:
st.report_pass("test_case_passed")
else:
st.log("BGP unnumbered neighborship failed warm reboot")
utils.exec_all(True, [[arp_obj.show_ndp, vars.D1, None],
[arp_obj.show_ndp, vars.D2, None]])
utils.exec_all(True, [[bgp_obj.show_bgp_ipv6_neighbor_vtysh, vars.D1],
[bgp_obj.show_bgp_ipv6_neighbor_vtysh, vars.D2]])
st.report_fail("test_case_failed")
def test_confed_route_distribution_with_rmap(self):
st.banner("Verify the behavior of Route-Maps over confederation peers")
result = False
network1 = '134.5.6.0/24'
network2 = '134.5.7.0/24'
network3 = '134.5.8.0'
as_path = '200'
access_list1 = 'test-access-list1'
access_list2 = 'test-access-list2'
access_list3 = 'test-access-list3'
st.log(
"Create access-lists and a route-map in DUT1, add to it permit, deny and AS-path prepending policies"
)
# Create access-list test-access-list1
ipapi.config_access_list(topo['dut_list'][0],
access_list1,
network3 + '/24',
'permit',
seq_num="1")
# Create route-map and permit network3
ipapi.config_route_map_match_ip_address(topo['dut_list'][0],
'test-rmap', 'permit', '10',
access_list1)
# Add set option to prepend as-path 200
ipapi.config_route_map_set_aspath(topo['dut_list'][0], 'test-rmap',
'permit', '10', as_path)
# Create access-list test-access-list2
ipapi.config_access_list(topo['dut_list'][0],
access_list2,
network1,
'deny',
seq_num="2")
# In route-map, deny network1
ipapi.config_route_map_match_ip_address(topo['dut_list'][0],
'test-rmap', 'deny', '20',
access_list2)
# Create access-list test-access-list3
ipapi.config_access_list(topo['dut_list'][0],
access_list3,
network2,
'permit',
seq_num="3")
# In route-map, permit network2
ipapi.config_route_map_match_ip_address(topo['dut_list'][0],
'test-rmap', 'permit', '30',
access_list3)
# Advertise three networks from leaf
st.log(
"Advertise the networks from DUT1 through BGP and associate with the route-map"
)
bgpapi.advertise_bgp_network(topo['dut_list'][0],
topo['D1_as'],
network1,
'test-rmap',
network_import_check=True)
bgpapi.advertise_bgp_network(topo['dut_list'][0],
topo['D1_as'],
network2,
'test-rmap',
network_import_check=True)
bgpapi.advertise_bgp_network(topo['dut_list'][0],
topo['D1_as'],
network3 + '/24',
'test-rmap',
network_import_check=True)
st.log(
"Verify in peer DUT2 the network configured in {} has the AS-path prepended"
.format(access_list1))
# Verify that the neighbor has the as-path prepended
output = bgpapi.show_bgp_ipvx_prefix(topo['dut_list'][1],
prefix=network3,
masklen=topo['D1_as'])
for x in output: # type: basestring
peer_asn = x['peerasn']
peer_asn = peer_asn.split()
for each in peer_asn:
if each == as_path:
result = True
if result:
st.log("Pass: AS-Path {} found to be prepended with network {}/24".
format(as_path, network3))
else:
st.error(
"Fail: AS-Path {} not found to be prepended".format(as_path))
# Verify that network1 is not present in ip route table
st.log(
"Verify that peer DUT2 not learnt the network configured as 'deny' in {}"
.format(access_list2))
n1 = ipapi.verify_ip_route(topo['dut_list'][1], ip_address=network1)
if n1 is False:
result = result & True
st.log("Pass: DUT2 did not learn network {}".format(network1))
else:
result = result & False
st.error("Fail: DUT2 learned the network {}".format(network1))
# Verify that network2 is present in ip route table
st.log(
"Verify that peer DUT2 learnt the network configured as 'permit' in {}"
.format(access_list3))
n2 = ipapi.verify_ip_route(topo['dut_list'][1], ip_address=network2)
if n2:
result = result & True
st.log("Pass: DUT2 learned the network {}".format(network2))
else:
result = result & False
st.error("Fail: DUT2 did not learn network {}".format(network2))
if not result:
st.banner("Collecting techsupport")
exec_all(True, [[
st.generate_tech_support, topo['dut_list'][0],
"test_confed_route_distribution_with_rmap"
],
[
st.generate_tech_support, topo['dut_list'][1],
"test_confed_route_distribution_with_rmap"
]])
ipapi.config_route_map_mode(topo['dut_list'][0],
'test-rmap',
'permit',
'10',
config='no')
# Clear applied configurations
st.banner("Cleanup for TestFunction")
ipapi.config_access_list(topo['dut_list'][0],
'test-access-list3',
network2,
'permit',
config='no',
seq_num="3")
ipapi.config_access_list(topo['dut_list'][0],
'test-access-list2',
network1,
'deny',
config='no',
seq_num="2")
ipapi.config_access_list(topo['dut_list'][0],
'test-access-list1',
network3 + '/24',
'permit',
config='no',
seq_num="1")
bgpapi.advertise_bgp_network(topo['dut_list'][0],
topo['D1_as'],
network1,
'test-rmap',
config='no')
bgpapi.advertise_bgp_network(topo['dut_list'][0],
topo['D1_as'],
network2,
'test-rmap',
config='no')
bgpapi.advertise_bgp_network(topo['dut_list'][0],
topo['D1_as'],
network3 + '/24',
'test-rmap',
config='no')
if result:
st.report_pass("test_case_passed")
else:
st.report_fail("test_case_failed")
