def pvst_elastic_function_hooks(request): if st.get_func_name(request) == "test_ft_stp_loopguard_lag_interfaces": vlan.clear_vlan_configuration(st.get_dut_names(), thread=False) st.log('Creating port-channel and adding members in both DUTs') portchannel.config_portchannel(vars.D1, vars.D2, sc_data.portchannel_name, sc_data.members_dut1, sc_data.members_dut2, "add") portchannel.config_portchannel(vars.D1, vars.D2, sc_data.portchannel_name2, sc_data.members_dut1_p2, sc_data.members_dut2_p2, "add") parallel.exec_all( True, [[vlan.create_vlan_and_add_members, sc_data.vlan_pc_d1], [vlan.create_vlan_and_add_members, sc_data.vlan_pc_d2]]) yield if st.get_func_name(request) == "test_ft_stp_loopguard_lag_interfaces": vlan.clear_vlan_configuration(st.get_dut_names(), thread=False) portchannel.clear_portchannel_configuration([vars.D1, vars.D2]) parallel.exec_all( True, [[vlan.create_vlan_and_add_members, sc_data.vlan_data_d1], [vlan.create_vlan_and_add_members, sc_data.vlan_data_d2]]) parallel.exec_all( True, [[vlan.create_vlan_and_add_members, sc_data.vlan1_data_d1], [vlan.create_vlan_and_add_members, sc_data.vlan1_data_d2]])
def full_cleanup(): bgpapi.cleanup_router_bgp(st.get_dut_names()) ipapi.clear_ip_configuration(st.get_dut_names(), thread=eh_data.thread_mode, family='all') vapi.clear_vlan_configuration(st.get_dut_names(), thread=eh_data.thread_mode)
def tg_vrf_bgp(**kwargs): 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 -101 for TG interface------######') for i in range(0,3): bgp_obj.config_bgp(dut = dut1, vrf_name = data.vrf_name[i], router_id = data.dut1_router_id, local_as = data.dut1_as[i], neighbor = data.tg1_dut1_vrf_ip[i], remote_as = data.dut1_tg_as[i], config = 'yes', config_type_list =['neighbor','activate']) st.log('######------Configure BGPv4+ in vrf-102 for TG interface ------######') bgp_obj.config_bgp(dut = dut1, vrf_name = data.vrf_name[i], router_id = data.dut1_router_id, addr_family ='ipv6', local_as = data.dut1_as[i], neighbor = data.tg1_dut1_vrf_ipv6[i], remote_as = data.dut1_tg_as[i], config = 'yes', config_type_list =['neighbor','activate']) 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.tg1_dut1_vrf_ipv6[i]) bgp_obj.config_bgp(dut = dut2, vrf_name = data.vrf_name[i], router_id = data.dut2_router_id, local_as = data.dut2_as[i], neighbor = data.tg1_dut2_vrf_ip[i], remote_as = data.dut2_tg_as[i], config = 'yes', config_type_list =['neighbor','activate']) bgp_obj.config_bgp(dut = dut2, vrf_name = data.vrf_name[i], router_id = data.dut2_router_id, addr_family ='ipv6', local_as = data.dut2_as[i], neighbor = data.tg1_dut2_vrf_ipv6[i], remote_as = data.dut2_tg_as[i], config = 'yes', config_type_list =['neighbor','activate']) 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.tg1_dut2_vrf_ipv6[i]) time.sleep(2) ''' for i in range(0,3): if not retry_api(bgp_obj.verify_bgp_summary,dut1,family='ipv4',shell="sonic",neighbor=data.tg1_dut1_vrf_ip[i], state='Established', vrf = data.vrf_name[i],delay=5,retry_count=5): st.log("FAIL: BGP not up") if not retry_api(bgp_obj.verify_bgp_summary,dut2,family='ipv6',shell="sonic",neighbor=data.tg1_dut2_vrf_ipv6[i], state='Established', vrf = data.vrf_name[i],delay=5,retry_count=5): st.log("FAIL: BGPv6 not up") ''' 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 bgp_fast_reboot_module_hooks(request): global vars vars = st.ensure_min_topology("D1D2:1", "D1T1:2") if not st.is_feature_supported("bgp-neighbotship-performance", vars.D1): data.neighborship_wait = 30 st.log("Enabling IPv6 mode globally") ip_obj.config_ipv6(vars.D1, action='enable') ip_obj.config_ipv6(vars.D2, action='enable') st.log("Configuring ipv4 addresses on routing interfaces") ipv4_ip_address_config() st.log("Verifying ipv4 addresses on routing interfaces") verify_ipv4_address_config() if data.ipv6_support: st.log("Configuring ipv6 addresses on routing interfaces") ipv6_address_config() st.log("Verifying ipv6 addresses on routing interfaces") verify_ipv6_address_config() st.log( "Configuring IPV6 eBGP config between DUT1 and DUT2,iBGP config between DUT1 and TG2" ) ipv6_bgp_config() st.log( "Configuring IPV4 eBGP config between DUT1 and DUT2,iBGP config between DUT1 and TG1" ) ipv4_bgp_config() if data.ipv6_support: st.log("Configuring TG2 V6 iBGP config") tg_bgpv6_config(vars, data.local_asn4, data.remote_asn4) st.log("Configuring TG1 V4 iBGP config") tg_bgp_config(vars, data.local_asn4, data.remote_asn4) st.log( "Verify IPV4 eBGP neighborship between D1 and D2 and iBGP neighborship between D1 and TG1" ) verify_v4_bgp_neigborship() if data.ipv6_support: st.log( "Verify IPV6 eBGP neighborship between D1 and D2 and iBGP neighborship between D1 and TG2" ) verify_v6_bgp_neigborship() yield bgp_obj.cleanup_router_bgp(st.get_dut_names()) ip_obj.clear_ip_configuration(st.get_dut_names()) if data.ipv6_support: ip_obj.clear_ip_configuration(st.get_dut_names(), 'ipv6') vlan_obj.clear_vlan_configuration(st.get_dut_names()) portchannel_obj.clear_portchannel_configuration(st.get_dut_names())
def vlan_module_epilog(): if st.is_feature_supported("strom-control", vars.D1): interface_list = [vars.D1T1P1, vars.D1T1P2] storm_control_type = ["broadcast", "unknown-multicast", "unknown-unicast"] for interface in interface_list: for stc_type in storm_control_type: scapi.config(vars.D1, type=stc_type, action="del", interface_name=interface, bits_per_sec=sc_data.kbps) vlan.clear_vlan_configuration(st.get_dut_names(), thread=False) portchannel.clear_portchannel_configuration(st.get_dut_names(),thread=True)
def bgp_rr_traffic_pre_config_cleanup(): st.banner("BGP RR WITH TRAFFIC CLASS CONFIG CLEANUP - START") bgplib.l3tc_vrfipv4v6_address_leafspine_bgp_config(config='no', rr_enable='true') bgplib.l3tc_vrfipv4v6_address_leafspine_config_unconfig(config='no') bgpapi.cleanup_router_bgp(st.get_dut_names()) ipapi.clear_ip_configuration(st.get_dut_names(), family='all', thread=True) bgplib.l3tc_underlay_config_unconfig(config='no') bgplib.l3tc_vrfipv4v6_address_leafspine_rr_tg_bgp_config(config='no', rr_enable='true') st.banner("BGP RR WITH TRAFFIC CLASS CONFIG CLEANUP - END")
def pre_test_l3_fwding(): # override from testbed vars = st.get_testbed_vars() data.my_dut_list = st.get_dut_names() ipfeature.clear_ip_configuration(st.get_dut_names()) ipfeature.clear_ip_configuration(st.get_dut_names(),'ipv6') vapi.clear_vlan_configuration(st.get_dut_names()) ipfeature.config_ip_addr_interface(vars.D1, vars.D1T1P1, data.d1t1_5_x_ip_addr, data.mask) ipfeature.config_ip_addr_interface(vars.D1, vars.D1T1P2, data.d1t2_5_x_ip_addr, data.mask)
def bgp_save_reboot_module_hooks(request): global vars vars = st.ensure_min_topology("D1D2:1", "D1T1:2") data.shell_vtysh = st.get_ui_type() if data.shell_vtysh == "click": data.shell_vtysh = "vtysh" if not st.is_feature_supported("bgp-neighbotship-performance", vars.D1): data.neighborship_wait = 30 st.log("Enabling IPv6 mode globally") st.exec_each([vars.D1, vars.D2], ip_obj.config_ipv6, action='enable') st.log("Configuring ipv4 addresses on routing interfaces") st.exec_each([vars.D1, vars.D2], ipv4_ip_address_config) st.log("Verifying ipv4 addresses on routing interfaces") st.exec_each([vars.D1, vars.D2], verify_ipv4_address_config) if data.ipv6_support: st.log("Configuring ipv6 addresses on routing interfaces") st.exec_each([vars.D1, vars.D2], ipv6_address_config) st.log("Verifying ipv6 addresses on routing interfaces") st.exec_each([vars.D1, vars.D2], verify_ipv6_address_config) st.log( "Configuring IPV6 eBGP config between DUT1 and DUT2,iBGP config between DUT1 and TG2" ) st.exec_each([vars.D1, vars.D2], ipv6_bgp_config) st.log( "Configuring IPV4 eBGP config between DUT1 and DUT2,iBGP config between DUT1 and TG1" ) st.exec_each([vars.D1, vars.D2], ipv4_bgp_config) if data.ipv6_support: st.log("Configuring TG2 V6 iBGP config") tg_bgpv6_config(vars, data.local_asn4, data.remote_asn4) st.log("Configuring TG1 V4 iBGP config") tg_bgp_config(vars, data.local_asn4, data.remote_asn4) yield bgp_obj.cleanup_router_bgp(st.get_dut_names()) ip_obj.clear_ip_configuration(st.get_dut_names()) if data.ipv6_support: ip_obj.clear_ip_configuration(st.get_dut_names(), 'ipv6', skip_error_check=True) vlan_obj.clear_vlan_configuration(st.get_dut_names()) portchannel_obj.clear_portchannel_configuration(st.get_dut_names())
def bum_clear_config(): interface_list = [vars.D1T1P1, vars.D1T1P2] storm_control_type = ["broadcast", "unknown-multicast", "unknown-unicast"] for interface in interface_list: for stc_type in storm_control_type: scapi.config(vars.D1, type=stc_type, action="del", interface_name=interface, bits_per_sec=data.kbps) vlan.clear_vlan_configuration(st.get_dut_names(), thread=False) portchannel.clear_portchannel_configuration(st.get_dut_names(), thread=True)
def tg_vrf_bind(**kwargs): vars = st.get_testbed_vars() dut1 = st.get_dut_names()[0] dut2 = st.get_dut_names()[1] if 'config' in kwargs: config = kwargs['config'] else: config = '' if config == '': st.log('######------Configure vlans on the PE--CE side-------######') for i in range(3): utils.exec_all(True, [[vlan_obj.create_vlan, vars.D1, data.dut1_tg1_vlan[i]], [vlan_obj.create_vlan, vars.D2, data.dut2_tg1_vlan[i]]]) utils.exec_all(True,[[vlan_obj.add_vlan_member,vars.D1,data.dut1_tg1_vlan[i],vars.D1T1P1,True,True], [vlan_obj.add_vlan_member,vars.D2,data.dut2_tg1_vlan[i],vars.D2T1P1,True,True]]) ''' vlan_obj.create_vlan(vars.D1, data.dut1_tg1_vlan[i]) # Vlan-1, VRF-101, port1 vlan_obj.add_vlan_member(vars.D1, data.dut1_tg1_vlan[i], vars.D1T1P1, True, True) vlan_obj.create_vlan(vars.D2, data.dut2_tg1_vlan[i]) vlan_obj.add_vlan_member(vars.D2, data.dut2_tg1_vlan[i], vars.D2T1P1, True, True) ''' st.log('######------Bind DUT1 <--> tg1 vlans to vrf, assign v4 and v6 address------######') for vrf, vlan, ip, ipv6 in zip(data.vrf_name[0:3], data.dut1_tg1_vlan[0:3],data.dut1_tg1_vrf_ip[0:3], data.dut1_tg1_vrf_ipv6[0:3]): vrf_api.bind_vrf_interface(dut = vars.D1, vrf_name = vrf, intf_name = 'Vlan'+vlan, skip_error = True) ipfeature.config_ip_addr_interface(vars.D1, 'Vlan'+vlan, ip, data.dut1_tg1_vrf_ip_subnet, 'ipv4') ipfeature.config_ip_addr_interface(vars.D1, 'Vlan'+vlan, ipv6, data.dut1_tg1_vrf_ipv6_subnet, 'ipv6') st.log('######------Bind DUT2 <--> tg1 vlans to vrf, assign v4 and v6 address------######') for vrf, vlan,ip,ipv6 in zip(data.vrf_name[0:3], data.dut2_tg1_vlan[0:3], data.dut2_tg1_vrf_ip[0:3], data.dut2_tg1_vrf_ipv6[0:3]): vrf_api.bind_vrf_interface(dut = vars.D2, vrf_name = vrf, intf_name = 'Vlan'+vlan, skip_error = True) ipfeature.config_ip_addr_interface(vars.D2, 'Vlan'+vlan, ip, data.dut2_tg1_vrf_ip_subnet, 'ipv4') ipfeature.config_ip_addr_interface(vars.D2, 'Vlan'+vlan, ipv6, data.dut2_tg1_vrf_ipv6_subnet, 'ipv6') else: st.log('######------Unbind DUT1 <--> tg1port1 vlans to vrf, assign v4 and v6 address------######') for vrf, vlan, ip, ipv6 in zip(data.vrf_name[0:3], data.dut1_tg1_vlan[0:3],data.dut1_tg1_vrf_ip[0:3], data.dut1_tg1_vrf_ipv6[0:3]): ipfeature.delete_ip_interface(dut1, 'Vlan'+vlan, ip, data.dut1_tg1_vrf_ip_subnet, 'ipv4') ipfeature.delete_ip_interface(dut1, 'Vlan'+vlan, ipv6, data.dut1_tg1_vrf_ipv6_subnet, 'ipv6') vrf_api.bind_vrf_interface(dut = dut1, vrf_name = vrf, intf_name = 'Vlan'+vlan, skip_error = True, config = 'no') st.log('######------Unbind DUT2 <--> tg1 vlans to vrf, assign v4 and v6 address------######') for vrf, vlan,ip,ipv6 in zip(data.vrf_name[0:3], data.dut2_tg1_vlan[0:3], data.dut2_tg1_vrf_ip[0:3], data.dut2_tg1_vrf_ipv6[0:3]): ipfeature.delete_ip_interface(dut2, 'Vlan'+vlan, ip, data.dut2_tg1_vrf_ip_subnet, 'ipv4') ipfeature.delete_ip_interface(dut2, 'Vlan'+vlan, ipv6, data.dut2_tg1_vrf_ipv6_subnet, 'ipv6') vrf_api.bind_vrf_interface(dut = dut2, vrf_name = vrf, intf_name = 'Vlan'+vlan, skip_error = True, config = 'no') st.log('######------Unconfigure vlans on the PE--CE side -------######') for i in range(3): vlan_obj.delete_vlan_member(dut1, data.dut1_tg1_vlan[i], vars.D1T1P1, tagging_mode=True) vlan_obj.delete_vlan(dut1, data.dut1_tg1_vlan[i]) # Vlan-1, VRF-101, port1 vlan_obj.delete_vlan_member(dut2, data.dut2_tg1_vlan[i], vars.D2T1P1, tagging_mode=True) vlan_obj.delete_vlan(dut2, data.dut2_tg1_vlan[i])
def dhcp_relay_module_config(request): initialize_variables() vars = st.ensure_min_topology("D1D2:1", "D2D3:2") bind_class_action_copp_policy(vars.D3, classifier='copp-system-dhcpl2', action_group='copp-system-dhcp') response = basic_obj.dhcp_server_config( vars.D1, dhcp_files_path=data.dhcp_files_path, server_port=vars.D1D2P1, server_ipv4=data.dhcp_server_ip, route_list=data.route_list, ipv4_relay_agent_ip=data.RA_ipaddress_1) if not response: st.report_fail("service_operation_status", "isc-dhcp-server", "installation", "failed") connected_port_ip_address_config() if not basic_obj.check_interface_status(vars.D2, data.dhcp_relay_params, "up"): basic_obj.ifconfig_operation(vars.D2, data.dhcp_relay_params, "up") if not ip_obj.ping(vars.D2, data.dhcp_server_ip): st.log( "Pinging to DHCP server failed from DUT, issue either with DUT or server" ) st.report_fail("ping_fail", data.dhcp_server_ip) basic_dhcp_relay_config_addition() yield response = basic_obj.dhcp_server_config( vars.D1, action="unconfig", dhcp_files_path=data.dhcp_files_path, server_port=vars.D1D2P1, server_ipv4=data.dhcp_server_ip, route_list=data.route_list, ipv4_relay_agent_ip=data.RA_ipaddress_1) if not response: st.report_fail("service_operation_status", "isc-dhcp-server", "uninstallation", "failed") dhcp_relay_obj.dhcp_relay_config_remove(vars.D2, vlan=data.vlan_int, IP=data.dhcp_server_ip) ip_obj.config_ip_addr_interface(vars.D2, data.dhcp_relay_params, data.RA_ipaddress_1, data.subnet, family=data.family, config='remove') ip_obj.clear_ip_configuration(st.get_dut_names()) ip_obj.clear_ip_configuration(st.get_dut_names(), 'ipv6') vlan_obj.clear_vlan_configuration(st.get_dut_names())
def nat_post_config(): vars = st.get_testbed_vars() util_nat_zone_config(vars, [vars.D1T1P1, vars.D1T1P2], [data.zone_1, data.zone_2], config=data.config_del) nat_obj.clear_nat_config(vars.D1) nat_obj.config_nat_feature(vars.D1, 'disable') ip_obj.delete_static_route(vars.D1, data.out_ip_addr_h, "{}/{}".format(data.global_ip_addr_rt, data.global_ip_addr_mask)) ip_obj.clear_ip_configuration(st.get_dut_names()) vlan_obj.clear_vlan_configuration(st.get_dut_names()) st.log("Cleaning up routing interfaces configured on TG") tg1.tg_interface_config(port_handle=tg_ph_1, handle=tg_rt_int_handle[0]['handle'], mode='destroy') tg1.tg_interface_config(port_handle=tg_ph_2, handle=tg_rt_int_handle[1]['handle'], mode='destroy') tgapi.traffic_action_control(tg_handler, actions=['reset'])
def pvst_elastic_module_hooks(request): global vars vars = st.ensure_min_topology("D1D2:4", "D1T1:2", "D2T1:2") vlan_variables() vlan.clear_vlan_configuration(st.get_dut_names(), thread=False) [_, exceptions] = exec_all(True, [[config_tg_stream], [looguard_module_prolog]], first_on_main=True) ensure_no_exception(exceptions) yield stp.config_stp_in_parallel(sc_data.dut_list, feature="rpvst", mode="disable", vlan=None) vlan.clear_vlan_configuration(st.get_dut_names(), thread=False)
def ndp_module_hooks(request): vars = st.ensure_min_topology("D1T1:2") # Initialize TG and TG port handlers tg_handler = tgapi.get_handles_byname("T1D1P1", "T1D1P2") tg = tg_handler["tg"] # Test setup details data.my_dut_list = st.get_dut_names() dut1 = data.my_dut_list[0] # NDP module configuration st.log("NDP module configuration.") ip_obj.config_ip_addr_interface(dut1, vars.D1T1P1, data.local_ip6_addr[0], 64, family=data.af_ipv6) vlan_obj.create_vlan(dut1, data.vlan_1) vlan_obj.add_vlan_member(dut1, data.vlan_1, vars.D1T1P2, True) ip_obj.config_ip_addr_interface(dut1, data.vlan_int_1, data.local_ip6_addr[1], 64, family=data.af_ipv6) # TG ports reset st.log("Resetting the TG ports") tg.tg_traffic_control(action="reset", port_handle=tg_handler["tg_ph_list"]) # TG protocol interface creation st.log("TG protocol interface creation") h1 = tg.tg_interface_config(port_handle=tg_handler["tg_ph_1"], mode='config', ipv6_intf_addr=data.neigh_ip6_addr_gw[0], ipv6_prefix_length='64', ipv6_gateway=data.local_ip6_addr[0], src_mac_addr=data.tg_mac1, arp_send_req='1', count=data.count) st.log("INTFCONF: " + str(h1)) h2 = tg.tg_interface_config(port_handle=tg_handler["tg_ph_2"], mode='config', ipv6_intf_addr=data.neigh_ip6_addr_gw[1], ipv6_prefix_length='64', ipv6_gateway=data.local_ip6_addr[1], src_mac_addr=data.tg_mac2, arp_send_req='1', vlan_id=data.vlan_1, vlan=1, count=data.count) st.log("INTFCONF: " + str(h2)) yield # NDP module cleanup st.log("NDP module cleanup.") ip_obj.clear_ip_configuration(dut1, family="ipv6", thread=data.clear_parallel) vlan_obj.clear_vlan_configuration(dut1, thread=data.clear_parallel)
def apis_common_init(scope, ref=None): """ :param scope: :type scope: :param ref: :type ref: :return: :rtype: """ from spytest import st, utils if scope == "session": return _api_common_session_begin() if scope == "module": st.debug("---- common module {} begin ----".format(ref)) elif scope == "function": st.debug("---- common test {} begin ----".format(ref)) if not os.getenv("SPYTEST_SKIP_INIT_COMMANDS"): def f(dut): if st.get_device_type(dut) in ["sonic", "vsonic"]: if not st.is_community_build(): st.show(dut, "show system status", skip_error_check=True, skip_tmpl=True) utils.exec_foreach(True, st.get_dut_names(), f)
def fill_alias(): alias = dict() for dut in st.get_dut_names(): alias[dut] = st.get_device_alias(dut) for tg in st.get_tg_names(): alias[tg] = st.get_device_alias(tg) return alias
def arp_static_route_reboot_module_hooks(request): # add things at the start of this module init_vars() initialize_variables() get_parms() global tg_handler tg_handler = tgapi.get_handles_byname("T1D1P1", "T1D1P2") global tg tg = tg_handler["tg"] tg_ph_list = [tg_handler["tg_ph_1"], tg_handler["tg_ph_2"]] st.log("configuring static route") adding_static_route() st.log("Getting ARP entry dynamically") adding_dynamic_arp() ip_obj.config_ip_addr_interface(vars.D1, vars.D1T1P2, data.ipv4_address_1, data.mask, family="ipv4", config='add') st.log("Configuring static ARP") arp_obj.add_static_arp(vars.D1, data.static_arp_ip, data.static_arp_mac, vars.D1T1P2) st.log( "Verifying static route entries before save and reboot/fast-reboot/warm-reboot" ) static_route_verify() st.log( "Verifying dynamic ARP entries before save and reboot/fast-reboot/warm-reboot" ) if not arp_obj.verify_arp(vars.D1, data.ipv4_address_ixia, data.src_mac_addr, vars.D1T1P1): st.report_fail("ARP_entry_dynamic_entry_fail", data.ipv4_address_ixia, vars.D1) else: st.log("Verified that dynamic ARP entry is present in arp table") st.log( "Verifying static ARP entries before save and reboot/fast-reboot/warm-reboot" ) if not arp_obj.verify_arp(vars.D1, data.static_arp_ip, data.static_arp_mac, ""): st.report_fail("static_arp_create_fail", vars.D1) else: st.log("Verified that static ARP entry is present in arp table") st.log("Save the config on the DUT") rb_obj.config_save(vars.D1) st.log("saving config in vtysh mode to save static route") rb_obj.config_save(vars.D1, shell="vtysh") yield # Below step will clear IP adresses configured on different interfaces in the device ip_obj.clear_ip_configuration(st.get_dut_names()) #Below step will clear static route configured in the device ip_obj.delete_static_route(vars.D1, data.ipv4_address_ixia, data.ipv4_address_network, family='ipv4', shell="vtysh") #Below step will delete static arp entries configured in the device arp_obj.delete_static_arp(vars.D1, data.static_arp_ip, vars.D1T1P2)
def vlan_func_hooks(request): bum_test_functions = [ "test_ft_stormcontrol_verification", "test_ft_stormcontrol_portchannel_intf", "test_ft_stormcontrol_incremental_bps_max_vlan", "test_ft_stormcontrol_fast_reboot", "test_ft_stormcontrol_warm_reboot" ] if st.get_func_name(request) in bum_test_functions: platform_check() if request.function.func_name == "test_ft_snmp_max_vlan_scale": vlan.clear_vlan_configuration(st.get_dut_names(), thread=False, cli_type="click") portchannel.clear_portchannel_configuration(st.get_dut_names(), thread=True) yield
def cmds_func_hooks(request): yield d1 = {'domain_id': 1, 'config': 'del', 'cli_type': 'click'} putils.exec_parallel(True, [data.d1, data.d2], mclag.config_domain, [d1, d1]) if st.get_func_name(request) == 'test_chef_evpn_vxlan_nvo': evpn_cleanup() bgp_cleanup() ip_obj.clear_ip_configuration(st.get_dut_names(), thread=data.clear_parallel) vlan.clear_vlan_configuration(st.get_dut_names(), thread=data.clear_parallel, cli_type=data.cli_type) clear_portchannel_configuration(st.get_dut_names(), thread=data.clear_parallel, cli_type=data.cli_type)
def initialize_topology(): st.log( "Script Starts Here!. Initialize.........................................................................................." ) vars = st.ensure_min_topology("D1D2:4", "D2D3:4", "D1T1:2", "D3T1:2") data.dut_list = st.get_dut_names() data.dut1 = data.dut_list[0] data.dut2 = data.dut_list[1] data.dut3 = data.dut_list[2] utils.exec_all(True, [[bgp_obj.enable_docker_routing_config_mode, data.dut1], [bgp_obj.enable_docker_routing_config_mode, data.dut2], [bgp_obj.enable_docker_routing_config_mode, data.dut3]]) data.d1_d2_ports = [vars.D1D2P1, vars.D1D2P2, vars.D1D2P3, vars.D1D2P4] data.d2_d1_ports = [vars.D2D1P1, vars.D2D1P2, vars.D2D1P3, vars.D2D1P4] data.d2_d3_ports = [vars.D2D3P1, vars.D2D3P2, vars.D2D3P3, vars.D2D3P4] data.d3_d2_ports = [vars.D3D2P1, vars.D3D2P2, vars.D3D2P3, vars.D3D2P4] data.dut1_tg_ports = [vars.D1T1P1, vars.D1T1P2] data.dut3_tg_ports = [vars.D3T1P1, vars.D3T1P2] data.tg_dut1_ports = [vars.T1D1P1, vars.T1D1P2] data.tg_dut3_ports = [vars.T1D3P1, vars.T1D3P2] data.tg = tgen_obj_dict[vars['tgen_list'][0]] data.tg_dut1_p1 = data.tg.get_port_handle(vars.T1D1P1) data.tg_dut3_p1 = data.tg.get_port_handle(vars.T1D3P1) data.tg_dut1_p2 = data.tg.get_port_handle(vars.T1D1P2) data.tg_dut3_p2 = data.tg.get_port_handle(vars.T1D3P2) data.d1_stream_list = {} data.d1_stream_list_vrf = {} data.d3_stream_list = {} if 'ixia' in vars['tgen_list'][0]: data.tgen_type = 'ixia' data.delay_factor = 2 else: data.tgen_type = 'stc' data.delay_factor = 1
def initialize_topology(): st.log( "Script Starts Here!. Initialize.........................................................................................." ) #DUT topology variables vars = st.ensure_min_topology("D1D2:4", "D1T1:2", "D2T1:2") data.dut_list = st.get_dut_names() data.dut1 = data.dut_list[0] data.dut2 = data.dut_list[1] data.d1_d2_ports = [vars.D1D2P1, vars.D1D2P2, vars.D1D2P3, vars.D1D2P4] data.d2_d1_ports = [vars.D2D1P1, vars.D2D1P2, vars.D2D1P3, vars.D2D1P4] #DUT-TG topology variables data.dut1_tg_ports = [vars.D1T1P1, vars.D1T1P2] data.dut2_tg_ports = [vars.D2T1P1, vars.D2T1P2] data.tg_dut1_ports = [vars.T1D1P1, vars.T1D1P2] data.tg_dut2_ports = [vars.T1D2P1, vars.T1D2P2] data.tg = tgen_obj_dict[vars['tgen_list'][0]] data.tg_dut1_p1 = data.tg.get_port_handle(vars.T1D1P1) data.tg_dut2_p1 = data.tg.get_port_handle(vars.T1D2P1) data.tg_dut1_p2 = data.tg.get_port_handle(vars.T1D1P2) data.tg_dut2_p2 = data.tg.get_port_handle(vars.T1D2P2) data.d1_stream_list = {} data.d2_stream_list = {} data.d1_gateway_mac = mac_obj.get_sbin_intf_mac(data.dut1, data.dut1_tg_ports[0]) #TGEN delay if 'ixia' in vars['tgen_list'][0]: data.tgen_type = 'ixia' data.delay_factor = 2 else: data.tgen_type = 'stc' data.delay_factor = 1
def post_test_l3_fwding(): vars = st.get_testbed_vars() data.my_dut_list = st.get_dut_names() ipfeature.delete_ip_interface(vars.D1, vars.D1T1P1, data.d1t1_5_x_ip_addr, data.mask) ipfeature.delete_ip_interface(vars.D1, vars.D1T1P2, data.d1t2_5_x_ip_addr, data.mask)
def initialize_topology_vars(): vars = st.ensure_min_topology("D1D3:4", "D2D3:4", "D1D4:4", "D2D4:4", "D3T1:1", "D4T1:1", "D1D2:1") data.dut_list = st.get_dut_names() data.dut1 = data.dut_list[0] data.dut2 = data.dut_list[1] data.dut3 = data.dut_list[2] data.dut4 = data.dut_list[3] for dut in vars.dut_list: bgp_api.enable_docker_routing_config_mode(dut) data.d1d2_ports = [vars.D1D2P1] data.d2d1_ports = [vars.D2D1P1] data.d1d3_ports = [vars.D1D3P1, vars.D1D3P2, vars.D1D3P3, vars.D1D3P4] data.d1d4_ports = [vars.D1D4P1, vars.D1D4P2, vars.D1D4P3, vars.D1D4P4] data.d2d3_ports = [vars.D2D3P1, vars.D2D3P2, vars.D2D3P3, vars.D2D3P4] data.d2d4_ports = [vars.D2D4P1, vars.D2D4P2, vars.D2D4P3, vars.D2D4P4] data.d3d1_ports = [vars.D3D1P1, vars.D3D1P2, vars.D3D1P3, vars.D3D1P4] data.d3d2_ports = [vars.D3D2P1, vars.D3D2P2, vars.D3D2P3, vars.D3D2P4] data.d4d1_ports = [vars.D4D1P1, vars.D4D1P2, vars.D4D1P3, vars.D4D1P4] data.d4d2_ports = [vars.D4D2P1, vars.D4D2P2, vars.D4D2P3, vars.D4D2P4] data.d4tg_ports = vars.D4T1P1 data.d3tg_ports = vars.D3T1P1 data.tg1 = tgen_obj_dict[vars['tgen_list'][0]] data.tg2 = tgen_obj_dict[vars['tgen_list'][0]] data.tgd3_ports = vars.T1D3P1 data.tgd4_ports = vars.T1D4P1 data.tg_dut3_p1 = data.tg1.get_port_handle(vars.T1D3P1) data.tg_dut4_p1 = data.tg2.get_port_handle(vars.T1D4P1) data.tg_handles = [data.tg_dut3_p1, data.tg_dut4_p1] data.D4_tg_mac = basic_api.get_ifconfig(data.dut4, data.d4tg_ports)[0]['mac'] if 'ixia' in vars['tgen_list'][0]: data.delay_factor = 2 else: data.delay_factor = 1
def nat_post_config(): vars = st.get_testbed_vars() util_nat_zone_config(vars.D2, [vars.D2D1P1, vars.D2D3P1], [data.zone_1, data.zone_2], config=data.config_del) nat_obj.clear_nat_config(vars.D2) nat_obj.config_nat_feature(vars.D2, 'disable') ip_obj.delete_static_route(vars.D1, data.d2d1_ip_addr,"{}/{}".format(data.d1_static_nw, data.ip_addr_mask)) ip_obj.delete_static_route(vars.D3, data.d2d3_ip_addr,"{}/{}".format(data.d3_static_nw, data.ip_addr_mask)) ip_obj.clear_ip_configuration(st.get_dut_names())
def test_reboot_dut(): """ This test is to reload all the DUTs mentioned as part of TestBed file. :return: """ for dut in st.get_dut_names(): st.reboot(dut) st.report_pass("build_reboot_success")
def tg_links_status_1(): results = dict() for dut in st.get_dut_names(): for local, partner, remote in st.get_tg_links(dut): (tg, ph) = tgapi.get_handle_byname(None, tg=partner, port=remote) name = "{}--{}".format(partner, remote) results[name] = get_link_status(tg, ph) return results
def duts_links_status(threads): results = dict() [rvs, exs] = utils.exec_foreach(threads, st.get_dut_names(), dut_links_status) for rv in rvs: if rv: results.update(rv) return results
def tg_links_status_using_hltapi(): results = dict() for dut in st.get_dut_names(): for _, partner, remote in st.get_tg_links(dut, native=use_native): (tg, ph) = tgapi.get_handle_byname(None, tg=partner, port=remote) name = "{}--{}".format(partner, remote) results[name] = get_tg_link_status(tg, ph) return results
def duts_links_status(hooks, threads): results = dict() [rvs, exps] = putils.exec_foreach2(threads, "trace", st.get_dut_names(), dut_links_status, hooks) for rv in rvs: if rv: results.update(rv) return results, any(exps)
def arp_module_hooks(request): global vars, tg_handler, tg, dut1, d1_mac_addr, h1, h2 # Min topology verification vars = st.ensure_min_topology("D1T1:2") # Initialize TG and TG port handlers tg_handler = tgapi.get_handles_byname("T1D1P1", "T1D1P2") tg = tg_handler["tg"] # Test setup details data.my_dut_list = st.get_dut_names() dut1 = data.my_dut_list[0] # Test variables d1_mac_addr = mac.get_sbin_intf_mac(dut1, "eth0") # ARP module configuration st.log("ARP module configuration.") ip_obj.config_ip_addr_interface(dut1, vars.D1T1P1, data.d1t1_ip_addr, data.mask) vlan_obj.create_vlan(dut1, data.vlan_1) vlan_obj.add_vlan_member(dut1, data.vlan_1, vars.D1T1P2, True) ip_obj.config_ip_addr_interface(dut1, data.vlan_int_1, data.d1t2_ip_addr, data.mask) # TG ports reset st.log("Resetting the TG ports") tg.tg_traffic_control(action="reset", port_handle=tg_handler["tg_ph_list"]) # TG protocol interface creation st.log("TG protocol interface creation") h1 = tg.tg_interface_config(port_handle=tg_handler["tg_ph_1"], mode='config', intf_ip_addr=data.t1d1_ip_addr, gateway=data.d1t1_ip_addr, src_mac_addr=data.t1d1_mac_addr, arp_send_req='1') st.log("INTFCONF: " + str(h1)) h2 = tg.tg_interface_config(port_handle=tg_handler["tg_ph_2"], mode='config', intf_ip_addr=data.t2d1_ip_addr, gateway=data.d1t2_ip_addr, src_mac_addr=data.t2d1_mac_addr, arp_send_req='1', vlan_id=data.vlan_1, vlan=1) st.log("INTFCONF: " + str(h2)) yield # ARP module cleanup st.log("ARP module cleanup.") ip_obj.clear_ip_configuration(dut1, family="ipv4", thread=data.clear_parallel) vlan_obj.clear_vlan_configuration(dut1, thread=data.clear_parallel)