def ipv6_link_local_config(action="add"): if action == "add": st.log("Creating VLAN and participating interfaces ...") vlan_data = [{ "dut": [vars.D1], "vlan_id": bgp_rst_data.vlan_id[0], "tagged": [vars.D1D2P2] }, { "dut": [vars.D2], "vlan_id": bgp_rst_data.vlan_id[0], "tagged": [vars.D2D1P2] }] create_vlan_and_add_members(vlan_data) st.log("Creating PortChannel and participating interfaces ...") config_portchannel(vars.D1, vars.D2, bgp_rst_data.portchannel_name, [vars.D1D2P3, vars.D1D2P4], [vars.D2D1P3, vars.D2D1P4]) st.log("Enable IPV6 on physical interface on both the devices") [_, exceptions] = exec_all(True, [[config_interface_ip6_link_local, vars.D1, ["Vlan{}".format(bgp_rst_data.vlan_id[0]), bgp_rst_data.portchannel_name]], \ [config_interface_ip6_link_local, vars.D2, ["Vlan{}".format(bgp_rst_data.vlan_id[0]), bgp_rst_data.portchannel_name]]]) ensure_no_exception(exceptions) else: [_, exceptions] = exec_all(True, [ [config_interface_ip6_link_local, vars.D1, [vars.D1D2P1, "Vlan{}".format(bgp_rst_data.vlan_id[0]), bgp_rst_data.portchannel_name], "disable"], \ [config_interface_ip6_link_local, vars.D2, [vars.D2D1P1, "Vlan{}".format(bgp_rst_data.vlan_id[0]), bgp_rst_data.portchannel_name], "disable"]]) ensure_no_exception(exceptions) clear_portchannel_configuration([vars.D1, vars.D2]) clear_vlan_configuration([vars.D1, vars.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 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 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 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_config(config='yes'): if config == 'yes': st.log("Creating max number of vlans") max_vlan_create() max_vlan_verify() add_vlan_members() else: vlan.clear_vlan_configuration([vars.D1])
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 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)
def sf_module_prolog(): clear_vlan_configuration(vars.D1) sf_data.vlan = str(random_vlan_list()[0]) create_vlan(vars.D1, sf_data.vlan) add_vlan_member(vars.D1, sf_data.vlan, port_list=sf_data.port_list, tagging_mode=True) sf_data.tg, sf_data.tg_ph_list, sf_data.stream_sf_data = sf_tg_stream_config( )
def vlan_module_hooks(request): global vars vars = st.ensure_min_topology("D1D2:2", "D1T1:2", "D2T1:2") sc_data.version_data = basic_obj.show_version(vars.D1) vlan_variables() if not st.is_feature_supported("vlan-range", vars.D1): sc_data.max_vlan = 100 [_, exceptions] = exec_all(True, [[config_tg_stream], [vlan_module_prolog]], first_on_main=True) ensure_no_exception(exceptions) yield vlan.clear_vlan_configuration(st.get_dut_names(), thread=False)
def interface_module_hooks(request): global vars vars = st.ensure_min_topology("D1D2:2", "D1T1:2") initialize_variables() if not vlanapi.create_vlan(vars.D1, intf_data.vlan_id): st.report_fail("vlan_create_fail", intf_data.vlan_id) if not vlanapi.add_vlan_member(vars.D1, intf_data.vlan_id, [vars.D1T1P1, vars.D1T1P2]): st.report_fail("vlan_untagged_member_fail", [vars.D1T1P1, vars.D1T1P2], intf_data.vlan_id) st.log("Getting TG handlers") _, intf_data.tg_ph_1 = tgapi.get_handle_byname("T1D1P1") _, intf_data.tg_ph_2 = tgapi.get_handle_byname("T1D1P2") intf_data.tg = tgapi.get_chassis(vars) st.log("Reset and clear statistics of TG ports") intf_data.tg.tg_traffic_control(action='reset', port_handle=[intf_data.tg_ph_1, intf_data.tg_ph_2]) intf_data.tg.tg_traffic_control(action='clear_stats', port_handle=[intf_data.tg_ph_1, intf_data.tg_ph_2]) st.log("Creating TG streams") intf_data.streams = {} stream = intf_data.tg.tg_traffic_config(port_handle=intf_data.tg_ph_1, mode='create', port_handle2=intf_data.tg_ph_2, length_mode='fixed', rate_pps=100, frame_size=intf_data.mtu1, l2_encap='ethernet_ii_vlan', transmit_mode='single_burst', pkts_per_burst=100, vlan_id=intf_data.vlan_id, mac_src=intf_data.source_mac, mac_dst=intf_data.destination_mac, vlan="enable") st.log('Stream output:{}'.format(stream)) intf_data.streams['mtu1'] = stream['stream_id'] stream = intf_data.tg.tg_traffic_config(port_handle=intf_data.tg_ph_1, mode='create', port_handle2=intf_data.tg_ph_2, length_mode='fixed', rate_pps=100, frame_size=intf_data.mtu2, l2_encap='ethernet_ii_vlan', transmit_mode='single_burst', pkts_per_burst=100, vlan_id=intf_data.vlan_id, mac_src=intf_data.source_mac, mac_dst=intf_data.destination_mac, vlan="enable") st.log('Stream output:{}'.format(stream)) intf_data.streams['mtu2'] = stream['stream_id'] stream = intf_data.tg.tg_traffic_config(port_handle=intf_data.tg_ph_1, mode='create', length_mode='fixed', frame_size='5000', transmit_mode='continuous') st.log('Stream output:{}'.format(stream)) intf_data.streams['traffic_tg1'] = stream['stream_id'] stream = intf_data.tg.tg_traffic_config(port_handle=intf_data.tg_ph_2, mode='create', length_mode='fixed', frame_size='5000', transmit_mode='continuous') st.log('Stream output:{}'.format(stream)) intf_data.streams['traffic_tg2'] = stream['stream_id'] yield vlanapi.clear_vlan_configuration(st.get_dut_names(), thread=True) # intf_data.tg.tg_traffic_control(action='stop', port_handle=[intf_data.tg_ph_1, intf_data.tg_ph_2]) intf_data.tg.tg_traffic_control(action='reset', port_handle=[intf_data.tg_ph_1, intf_data.tg_ph_2])
def l3fwd_func_hooks(request): global vars vars = st.get_testbed_vars() st.log("PRE TSET : Cleanup call are started.") 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()) yield st.log("POST TSET : Cleanup call are started.") 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())
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 storm_control_module_hooks(request): global vars vars = st.ensure_min_topology("D1D2:2", "D1T1:2", "D2T1:2") sc_data.version_data = basic_obj.show_version(vars.D1) vlan_variables() [out, exceptions] = exec_all(True, [[config_tg_stream], [vlan_module_prolog]], first_on_main=True) ensure_no_exception(exceptions) yield vlan.clear_vlan_configuration(st.get_dut_names(), thread=False, cli_type="click")
def portchannel_module_hooks(request): # add things at the start of this module global vars vars = st.ensure_min_topology("D1D2:4", "D1T1:1", "D2T1:1") initialize_variables() exec_all( True, [[static_port_channel_tg_config], [static_port_channel_dut_config]], first_on_main=True) yield st.log('Module config Cleanup') clear_vlan_configuration([vars.D1, vars.D2]) portchannelobj.clear_portchannel_configuration([vars.D1, vars.D2])
def reboot_module_hooks(request): global vars global data data = SpyTestDict() data.iter_count = 3 data.idle_sleep = 300 data.max_vlan = 4093 vars = st.get_testbed_vars() vars = st.ensure_min_topology("D1") vlan_obj.config_vlan_range(vars.D1, "1 {}".format(data.max_vlan), config='add') yield vlan_obj.clear_vlan_configuration(st.get_dut_names(), thread=False)
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 reboot_module_hooks(request): global vars data.iter_count = 3 data.idle_sleep = 300 data.max_vlan = 4093 vars = st.ensure_min_topology("D1") if not st.is_feature_supported("vlan-range", vars.D1): # limit the number of VLANS so reduce run time data.max_vlan = 100 vlan_obj.config_vlan_range(vars.D1, "1 {}".format(data.max_vlan), config='add') data.version_data = basic_obj.get_hwsku(vars.D1) data.hw_constants_DUT = st.get_datastore(vars.D1, "constants") yield vlan_obj.clear_vlan_configuration(st.get_dut_names(), thread=False)
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 tacacs_module_hooks(request): # add things at the start of this module global vars vars = st.ensure_min_topology("D1") tacacs_params = st.get_service_info(vars.D1, "tacacs") st.log("Getting IP address of the device") data.clear() data.hosts = ensure_service_params(vars.D1, "tacacs", "hosts") data.tacacs_ser_ip_1 = ensure_service_params(vars.D1, "tacacs", "hosts", 0, "ip") data.tcp_port = ensure_service_params(vars.D1, "tacacs", "hosts", 0, "tcp_port") data.passkey = ensure_service_params(vars.D1, "tacacs", "hosts", 0, "passkey") data.priority = ensure_service_params(vars.D1, "tacacs", "hosts", 0, "priority") data.timeout = ensure_service_params(vars.D1, "tacacs", "hosts", 0, "timeout") data.auth_type = ensure_service_params(vars.D1, "tacacs", "hosts", 0, "auth_type") data.tacacs_ser_ip_2 = ensure_service_params(vars.D1, "tacacs", "hosts", 1, "ip") data.priority_server2 = ensure_service_params(vars.D1, "tacacs", "hosts", 1, "priority") data.time_out = '10' data.username = '******' data.password = '******' data.protocol = 'ssh' data.ssh_port = '22' data.login_type = "tacacs+" data.failthrough_mode = 'enable' data.local_username = '******' data.local_password = '******' data.local_password2 = 'broadcom' data.username1 = 'test' data.password1 = 'test' data.rw_user = {'username': data.username, 'password': data.password, 'mode': 'rw'} data.ro_username = ensure_service_params(vars.D1, "radius", "ro_user", "username") ensure_device_ipaddress() st.log("Configuring authentication login parameter as tacacs+ and local") tacacs_obj.set_aaa_authentication_properties(vars.D1, 'login', 'tacacs+ local') tacacs_obj.set_tacacs_server(vars.D1, 'add', data.tacacs_ser_ip_1, data.tcp_port, data.timeout, data.passkey, data.auth_type, data.priority) yield config_default_tacacs_properties(vars.D1) st.log("Deleting all TACACS+ servers from the device") for i in range(0, 8): tacacs_obj.set_tacacs_server(vars.D1, 'delete', tacacs_params.hosts[i].ip) st.log("Making AAA parameters to default") tacacs_obj.set_aaa_authentication_properties(vars.D1, 'login', 'default') tacacs_obj.set_aaa_authentication_properties(vars.D1, 'failthrough', 'default') clear_vlan_configuration([vars.D1])
def scheduling_module_config(config='yes'): if config == 'yes': st.debug("Configuring MAC age out time") [output, exceptions] = exec_all( True, [[config_mac_agetime, vars.D1, scheduling_data.ageout_time], [config_mac_agetime, vars.D2, scheduling_data.ageout_time]]) ensure_no_exception(exceptions) if not all(output): st.report_fail("mac_aging_time_failed_config") st.debug("Verifying MAC age out time") [output, exceptions ] = exec_all(True, [[get_mac_agetime, vars.D1], [get_mac_agetime, vars.D2]]) ensure_no_exception(exceptions) if not ((int(output[0]) == scheduling_data.ageout_time) and (int(output[1]) == scheduling_data.ageout_time)): st.report_fail( "msg", "MAC age out time is not configured as: {}".format( scheduling_data.ageout_time)) st.debug("Create a vlan and add ports as tagged members to it") if not create_vlan_and_add_members( [{ "dut": [vars.D1], "vlan_id": scheduling_data.vlan, "tagged": [vars.D1T1P1, vars.D1T1P2, vars.D1D2P1] }, { "dut": [vars.D2], "vlan_id": scheduling_data.vlan, "tagged": [vars.D2T1P1, vars.D2T1P2, vars.D2D1P1] }]): st.report_fail( "msg", "Failed to add port as tagged members of VLAN: {}".format( scheduling_data.vlan)) else: # clearing scheduling and vlan config clear_port_shaper(vars.D1, port=vars.D1D2P1, shaper_data=scheduling_data.policy_name, qos_clear=True) clear_vlan_configuration([vars.D1, vars.D2], thread=True) scheduling_data.tg.tg_traffic_control( action='stop', stream_handle=scheduling_data.streams.values())
def sanity_l3_func_hooks(request): # add things at the start every test case # use 'st.get_func_name(request)' to compare # if any thing specific a particular test case global vars vars = st.ensure_min_topology("D1D2:1", "D1T1:1", "D2T1:1") st.log("POST TEST : Cleanup call are started..") ipfeature.clear_ip_configuration(st.get_dut_names(), thread=data.clear_parallel) ipfeature.clear_ip_configuration(st.get_dut_names(), 'ipv6', thread=data.clear_parallel) vapi.clear_vlan_configuration(st.get_dut_names(), thread=data.clear_parallel) portchannel_obj.clear_portchannel_configuration(st.get_dut_names(), thread=data.clear_parallel) pre_test_l3_fwding() yield post_test_l3_fwding()
def pvst_elastic_module_hooks(request): global vars global stp_ela try: vars = st.ensure_min_topology("D1D2:3", "D2D3:3", "D1D3:3") lib_stp.init_cli_type() stp_ela = stp_wrap.apply_and_verify_module_config(vars, stp_protocol) st.log(stp_ela) except Exception as e: st.log(e) st.report_fail("exception", e) dut_list = stp_wrap.get_dut_list(vars) for d in dut_list: slog.clear_logging(d) yield stp.config_stp_in_parallel(dut_list, feature=stp_protocol, mode="disable") vlan.clear_vlan_configuration(dut_list) portchannel.clear_portchannel_configuration(dut_list) stp_wrap.complete_data.clear()
def vlan_module_epilog(): if not st.is_community_build(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, cli_type="click") vlan.clear_vlan_configuration(st.get_dut_names(), thread=False, cli_type="click") portchannel.clear_portchannel_configuration(st.get_dut_names(), thread=True)
def chef_module_hooks(request): global vars vars = st.ensure_min_topology("D1") if st.get_ui_type() in ['klish']: st.report_unsupported( 'test_execution_skipped', 'Skipping Chef test case for ui_type={}'.format(st.get_ui_type())) global free_ports global node_name global exclude_list global free_ports_samespeed free_ports = st.get_free_ports(vars.D1) if not free_ports: st.log("No free ports available") st.report_env_fail("test_case_not_executeds") vlan_members = [free_ports[0], free_ports[1], free_ports[2]] st.log("VLAN Members: {}".format(",".join(vlan_members))) free_ports_samespeed = get_free_ports_speed_list(vars.D1, vlan_members) st.log("Free ports same speed: {}".format(",".join(free_ports_samespeed))) exclude_list = vlan_members + [ free_ports_samespeed[0], free_ports_samespeed[1], free_ports_samespeed[2] ] node_name = 'testsonic{}'.format(random.randrange(1, 5000)) chef_params.client_path = util_obj.ensure_service_params( vars.D1, "chef", "client_path") chef_obj.delete_client_pem_files( vars.D1, "{}/{}".format(chef_params.client_path, "client.pem")) chef_obj.delete_client_pem_files( vars.D1, "{}/{}".format(chef_params.client_path, "validation.pem")) chef_pre_config_in_parallel() yield vlan_obj.clear_vlan_configuration(vars.D1) portchannel_obj.clear_portchannel_configuration(vars.D1) mac_obj.clear_mac(vars.D1) basic_obj.service_operations(vars.D1, "chef-client", "stop") chef_obj.delete_client_pem_files( vars.D1, "{}/{}".format(chef_params.client_path, "client.pem")) chef_obj.delete_chef_node(ssh_conn_obj, node_name) if ssh_conn_obj: con_obj.ssh_disconnect(ssh_conn_obj)