def test_ft_sytem_bootup_logging_debug(): """ Author : Praveen Kumar Kota <*****@*****.**> Testbed : D1 --- Mgmt Network Verify that no unwanted logs are shown on DUT console with logging level "Debug". """ st.log("clearing the logging buffer") if not log.clear_logging(vars.D1): st.report_fail("failed_to_clear_logs", vars.D1) st.log("enabling logging level as debug") if not log.set_logging_severity(vars.D1, severity="Debug"): st.report_fail("logging_severity_level_change_failed", vars.D1) st.log("waiting the DUT to idle for sometime") st.wait(data.idle_sleep) log.set_logging_severity(vars.D1, severity="INFO") platform = basic_obj.get_hwsku(vars.D1) logs = ['in obtaining media setting for' ] if platform.lower() in ['accton-as9716-32d'] else [] if not log.check_for_logs_after_reboot( vars.D1, 'Error', log_severity=['DEBUG', 'INFO' ], except_logs=logs): st.report_fail("logs_are_getting_generated_after_reboot", vars.D1) if not log.check_unwanted_logs_in_logging(vars.D1, user_filter=[]): st.report_fail("logs_are_getting_generated_after_reboot", vars.D1) st.report_pass("test_case_passed")
def test_dhcp_relay_warm_reboot(): ################################################# # # Objective - Configure DHCP relay and verify if the configuration is retained after warm reboot. # ################################################# data.platform = basic_obj.get_hwsku(vars.D2) data.constants = st.get_datastore(vars.D2, "constants", 'default') st.log("OUTPUT:{}".format(data.constants)) if not data.platform.lower( ) in data.constants['WARM_REBOOT_SUPPORTED_PLATFORMS']: st.report_fail('test_case_unsupported') st.log("Performing Config save") rb_obj.config_save(vars.D2) st.log("Performing warm Reboot") st.reboot(vars.D2, "warm") if not basic_obj.poll_for_system_status(vars.D2, 'dhcp_relay.service', 120, 1): st.report_fail("service_not_running", "dhcp-relay") if not st.poll_wait(basic_obj.verify_service_status, 60, vars.D2, "dhcp_relay"): st.log("DHCP relay service not running") st.log("Verifying DHCP Helper configuration post reboot") check_dhcp_relay_config() dhcp_relay_obj.dhcp_client_start(vars.D3, vars.D3D2P1) if ip_obj.verify_interface_ip_address(vars.D3, vars.D3D2P1, data.pool_ip_address, family="ipv4", vrfname=''): st.report_fail("IP_address_assignment_failed", vars.D3) st.log( "Successfully verified DHCP Helper configuration is retained after warm reboot" ) st.report_pass("test_case_passed")
def vlan_variables(): global tg global tg_handler,hw_constants_DUT sc_data.cli_type_click = "click" sc_data.cli_type= st.get_ui_type(vars.D1, cli_type="") sc_data.vlan_list = random_vlan_list(count=2) sc_data.vlan_id = str(sc_data.vlan_list[0]) sc_data.vlan = str(sc_data.vlan_list[1]) sc_data.kbps = 1000 sc_data.frame_size = 68 sc_data.rate_pps =5000 sc_data.packets = (sc_data.kbps*1024)/(sc_data.frame_size*8) sc_data.bum_deviation = int(0.10 * sc_data.packets) sc_data.lower_pkt_count = int(sc_data.packets - sc_data.bum_deviation) sc_data.higher_pkt_count = int(sc_data.packets + sc_data.bum_deviation) sc_data.max_vlan = 4093 sc_data.source_mac = "00:0A:01:00:00:01" sc_data.source_mac1 = "00:0A:02:00:00:01" sc_data.line_rate = 100 sc_data.wait_stream_run = 10 sc_data.wait_for_stats = 10 sc_data.free_port = st.get_free_ports(vars.D1)[0] tg_handler = tgapi.get_handles_byname("T1D1P1", "T1D1P2", "T1D2P1", "T1D2P2") tg = tg_handler["tg"] tg_info['tg_info'] = tg_handler tg_info['vlan_id'] = sc_data.vlan sc_data.vlan_id_start = 1 sc_data.mac_count = 100 sc_data.dut_platform = basic_obj.get_hwsku(vars.D1) sc_data.vlan_data = [{"dut": [vars.D1], "vlan_id": sc_data.vlan, "tagged": [vars.D1T1P1, vars.D1T1P2]}] hw_constants_DUT = st.get_datastore(vars.D1, "constants") sc_data.warm_reboot_supported_platforms = hw_constants_DUT['WARM_REBOOT_SUPPORTED_PLATFORMS']
def global_vars_and_constants_init(): global vars global tf_data vars = st.ensure_min_topology('D1T1:4') tf_data = SpyTestDict() hw_constants = st.get_datastore(vars.D1, "constants") scapi.get_running_config(vars.D1) # Global Vars tf_data.tg_port_list = [vars.T1D1P1, vars.T1D1P2, vars.T1D1P3, vars.T1D1P4] tf_data.port_list = [vars.D1T1P1, vars.D1T1P2, vars.D1T1P3, vars.D1T1P4] tf_data.platform = bcapi.get_hwsku(vars.D1).lower() tf_data.unicast = 'unicast' tf_data.multicast = 'multicast' tf_data.tg_current_mode = tf_data.unicast tf_data.queues_to_check = [ 'COUNTERS_PG_NAME_MAP', 'COUNTERS_QUEUE_NAME_MAP' ] tf_data.max_time_to_check_sys_maps = [150, 2] # Seconds tf_data.traffic_duration = 3 # Seconds tf_data.test_max_retries_count = 3 tf_data.need_debug_prints = True # Common Constants tf_data.pg_headroom_un_supported_platforms = hw_constants[ 'THRESHOLD_FEATURE_PG_HEADROOM_UN_SUPPORTED_PLATFORMS'] tf_data.th3_platforms = hw_constants['TH3_PLATFORMS'] return tf_data
def global_vars_and_constants_init(): global tf_rest_data global vars vars = st.ensure_min_topology('D1') tf_rest_data = SpyTestDict() hw_constants = st.get_datastore(vars.D1, "constants") tf_rest_data.all_ports = intapi.get_all_interfaces(vars.D1, int_type='physical') # Global Vars tf_rest_data.platform = bcapi.get_hwsku(vars.D1) tf_rest_data.show_version = bcapi.show_version(vars.D1) tf_rest_data.feature = "bst" tf_rest_data.configure_bst_thresholds = "configure-bst-thresholds" tf_rest_data.configure_bst_multi_thresholds = "configure-bst-multi-thresholds" tf_rest_data.get_bst_thresholds = "get-bst-thresholds" tf_rest_data.clear_bst_thresholds = "clear-bst-thresholds" tf_rest_data.queues_to_check = [ 'COUNTERS_PG_NAME_MAP', 'COUNTERS_QUEUE_NAME_MAP' ] tf_rest_data.max_time_to_check_sys_maps = [150, 2] # Seconds tf_rest_data.default_threshold_value = 0 # Percentage # Common Constants tf_rest_data.pg_headroom_un_supported_platforms = \ hw_constants['THRESHOLD_FEATURE_PG_HEADROOM_UN_SUPPORTED_PLATFORMS'] tf_rest_data.build_product_info = hw_constants[ 'BUILD_BROADCOM_CLOUD_ADVANCED'] + hw_constants[ 'BUILD_BROADCOM_ENTERPRISE_ADVANCED']
def nat_pre_config(): global vars vars = st.ensure_min_topology("D1D2:1", "D2D3:1") platform = basic_obj.get_hwsku(vars.D2) common_constants = st.get_datastore(vars.D2, "constants", "default") if platform.lower() in common_constants['TH3_PLATFORMS']: st.error("NAT is not supported for this platform {}".format(platform)) st.report_unsupported('NAT_unsupported_platform',platform) ip_obj.config_ip_addr_interface(vars.D1, vars.D1D2P1, data.d1d2_ip_addr, data.ip_addr_mask, family=data.af_ipv4) ip_obj.config_ip_addr_interface(vars.D2, vars.D2D1P1, data.d2d1_ip_addr, data.ip_addr_mask, family=data.af_ipv4) ip_obj.config_ip_addr_interface(vars.D2, vars.D2D3P1, data.d2d3_ip_addr, data.ip_addr_mask, family=data.af_ipv4) ip_obj.config_ip_addr_interface(vars.D3, vars.D3D2P1, data.d3d2_ip_addr, data.ip_addr_mask, family=data.af_ipv4) ip_obj.create_static_route(vars.D1, data.d2d1_ip_addr,"{}/{}".format(data.d1_static_nw, data.ip_addr_mask), shell=data.shell_vtysh, family=data.af_ipv4) ip_obj.create_static_route(vars.D3, data.d2d3_ip_addr, "{}/{}".format(data.d3_static_nw, data.ip_addr_mask), shell=data.shell_vtysh, family=data.af_ipv4) st.log("NAT Configuration") nat_obj.config_nat_feature(vars.D2, 'enable') util_nat_zone_config(vars.D2, [vars.D2D1P1, vars.D2D3P1], [data.zone_1, data.zone_2], config=data.config_add) st.log("Creating NAT Pool") nat_obj.config_nat_pool(vars.D2, pool_name=data.pool_name[0], global_ip_range=data.d2d1_ip_addr, global_port_range=data.global_port_range, config=data.config_add) st.log("Creating NAT Pool binding") nat_obj.config_nat_pool_binding(vars.D2, binding_name=data.bind_name[0], pool_name=data.pool_name[0], config=data.config_add) utils.exec_all(True, [[ip_obj.show_ip_route, vars.D1], [ip_obj.show_ip_route, vars.D2]]) ip_obj.show_ip_route(vars.D3)
def is_supported_platform(dut): name = get_hwsku(dut) plt_str = name.split('-') if (str(plt_str[1]) == "AS7712"): return True else: return False
def test_ft_dynamic_nat_warmboot(): # ################ Author Details ################ # Name: Kesava Swamy Karedla # Eamil: [email protected] # ################################################ # Objective - FtOpSoRoNatWb001 - Verify warm boot with dynamic nat scaling entries. # ################################################# result_flag=0 platform = basic_obj.get_hwsku(vars.D1) common_constants = st.get_datastore(vars.D1, "constants", "default") if not platform.lower() in common_constants['WARM_REBOOT_SUPPORTED_PLATFORMS']: st.error("Warm-Reboot is not supported for this platform {}".format(platform)) st.report_unsupported('test_case_unsupported') nat_obj.clear_nat(vars.D1, translations=True) nat_obj.config_nat_pool_binding(vars.D1, binding_name=data.bind_name[0], pool_name=data.pool_name[0], config=data.config_del) nat_obj.config_nat_pool_binding(vars.D1, binding_name="scale_bind", pool_name="scale_pool", acl_name=data.acl_table_in_nat_eg, config=data.config_add) st.log("Sending continuous traffic at 600 pps for the max dynamic nat entries to get learned") tg1.tg_traffic_control(action='run', handle=tg_str_data[1]["tg1_scale_nat_udp_data_str_id_1"]) st.log("Waiting for traffic to run, such that max nat entries get learned") if not util_check_nat_translations_count(vars.D1,20,data.max_nat_entries): nat_reboot_debug_fun() st.log("Failed to learn max nat entries") result_flag = 1 tg1.tg_traffic_control(action='stop', handle=tg_str_data[1]["tg1_scale_nat_udp_data_str_id_1"]) # Show command for debugging purpose in case of failures. intf_obj.show_interface_counters_all(vars.D1) st.log("Warm boot verification") tgapi.traffic_action_control(tg_handler, actions=['clear_stats']) tg1.tg_traffic_control(action='run', handle=tg_str_data[1]["tg1_scale_nat_udp_data_str_id_1"]) st.log("Performing warm-reboot, while traffic is forwarding for nat entries") st.reboot(vars.D1, 'warm') tg1.tg_traffic_control(action='stop', handle=tg_str_data[1]["tg1_scale_nat_udp_data_str_id_1"]) traffic_details = { '1': { 'tx_ports': [vars.T1D1P1], 'tx_obj': [tg1], 'exp_ratio': [1], 'rx_ports': [vars.T1D1P2], 'rx_obj': [tg2], } } filter_result = tgapi.validate_tgen_traffic(traffic_details=traffic_details, mode='aggregate', comp_type='packet_count') if not filter_result: nat_reboot_debug_fun() st.log("Traffic loss observed for the SNAT traffic during warm-boot") result_flag = 1 nat_obj.config_nat_pool_binding(vars.D1, binding_name=data.bind_name[1], pool_name=data.pool_name[1], config=data.config_add) nat_obj.config_nat_pool_binding(vars.D1, binding_name="scale_bind", pool_name="scale_pool", acl_name=data.acl_table_in_nat_eg, config=data.config_del) if result_flag: st.report_fail("nat_warm_reboot_failed") st.report_pass("test_case_passed")
def set_speed(dut, data, cli_type=""): cli_type = st.get_ui_type(dut, cli_type=cli_type) cli_type = 'klish' if cli_type in ['rest-patch', 'rest-put'] else cli_type platform = basic.get_hwsku(dut) ports_per_pg = 12 if platform in ["Accton-AS7326-56X"] else 4 non_portgroup_platforms = [ "Accton-AS7712-32X", "Quanta-IX8A-BWDE-56X", "AS5835-54X" ] if not st.is_feature_supported("port-group", dut): non_portgroup_platforms.append(platform) ports_dict = dict() port_name_dict = dict() for index in range(0, len(data), 2): port = st.get_other_names( dut, [data[index]])[0] if "/" in data[index] else data[index] port_name_dict[port] = data[index + 1] id = re.search(r"\d+", port).group(0) id = (int(int(id) / ports_per_pg)) + 1 ports_dict[str(id)] = data[index + 1] st.debug("port-group speed data: {}".format(ports_dict)) commands = list() if cli_type == 'click': if platform not in non_portgroup_platforms: commands = [ "config portgroup speed {} {}".format(index, speed) for index, speed in ports_dict.items() ] else: commands = [ "portconfig -p {} -s {}".format(port, speed) for port, speed in port_name_dict.items() ] elif cli_type == 'klish': if platform not in non_portgroup_platforms: commands = [ "port-group {} speed {}".format(index, speed) for index, speed in ports_dict.items() ] else: for port, speed in port_name_dict.items(): intf_details = get_interface_number_from_name(port) if not intf_details: st.error("Interface data not found for {} ".format(port)) continue commands.append("interface {} {}".format( intf_details["type"], intf_details["number"])) commands.append("speed {}".format(speed)) commands.append("exit") else: st.error("Unsupported CLI_TYPE: {}".format(cli_type)) if commands: st.config(dut, commands, type=cli_type) return True
def global_vars_and_constants_init(): sf_data.clear() sf_data.tg_port_list = [vars.T1D1P1, vars.T1D1P2, vars.T1D1P3, vars.T1D1P4] sf_data.port_list = [vars.D1T1P1, vars.D1T1P2, vars.D1T1P3, vars.D1T1P4] sf_data.default_snapshot_interval = 10 sf_data.snapshot_interval = 5 sf_data.telemetry_interval = 30 sf_data.default_telemetry_interval = 120 sf_data.unicast = 'unicast' sf_data.multicast = 'multicast' sf_data.cpu = 'cpu' sf_data.periodic = 'periodic' sf_data.dut_mac = get_ifconfig_ether(vars.D1, 'eth0') sf_data.tg_current_mode = sf_data.unicast sf_data.traffic_duration = 5 sf_data.initial_counter_value = 0 sf_data.PG = ['shared', 'headroom', 'unicast', 'multicast'] sf_data.group = ['priority-group', 'queue'] sf_data.table = ['watermark', 'persistent-watermark'] sf_data.platform = get_hwsku(vars.D1).lower() sf_data.config_file = "buffers.json" sf_data.device_j2_file = "buffers.json.j2" sf_data.vlan1 = 1 sf_data.reload_interval = 70 sf_data.FMT = '%H:%M:%S' sf_data.buffer_pool_tolerance = 2080 sf_data.percentage = ['--percentage', '-p'] sf_data.dot1p_to_tc_map_dict = { '0': '0', '1': '1', '2': '2', '3': '3', '4': '4', '5': '5', '6': '6', '7': '7' } sf_data.tc_to_pg_map_dict = {'0-7': '7'} sf_data.obj_name = ['dot1p_tc_map', 'tc_pg_map'] sf_data.map_name = ['dot1p_to_tc_map', 'tc_to_pg_map'] sf_data.dot1p_tc_bind_map = { 'port': vars.D1T1P1, 'map': sf_data.map_name[0], 'obj_name': sf_data.obj_name[0] } sf_data.tc_pg_bind_map = { 'port': vars.D1T1P1, 'map': sf_data.map_name[1], 'obj_name': sf_data.obj_name[1] } sf_data.sflow_sample_rate = 256 return sf_data
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 test_ft_sys_soft_reboot_multiple_iter(): ''' Author : Sreenivasula Reddy <*****@*****.**> ''' st.log("Performing save and soft-reboot") reboot_obj.config_save(vars.D1) st.log("Soft rebooting device for multiple iterations") for each_iter in range(1, data.iter_count + 1): st.log("Reload iteration number {}".format(each_iter)) st.log("About to reload the switch") st.reboot(vars.D1, "fast") intf_obj.poll_for_interfaces(vars.D1, iteration_count=180, delay=1) st.log("After reload about to check 'show platform summary'") if not basic_obj.get_hwsku(vars.D1): st.report_fail("After_soft_reboot_DUT_access_fail", data.iter_count) st.log("performing clearconfig operation") reboot_obj.config_reload(vars.D1) st.report_pass('test_case_passed')
def port_fec_no_fec(vars, speed, fec=["none", "rs"]): """ Author : Nagarjuna Suravarapu <[email protected] By using this function we can pass parameters where we required (In my usage only fec parameter is changed ) and we can also reuse the code so that we can reduce the codes of line. """ if not isinstance(fec, list): st.log("FEC is not matching the criteria ..") st.report_fail("interface_is_down_on_dut", [vars.D1D2P1, vars.D1D2P2]) st.log("Observed that speed as {} on interface {}".format(speed, vars.D1D2P1)) if not st.poll_wait(intfapi.verify_interface_status, 20, vars.D1, [vars.D1D2P1, vars.D1D2P2], 'oper', 'up'): st.report_fail("interface_is_down_on_dut", [vars.D1D2P1, vars.D1D2P2]) if not st.poll_wait(intfapi.verify_interface_status, 20, vars.D2, [vars.D2D1P1, vars.D2D1P2], 'oper', 'up'): st.report_fail("interface_is_down_on_dut", [vars.D2D1P1, vars.D2D1P2]) if base_obj.get_hwsku(vars.D1).lower() in vars.constants[vars.D1]["TH3_PLATFORMS"]: if speed not in ['400G', '400000']: st.log("enabling the fec on Dut1") st.log(" if the fec on both duts interfaces mismatch then the ports should be down") intfapi.interface_properties_set(vars.D1, [vars.D1D2P1, vars.D1D2P2], "fec", fec[0], skip_error=False) if not st.poll_wait(intfapi.verify_interface_status, 20, vars.D1, [vars.D1D2P1, vars.D1D2P2], 'oper', 'down'): st.report_fail("interface_is_up_on_dut", [vars.D1D2P1, vars.D1D2P2]) if not st.poll_wait(intfapi.verify_interface_status, 20, vars.D2, [vars.D2D1P1, vars.D2D1P2], 'oper', 'down'): st.report_fail("interface_is_up_on_dut", [vars.D2D1P1, vars.D2D1P2]) st.log("disabling the fec on Dut1") intfapi.interface_properties_set(vars.D1, [vars.D1D2P1, vars.D1D2P2], "fec", fec[1], skip_error=False, no_form=True) if not st.poll_wait(intfapi.verify_interface_status, 20, vars.D1, [vars.D1D2P1, vars.D1D2P2], 'oper', 'up'): st.report_fail("interface_is_down_on_dut", [vars.D1D2P1, vars.D1D2P2]) if not st.poll_wait(intfapi.verify_interface_status, 20, vars.D2, [vars.D2D1P1, vars.D2D1P2], 'oper', 'up'): st.report_fail("interface_is_down_on_dut", [vars.D2D1P1, vars.D2D1P2]) else: st.log("enabling the fec on Dut1") st.log("if the fec on both duts interfaces mismatch then the ports should be down") intfapi.interface_properties_set(vars.D1, [vars.D1D2P1, vars.D1D2P2], "fec", fec[1], skip_error=False) if not st.poll_wait(intfapi.verify_interface_status, 20, vars.D1, [vars.D1D2P1, vars.D1D2P2], 'oper', 'down'): st.report_fail("interface_is_up_on_dut", [vars.D1D2P1, vars.D1D2P2]) if not st.poll_wait(intfapi.verify_interface_status, 20, vars.D2, [vars.D2D1P1, vars.D2D1P2], 'oper', 'down'): st.report_fail("interface_is_up_on_dut", [vars.D2D1P1, vars.D2D1P2]) st.log("disabling the fec on Dut1") intfapi.interface_properties_set(vars.D1, [vars.D1D2P1, vars.D1D2P2], "fec", fec[0], skip_error=False) if not st.poll_wait(intfapi.verify_interface_status, 20, vars.D1, [vars.D1D2P1, vars.D1D2P2], 'oper', 'up'): st.report_fail("interface_is_down_on_dut", [vars.D1D2P1, vars.D1D2P2]) if not st.poll_wait(intfapi.verify_interface_status, 20, vars.D2, [vars.D2D1P1, vars.D2D1P2], 'oper', 'up'): st.report_fail("interface_is_down_on_dut", [vars.D2D1P1, vars.D2D1P2])
def test_chef_evpn_vxlan_nvo(): for dut in [data.d2, data.d3]: dut_type = get_hwsku(dut) if "7326" in dut_type or "AS7726" in dut_type or "S5232f" in dut_type or "S5248f" in dut_type or "S5296f" in dut_type or "AS5835" in dut_type or "IX8A" in dut_type or "IX8" in dut_type: st.log( "platform {} can be used as leaf node for EVPN testing".format( dut_type)) else: st.error( "expecting leaf node for EVPN testing to be \"7326\" or \"AS7726\" or \"S5232f\" or \"S5248f\" or \"S5296f\" or \"AS5835\" or \"IX8A\" or \"IX8\"" ) st.report_env_fail("platform_check_fail", dut) chef_server.role_dir = os.path.join(chef_server.path, 'roles') for file_name, role, node_name in zip(data.role_tc_list_evpn, data.role_list_mc, data.node_list_mc): new_file_name = modify_role_jsonfile(file_name) loc_lib.copy_role_file_to_chef_server(new_file_name) st.log('{}, {}, {}'.format(file_name, role, node_name)) chef_evpn_obj.upload_role_chef_server(chef_server.ssh_obj, chef_server.role_dir, file_name=new_file_name) run_list = 'role[{}],recipe[sonic::vlan],recipe[sonic::vxlan],recipe[sonic::interface],recipe[sonic::evpn_nvo],recipe[sonic::loopback],recipe[sonic::router],recipe[sonic::bgprouter]'.format( role) chef_evpn_obj.update_node_run_list(chef_server.ssh_obj, node_name, run_list) run_chef_all_nodes() st.wait(data.wait) if not verify_vxlan_tunnel_status(data.d2, '3.3.3.2', ['4.4.4.2'], ['oper_up']): st.report_fail('test_case_failed') if not verify_vxlan_tunnel_status(data.d3, '4.4.4.2', ['3.3.3.2'], ['oper_up']): st.report_fail('test_case_failed') st.report_pass('test_case_passed')
def l3_performance_enhancements_module_hooks(request): global vars, tg_handler, tg, dut, dut_to_tg_port_1, dut_to_tg_port_2, cli_type global hwsku_under_test, def_v4_route_count, def_v6_route_count vars = st.ensure_min_topology("D1T1:2") # Initialize TG and TG port handlers tg_handler = tgapi.get_handles(vars, [vars.T1D1P1, vars.T1D1P2]) tg = tg_handler["tg"] if tgapi.is_soft_tgen(vars): data.test_bgp_route_count = 200 # Test setup details dut = vars.D1 dut_to_tg_port_1 = vars.D1T1P1 dut_to_tg_port_2 = vars.D1T1P2 hwsku_under_test = basic_obj.get_hwsku(dut) cli_type = st.get_ui_type(dut) # Module Configuration st.log("L3 Performance Enhancements Module Configuration.") # Configuring v4/v6 routing interfaces on the DUT. ipfeature.config_ipv6(dut, action='enable') ipfeature.config_ip_addr_interface(dut, dut_to_tg_port_1, data.my_ip_addr, data.ip_prefixlen, family="ipv4") ipfeature.config_ip_addr_interface(dut, dut_to_tg_port_1, data.my_ipv6_addr, data.ipv6_prefixlen, family="ipv6") ipfeature.config_ip_addr_interface(dut, dut_to_tg_port_2, data.intf_ip_addr, data.ip_prefixlen, family="ipv4") ipfeature.config_ip_addr_interface(dut, dut_to_tg_port_2, data.intf_ipv6_addr, data.ipv6_prefixlen, family="ipv6") # Configuring BGP router and v4/v6 neighbors on the DUT. bgpfeature.create_bgp_router(dut, data.as_num, '') bgpfeature.create_bgp_neighbor(dut, data.as_num, data.neigh_ip_addr, data.remote_as_num) bgpfeature.create_bgp_neighbor(dut, data.as_num, data.neigh_ipv6_addr, data.remote_as_num, family="ipv6") # Get the default route count from DUT def_v4_route_count = asicapi.get_ipv4_route_count(dut) def_v6_route_count = asicapi.get_ipv6_route_count(dut) yield # Module Cleanup st.log("L3 Performance Enhancements Module Cleanup.") ipfeature.delete_ip_interface(dut, dut_to_tg_port_1, data.my_ip_addr, data.ip_prefixlen, family="ipv4") ipfeature.delete_ip_interface(dut, dut_to_tg_port_1, data.my_ipv6_addr, data.ipv6_prefixlen, family="ipv6") ipfeature.delete_ip_interface(dut, dut_to_tg_port_2, data.intf_ip_addr, data.ip_prefixlen, family="ipv4") ipfeature.delete_ip_interface(dut, dut_to_tg_port_2, data.intf_ipv6_addr, data.ipv6_prefixlen, family="ipv6") bgpfeature.delete_bgp_neighbor(dut, data.as_num, data.neigh_ip_addr, data.remote_as_num) bgpfeature.delete_bgp_neighbor(dut, data.as_num, data.neigh_ipv6_addr, data.remote_as_num) bgpfeature.cleanup_router_bgp(dut)
def bgp_warm_reboot_module_hooks(request): global vars, tg_handler, tg, dut, ctrl_start, ctrl_stop global dut_to_tg_port_1, dut_to_tg_port_2, hwsku_under_test initialize_variables() vars = st.ensure_min_topology("D1T1:2") # Initialize TG and TG port handlers tg_handler = tgapi.get_handles(vars, [vars.T1D1P1, vars.T1D1P2]) tg = tg_handler["tg"] ctrl_start = {'mode': 'start'} ctrl_stop = {'mode': 'stop'} # Test setup details dut = vars.D1 dut_to_tg_port_1 = vars.D1T1P1 dut_to_tg_port_2 = vars.D1T1P2 hwsku_under_test = basic_obj.get_hwsku(dut) # Configuring v4/v6 routing interfaces on the DUT. ipfeature.clear_ip_configuration(st.get_dut_names()) ipfeature.clear_ip_configuration(st.get_dut_names(), 'ipv6') ipfeature.config_ip_addr_interface(dut, dut_to_tg_port_1, data.my_ip_addr, data.ip_prefixlen, family="ipv4") ipfeature.config_ip_addr_interface(dut, dut_to_tg_port_1, data.my_ipv6_addr, data.ipv6_prefixlen, family="ipv6") ipfeature.config_ip_addr_interface(dut, dut_to_tg_port_2, data.intf_ip_addr, data.ip_prefixlen, family="ipv4") ipfeature.config_ip_addr_interface(dut, dut_to_tg_port_2, data.intf_ipv6_addr, data.ipv6_prefixlen, family="ipv6") # Configuring BGP router and v4/v6 neighbors on the DUT. bgpfeature.create_bgp_router(dut, data.as_num, '') bgpfeature.create_bgp_neighbor(dut, data.as_num, data.neigh_ip_addr, data.remote_as_num) bgpfeature.create_bgp_neighbor(dut, data.as_num, data.neigh_ipv6_addr, data.remote_as_num, family="ipv6") yield st.log("L3 Performance Enhancements Module Cleanup.") ipfeature.delete_ip_interface(dut, dut_to_tg_port_1, data.my_ip_addr, data.ip_prefixlen, family="ipv4") ipfeature.delete_ip_interface(dut, dut_to_tg_port_1, data.my_ipv6_addr, data.ipv6_prefixlen, family="ipv6") ipfeature.delete_ip_interface(dut, dut_to_tg_port_2, data.intf_ip_addr, data.ip_prefixlen, family="ipv4") ipfeature.delete_ip_interface(dut, dut_to_tg_port_2, data.intf_ipv6_addr, data.ipv6_prefixlen, family="ipv6") bgpfeature.delete_bgp_neighbor(dut, data.as_num, data.neigh_ip_addr, data.remote_as_num) bgpfeature.delete_bgp_neighbor(dut, data.as_num, data.neigh_ipv6_addr, data.remote_as_num) bgpfeature.cleanup_router_bgp(dut)
def crm_ft_test_all(): data = SpyTestDict() data.my_dut_list = st.get_dut_names() if len(data.my_dut_list) < 1: st.error("DUT Unavailable") return False data.D1 = data.my_dut_list[0] data.fdb_count = 0 data.crm_polling_interval = 1 crm_obj.set_crm_clear_config(data.D1) crm_obj.set_crm_polling_interval(data.D1, data.crm_polling_interval) data.af_ipv4 = "ipv4" data.af_ipv6 = "ipv6" data.local_asn = 65001 data.router_id_1 = "110.110.110.1" data.router_id_2 = "120.120.120.1" data.remote_asn = 65007 data.loopback_1 = "66.66.66.66" data.loopback_2 = "77.77.77.77" data.tg_bgp6_route_prfix = "1001::1" data.tg_bgp6_routes = '1100' data.shell_sonic = 'vtysh' data.used_counter = dict() data.free_counter = dict() data.resource_count_max = dict() data.thresh_percent_low = dict() data.thresh_percent_high = dict() data.thresh_used_low = dict() data.thresh_used_high = dict() data.thresh_free_low = dict() data.thresh_free_high = dict() data.cur_thresh_type = dict() data.cli_type = st.get_ui_type(data.D1) family_list = crm_obj.crm_get_family_list(data.D1) if base_obj.get_hwsku( vars.D1).lower() in vars.constants[vars.D1]["TH3_PLATFORMS"]: for family in family_list: if family in ['dnat', 'snat']: family_list.remove(family) st.log("Verify CRM polling interval:") st.wait(data.crm_polling_interval) if not crm_obj.verify_crm_summary( data.D1, pollinginterval=data.crm_polling_interval): st.error('polling interval did not match with the configured value') return False st.log("Calculate Max resources:") for family in family_list: if family != 'acl_group_counter' and family != 'acl_group_entry' and 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] for family in family_list: if family != 'acl_group_counter' and family != 'acl_group_entry' and family != 'all': st.log('{} {}/{}/{}'.format(family, data.used_counter[family], data.free_counter[family], data.resource_count_max[family])) data.routing_subnet = 24 data.dut_p1 = vars.T1D1P1 data.dut_p1_interface = vars.D1T1P1 data.dut_p1_ipaddr = '7.7.7.1' data.dut_p1_ipaddr_subnet = 24 data.dut_p1_ipaddr_peer = '7.7.7.2' data.adv_routes_cnt = 1000 data.adv_routes_prefix = "100.0.0.0" data.neighbor_cnt = 100 data.dut_p2 = vars.T1D1P2 data.dut_p2_interface = vars.D1T1P2 data.dut_p2_ipaddr = '2001::1' data.dut_p2_ipaddr_subnet = 64 data.dut_p2_ipaddr_peer = '2001::2' data.adv_routes_cnt_v6 = 1000 data.adv_routes_prefix_v6 = '2121::0' data.neighbor_cnt_v6 = 100 data.vlanid = 777 st.log('crminfo: VLAN ID {}'.format(data.vlanid)) crm_fdb_config(data) crm_acl_config(data) crm_bgp_config_v4(data.local_asn, data.remote_asn, data) crm_ecmp_config(data) if st.is_feature_supported("config-ipv6-command", data.D1): crm_bgp_config_v6(data.local_asn, data.remote_asn, data) verify_thresholds(data) # debug trace crm_obj.get_crm_resources(data.D1, "all") global crm_test_status crm_test_status = True
def nat_pre_config(): global vars vars = st.ensure_min_topology("D1T1:2") platform = basic_obj.get_hwsku(vars.D1) common_constants = st.get_datastore(vars.D1, "constants", "default") if platform.lower() in common_constants['TH3_PLATFORMS']: st.error("NAT is not supported for this platform {}".format(platform)) st.report_unsupported('NAT_unsupported_platform',platform) global tg_handler, tg1, tg2, tg_ph_1, tg_ph_2, dut1_rt_int_mac, tg_str_data, tg_rt_int_handle tg_handler = util_tg_init(vars, [vars.T1D1P1, vars.T1D1P2]) tg1 = tg_handler["tg"] tg2 = tg_handler["tg"] tg_ph_1 = tg_handler["tg_ph_1"] tg_ph_2 = tg_handler["tg_ph_2"] ip_obj.config_ip_addr_interface(vars.D1, vars.D1T1P1, data.in1_ip_addr, data.in1_ip_addr_mask, family=data.af_ipv4) ip_obj.config_ip_addr_interface(vars.D1, vars.D1T1P2, data.out_ip_addr_l[0], data.out_ip_addr_mask, family=data.af_ipv4) dut1_rt_int_mac = basic_obj.get_ifconfig_ether(vars.D1, vars.D1T1P1) ip_obj.create_static_route(vars.D1, data.out_ip_addr_h, "{}/{}".format(data.global_ip_addr_rt, data.global_ip_addr_mask), shell=data.shell_vtysh, family=data.af_ipv4) ip_obj.create_static_route(vars.D1, data.in1_ip_addr_h[0], "{}/{}".format(data.s_global_ip_rt, data.s_global_ip_mask)) tg_rt_int_handle = util_tg_routing_int_config(vars, tg1, tg2, tg_ph_1, tg_ph_2) st.log("NAT Configuration") nat_obj.config_nat_feature(vars.D1, 'enable') util_nat_zone_config(vars, [vars.D1T1P1, vars.D1T1P2], [data.zone_1, data.zone_2], config=data.config_add) nat_obj.config_nat_static(vars.D1, protocol=data.proto_all, global_ip=data.out_ip_addr_l[0], local_ip=data.in1_ip_addr_h[0], config=data.config_add, nat_type=data.nat_type_dnat) nat_obj.config_nat_static(vars.D1, protocol=data.proto_tcp, global_ip=data.out_ip_addr_l[1], local_ip=data.in1_ip_addr_h[1], local_port_id=data.tcp_src_local_port, global_port_id=data.tcp_src_global_port, config=data.config_add, nat_type=data.nat_type_dnat) nat_obj.config_nat_static(vars.D1, protocol=data.proto_udp, global_ip=data.in1_ip_addr_h[2], local_ip=data.out_ip_addr_l[2], local_port_id=data.udp_src_global_port, global_port_id=data.udp_src_local_port, config=data.config_add, nat_type=data.nat_type_snat) nat_obj.config_nat_static(vars.D1, protocol=data.proto_all, global_ip=data.s_global_ip, local_ip=data.s_local_ip, config=data.config_add, nat_type=data.nat_type_snat) nat_obj.config_nat_static(vars.D1,protocol=data.proto_all,global_ip=data.out_ip_addr_l[3],local_ip=data.in1_ip_addr_h[3], config=data.config_add,nat_type=data.nat_type_dnat,twice_nat_id=data.twice_nat_id_1) nat_obj.config_nat_static(vars.D1, protocol=data.proto_all, global_ip=data.global_ip_addr, local_ip=data.test_ip_addr, config=data.config_add, nat_type=data.nat_type_snat, twice_nat_id=data.twice_nat_id_1) # dynamic NAT config st.log("Creating NAT Pool-1") nat_obj.config_nat_pool(vars.D1, pool_name=data.pool_name[0], global_ip_range=data.out_ip_range, global_port_range= data.global_port_range, config=data.config_add) nat_obj.config_nat_pool(vars.D1, pool_name="scale_pool", global_ip_range="125.56.90.23-125.56.90.30", global_port_range="1001-8001", config=data.config_add) st.log("Creating NAT Pool binding") nat_obj.config_nat_pool_binding(vars.D1, binding_name=data.bind_name[0], pool_name=data.pool_name[0], config=data.config_add) st.log("Creating NAT Pool-2") nat_obj.config_nat_pool(vars.D1, pool_name=data.pool_name[1], global_ip_range=data.out2_ip_range, config=data.config_add) st.log("Creating NAT Pool-2 binding") nat_obj.config_nat_pool_binding(vars.D1, binding_name=data.bind_name[1], pool_name=data.pool_name[1], config=data.config_add) # nat acl for ingress traffic acl_obj.create_acl_table(vars.D1, name=data.acl_table_in_nat_eg, stage="INGRESS", type=data.type, description="ingress-acl", ports=[vars.D1T1P1]) acl_obj.create_acl_rule(vars.D1, table_name=data.acl_table_in_nat_eg, rule_name="rule-32", packet_action=data.packet_forward_action, SRC_IP="{}/{}".format(data.in1_ip_addr_rt, data.in1_ip_addr_mask), priority='98', type=data.type, ip_protocol="4") acl_obj.create_acl_rule(vars.D1, table_name=data.acl_table_in_nat_eg, rule_name="rule-33", packet_action=data.packet_do_not_nat_action, SRC_IP="{}/{}".format('14.1.0.1', data.mask), priority='97', type=data.type, ip_protocol="4") # Checking arp table for debugging arp_obj.show_arp(vars.D1) ip_obj.show_ip_route(vars.D1) # Clearing all interface counters for debugging purpose intf_obj.clear_interface_counters(vars.D1) tg_str_data = util_tg_stream_config(tg1, tg2, tg_ph_1, tg_ph_2)
def l3_performance_enhancements_module_hooks(request): global vars global tg_handler global tg global dut1 global dut2 global dut3 global dut4 global dut1_to_tg_port_1 global dut1_to_dut2_port_1 global dut2_to_dut1_port_1 global dut1_to_dut3_port_1 global dut3_to_dut1_port_1 global dut2_to_dut4_port_1 global dut4_to_dut2_port_1 global dut3_to_dut4_port_1 global dut4_to_dut3_port_1 global dut4_to_tg_port_1 global hwsku_under_test1 global hwsku_under_test2 global hwsku_under_test3 global hwsku_under_test4 global def_v4_route_count_d1 global def_v4_route_count_d4 global def_v6_route_count_d1 global def_v6_route_count_d4 # Min topology verification st.log("Ensuring minimum topology") vars = st.ensure_min_topology("D1D2:1", "D1D3:1", "D2D4:1", "D3D4:1", "D1T1:1", "D4T1:1") # Initialize TG and TG port handlers tg_handler = tgapi.get_handles(vars, [vars.T1D1P1, vars.T1D4P1]) tg = tg_handler["tg"] # Test setup details dut1 = vars.D1 dut2 = vars.D2 dut3 = vars.D3 dut4 = vars.D4 dut1_to_tg_port_1 = vars.D1T1P1 dut1_to_dut2_port_1 = vars.D1D2P1 dut2_to_dut1_port_1 = vars.D2D1P1 dut1_to_dut3_port_1 = vars.D1D3P1 dut3_to_dut1_port_1 = vars.D3D1P1 dut2_to_dut4_port_1 = vars.D2D4P1 dut4_to_dut2_port_1 = vars.D4D2P1 dut3_to_dut4_port_1 = vars.D3D4P1 dut4_to_dut3_port_1 = vars.D4D3P1 dut4_to_tg_port_1 = vars.D4T1P1 hwsku_under_test1 = basic_obj.get_hwsku(dut1) hwsku_under_test2 = basic_obj.get_hwsku(dut2) hwsku_under_test3 = basic_obj.get_hwsku(dut3) hwsku_under_test4 = basic_obj.get_hwsku(dut4) # Module Configuration st.log("L3 Performance Enhancements Module Configuration.") # Configuring v4/v6 routing interfaces on the DUT. st.log("Configuring IPv4 routing interfaces.") ipfeature.config_ip_addr_interface(dut1, dut1_to_tg_port_1, data.dut1_to_tg_port_1_ip, data.ip_prefixlen, family="ipv4") ipfeature.config_ip_addr_interface(dut1, dut1_to_dut2_port_1, data.dut1_to_dut2_port_1_ip, data.ip_prefixlen, family="ipv4") ipfeature.config_ip_addr_interface(dut1, dut1_to_dut3_port_1, data.dut1_to_dut3_port_1_ip, data.ip_prefixlen, family="ipv4") ipfeature.config_ip_addr_interface(dut2, dut2_to_dut1_port_1, data.dut2_to_dut1_port_1_ip, data.ip_prefixlen, family="ipv4") ipfeature.config_ip_addr_interface(dut2, dut2_to_dut4_port_1, data.dut2_to_dut4_port_1_ip, data.ip_prefixlen, family="ipv4") ipfeature.config_ip_addr_interface(dut3, dut3_to_dut1_port_1, data.dut3_to_dut1_port_1_ip, data.ip_prefixlen, family="ipv4") ipfeature.config_ip_addr_interface(dut3, dut3_to_dut4_port_1, data.dut3_to_dut4_port_1_ip, data.ip_prefixlen, family="ipv4") ipfeature.config_ip_addr_interface(dut4, dut4_to_dut2_port_1, data.dut4_to_dut2_port_1_ip, data.ip_prefixlen, family="ipv4") ipfeature.config_ip_addr_interface(dut4, dut4_to_dut3_port_1, data.dut4_to_dut3_port_1_ip, data.ip_prefixlen, family="ipv4") ipfeature.config_ip_addr_interface(dut4, dut4_to_tg_port_1, data.dut4_to_tg_port_1_ip, data.ip_prefixlen, family="ipv4") st.log("Configuring IPv6 routing interfaces.") ipfeature.config_ipv6(dut1, action='enable') ipfeature.config_ip_addr_interface(dut1, dut1_to_tg_port_1, data.dut1_to_tg_port_1_ip6, data.ipv6_prefixlen, family="ipv6") ipfeature.config_ip_addr_interface(dut1, dut1_to_dut2_port_1, data.dut1_to_dut2_port_1_ip6, data.ipv6_prefixlen, family="ipv6") ipfeature.config_ip_addr_interface(dut1, dut1_to_dut3_port_1, data.dut1_to_dut3_port_1_ip6, data.ipv6_prefixlen, family="ipv6") ipfeature.config_ipv6(dut2, action='enable') ipfeature.config_ip_addr_interface(dut2, dut2_to_dut1_port_1, data.dut2_to_dut1_port_1_ip6, data.ipv6_prefixlen, family="ipv6") ipfeature.config_ip_addr_interface(dut2, dut2_to_dut4_port_1, data.dut2_to_dut4_port_1_ip6, data.ipv6_prefixlen, family="ipv6") ipfeature.config_ipv6(dut3, action='enable') ipfeature.config_ip_addr_interface(dut3, dut3_to_dut1_port_1, data.dut3_to_dut1_port_1_ip6, data.ipv6_prefixlen, family="ipv6") ipfeature.config_ip_addr_interface(dut3, dut3_to_dut4_port_1, data.dut3_to_dut4_port_1_ip6, data.ipv6_prefixlen, family="ipv6") ipfeature.config_ipv6(dut4, action='enable') ipfeature.config_ip_addr_interface(dut4, dut4_to_dut2_port_1, data.dut4_to_dut2_port_1_ip6, data.ipv6_prefixlen, family="ipv6") ipfeature.config_ip_addr_interface(dut4, dut4_to_dut3_port_1, data.dut4_to_dut3_port_1_ip6, data.ipv6_prefixlen, family="ipv6") ipfeature.config_ip_addr_interface(dut4, dut4_to_tg_port_1, data.dut4_to_tg_port_1_ip6, data.ipv6_prefixlen, family="ipv6") # Configuring BGP router and v4/v6 neighbors on the DUT. st.log("Configuring BGP routers.") bgpfeature.create_bgp_router(dut1, data.as_num_1, '') bgpfeature.create_bgp_router(dut2, data.as_num_2, '') bgpfeature.create_bgp_router(dut3, data.as_num_3, '') bgpfeature.create_bgp_router(dut4, data.as_num_4, '') st.log("Configuring BGP IPv4 neighbors.") bgpfeature.create_bgp_neighbor(dut1, data.as_num_1, data.tg_to_dut1_port_1_ip, data.remote_as_num1) bgpfeature.create_bgp_neighbor(dut1, data.as_num_1, data.dut2_to_dut1_port_1_ip, data.as_num_2) bgpfeature.create_bgp_neighbor(dut1, data.as_num_1, data.dut3_to_dut1_port_1_ip, data.as_num_3) bgpfeature.create_bgp_neighbor(dut2, data.as_num_2, data.dut1_to_dut2_port_1_ip, data.as_num_1) bgpfeature.create_bgp_neighbor(dut2, data.as_num_2, data.dut4_to_dut2_port_1_ip, data.as_num_4) bgpfeature.create_bgp_neighbor(dut3, data.as_num_3, data.dut1_to_dut3_port_1_ip, data.as_num_1) bgpfeature.create_bgp_neighbor(dut3, data.as_num_3, data.dut4_to_dut3_port_1_ip, data.as_num_4) bgpfeature.create_bgp_neighbor(dut4, data.as_num_4, data.dut2_to_dut4_port_1_ip, data.as_num_2) bgpfeature.create_bgp_neighbor(dut4, data.as_num_4, data.dut3_to_dut4_port_1_ip, data.as_num_3) st.log("Configuring BGP IPv6 neighbors.") bgpfeature.create_bgp_neighbor(dut1, data.as_num_1, data.tg_to_dut1_port_1_ip6, data.remote_as_num1, family="ipv6") bgpfeature.create_bgp_neighbor(dut1, data.as_num_1, data.dut2_to_dut1_port_1_ip6, data.as_num_2, family="ipv6") bgpfeature.create_bgp_neighbor(dut1, data.as_num_1, data.dut3_to_dut1_port_1_ip6, data.as_num_3, family="ipv6") bgpfeature.create_bgp_neighbor(dut2, data.as_num_2, data.dut1_to_dut2_port_1_ip6, data.as_num_1, family="ipv6") bgpfeature.create_bgp_neighbor(dut2, data.as_num_2, data.dut4_to_dut2_port_1_ip6, data.as_num_4, family="ipv6") bgpfeature.create_bgp_neighbor(dut3, data.as_num_3, data.dut1_to_dut3_port_1_ip6, data.as_num_1, family="ipv6") bgpfeature.create_bgp_neighbor(dut3, data.as_num_3, data.dut4_to_dut3_port_1_ip6, data.as_num_4, family="ipv6") bgpfeature.create_bgp_neighbor(dut4, data.as_num_4, data.dut2_to_dut4_port_1_ip6, data.as_num_2, family="ipv6") bgpfeature.create_bgp_neighbor(dut4, data.as_num_4, data.dut3_to_dut4_port_1_ip6, data.as_num_3, family="ipv6") # st.log("Configuring BGP as-path multipath-relax.") bgpfeature.create_bgp_best_path(dut1, data.as_num_1, "as-path multipath-relax") bgpfeature.create_bgp_best_path(dut2, data.as_num_2, "as-path multipath-relax") bgpfeature.create_bgp_best_path(dut3, data.as_num_3, "as-path multipath-relax") bgpfeature.create_bgp_best_path(dut4, data.as_num_4, "as-path multipath-relax") # Get the default route count from DUT def_v4_route_count_d1 = asicapi.bcmcmd_route_count_hardware(dut1) def_v4_route_count_d4 = asicapi.bcmcmd_route_count_hardware(dut4) def_v6_route_count_d1 = asicapi.bcmcmd_ipv6_route_count_hardware(dut1) def_v6_route_count_d4 = asicapi.bcmcmd_ipv6_route_count_hardware(dut4) # Verifying the BGP neighborship st.wait(20) st.log("Verifying the BGP IPv4 neighborships.") if not poll_wait(bgpfeature.verify_bgp_summary, 120, dut1, neighbor=data.dut2_to_dut1_port_1_ip,state='Established'): st.report_fail("bgp_ip_peer_establish_fail", data.dut2_to_dut1_port_1_ip) if not poll_wait(bgpfeature.verify_bgp_summary, 120, dut1, neighbor=data.dut3_to_dut1_port_1_ip,state='Established'): st.report_fail("bgp_ip_peer_establish_fail", data.dut3_to_dut1_port_1_ip) if not poll_wait(bgpfeature.verify_bgp_summary, 120, dut2, neighbor=data.dut1_to_dut2_port_1_ip,state='Established'): st.report_fail("bgp_ip_peer_establish_fail", data.dut1_to_dut2_port_1_ip) if not poll_wait(bgpfeature.verify_bgp_summary, 120, dut2, neighbor=data.dut4_to_dut2_port_1_ip,state='Established'): st.report_fail("bgp_ip_peer_establish_fail", data.dut4_to_dut2_port_1_ip) # if not bgpfeature.verify_bgp_summary(dut1, neighbor=data.dut2_to_dut1_port_1_ip, state='Established'): # st.report_fail("bgp_ip_peer_establish_fail", data.dut2_to_dut1_port_1_ip) # if not bgpfeature.verify_bgp_summary(dut1, neighbor=data.dut3_to_dut1_port_1_ip, state='Established'): # st.report_fail("bgp_ip_peer_establish_fail", data.dut3_to_dut1_port_1_ip) # if not bgpfeature.verify_bgp_summary(dut2, neighbor=data.dut1_to_dut2_port_1_ip, state='Established'): # st.report_fail("bgp_ip_peer_establish_fail", data.dut1_to_dut2_port_1_ip) # if not bgpfeature.verify_bgp_summary(dut2, neighbor=data.dut4_to_dut2_port_1_ip, state='Established'): # st.report_fail("bgp_ip_peer_establish_fail", data.dut4_to_dut2_port_1_ip) if not bgpfeature.verify_bgp_summary(dut3, neighbor=data.dut1_to_dut3_port_1_ip, state='Established'): st.report_fail("bgp_ip_peer_establish_fail", data.dut1_to_dut3_port_1_ip) if not bgpfeature.verify_bgp_summary(dut3, neighbor=data.dut4_to_dut3_port_1_ip, state='Established'): st.report_fail("bgp_ip_peer_establish_fail", data.dut4_to_dut3_port_1_ip) if not bgpfeature.verify_bgp_summary(dut4, neighbor=data.dut2_to_dut4_port_1_ip, state='Established'): st.report_fail("bgp_ip_peer_establish_fail", data.dut2_to_dut4_port_1_ip) if not bgpfeature.verify_bgp_summary(dut4, neighbor=data.dut3_to_dut4_port_1_ip, state='Established'): st.report_fail("bgp_ip_peer_establish_fail", data.dut3_to_dut4_port_1_ip) st.log("Verifying the BGP IPv6 neighborships.") if not bgpfeature.verify_bgp_summary(dut1, family='ipv6', neighbor=data.dut2_to_dut1_port_1_ip6, state='Established'): st.report_fail("bgp_ip_peer_establish_fail", data.dut2_to_dut1_port_1_ip6) if not bgpfeature.verify_bgp_summary(dut1, family='ipv6', neighbor=data.dut3_to_dut1_port_1_ip6, state='Established'): st.report_fail("bgp_ip_peer_establish_fail", data.dut3_to_dut1_port_1_ip6) if not bgpfeature.verify_bgp_summary(dut2, family='ipv6', neighbor=data.dut1_to_dut2_port_1_ip6, state='Established'): st.report_fail("bgp_ip_peer_establish_fail", data.dut1_to_dut2_port_1_ip6) if not bgpfeature.verify_bgp_summary(dut2, family='ipv6', neighbor=data.dut4_to_dut2_port_1_ip6, state='Established'): st.report_fail("bgp_ip_peer_establish_fail", data.dut4_to_dut2_port_1_ip6) if not bgpfeature.verify_bgp_summary(dut3, family='ipv6', neighbor=data.dut1_to_dut3_port_1_ip6, state='Established'): st.report_fail("bgp_ip_peer_establish_fail", data.dut1_to_dut3_port_1_ip6) if not bgpfeature.verify_bgp_summary(dut3, family='ipv6', neighbor=data.dut4_to_dut3_port_1_ip6, state='Established'): st.report_fail("bgp_ip_peer_establish_fail", data.dut4_to_dut3_port_1_ip6) if not bgpfeature.verify_bgp_summary(dut4, family='ipv6', neighbor=data.dut2_to_dut4_port_1_ip6, state='Established'): st.report_fail("bgp_ip_peer_establish_fail", data.dut2_to_dut4_port_1_ip6) if not bgpfeature.verify_bgp_summary(dut4, family='ipv6', neighbor=data.dut3_to_dut4_port_1_ip6, state='Established'): st.report_fail("bgp_ip_peer_establish_fail", data.dut3_to_dut4_port_1_ip6) yield # Module Cleanup st.log("L3 Performance Enhancements Module Cleanup.") st.log("Unconfiguring IPv4 routing interfaces.") ipfeature.delete_ip_interface(dut1, dut1_to_tg_port_1, data.dut1_to_tg_port_1_ip, data.ip_prefixlen, family="ipv4") ipfeature.delete_ip_interface(dut1, dut1_to_dut2_port_1, data.dut1_to_dut2_port_1_ip, data.ip_prefixlen, family="ipv4") ipfeature.delete_ip_interface(dut1, dut1_to_dut3_port_1, data.dut1_to_dut3_port_1_ip, data.ip_prefixlen, family="ipv4") ipfeature.delete_ip_interface(dut2, dut2_to_dut1_port_1, data.dut2_to_dut1_port_1_ip, data.ip_prefixlen, family="ipv4") ipfeature.delete_ip_interface(dut2, dut2_to_dut4_port_1, data.dut2_to_dut4_port_1_ip, data.ip_prefixlen, family="ipv4") ipfeature.delete_ip_interface(dut3, dut3_to_dut1_port_1, data.dut3_to_dut1_port_1_ip, data.ip_prefixlen, family="ipv4") ipfeature.delete_ip_interface(dut3, dut3_to_dut4_port_1, data.dut3_to_dut4_port_1_ip, data.ip_prefixlen, family="ipv4") ipfeature.delete_ip_interface(dut4, dut4_to_dut2_port_1, data.dut4_to_dut2_port_1_ip, data.ip_prefixlen, family="ipv4") ipfeature.delete_ip_interface(dut4, dut4_to_dut3_port_1, data.dut4_to_dut3_port_1_ip, data.ip_prefixlen, family="ipv4") ipfeature.delete_ip_interface(dut4, dut4_to_tg_port_1, data.dut4_to_tg_port_1_ip, data.ip_prefixlen, family="ipv4") st.log("Unconfiguring IPv6 routing interfaces.") ipfeature.delete_ip_interface(dut1, dut1_to_tg_port_1, data.dut1_to_tg_port_1_ip6, data.ipv6_prefixlen, family="ipv6") ipfeature.delete_ip_interface(dut1, dut1_to_dut2_port_1, data.dut1_to_dut2_port_1_ip6, data.ipv6_prefixlen, family="ipv6") ipfeature.delete_ip_interface(dut1, dut1_to_dut3_port_1, data.dut1_to_dut3_port_1_ip6, data.ipv6_prefixlen, family="ipv6") ipfeature.delete_ip_interface(dut2, dut2_to_dut1_port_1, data.dut2_to_dut1_port_1_ip6, data.ipv6_prefixlen, family="ipv6") ipfeature.delete_ip_interface(dut2, dut2_to_dut4_port_1, data.dut2_to_dut4_port_1_ip6, data.ipv6_prefixlen, family="ipv6") ipfeature.delete_ip_interface(dut3, dut3_to_dut1_port_1, data.dut3_to_dut1_port_1_ip6, data.ipv6_prefixlen, family="ipv6") ipfeature.delete_ip_interface(dut3, dut3_to_dut4_port_1, data.dut3_to_dut4_port_1_ip6, data.ipv6_prefixlen, family="ipv6") ipfeature.delete_ip_interface(dut4, dut4_to_dut2_port_1, data.dut4_to_dut2_port_1_ip6, data.ipv6_prefixlen, family="ipv6") ipfeature.delete_ip_interface(dut4, dut4_to_dut3_port_1, data.dut4_to_dut3_port_1_ip6, data.ipv6_prefixlen, family="ipv6") ipfeature.delete_ip_interface(dut4, dut4_to_tg_port_1, data.dut4_to_tg_port_1_ip6, data.ipv6_prefixlen, family="ipv6") st.log("Unconfiguring BGP IPv4 neighbors.") bgpfeature.delete_bgp_neighbor(dut1, data.as_num_1, data.tg_to_dut1_port_1_ip, data.remote_as_num1) bgpfeature.delete_bgp_neighbor(dut1, data.as_num_1, data.dut2_to_dut1_port_1_ip, data.as_num_2) bgpfeature.delete_bgp_neighbor(dut1, data.as_num_1, data.dut3_to_dut1_port_1_ip, data.as_num_3) bgpfeature.delete_bgp_neighbor(dut2, data.as_num_2, data.dut1_to_dut2_port_1_ip, data.as_num_1) bgpfeature.delete_bgp_neighbor(dut2, data.as_num_2, data.dut4_to_dut2_port_1_ip, data.as_num_4) bgpfeature.delete_bgp_neighbor(dut3, data.as_num_3, data.dut1_to_dut3_port_1_ip, data.as_num_1) bgpfeature.delete_bgp_neighbor(dut3, data.as_num_3, data.dut4_to_dut3_port_1_ip, data.as_num_4) bgpfeature.delete_bgp_neighbor(dut4, data.as_num_4, data.dut2_to_dut4_port_1_ip, data.as_num_2) bgpfeature.delete_bgp_neighbor(dut4, data.as_num_4, data.dut3_to_dut4_port_1_ip, data.as_num_3) st.log("Unconfiguring BGP IPv6 neighbors.") bgpfeature.delete_bgp_neighbor(dut1, data.as_num_1, data.tg_to_dut1_port_1_ip6, data.remote_as_num1) bgpfeature.delete_bgp_neighbor(dut1, data.as_num_1, data.dut2_to_dut1_port_1_ip6, data.as_num_2) bgpfeature.delete_bgp_neighbor(dut1, data.as_num_1, data.dut3_to_dut1_port_1_ip6, data.as_num_3) bgpfeature.delete_bgp_neighbor(dut2, data.as_num_2, data.dut1_to_dut2_port_1_ip6, data.as_num_1) bgpfeature.delete_bgp_neighbor(dut2, data.as_num_2, data.dut4_to_dut2_port_1_ip6, data.as_num_4) bgpfeature.delete_bgp_neighbor(dut3, data.as_num_3, data.dut1_to_dut3_port_1_ip6, data.as_num_1) bgpfeature.delete_bgp_neighbor(dut3, data.as_num_3, data.dut4_to_dut3_port_1_ip6, data.as_num_4) bgpfeature.delete_bgp_neighbor(dut4, data.as_num_4, data.dut2_to_dut4_port_1_ip6, data.as_num_2) bgpfeature.delete_bgp_neighbor(dut4, data.as_num_4, data.dut3_to_dut4_port_1_ip6, data.as_num_3) st.log("Unconfiguring BGP routers.") bgpfeature.cleanup_router_bgp(dut1) bgpfeature.cleanup_router_bgp(dut2) bgpfeature.cleanup_router_bgp(dut3) bgpfeature.cleanup_router_bgp(dut4)
def global_vars_and_constants_init(): global eh_data, vars eh_data = SpyTestDict() vars = st.ensure_min_topology('D1D2:1', 'D1T1:2') eh_data.platform = bsapi.get_hwsku(vars.D1).lower() hw_constants = st.get_datastore(vars.D1, "constants", eh_data.platform) if not hw_constants: hw_constants = st.get_datastore(vars.D1, "constants") # Falgs eh_data.debug = True eh_data.clear_logs = True eh_data.thread_mode = True eh_data.dut_list = [vars.D1, vars.D2] eh_data.ping_delay = 5 eh_data.ping_retry = 1 eh_data.error_route_table = "ERROR_ROUTE_TABLE" eh_data.error_neigh_table = "ERROR_NEIGH_TABLE" eh_data.swss_rc_success = "SWSS_RC_SUCCESS" eh_data.swss_rc_exists = "SWSS_RC_EXISTS" eh_data.swss_rc_not_found = "SWSS_RC_NOT_FOUND" eh_data.swss_rc_table_full = "SWSS_RC_TABLE_FULL" eh_data.log_str_swss = "swss#orchagent:" eh_data.log_str_bgp = "bgp#fpmsyncd:" eh_data.route_not_install_flag = '#' # Global vars eh_data.ipv4_addr = "10.1.1.1" eh_data.ipv4_nbr = "10.1.1.2" eh_data.ipv4_mask = "255.255.255.0" eh_data.ipv4_mask_len = '24' eh_data.ipv6_addr = "2001::1" eh_data.ipv6_nbr = "2001::2" eh_data.ipv6_mask_len = '64' eh_data.local_asn = '65400' eh_data.remote_asn = '65007' eh_data.tg_remote_asn = '65009' eh_data.ipv4_route = "12.12.12.0" eh_data.ipv4_route2 = "13.13.13.0" eh_data.ipv6_route = "0600:0000:0000:0000:0000:0000:0000:0000" eh_data.ipv6_route2 = "0700:0000:0000:0000:0000:0000:0000:0000" eh_data.ipv6_route_mask = "600::0/64" eh_data.ipv6_route2_mask = "700::0/64" eh_data.ipv6_route_sf = "600::" eh_data.ipv6_route2_sf = "700::" eh_data.egr_intf = '100002' eh_data.vrf = '0' eh_data.loopback4_1 = "66.66.66.66" eh_data.loopback4_2 = "77.77.77.77" eh_data.loopback6_1 = "6666::6666" eh_data.loopback6_2 = "7777::7777" eh_data.af_ipv4 = "ipv4" eh_data.af_ipv6 = "ipv6" eh_data.shell_sonic = "sonic" eh_data.shell_vtysh = "vtysh" eh_data.route_map_name = 'error_handling_route_map' eh_data.peer_gp_namev4 = 'error_handlingv4' eh_data.tg_peer_gp_namev4 = 'tg_error_handlingv4' eh_data.peer_gp_namev6 = 'error_handlingv6' eh_data.tg_peer_gp_namev6 = 'tg_error_handlingv6' eh_data.ipv4_nbr2 = "10.1.1.3" eh_data.ipv6_nbr2 = "2001::3" eh_data.ipv4_nbr2_mac = "00:00:00:00:00:01" eh_data.ipv6_nbr2_mac = "00:00:00:00:00:02" eh_data.ipv4_nbr3 = "10.1.1.4" eh_data.ipv6_nbr3 = "2001::4" eh_data.ipv4_nbr3_mac = "00:00:00:00:00:03" eh_data.ipv6_nbr3_mac = "00:00:00:00:00:04" # TG vars eh_data.tg1_ipv4_addr = "20.1.1.1" eh_data.tg1_ipv4_nbr = "20.1.1.2" eh_data.tg1_ipv4_mask = "255.255.255.0" eh_data.tg1_ipv4_mask_len = '24' eh_data.tg1_ipv6_addr = "3001::1" eh_data.tg1_ipv6_nbr = "3001::2" eh_data.tg1_ipv6_mask_len = '64' # Constants eh_data.ipv4_max_routes = int( hw_constants['MAX_IPV4_ROUTES_FOR_ERROR_HANDLING']) st.log("MAX_IPV4_ROUTES_FOR_ERROR_HANDLING: {}".format( eh_data.ipv4_max_routes)) eh_data.ipv6_max_routes = int( hw_constants['MAX_IPV6_ROUTES_FOR_ERROR_HANDLING']) st.log("MAX_IPV6_ROUTES_FOR_ERROR_HANDLING: {}".format( eh_data.ipv6_max_routes)) eh_data.max_route_install_wait_time = 120 eh_data.bcmcmd_timeout = 600 eh_data.cli_type = st.get_ui_type(vars.D1)
def test_ft_bgp_unnumbered_warmboot(): # ################ Author Details ################ # Name: Kiran Vedula # Email: [email protected] # ################################################ utils_obj.banner_log('FtOtSoRtBgpUnFn009') utils.exec_all(True, [[bgp_obj.show_bgp_ipv6_summary_vtysh, vars.D1], [bgp_obj.show_bgp_ipv6_summary_vtysh, vars.D2]]) utils.exec_all( True, [[arp_obj.show_ndp, vars.D1, None], [arp_obj.show_ndp, vars.D2, None]]) result = 0 st.log('######------Warm reboot with BGP unnumbered------######') platform = basic_obj.get_hwsku(vars.D1) common_constants = st.get_datastore(vars.D1, "constants", "default") if not platform.lower( ) in common_constants['WARM_REBOOT_SUPPORTED_PLATFORMS']: st.error("Warm-Reboot is not supported for this platform {}".format( platform)) st.report_unsupported('Warmboot_unsupported_platform', platform) reboot_obj.config_save(vars.D1, "sonic") reboot_obj.config_save(vars.D1, "vtysh") st.reboot(vars.D1, 'warm') st.wait(data.wait) if not utils.poll_wait(bgp_obj.verify_bgp_summary, data.wait_timer, vars.D2, family='ipv6', shell=bgp_cli_type, neighbor=vars.D2D1P1, state='Established'): st.log("Failed to form BGP unnumbered peering after warm reboot") result += 1 st.wait(data.wait) if not utils.poll_wait(bgp_obj.verify_bgp_summary, data.wait_timer, vars.D2, family='ipv6', shell=bgp_cli_type, neighbor=data.vlan_in_1, state='Established'): st.log("Failed to form BGP unnumbered peering after warm reboot") result += 1 st.wait(data.wait) if not utils.poll_wait(bgp_obj.verify_bgp_summary, data.wait_timer, vars.D2, family='ipv6', shell=bgp_cli_type, neighbor=data.portchannel_name, state='Established'): st.log("Failed to form BGP unnumbered peering after warm reboot") result += 1 if result == 0: st.report_pass("test_case_passed") else: st.log("BGP unnumbered neighborship failed warm reboot") utils.exec_all(True, [[arp_obj.show_ndp, vars.D1, None], [arp_obj.show_ndp, vars.D2, None]]) utils.exec_all(True, [[bgp_obj.show_bgp_ipv6_neighbor_vtysh, vars.D1], [bgp_obj.show_bgp_ipv6_neighbor_vtysh, vars.D2]]) st.report_fail("test_case_failed")
def get_parms(): data.platform = basic_obj.get_hwsku(vars.D1) data.constants = st.get_datastore(vars.D1, "constants", "default")
def breakout(dut, data, undo=False, brk_verify=True, cli_type="", skip_error=False): cli_type = st.get_ui_type(dut, cli_type=cli_type) platform_check=False cmds = [] cmds_1 =[] dut_type=basic.get_hwsku(dut) if dut_type: if "9716" in dut_type or "IX9" in dut_type: platform_check=True data_port = list(data) if cli_type == "klish": for x in range(0,len(data_port),2): res1 = get_interface_breakout_mode(dut, data_port[x], 'port') if res1: data_port[x] = 'port ' + res1[0]['port'] else: st.error('Invalid interface, cannot breakout') return False for index in range(0, len(data_port), 2): intf, opt = data_port[index].strip(), data_port[index+1].strip() if not opt.endswith("G"): opt = "{}G".format(opt) if intf in ['port 1/31','port 1/32'] and platform_check: if intf == 'port 1/31': intf1 = 'Ethernet240' else: intf1 = 'Ethernet248' st.log("The platform used is {}, if the ports are 1/31 (Intf: Ethernet240) or 1/32 (Intf: Ethernet248) it will be broken into 8x10G by default".format(dut_type)) if undo: cmds_1.append("config interface breakout {} 1x400G -y".format(intf1)) else: cmds_1.append("config interface breakout {} 8x10G -y".format(intf1)) else: if undo: cmds.append("no interface breakout {}".format(intf)) else: cmds.append("interface breakout {} mode {}".format(intf, opt)) elif cli_type == "click": for index in range(0, len(data), 2): intf, opt = data[index].strip(), data[index+1].strip() if not opt.endswith("G"): opt = "{}G".format(opt) if intf in ['Ethernet240','Ethernet248'] and platform_check: st.log("The platform used is {}, if the ports are Ethernet240 or Ethernet248 it will be broken into 8x10G by default".format(dut_type)) if undo: cmds.append("config interface breakout {} 1x400G -y -f".format(intf)) else: cmds.append("config interface breakout {} 8x10G -y -f".format(intf)) else: if undo: cmds.append("config interface breakout {} 1x100G -y -f".format(intf)) else: cmds.append("config interface breakout {} {} -y -f".format(intf, opt)) else: st.error("Unsupported CLI TYPE {}".format(cli_type)) return False if len(cmds_1) > 0: st.config(dut, cmds_1, type='click', skip_error_check=skip_error) try: st.config(dut, cmds, type=cli_type, skip_error_check=skip_error) except Exception as e: st.log(e) if brk_verify and cli_type == "klish" and not undo: for index in range(0, len(data), 2): intf, opt = data_port[index].strip(), data_port[index+1].strip() if not opt.endswith("G"): opt = "{}G".format(opt) intf = "Ethernet".join(intf.split("Ethernet")) if retry_api(verify_dpb_status,dut,interface=intf,status='Completed',breakout_mode=opt,retry_count=12, delay=5): st.log("Breakout of {} to speed {} is successful".format(intf,opt)) else: st.error("Breakout is not successful for {} of speed {}, even after 60 seconds".format(intf,opt)) return False return True