def test_ft_arp_static_route_config_mgmt_verifying_config_with_warm_reboot(): ''' Author: Surendra Kumar Vella([email protected]) Verify static ARP route config after warm-reboot ''' st.log("Checking whether the platform supports warm-reboot") if not data.platform.lower( ) in data.constants['WARM_REBOOT_SUPPORTED_PLATFORMS']: st.report_unsupported('test_case_unsupported') st.log("Performing warm-reboot on DUT") st.reboot(vars.D1, "warm") st.log("Verifying static route entries after save and warm-reboot") st.wait(5) static_route_verify() st.log("Verifying dynamic ARP entries after save and warm-reboot") if not arp_obj.verify_arp(vars.D1, data.ipv4_address_tgen, data.src_mac_addr, vars.D1T1P1): st.report_fail("ARP_entry_dynamic_entry_fail", data.ipv4_address_tgen, vars.D1) else: st.log("Verified that dynamic ARP entry is present in arp table") if st.get_ui_type(vars.D1) != "click": st.log("Verifying static ARP entries after save and warm-reboot") if not arp_obj.verify_arp(vars.D1, data.static_arp_ip, data.static_arp_mac, ""): st.report_fail("static_arp_create_fail", vars.D1) else: st.log("Verified that static ARP entry is present in arp table") st.report_pass("test_case_passed")
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 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 tf_rest_support_checker(): if tf_rest_supported: st.log( "Threshold REST - Supported in this Build, Hence test proceeding..." ) else: st.log( "Threshold REST - NOT Supported in this Build, Hence test moving to UnSupported..." ) st.report_unsupported('test_case_unsupported')
def test_ft_enable_kdump(): vars = st.get_testbed_vars() if not st.is_feature_supported("show-kdump-status-command", vars.D1): st.report_unsupported('test_case_unsupported') result = perform_test(vars) clean_up(vars) st.config(vars.D1, 'rm -rf /var/crash/20*') if result: st.report_fail("msg", result) st.report_pass("operation_successful")
def new_version(version, flag="major"): if version: try: [major, minor, patch] = version.split(".") if flag == "major": major = str(int(major) + 1) elif flag == "minor": minor = str(int(minor) + 1) elif flag == "patch": patch = str(int(patch) + 1) return "{}.{}.{}".format(major, minor, patch) except ValueError as e: st.error(e) st.report_unsupported("ocyang_unsupported_build_version") return version
def initialize_topology_vars(): global vars, tg, d3_tg_ph1, d3_tg_ph2, d4_tg_ph1, d4_tg_ph2, d5_tg_ph1, d5_tg_ph2, tg_all, dut_list vars = st.ensure_min_topology("D1D3:3", "D1D4:3", "D1D5:3", "D2D3:3", "D2D4:3", "D2D5:3", "D3T1:2", "D4T1:2", "D5T1:2", "D3CHIP=TD3", "D4CHIP=TD3", "D5CHIP=TD3") vars = st.get_testbed_vars() if st.get_ui_type() == 'click': st.report_unsupported("test_execution_skipped", "Skipping cli mode CLICK") data.dut_list = st.get_dut_names() data.rtr_list = data.dut_list[0:] data.leaf_list = data.rtr_list[2:] data.dut1 = data.dut_list[0] data.dut2 = data.dut_list[1] data.dut3 = data.dut_list[2] data.dut4 = data.dut_list[3] data.dut5 = data.dut_list[4] dut_list = [data.dut1, data.dut2, data.dut3, data.dut4, data.dut5] data.d1d3_ports = [vars.D1D3P1, vars.D1D3P2, vars.D1D3P3] data.d3d1_ports = [vars.D3D1P1, vars.D3D1P2, vars.D3D1P3] data.d1d4_ports = [vars.D1D4P1, vars.D1D4P2, vars.D1D4P3] data.d4d1_ports = [vars.D4D1P1, vars.D4D1P2, vars.D4D1P3] data.d1d5_ports = [vars.D1D5P1, vars.D1D5P2, vars.D1D5P3] data.d5d1_ports = [vars.D5D1P1, vars.D5D1P2, vars.D5D1P3] data.d2d3_ports = [vars.D2D3P1, vars.D2D3P2, vars.D2D3P3] data.d3d2_ports = [vars.D3D2P1, vars.D3D2P2, vars.D3D2P3] data.d2d4_ports = [vars.D2D4P1, vars.D2D4P2, vars.D2D4P3] data.d4d2_ports = [vars.D4D2P1, vars.D4D2P2, vars.D4D2P3] data.d2d5_ports = [vars.D2D5P1, vars.D2D5P2, vars.D2D5P3] data.d5d2_ports = [vars.D5D2P1, vars.D5D2P2, vars.D5D2P3] data.t1d3_ports = [vars.T1D3P1, vars.T1D3P2] data.t1d4_ports = [vars.T1D4P1, vars.T1D4P2] data.t1d5_ports = [vars.T1D5P1, vars.T1D5P2] data.d3t1_ports = [vars.D3T1P1, vars.D3T1P2] data.d4t1_ports = [vars.D4T1P1, vars.D4T1P2] data.d5t1_ports = [vars.D5T1P1, vars.D5T1P2] tg = tgapi.get_chassis(vars) d3_tg_ph1, d3_tg_ph2 = tg.get_port_handle(vars.T1D3P1), tg.get_port_handle( vars.T1D3P2) d4_tg_ph1, d4_tg_ph2 = tg.get_port_handle(vars.T1D4P1), tg.get_port_handle( vars.T1D4P2) d5_tg_ph1, d5_tg_ph2 = tg.get_port_handle(vars.T1D5P1), tg.get_port_handle( vars.T1D5P2) tg_all = [d3_tg_ph1, d3_tg_ph2, d4_tg_ph1, d4_tg_ph2, d5_tg_ph1, d5_tg_ph2]
def security_warm_reboot_module_hooks(request): # add things at the start of this module init_vars() initialize_variables() get_parms() st.log("Checking whether the platform supports warm-reboot") if not data.platform.lower() in data.constants['WARM_REBOOT_SUPPORTED_PLATFORMS']: st.report_unsupported('test_case_unsupported') st.log("configuring tacacs server") tacacs_config() st.log("Verifying tacacs server details in running-config before warm-reboot") tacacs_config_verify() yield # add things at the end of this module" #Below step will clear the TACACS+ server config from the device tacacs_params = st.get_service_info(vars.D1, "tacacs") tacacs_obj.set_tacacs_server(vars.D1, 'delete', tacacs_params.hosts[0].ip)
def test_ft_tf_config_priority_group_headroom_rest(): """ Author : Prudvi Mangadu ([email protected]) """ if tf_rest_data.platform and tf_rest_data.platform.lower( ) in tf_rest_data.pg_headroom_un_supported_platforms: st.error( "Threshold priority-group headroom is not supported for this platform ({})" .format(tf_rest_data.platform)) st.report_unsupported('test_case_unsupported') data = { 'dut': vars.D1, 'threshold_type': "priority-group", 'buffer_type': 'headroom', 'index_name': 'pg4', 'port_alias': dut_port[0], 'threshold_value': 89 } tf_rest_config_testing(**data)
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)
def qos_warm_reboot_module_hooks(request): # add things at the start of this module init_vars() initialize_variables() get_parms() st.log("Checking whether the platform supports warm-reboot") if not data.platform.lower( ) in data.constants['WARM_REBOOT_SUPPORTED_PLATFORMS']: st.report_unsupported('test_case_unsupported') st.log("Configuring supported QoS features") wred_data = wred_config.init_vars(vars) st.log('Creating WRED and ECN table') putils.exec_all(True, [ putils.ExecAllFunc(apply_wred_ecn_config, vars.D1, wred_data['wred_ecn_json_config']) ]) st.log("Checking for wred config before save and warm-reboot") wred_verify() st.log("checking for ecn config before save and warm-reboot") ecn_verify() st.log("Configuring IPV4 ACL with rule") ipv4_acl_config() st.log("Configuring IPV6 ACL with rule") ipv6_acl_config() st.log("Checking for IPV4 ACL config before save and warm-reboot") ipv4_acl_verify() st.log("Checking for IPV6 ACL config before save and warm-reboot") ipv6_acl_verify() st.log("Configuring COS") cos_config() st.log("Checking for COS config before save and warm-reboot") cos_config_verify() yield # add things at the end of this module" #Below step will clear COS, WRED and ECN config from the device. qos_obj.clear_qos_config(vars.D1) #Below step will clear all ACL config from the device. acl_obj.clear_acl_config(vars.D1)
def evpn_underlay_hooks(request): global vars create_glob_vars() vars = st.get_testbed_vars() if st.get_ui_type() == 'click': st.report_unsupported("test_execution_skipped", "Not supported for ui_type - click") api_list = [[create_evpn_5549_config]] parallel.exec_all(True, api_list, True) create_stream() st.log("verify MC LAG status in LVTEP nodes") mclag.verify_domain( evpn_dict["leaf_node_list"][0], domain_id=evpn_dict["l3_vni_sag"]['mlag_domain_id'], session_status='OK', local_ip=evpn_dict['leaf1']['iccpd_ip_list'][0], peer_ip=evpn_dict['leaf1']['iccpd_ip_list'][1], mclag_intfs=1, peer_link_inf=evpn_dict["leaf1"]["iccpd_pch_intf_list"][0], node_role='Active') mclag.verify_domain( evpn_dict["leaf_node_list"][1], domain_id=evpn_dict["l3_vni_sag"]['mlag_domain_id'], session_status='OK', local_ip=evpn_dict['leaf2']['iccpd_ip_list'][0], peer_ip=evpn_dict['leaf2']['iccpd_ip_list'][1], mclag_intfs=1, peer_link_inf=evpn_dict["leaf2"]["iccpd_pch_intf_list"][0], node_role='Standby') st.log("verify MC LAG interface status in LVTEP nodes") mclag.verify_interfaces( evpn_dict["leaf_node_list"][0], domain_id=evpn_dict["l3_vni_sag"]['mlag_domain_id'], mclag_intf=evpn_dict["leaf1"]["mlag_pch_intf_list"][0], mclag_intf_local_state="Up", mclag_intf_peer_state="Up", mclag_intf_l3_status='No', isolate_peer_link='Yes', traffic_disable='No') mclag.verify_interfaces( evpn_dict["leaf_node_list"][1], domain_id=evpn_dict["l3_vni_sag"]['mlag_domain_id'], mclag_intf=evpn_dict["leaf2"]["mlag_pch_intf_list"][0], mclag_intf_local_state="Up", mclag_intf_peer_state="Up", mclag_intf_l3_status='No', isolate_peer_link='Yes', traffic_disable='No') st.log("verify BGP EVPN neighborship for all nodes ") result = st.exec_all([[spine1_verify_evpn], [spine2_verify_evpn], [leaf1_verify_evpn], [leaf2_verify_evpn], [leaf3_verify_evpn]]) if result[0].count(False) > 0: st.error( "########## BGP EVPN neighborship is NOT UP on all spine and leaf nodes; Abort the suite ##########" ) st.report_fail("base_config_verification_failed") st.log("verify vxlan tunnel status on leaf nodes") result = st.exec_all([[leaf1_verify_vxlan], [leaf2_verify_vxlan], [leaf3_verify_vxlan]]) if result[0].count(False) > 0: st.error( "########## VxLAN tunnel status is NOT up on all leaf nodes; Abort the suite ##########" ) st.report_fail("base_config_verification_failed") get_mlag_active_stdby('Active') st.exec_all([[reboot_api.config_save, data['active']], [reboot_api.config_save, data['stdby']], [reboot_api.config_save, evpn_dict['spine_node_list'][0]]]) st.exec_all( [[reboot_api.config_save, data['active'], 'vtysh'], [reboot_api.config_save, data['stdby'], 'vtysh'], [reboot_api.config_save, evpn_dict['spine_node_list'][0], 'vtysh']]) data.config_tgen_bgp = False yield
def platform_check(): if pddf_data.platform_hwsku not in pddf_data.hw_constants[ pddf_data.support[pddf_data.feature]]: st.report_unsupported('pddf_unsupported', pddf_data.feature, pddf_data.platform_hwsku)
def qos_module_hooks(request): # add things at the start of this module global vars vars = dict() vars = st.ensure_min_topology("D1D2:1", "D1T1:2", "D2T1:2") intf_show = interface_status_show(vars.D1, interfaces=[vars.D1T1P1, vars.D1D2P1]) port_speed_info = dict() for port in [vars.D1T1P1, vars.D1D2P1]: filter_data = filter_and_select(intf_show, ['speed'], {'interface': port}) if filter_data and 'speed' in filter_data[0]: port_speed_info[port] = int(filter_data[0]['speed'].replace( 'G', '000')) if port_speed_info[vars.D1D2P1] != port_speed_info[vars.D1T1P1]: st.debug("The TG connected port speed: {}".format( port_speed_info[vars.D1T1P1])) st.debug("The DUT interconnected port speed: {}".format( port_speed_info[vars.D1D2P1])) st.report_unsupported( "msg", "The TG connected port and the DUT interconnected port speeds are not equal" ) scheduling_vars() scheduling_data.pmap_details = asicapi.get_intf_pmap( vars.D1, interface_name=[vars.D1D2P1]) if not scheduling_data.pmap_details: st.debug("PMAP details are: {}".format(scheduling_data.pmap_details)) st.report_fail('no_data_found') scheduling_module_config(config='yes') st.debug("Getting TG handlers") tg1, scheduling_data.tg_ph_1 = tgapi.get_handle_byname("T1D1P1") tg2, scheduling_data.tg_ph_2 = tgapi.get_handle_byname("T1D1P2") tg3, scheduling_data.tg_ph_3 = tgapi.get_handle_byname("T1D2P1") tg4, scheduling_data.tg_ph_4 = tgapi.get_handle_byname("T1D2P2") scheduling_data.tg = tg1 st.unused(tg2, tg3, tg4) st.debug("Reset and clear statistics of TG ports") scheduling_data.tg.tg_traffic_control(action='reset', port_handle=[ scheduling_data.tg_ph_1, scheduling_data.tg_ph_2, scheduling_data.tg_ph_3, scheduling_data.tg_ph_4 ]) scheduling_data.tg.tg_traffic_control(action='clear_stats', port_handle=[ scheduling_data.tg_ph_1, scheduling_data.tg_ph_2, scheduling_data.tg_ph_3, scheduling_data.tg_ph_4 ]) st.debug("Creating TG streams") scheduling_data.streams = {} stream = scheduling_data.tg.tg_traffic_config( port_handle=scheduling_data.tg_ph_3, mode='create', length_mode='fixed', frame_size=64, pkts_per_burst=10, l2_encap='ethernet_ii_vlan', transmit_mode='single_burst', vlan_id=scheduling_data.vlan, mac_src=scheduling_data.mac_egress_1, mac_dst='00:0a:12:00:00:01', vlan="enable") scheduling_data.streams['vlan_tagged_egress_port1'] = stream['stream_id'] stream = scheduling_data.tg.tg_traffic_config( port_handle=scheduling_data.tg_ph_4, mode='create', length_mode='fixed', frame_size=64, pkts_per_burst=10, l2_encap='ethernet_ii_vlan', transmit_mode='single_burst', vlan_id=scheduling_data.vlan, mac_src=scheduling_data.mac_egress_2, mac_dst='00:0a:12:00:00:02', vlan="enable") scheduling_data.streams['vlan_tagged_egress_port2'] = stream['stream_id'] stream = scheduling_data.tg.tg_traffic_config( port_handle=scheduling_data.tg_ph_1, mode='create', transmit_mode='continuous', length_mode='fixed', rate_percent=100, l2_encap='ethernet_ii_vlan', frame_size=1024, vlan_id=scheduling_data.vlan, vlan="enable", vlan_user_priority=scheduling_data.dwrr_queue1, mac_src="00:00:00:00:00:11", mac_dst=scheduling_data.mac_egress_1) scheduling_data.streams['scheduling_port_dwrr_ingress1'] = stream[ 'stream_id'] stream = scheduling_data.tg.tg_traffic_config( port_handle=scheduling_data.tg_ph_2, mode='create', transmit_mode='continuous', length_mode='fixed', rate_percent=100, l2_encap='ethernet_ii_vlan', frame_size=1024, vlan_id=scheduling_data.vlan, vlan="enable", vlan_user_priority=scheduling_data.dwrr_queue2, mac_src="00:00:00:00:00:22", mac_dst=scheduling_data.mac_egress_2) scheduling_data.streams['scheduling_port_dwrr_ingress2'] = stream[ 'stream_id'] yield st.debug('Module config Cleanup') scheduling_module_config(config='no')
def platform_check(): if not data.version_data.lower( ) in data.hw_constants_DUT['HW_WATCHDOG_SUPPORTED_PLATFORMS']: st.log("--- Detected HW watchdog unsupported Platform..") st.report_unsupported("hw_watchdog_unsupported")
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 platform_check(): if sc_data.version_data['hwsku'].lower( ) in hw_constants_DUT['TH3_PLATFORMS']: st.log("--- Detected BUM UnSupported Platform..") st.report_unsupported("storm_control_unsupported")
def prologue_epilogue(): if st.get_ui_type() in ['klish']: st.report_unsupported( 'test_execution_skipped', 'Skipping Chef_MCLAG test case for ui_type={}'.format( st.get_ui_type())) st.log('Define Common config, including TGEN related, if any') initialize_topology() loc_lib.chef_pre_config(data.d1, data.d1_ip) if not chef_evpn_obj.sync_with_server_time( data.my_dut_list, chef_server.ip, chef_server.username, chef_server.password): st.report_env_fail("test_case_not_executeds") f1 = lambda x: chef_evpn_obj.delete_client_pem_files( data.d1, chef_server.client_path) f2 = lambda x: chef_evpn_obj.delete_client_pem_files( data.d2, chef_server.client_path) f3 = lambda x: chef_evpn_obj.delete_client_pem_files( data.d3, chef_server.client_path) putils.exec_all(True, [[f1, 1], [f2, 1], [f3, 1]]) chef_evpn_obj.generate_certs(chef_server.ssh_obj, chef_server.path) # Cleanup exisitng node if any chef_evpn_obj.delete_chef_node(chef_server.ssh_obj, ' '.join(data.node_list_mc), ' '.join(data.role_list_mc)) # Generate certs and bootstrap node chef_evpn_obj.generate_certs(chef_server.ssh_obj, chef_server.path) if not chef_evpn_obj.bootstrap_chef_node( chef_server.ssh_obj, chef_server.path, data.d1_ip, 'admin', 'broadcom', data.node_list_mc[0]): st.report_env_fail("chef_bootstrap_fail") if not chef_evpn_obj.bootstrap_chef_node( chef_server.ssh_obj, chef_server.path, data.d2_ip, 'admin', 'broadcom', data.node_list_mc[1]): st.report_env_fail("chef_bootstrap_fail") if not chef_evpn_obj.bootstrap_chef_node( chef_server.ssh_obj, chef_server.path, data.d3_ip, 'admin', 'broadcom', data.node_list_mc[2]): st.report_env_fail("chef_bootstrap_fail") # upload cookbook #chef_evpn_obj.upload_chef_cookbook(chef_server.ssh_obj, chef_server.path) yield st.log('Define Common cleanup, including TGEN related, if any') for role, node_name in zip(data.role_list_mc, data.node_list_mc): run_list = 'role[{}],recipe[sonic::vlan],recipe[sonic::lag],recipe[sonic::interface],recipe[sonic::mclag]'.format( role) chef_evpn_obj.update_node_run_list(chef_server.ssh_obj, node_name, run_list, 'remove') # Cleanup exisitng node if any chef_evpn_obj.delete_chef_node(chef_server.ssh_obj, ' '.join(data.node_list_mc), ' '.join(data.role_list_mc))
def test_ft_vlan_save_config_warm_and_fast_reboot(): ''' Author: Sai Durga <*****@*****.**> This script covers the below scenarios ft_max_vlan_save_reload Verify the save and reload functionality with max vlan configuration. ft_max_vlan_fast_reload Verify the max vlan configuration is retained after fast-reboot. FtOpSoSwVlFn026 Verify that VLAN is present and traffic is not disturbed during and after warm reboot FtOpSoSysFRFn005 Verify the Fast-Reboot must disrupt control plane not more than 90 seconds (from sonic test suite -configuration tests) ft_reboot_fdb_fast_reboot Verify that the FDB entry is retained after fast reboot. ''' status = True msg_id = "max_vlan_config_retain_after_save_fast_warm_reboot" vlan_module_epilog() vlan_module_config(config='yes') st.log("Device name is : {}".format(sc_data.dut_platform)) if sc_data.dut_platform and sc_data.dut_platform.lower( ) not in sc_data.warm_reboot_supported_platforms: st.error("Warm-Reboot is not supported for this platform ({})".format( sc_data.dut_platform)) st.report_unsupported('test_case_unsupported') st.log("Saving the MAX VLAN config on the device") reboot.config_save(vars.D1) st.log("Performing reboot and checking the VLAN configuration") st.reboot(vars.D1) st.log("Checking VLAN config after reboot") max_vlan_verify() st.log( "Sending traffic with 100 MAC,Checking FDB table updated with 100 MAC addresses and performing reboot and checking the VLAN configuration" ) tg.tg_traffic_control(action="reset", port_handle=tg_handler["tg_ph_list"]) tg_1 = tg.tg_traffic_config(port_handle=tg_handler["tg_ph_1"], mode='create', length_mode='fixed', frame_size=72, mac_src='00:01:00:00:00:01', mac_src_step='00:00:00:00:00:01', mac_src_mode='increment', mac_src_count=sc_data.mac_count, mac_dst='00:02:00:00:00:02', rate_pps=2000, l2_encap='ethernet_ii_vlan', vlan="enable", vlan_id=sc_data.vlan, transmit_mode='continuous') tg_info['tg1_stream_id'] = tg_1['stream_id'] tg.tg_traffic_control(action='run', stream_handle=tg_info['tg1_stream_id']) st.wait(2) tg.tg_traffic_control(action='stop', stream_handle=tg_info['tg1_stream_id']) if not poll_wait(mac_verify, 300): st.error("mac_address_verification_fail") st.log("Performing fast-reboot and checking the VLAN configuration") st.reboot(vars.D1, 'fast') st.log("Checking VLAN config after fast-reboot") max_vlan_verify() st.log("Sending traffic after fast reboot and checking the FDB table") tg.tg_traffic_control(action='run', stream_handle=tg_info['tg1_stream_id']) st.wait(2) tg.tg_traffic_control(action='stop', stream_handle=tg_info['tg1_stream_id']) if not poll_wait(mac_verify, 300): st.error("mac_address_verification_fail") st.log("Performing warm reboot and checking the traffic") ifapi.clear_interface_counters(vars.D1) st.wait(2) ifapi.show_interface_counters_all(vars.D1) st.wait(2) tg.tg_traffic_control(action='run', stream_handle=tg_info['tg1_stream_id']) st.wait(2) st.reboot(vars.D1, 'warm') st.log("Checking VLAN config after warm-reboot") max_vlan_verify() tg.tg_traffic_control(action='stop', stream_handle=tg_info['tg1_stream_id']) st.log("Checking traffic is forwarded without any loss after warm-reboot") st.log("Fetching IXIA statistics") st.wait(2) ifapi.show_interface_counters_all(vars.D1) stats_tg1 = tgapi.get_traffic_stats(tg, mode="aggregate", port_handle=tg_handler["tg_ph_1"]) total_tx_tg1 = stats_tg1.tx.total_bytes stats_tg2 = tgapi.get_traffic_stats(tg, mode="aggregate", port_handle=tg_handler["tg_ph_2"]) total_rx_tg2 = stats_tg2.rx.total_bytes percentage_95_total_tx_tg1 = (95 * int(total_tx_tg1)) / 100 st.log("###############") st.log("Sent bytes: {} and Received bytes : {}".format( percentage_95_total_tx_tg1, total_rx_tg2)) st.log("##############") if not int(percentage_95_total_tx_tg1) <= int(total_rx_tg2): st.report_fail("traffic_transmission_failed", vars.T1D1P1) report_result(status, msg_id)
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)