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