def test_ft_stp_loopguard_enable_interface_shut_noshut(): st.log("Verify the stp convergence") if not stp_wrap.poll_stp_convergence( vars, sc_data.vlan, iteration=20, delay=1): st.report_fail("stp_convergence_fail") st.log("Enable loop guard on interface") stp.config_stp_interface_params(vars.D1, vars.D1D2P2, loop_guard='enable') st.log("disable stp on an interface") stp.config_stp_enable_interface(vars.D2, vars.D2D1P2, mode="disable") st.wait(5) st.log("verify port moved to inconsistent state") if not stp.check_rg_current_state(vars.D1, sc_data.vlan, vars.D1D2P2): st.report_fail("port_inconsistent_state_fail") st.log("shutdown the root forwarding port") interface.interface_shutdown(vars.D1, vars.D1D2P1) st.log("enable stp on an interface") stp.config_stp_enable_interface(vars.D2, vars.D2D1P2, mode="enable") st.wait(5) if not stp.verify_stp_intf_status(vars.D1, interface=vars.D1D2P2, status="FORWARDING", vlanid=sc_data.vlan): st.report_fail("port_forwarding_fail") interface.interface_noshutdown(vars.D1, vars.D1D2P1) st.log("Unconfiguring the loop guard interface mode") stp.config_stp_interface_params(vars.D1, vars.D1D2P2, loop_guard='disable') st.report_pass("test_case_passed")
def ztp_module_hooks(request): st.add_prevent("ztp") initialize_variables() pre_config_ztp() path_list = [ztp_params.home_path+ztp_params.config_path, ztp_params.home_path+ztp_params.provision_script_path] ztp_obj.create_required_folders(ssh_conn_obj, path_list) basic_obj.move_file_to_local_path(vars.D1, "/etc/sonic/snmp.yml", "/etc/sonic/snmp.yml.bkp") source_path = "{}{}".format(config_params.local_provision_scripts_folder, config_params.snmp_filename) st.upload_file_to_dut(vars.D1, source_path, "/home/admin/snmp.yml") basic_obj.copy_file_to_local_path(vars.D1, "/home/admin/snmp.yml", "/etc/sonic/snmp.yml") if ztp_params.breakout: if breakout(vars.D1, ztp_params.breakout, cli_type="klish", skip_error=True): intf_details = get_interface_details_by_alt_name(vars.D1, ztp_params.inband_port) if isinstance(intf_details, dict): inband_port = intf_details["interface"] else: inband_port = intf_details interface_noshutdown(vars.D1, inband_port) config_ip_addr_interface(vars.D1, inband_port, ztp_params.dhcp6.client_ip_inband, ztp_params.dhcp6.inband_v6_subnet, family="ipv6") # enable_dhcp_on_interface(vars.D1, ztp_params.inband_port) if not ping(vars.D1, ztp_params.dhcp6.inband_static_ip, family="ipv6"): st.log("Pinging to DHCP server failed from DUT, issue either with DUT or server") # config_save(vars.D1) yield ztp_cfg = {"admin-mode": True, "restart-ztp-interval": 30, "feat-console-logging": feat_logging_console} ztp_obj.config_ztp_backdoor_options(vars.D1, ztp_cfg) reset_module_config() basic_obj.move_file_to_local_path(vars.D1, "/etc/sonic/snmp.yml.bkp", "/etc/sonic/snmp.yml")
def ztp_module_hooks(request): st.add_prevent("ztp") initialize_config_params() pre_config_ztp() initialize_data_variables() path_list = [ztp_params.home_path+ztp_params.config_path, ztp_params.home_path+ztp_params.firmware_path, ztp_params.home_path+ztp_params.provision_script_path, ztp_params.home_path+ztp_params.xml_path] ztp_obj.create_required_folders(ssh_conn_obj, path_list) basic_obj.move_file_to_local_path(vars.D1, "/etc/sonic/snmp.yml", "/etc/sonic/snmp.yml.bkp") source_path = "{}{}".format(config_params.local_provision_scripts_folder, config_params.snmp_filename) st.upload_file_to_dut(vars.D1, source_path, "/home/admin/snmp.yml") basic_obj.copy_file_to_local_path(vars.D1, "/home/admin/snmp.yml", "/etc/sonic/snmp.yml") if ztp_params.breakout: if breakout(vars.D1, ztp_params.breakout, cli_type="klish", skip_error=True): intf_details = get_interface_details_by_alt_name(vars.D1, ztp_params.inband_port) if isinstance(intf_details, dict): inband_port = intf_details["interface"] else: inband_port = intf_details interface_noshutdown(vars.D1, inband_port) config_ip_addr_interface(vars.D1, inband_port, ztp_params.dhcp.client_ip_inband, ztp_params.dhcp.inband_v4_subnet) # enable_dhcp_on_interface(vars.D1, ztp_params.inband_port) if not ping(vars.D1, ztp_params.dhcp.inband_static_ip): st.log("Pinging to DHCP server failed from DUT, issue either with DUT or server") # config_save(vars.D1) # write_config_db(vars.D1, interface_data) yield reset_module_config() basic_obj.move_file_to_local_path(vars.D1, "/etc/sonic/snmp.yml.bkp", "/etc/sonic/snmp.yml")
def test_ft_port_fn_verify_shut_noshut(): if not ipapi.config_ip_addr_interface(vars.D1, interface_name=vars.D1D2P1, ip_address=intf_data.ip_address, subnet=intf_data.mask, family="ipv4", config='add'): st.report_fail("operation_failed") if not ipapi.config_ip_addr_interface(vars.D2, interface_name=vars.D2D1P1, ip_address=intf_data.ip_address1, subnet=intf_data.mask, family="ipv4", config='add'): st.report_fail("operation_failed") if not ipapi.ping(vars.D1, intf_data.ip_address1, family='ipv4', count=1): st.report_fail("ping_fail", intf_data.ip_address, intf_data.ip_address1) if not ipapi.ping(vars.D2, intf_data.ip_address, family='ipv4', count=1): st.report_fail("ping_fail", intf_data.ip_address1, intf_data.ip_address) for _ in range(3): intfapi.interface_shutdown(vars.D1, [vars.D1D2P1], skip_verify=True) intfapi.interface_noshutdown(vars.D1, [vars.D1D2P1], skip_verify=True) if not ipapi.ping(vars.D1, intf_data.ip_address1, family='ipv4', count=5): st.report_fail("ping_fail", intf_data.ip_address, intf_data.ip_address1) if not ipapi.ping(vars.D2, intf_data.ip_address, family='ipv4', count=1): st.report_fail("ping_fail", intf_data.ip_address1, intf_data.ip_address) rbapi.config_save_reload(vars.D1) if not ipapi.config_ip_addr_interface(vars.D1, interface_name=vars.D1D2P1, ip_address=intf_data.ip_address, subnet=intf_data.mask, family="ipv4", config='remove'): st.report_fail("operation_failed") if not ipapi.config_ip_addr_interface(vars.D2, interface_name=vars.D2D1P1, ip_address=intf_data.ip_address1, subnet=intf_data.mask, family="ipv4", config='remove'): st.report_fail("operation_failed") for _ in range(3): intfapi.interface_shutdown(vars.D1, [vars.D1D2P1], skip_verify=True) intfapi.interface_noshutdown(vars.D1, [vars.D1D2P1], skip_verify=True) if not st.poll_wait(intfapi.verify_interface_status, 15, vars.D1, vars.D1D2P1, "oper", "up"): st.report_fail("interface_is_down_on_dut", [vars.D1D2P1]) if not st.poll_wait(intfapi.verify_interface_status, 15, vars.D2, vars.D2D1P1, "oper", "up"): st.report_fail("interface_is_down_on_dut", [vars.D2D1P1]) st.report_pass("test_case_passed")
def verifyPortStatus(): data.my_dut_list = st.get_dut_names() intapi.interface_noshutdown(vars.D1, [vars.D1T1P1, vars.D1D2P1]) intapi.interface_noshutdown(vars.D2, [vars.D2T1P1, vars.D2D1P1]) st.wait(5) for dut, portList in zip( data.my_dut_list, [[vars.D1T1P1, vars.D1D2P1], [vars.D2T1P1, vars.D2D1P1]]): for port in portList: if not intapi.verify_interface_status(dut, port, 'oper', 'up'): return False return True
def test_ft_erspan_portchannel_shut_noshut(): """ Author: Kanala Ramprakash Reddy ( [email protected]) TC1 FtOpSoSyErspanFn020: Verify that ERSPAN is working as expected after portchannel shut/no shut. :return: """ st.log("############### Test started to check ERSPAN status between multiple link flaps###############") st.log("Creating mirror session") mirror.create_session(vars.D1, session_name=data.mirror_session, gre_type=data.gre_type, dscp=data.dscp, ttl=data.ttl, queue=data.queue, src_ip=data.ip_T1D1P2, dst_ip=data.ip_T1D2P1) st.log("Creating ACL Policy") acl_dscp.config_classifier_table(vars.D1, enable='create', match_type="fields", class_name=data.acl_rule) acl_dscp.config_classifier_table(vars.D1, enable='yes', class_criteria="--src-ip", class_name=data.acl_rule, criteria_value=data.src_ip_mask, match_type="fields") acl_dscp.config_flow_update_table(vars.D1, policy_name=data.acl_table_name, flow='add', policy_type=data.type, class_name=data.acl_rule, priority_value=data.priority, description=data.description) acl_dscp.config_flow_update_table(vars.D1, policy_name=data.acl_table_name, flow='update', policy_type=data.type, class_name=data.acl_rule, priority_option='--mirror-session', priority_value=data.mirror_action) stream = data.tg1.tg_traffic_config(port_handle=data.tg_ph_1, mode='create', transmit_mode='continuous', length_mode='fixed', rate_pps=data.rate_pps, l2_encap='ethernet_ii', mac_src='00:0a:01:00:00:01', mac_dst=dut_mac, l3_protocol="ipv4", ip_src_addr=data.ip_T1D1P1, ip_dst_addr=data.ip_T1D1P2)['stream_id'] intf_obj.clear_interface_counters(vars.D1) st.log("Starting the traffic") data.tg1.tg_traffic_control(action='run', stream_handle=stream) for _ in range(5): intf_obj.interface_shutdown(vars.D1, [vars.D1D2P1], skip_verify=True) if not poll_wait(mirror.verify_session_all, 20, vars.D1, mirror_type="erspan", status="inactive", session_name=data.mirror_session): st.error("Mirror session status should be inactive after port shutdown") data.flag = 0 intf_obj.interface_noshutdown(vars.D1, [vars.D1D2P1], skip_verify=True) if not poll_wait(mirror.verify_session_all, 20, vars.D1, mirror_type="erspan", status="active", session_name=data.mirror_session): st.error("Mirror session status should be active after port startup") data.flag = 0 data.tg1.tg_traffic_control(action='stop', stream_handle=stream) if data.flag == 0: st.report_fail("test_case_failed") else: st.report_pass("test_case_passed")
def test_ft_snmp_link_up_trap(): """ Author : Prasad Darnasi<*****@*****.**> Verify that trap is sent when a link is UP. """ check_flag = snmptrapd_checking() if not check_flag: st.report_fail("snmptrapd_not_running") # trigger trap on DUT intf_obj.interface_shutdown(vars.D1, vars.D1T1P1) intf_obj.interface_noshutdown(vars.D1, vars.D1T1P1) # get data from capture read_cmd = "cat {}".format(capture_file) output = execute_command(ssh_conn_obj, read_cmd) trap_lines = output.split("\n")[:-1] result = any('linkUp' in x for x in trap_lines) if result == 0: st.report_fail("snmp_output_failed", "linkUp") else: st.report_pass("test_case_passed")
def test_system_up_performance(): timer_dict = {} test_port = vars.D1D2P1 max_port_up_time = 20 if not intapi.verify_interface_status(vars.D1, test_port, 'oper', 'up'): st.error('{} interface is down on dut'.format(test_port)) st.report_fail('test_case_failed') st.banner("START - REBOOT TEST ") tstart = datetime.now() st.reboot(vars.D1) bcapi.get_system_status(vars.D1) tdiff = datetime.now() - tstart timer_dict['REBOOT_TEST'] = "{} {}".format(tdiff, 'H:M:S:msec') st.banner("END - REBOOT TEST -- {}".format(timer_dict['REBOOT_TEST'])) st.banner("START - CONFIG REBOOT TEST ") tstart = datetime.now() config_reload(vars.D1) bcapi.get_system_status(vars.D1) tdiff = datetime.now() - tstart timer_dict['CONFIG_REBOOT_TEST'] = "{} {}".format(tdiff, 'H:M:S:msec') st.banner("END - CONFIG REBOOT TEST -- {}".format( timer_dict['CONFIG_REBOOT_TEST'])) st.banner("START - PORT UP TEST ") logapi.clear_logging(vars.D1) intapi.interface_shutdown(vars.D1, test_port) intapi.verify_interface_status(vars.D1, test_port, 'oper', 'down') st.wait(5) intapi.interface_noshutdown(vars.D1, test_port) if not intapi.poll_for_interface_status( vars.D1, test_port, 'oper', 'up', iteration=max_port_up_time, delay=1): st.error('{} interface is down on dut for MAX time = {}'.format( test_port, max_port_up_time)) log_down = logapi.show_logging( vars.D1, filter_list=['sudo config interface startup {}'.format(test_port)]) log_up = logapi.show_logging( vars.D1, filter_list=[ 'Set operation status UP to host interface {}'.format(test_port) ]) logapi.show_logging(vars.D1) log_down_time = utils.log_parser(log_down[0])[0] log_up_time = utils.log_parser(log_up[0])[0] f_down_time = utils.convert_time_to_milli_seconds( days=0, hours=log_down_time['hours'], minutes=log_down_time['minutes'], seconds=log_down_time['seconds'], milli_second=log_down_time['micro_second']) f_up_time = utils.convert_time_to_milli_seconds( days=0, hours=log_up_time['hours'], minutes=log_up_time['minutes'], seconds=log_up_time['seconds'], milli_second=log_up_time['micro_second']) st.log("f_down_time : {} , f_up_time : {}".format(f_down_time, f_up_time)) timer_dict['PORT_UP_TEST'] = "{} {}".format( (f_up_time - f_down_time) / 1000, 'mili sec') st.banner("END - PORT UP TEST -- {}".format(timer_dict['PORT_UP_TEST'])) st.log("\n" + pprint.pformat(timer_dict, width=2) + '\n') st.log('\n' + cutils.sprint_vtable(['Test Name', 'Time'], timer_dict.items()) + '\n') csv_str = '\nTest, Result\n' for i, j in timer_dict.items(): csv_str += "{}, {}\n".format(i, j) st.log(csv_str) st.report_pass('test_case_passed')
def config_and_verify_dhcp_option(ssh_conn_obj, dut, ztp_params, data, expect_reboot=False, reboot_on_success=list(), cli_type=""): """ Common function to configure DHCP option along with status / logs verification Author: Chaitanya Vella ([email protected]) :param ssh_conn_obj: :param dut: :param ztp_params: :param data: :return: """ cli_type = st.get_ui_type(dut,cli_type=cli_type) cli_type = "klish" if cli_type in ["rest-put", "rest-patch"] else cli_type retry_count = data.retry_count if "retry_count" in data and data.retry_count else 0 iteration = data.iteration if "iteration" in data and data.iteration else 300 delay = data.delay if "delay" in data and data.delay else 3 if "func_name" in data: syslog_file_names = ["syslog_1_{}".format(data.func_name), "syslog_{}".format(data.func_name)] # basic_obj.copy_config_db_to_temp(dut, data.config_db_path, data.config_db_temp) if "config_file_type" in data and data.config_file_type == "text": file_path = "/tmp/file_temp.json" basic_obj.write_to_file(ssh_conn_obj, data.json_content, file_path, device="server") elif "config_file_type" in data and data.config_file_type == "EoL": file_path = "" else: file_path = basic_obj.write_to_json_file(data.json_content) if file_path: destination_path = "{}{}/{}".format(ztp_params.home_path, ztp_params.config_path, data.config_file) basic_obj.copy_file_from_client_to_server(ssh_conn_obj, src_path=file_path, dst_path=destination_path) if "config_db_location" in data and data.config_db_location == "json": st.download_file_from_dut(dut, data.config_db_temp, file_path) destination_path = "{}{}/{}".format(ztp_params.home_path, ztp_params.config_path, data.config_db_file_name) basic_obj.copy_file_from_client_to_server(ssh_conn_obj, src_path=file_path, dst_path=destination_path) if "scenario" in data and data.scenario == "invalid-json": st.log("Writing invalid content to make invalid json ...") basic_obj.write_to_file_to_line(ssh_conn_obj, ",", 5, destination_path, "server") if data.option_type == "67": st.log("Creating {} file on DHCP server ...".format(data.config_file)) data.search_pattern = r'\s*option\s+bootfile-name\s*\S*\s*"\S+";' data.option_string = "option bootfile-name" if data.type == "http": data.option_url = "http://{}{}/{}".format(data.static_ip, data.config_path, data.config_file) elif data.type == "tftp": data.option_url = "tftp://{}/{}/{}".format(data.static_ip, data.config_path, data.config_file) elif data.type == "ftp": data.option_url = "ftp://{}/{}/{}".format(data.static_ip, data.config_path, data.config_file) write_option_to_dhcp_server(ssh_conn_obj, data) basic_obj.service_operations(ssh_conn_obj, data.dhcp_service_name, data.action, data.device) if not verify_dhcpd_service_status(ssh_conn_obj, data.dhcpd_pid): st.log("{} service not running".format(data.dhcp_service_name)) st.report_fail("service_not_running", data.dhcp_service_name) # write_option_67_to_dhcp_server(ssh_conn_obj, data) data.device_action = "reboot" if cli_type == "klish" else data.device_action if data.device_action == "reboot": reboot_type = data.reboot_type if "reboot_type" in data and data.reboot_type else "normal" basic_obj.remove_file(dut, data.config_db_path) st.reboot(dut, reboot_type, skip_port_wait=True) st.wait_system_status(dut, 500) elif data.device_action == "run": ztp_operations(dut, data.device_action) if "band_type" in data and data.band_type=="inband": if not basic_obj.poll_for_system_status(dut): st.log("Sytem is not ready ..") st.report_env_fail("system_not_ready") if not basic_obj.check_interface_status(dut, ztp_params.oob_port,"up"): basic_obj.ifconfig_operation(dut, ztp_params.oob_port, "down") interface_status = basic_obj.check_interface_status(dut, ztp_params.inband_port, "up") if interface_status is not None: if not interface_status: intf_obj.interface_noshutdown(dut, ztp_params.inband_port, cli_type=cli_type) if "service" in data and data.service == "disable": basic_obj.service_operations_by_systemctl(dut, "ztp", "stop") if basic_obj.verify_service_status(dut, "ztp"): st.log("ZTP status is not stopped") st.report_fail("service_not_stopped", "ztp") basic_obj.service_operations_by_systemctl(dut, "ztp", "start") if not poll_ztp_status(dut, ["IN-PROGRESS", "Not Started", "SUCCESS"], cli_type=cli_type): st.report_fail("ztp_max_polling_interval") if "check" in data and data.check == "not": if verify_ztp_status(dut, retry_count, iteration, delay, cli_type=cli_type): if "logs_path" in data and "func_name" in data: capture_syslogs(dut, data.logs_path, syslog_file_names) st.log("ZTP status verification failed") st.report_fail("ztp_status_verification_failed") else: st.log("Iteration count {}".format(iteration)) st.log("REBOOT ON SUCCESS - {}".format(reboot_on_success)) if reboot_on_success: if "configdb-json" in reboot_on_success: st.wait_system_reboot(dut) st.wait_system_status(dut, 300) result = verify_ztp_status(dut, retry_count, iteration, delay, expect_reboot=expect_reboot, reboot_on_success=reboot_on_success, cli_type=cli_type) else: result = verify_ztp_status(dut, retry_count, iteration, delay, expect_reboot=expect_reboot, cli_type=cli_type) if not result: if "logs_path" in data and "func_name" in data: capture_syslogs(dut, data.logs_path, syslog_file_names) st.log("ZTP status verification failed") st.report_fail("ztp_status_verification_failed") if reboot_on_success: output = show_ztp_status(dut, cli_type=cli_type) if output["status"] != "SUCCESS": st.wait(300, "Waiting for device to reboot after success...") st.wait_system_status(dut, 300) # st.wait_system_reboot(dut) if not verify_ztp_status(dut, retry_count, iteration, delay, cli_type=cli_type): if "logs_path" in data and "func_name" in data: capture_syslogs(dut, data.logs_path, syslog_file_names) st.log("ZTP status verification failed") st.report_fail("ztp_status_verification_failed") st.banner(boot_up_obj.sonic_installer_list(dut)) verify_ztp_filename_logs(dut, data) if "ztp_log_string" in data and data.ztp_log_string: if not basic_obj.poll_for_error_logs(dut, data.ztp_log_path, data.ztp_log_string): st.log("ZTP log {} verification failed for message {}".format(data.ztp_log_path, data.ztp_log_string)) if not basic_obj.poll_for_error_logs(dut, data.ztp_log_path_1, data.ztp_log_string): st.log("ZTP log {} verification failed for message {}".format(data.ztp_log_path_1, data.ztp_log_string)) st.report_fail("ztp_log_verification_failed", data.ztp_log_path_1, data.ztp_log_string) if "result" in data and data.result == "pass": st.report_pass("test_case_passed")
def verify_thresholds(data=[]): max_threshold = 999999 var_delay = 2 opt_delay = 2 clear_wait = 8 final_wait = 20 mymode = "" family_list = crm_obj.crm_get_family_list(data.D1) for family in family_list: if family != 'all': (data.used_counter[family], data.free_counter[family]) = crm_obj.crm_get_resources_count( data.D1, family) data.resource_count_max[ family] = data.used_counter[family] + data.free_counter[family] st.log("verify_thresholds: {} used {} free {} max {}".format( family, data.used_counter[family], data.free_counter[family], data.resource_count_max[family])) ##################### USED ############################# for family in family_list: if family != 'all': crm_obj.set_crm_thresholds_type(data.D1, family=family, type="used") crm_obj.set_crm_thresholds_value(data.D1, family=family, mode="high", value=max_threshold) crm_obj.set_crm_thresholds_value(data.D1, family=family, mode="low", value=max_threshold) #show logs st.log("show log messages:") slog_obj.show_logging(data.D1, lines=50) # Clear Logs slog_obj.clear_logging(data.D1) st.log("configure Thresholds for used") for family in family_list: if family != 'all': hi_th = data.used_counter[family] - 1 if hi_th < 0: hi_th = 0 mymode = "high" if family in acl_family_list: mymode = "low" crm_obj.set_crm_thresholds_value(data.D1, family=family, mode=mymode, value=hi_th) mymode = "low" if family in acl_family_list: mymode = "high" low_th = hi_th - 1 if low_th < 0: low_th = 0 #crm_obj.set_crm_thresholds_type(data.D1, family=family, type="used") crm_obj.set_crm_thresholds_value(data.D1, family=family, mode=mymode, value=low_th) crm_obj.set_crm_thresholds_type(data.D1, family=family, type="used") st.wait(opt_delay) ## EXCEED st.wait(var_delay) ## EXCEED crm_obj.get_crm_resources(data.D1, "all") interface_obj.interface_shutdown(data.D1, data.dut_p1_interface, skip_verify=False) interface_obj.interface_shutdown(data.D1, data.dut_p2_interface, skip_verify=False) macapi.clear_mac(data.D1) crm_fdb_config_clear(data) st.wait(opt_delay) ## CLEAR # Restore interface_obj.interface_noshutdown(data.D1, data.dut_p1_interface, skip_verify=False) interface_obj.interface_noshutdown(data.D1, data.dut_p2_interface, skip_verify=False) st.wait(opt_delay) # delay is required to populate tables ##################### PERCENTAGE ############################# for family in family_list: if family != 'all': crm_obj.set_crm_thresholds_value(data.D1, family=family, mode="high", value=max_threshold) crm_obj.set_crm_thresholds_value(data.D1, family=family, mode="low", value=max_threshold) crm_fdb_send_traffic(data) st.log("Configure Thresholds for percentage") for family in family_list: if family != 'all' and family != 'snat' and family != 'dnat' and family != 'ipmc': hi_th = 0 mymode = "high" crm_obj.set_crm_thresholds_value(data.D1, family=family, mode=mymode, value=hi_th) mymode = "low" low_th = 100 #crm_obj.set_crm_thresholds_type(data.D1, family=family, type="percentage") crm_obj.set_crm_thresholds_value(data.D1, family=family, mode=mymode, value=low_th) crm_obj.set_crm_thresholds_type(data.D1, family=family, type="percentage") st.wait(opt_delay) ## EXCEED st.wait(var_delay) ## EXCEED crm_obj.get_crm_resources(data.D1, "all") crm_acl_unconfig(data) crm_acl_config(data) interface_obj.interface_shutdown(data.D1, data.dut_p1_interface, skip_verify=False) interface_obj.interface_shutdown(data.D1, data.dut_p2_interface, skip_verify=False) macapi.clear_mac(data.D1) crm_fdb_config_clear(data) st.wait(opt_delay) ## CLEAR st.wait(var_delay) ## EXCEED ##################### FREE ############################# crm_obj.get_crm_resources(data.D1, "all") for family in family_list: if family != 'all': crm_obj.set_crm_thresholds_type(data.D1, family=family, type="used") crm_obj.set_crm_thresholds_value(data.D1, family=family, mode="high", value=max_threshold) crm_obj.set_crm_thresholds_value(data.D1, family=family, mode="low", value=max_threshold) st.wait(clear_wait) st.log("configure Thresholds for free") for family in family_list: if family != 'all': mymode = "high" hi_th = 0 crm_obj.set_crm_thresholds_value(data.D1, family=family, mode=mymode, value=hi_th) mymode = "low" low_th = max_threshold #crm_obj.set_crm_thresholds_type(data.D1, family=family, type="free") crm_obj.set_crm_thresholds_value(data.D1, family=family, mode=mymode, value=low_th) crm_obj.set_crm_thresholds_type(data.D1, family=family, type="free") st.wait(opt_delay) ## EXCEED crm_obj.get_crm_resources(data.D1, "all") interface_obj.interface_noshutdown(data.D1, data.dut_p1_interface, skip_verify=False) interface_obj.interface_noshutdown(data.D1, data.dut_p2_interface, skip_verify=False) crm_fdb_send_traffic(data) # CLEAR TH st.wait(final_wait) ## CLEAR if not poll_wait(check_logging_result, 60, data): crm_obj.get_crm_resources(data.D1, "all") st.error('Failed to get threshold logs, CRM threshold tests failed')