def bgp_module_hooks(request): global bgp_cli_type st.ensure_min_topology('D1D2:1', 'D1T1:1', 'D2T1:1') bgp_cli_type = st.get_ui_type() if bgp_cli_type == 'click': bgp_cli_type = 'vtysh' bgplib.init_resource_data(st.get_testbed_vars()) bgp_pre_config() yield bgp_pre_config_cleanup()
def bgp_pre_config(): global topo st.banner("BGP MODULE CONFIG - START") st.log("Ensure minimum linear 4-node topology") st.ensure_min_topology('D1D2:1', 'D2D3:1', 'D3D4:1') bgp4nodelib.l3_ipv4v6_address_config_unconfig(config='yes', config_type='all') # Ping Verification if not bgp4nodelib.l3tc_vrfipv4v6_address_ping_test(config_type='all', ping_count=3): st.error("Ping failed in between DUTs") st.report_fail('test_case_failed') topo = bgp4nodelib.get_confed_topology_info() st.log(topo) st.banner("BGP MODULE CONFIG - END")
def test_ft_vlan_delete_with_member(): """ Author: Surendra Kumar Vella ([email protected]) Verify that user is not able to delete a valn till its members are deleted """ vars = st.ensure_min_topology("D1T1:1") st.log( "Adding TGen connected interfaces to newly created vlan in tagging mode." ) if not vlan.add_vlan_member(vars.D1, sc_data.vlan, [vars.D1D2P1], tagging_mode=True, cli_type=sc_data.cli_type): st.report_fail("vlan_tagged_member_fail", vars.D1D2P1, sc_data.vlan) st.log("checking whether vlan with member is deleted or not ") if not st.is_community_build(vars.D1): if vlan.delete_vlan(vars.D1, sc_data.vlan, cli_type="click"): st.report_fail("vlan_deletion_successfull_albiet_having_member", sc_data.vlan) if not vlan.delete_vlan_member( vars.D1, sc_data.vlan, vars.D1D2P1, cli_type=sc_data.cli_type): st.report_fail("vlan_tagged_member_fail", vars.D1D2P1, sc_data.vlan) else: if not vlan.delete_vlan(vars.D1, sc_data.vlan, cli_type="click"): st.report_fail("vlan_delete_fail", sc_data.vlan) st.log("deleting the vlan after its member deletion") st.report_pass("test_case_passed")
def test_ft_vlan_syslog_verify(): """ Author:Anil Kumar Kacharla <*****@*****.**> Referrence Topology : Test bed ID:4 D1--Mgmt network verify VLAN syslog functionality. """ vars = st.ensure_min_topology("D1") sc_data.vlan_test = str(random_vlan_list(1, [int(sc_data.vlan)])[0]) result = 1 st.log("checking vlan count before vlan addition or deletion") count_before_add = slog.get_logging_count(vars.D1, severity="NOTICE", filter_list=["addVlan"]) count_before_delete = slog.get_logging_count(vars.D1, severity="NOTICE", filter_list=["removeVlan"]) st.log("vlan count before adding vlan:{}".format(count_before_add)) st.log("vlan count before deleting vlan:{}".format(count_before_delete)) vlan.create_vlan(vars.D1, sc_data.vlan_test) vlan.delete_vlan(vars.D1, sc_data.vlan_test) st.log("checking vlan count after adding vlan") count_after_add = slog.get_logging_count(vars.D1, severity="NOTICE", filter_list=["addVlan"]) st.log("vlan count after adding vlan:{}".format(count_after_add)) count_after_delete = slog.get_logging_count(vars.D1, severity="NOTICE", filter_list=["removeVlan"]) st.log("vlan count after deleting vlan:{}".format(count_after_delete)) if not count_after_add > count_before_add: st.error("vlan log count increamented after adding vlan:{}".format(count_after_add)) result = 0 if not count_after_delete > count_before_delete: st.error("vlan log count increamented after deleting vlan:{}".format(count_after_delete)) result = 0 if not result: st.report_fail("test_case_fail") st.log(" vlan count after adding or deleting vlan is incremented") st.report_pass("test_case_passed")
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 ndp_module_hooks(request): vars = st.ensure_min_topology("D1T1:2") # Initialize TG and TG port handlers tg_handler = tgapi.get_handles_byname("T1D1P1", "T1D1P2") tg = tg_handler["tg"] # Test setup details data.my_dut_list = st.get_dut_names() dut1 = data.my_dut_list[0] # NDP module configuration st.log("NDP module configuration.") ip_obj.config_ip_addr_interface(dut1, vars.D1T1P1, data.local_ip6_addr[0], 64, family=data.af_ipv6) vlan_obj.create_vlan(dut1, data.vlan_1) vlan_obj.add_vlan_member(dut1, data.vlan_1, vars.D1T1P2, True) ip_obj.config_ip_addr_interface(dut1, data.vlan_int_1, data.local_ip6_addr[1], 64, family=data.af_ipv6) # TG ports reset st.log("Resetting the TG ports") tg.tg_traffic_control(action="reset", port_handle=tg_handler["tg_ph_list"]) # TG protocol interface creation st.log("TG protocol interface creation") h1 = tg.tg_interface_config(port_handle=tg_handler["tg_ph_1"], mode='config', ipv6_intf_addr=data.neigh_ip6_addr_gw[0], ipv6_prefix_length='64', ipv6_gateway=data.local_ip6_addr[0], src_mac_addr=data.tg_mac1, arp_send_req='1', count=data.count) st.log("INTFCONF: " + str(h1)) h2 = tg.tg_interface_config(port_handle=tg_handler["tg_ph_2"], mode='config', ipv6_intf_addr=data.neigh_ip6_addr_gw[1], ipv6_prefix_length='64', ipv6_gateway=data.local_ip6_addr[1], src_mac_addr=data.tg_mac2, arp_send_req='1', vlan_id=data.vlan_1, vlan=1, count=data.count) st.log("INTFCONF: " + str(h2)) yield # NDP module cleanup st.log("NDP module cleanup.") ip_obj.clear_ip_configuration(dut1, family="ipv6", thread=data.clear_parallel) vlan_obj.clear_vlan_configuration(dut1, thread=data.clear_parallel)
def rbac_module_hooks(): global vars vars = st.ensure_min_topology("D1 D2") rbac_variables_init() rbac_module_prolog() yield rbac_module_epilog()
def initialize_topology(): st.log( "Script Starts Here!. Initialize.........................................................................................." ) vars = st.ensure_min_topology("D1D2:4", "D2D3:4", "D1T1:2", "D3T1:2") data.dut_list = st.get_dut_names() data.dut1 = data.dut_list[0] data.dut2 = data.dut_list[1] data.dut3 = data.dut_list[2] utils.exec_all(True, [[bgp_obj.enable_docker_routing_config_mode, data.dut1], [bgp_obj.enable_docker_routing_config_mode, data.dut2], [bgp_obj.enable_docker_routing_config_mode, data.dut3]]) data.d1_d2_ports = [vars.D1D2P1, vars.D1D2P2, vars.D1D2P3, vars.D1D2P4] data.d2_d1_ports = [vars.D2D1P1, vars.D2D1P2, vars.D2D1P3, vars.D2D1P4] data.d2_d3_ports = [vars.D2D3P1, vars.D2D3P2, vars.D2D3P3, vars.D2D3P4] data.d3_d2_ports = [vars.D3D2P1, vars.D3D2P2, vars.D3D2P3, vars.D3D2P4] data.dut1_tg_ports = [vars.D1T1P1, vars.D1T1P2] data.dut3_tg_ports = [vars.D3T1P1, vars.D3T1P2] data.tg_dut1_ports = [vars.T1D1P1, vars.T1D1P2] data.tg_dut3_ports = [vars.T1D3P1, vars.T1D3P2] data.tg = tgen_obj_dict[vars['tgen_list'][0]] data.tg_dut1_p1 = data.tg.get_port_handle(vars.T1D1P1) data.tg_dut3_p1 = data.tg.get_port_handle(vars.T1D3P1) data.tg_dut1_p2 = data.tg.get_port_handle(vars.T1D1P2) data.tg_dut3_p2 = data.tg.get_port_handle(vars.T1D3P2) data.d1_stream_list = {} data.d1_stream_list_vrf = {} data.d3_stream_list = {} if 'ixia' in vars['tgen_list'][0]: data.tgen_type = 'ixia' data.delay_factor = 2 else: data.tgen_type = 'stc' data.delay_factor = 1
def 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 snapshot_feature_module_hooks(request): global vars vars = st.ensure_min_topology('D1T1:4') global_vars_and_constants_init() sf_module_prolog() yield sf_module_epilog()
def initialize_topology_vars(): vars = st.ensure_min_topology("D1D3:4", "D2D3:4", "D1D4:4", "D2D4:4", "D3T1:1", "D4T1:1", "D1D2:1") data.dut_list = st.get_dut_names() data.dut1 = data.dut_list[0] data.dut2 = data.dut_list[1] data.dut3 = data.dut_list[2] data.dut4 = data.dut_list[3] for dut in vars.dut_list: bgp_api.enable_docker_routing_config_mode(dut) data.d1d2_ports = [vars.D1D2P1] data.d2d1_ports = [vars.D2D1P1] data.d1d3_ports = [vars.D1D3P1, vars.D1D3P2, vars.D1D3P3, vars.D1D3P4] data.d1d4_ports = [vars.D1D4P1, vars.D1D4P2, vars.D1D4P3, vars.D1D4P4] data.d2d3_ports = [vars.D2D3P1, vars.D2D3P2, vars.D2D3P3, vars.D2D3P4] data.d2d4_ports = [vars.D2D4P1, vars.D2D4P2, vars.D2D4P3, vars.D2D4P4] data.d3d1_ports = [vars.D3D1P1, vars.D3D1P2, vars.D3D1P3, vars.D3D1P4] data.d3d2_ports = [vars.D3D2P1, vars.D3D2P2, vars.D3D2P3, vars.D3D2P4] data.d4d1_ports = [vars.D4D1P1, vars.D4D1P2, vars.D4D1P3, vars.D4D1P4] data.d4d2_ports = [vars.D4D2P1, vars.D4D2P2, vars.D4D2P3, vars.D4D2P4] data.d4tg_ports = vars.D4T1P1 data.d3tg_ports = vars.D3T1P1 data.tg1 = tgen_obj_dict[vars['tgen_list'][0]] data.tg2 = tgen_obj_dict[vars['tgen_list'][0]] data.tgd3_ports = vars.T1D3P1 data.tgd4_ports = vars.T1D4P1 data.tg_dut3_p1 = data.tg1.get_port_handle(vars.T1D3P1) data.tg_dut4_p1 = data.tg2.get_port_handle(vars.T1D4P1) data.tg_handles = [data.tg_dut3_p1, data.tg_dut4_p1] data.D4_tg_mac = basic_api.get_ifconfig(data.dut4, data.d4tg_ports)[0]['mac'] if 'ixia' in vars['tgen_list'][0]: data.delay_factor = 2 else: data.delay_factor = 1
def copp_module_hooks(request): global vars, tg, tg_ph_1, d1_p1, hw_constants, deviation_percentage, d1_p1_mac, copp_data, vlan_igmp, copp_data_pir vars = st.ensure_min_topology("D1T1:1") hw_constants = st.get_datastore(vars.D1, "constants", "default") st.debug("hw_constants: {}".format(hw_constants)) tg, tg_ph_1 = tgapi.get_handle_byname("T1D1P1") d1_p1 = vars.D1T1P1 vlan_igmp = 3188 vlan_obj.create_vlan(vars.D1, vlan_igmp) deviation_percentage = 0.05 ret_val = copp_obj.get_copp_config(dut=vars.D1, table_name='all') if ret_val: copp_data = ret_val else: st.report_fail('module_config_failed', 'show copp config command failed') copp_data_pir = copp_obj.set_copp_pir_config(vars.D1, config='get') # Get the DUT mac address d1_p1_mac = basic_obj.get_ifconfig(vars.D1, d1_p1)[0]['mac'] # Config the routing interface ip_obj.config_ip_addr_interface(dut=vars.D1, interface_name=d1_p1, ip_address='1.1.1.2', subnet='24') yield # Un-configure the routing interface ip_obj.delete_ip_interface(dut=vars.D1, interface_name=d1_p1, ip_address='1.1.1.2', subnet='24') vlan_obj.delete_vlan(vars.D1, vlan_igmp)
def create_glob_vars(): global vars vars = st.ensure_min_topology("D1D2:2", "D2D3:2", "D1T1:1", "D3T1:1") tg_dict["tg"], tg_dict["d1_tg_ph1"] = tgapi.get_handle_byname("T1D1P1") tg_dict["tg"], tg_dict["d3_tg_ph1"] = tgapi.get_handle_byname("T1D3P1") tg_dict["d1_tg_port1"], tg_dict["d3_tg_port1"] = vars.T1D1P1, vars.T1D3P1 tg_dict["tgen_rate_pps"] = '1000' tg_dict["l3_len"] = '512' tg_dict["duration"] = 5 acl_dict["dut_list"] = [vars.D1, vars.D2, vars.D3] acl_dict["dut1"]["intf_list_tg"] = [vars.D1T1P1] acl_dict["dut1"]["intf_list_dut2"] = [vars.D1D2P1, vars.D1D2P2] acl_dict["dut2"]["intf_list_tg"] = [vars.D2T1P1] acl_dict["dut2"]["intf_list_dut1"] = [vars.D2D1P1, vars.D2D1P2] acl_dict["dut2"]["intf_list_dut3"] = [vars.D2D3P1, vars.D2D3P2] acl_dict["dut3"]["intf_list_tg"] = [vars.D3T1P1] acl_dict["dut3"]["intf_list_dut2"] = [vars.D3D2P1, vars.D3D2P2] acl_dict["dut1_gw_mac"] = basic.get_ifconfig(vars.D1, vars.D1T1P1)[0]['mac'] acl_dict["dut3_gw_mac"] = basic.get_ifconfig(vars.D3, vars.D3T1P1)[0]['mac'] d1_out = st.get_credentials(vars.D1) d3_out = st.get_credentials(vars.D3) acl_dict["d1_uname"] = d1_out[0] acl_dict["d3_uname"] = d3_out[0] acl_dict["d1_pwd"] = d1_out[3] acl_dict["d3_pwd"] = d3_out[3] tg_dict["live_stream"] = ""
def security_module_hooks(request): global vars vars = st.ensure_min_topology("D1") security_variables() security_module_prolog() yield security_module_epilog()
def test_ft_logging_verify_logs_after_system_reboot(): """ Author: Anil Kumar Kacharla <*****@*****.**> Referrence Topology : Test bed ID:4 D1--Mgmt network Verify that logs get generated upon system reboot. """ st.log("Ensuring minimum topology") vars = st.ensure_min_topology("D1") data.count = '0' st.log("configuring syslog server in config_db file") slog_obj.config_syslog_server(vars.D1, [data.syslog_server]) st.log("checking logging count") slog_obj.get_logging_count(vars.D1) count = slog_obj.get_logging_count(vars.D1) st.log("logging count:{}".format(count)) st.log("performing system reboot") st.reboot(vars.D1, 'fast') st.log("checking logs after system reboot ") count = slog_obj.get_logging_count(vars.D1) if slog_obj.get_logging_count(vars.D1) == data.count: st.report_fail("logs_are_not_getting_generated_after_reboot") else: st.log("Logs are generated after reboot") st.log("logs count after reboot:{}".format(count)) output = bsapi.generate_tech_support(vars.D1) if "Tar append operation failed" in output: st.report_fail("Tech_support_operation_failed") st.report_pass("test_case_passed")
def bgp_rst_prologue(): global vars vars = st.ensure_min_topology("D1D2:4") st.banner("Routing interface configuration in both DUTs") [_, exceptions] = exec_all( True, [[dut1_routing_int_cfg, "add"], [dut2_routing_int_cfg, "add"]]) ensure_no_exception(exceptions)
def qos_fast_reboot_module_hooks(request): # add things at the start of this module global vars vars = st.ensure_min_topology("D1T1:1") 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 fast-reboot") wred_verify() st.log("checking for ecn config before save and fast-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 fast-reboot") ipv4_acl_verify() st.log("Checking for IPV6 ACL config before save and fast-reboot") ipv6_acl_verify() st.log("Configuring COS") cos_config() st.log("Checking for COS config before save and fast-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 initialize_topology(): st.log( "Script Starts Here!. Initialize.........................................................................................." ) #DUT topology variables vars = st.ensure_min_topology("D1D2:4", "D1T1:2", "D2T1:2") data.dut_list = st.get_dut_names() data.dut1 = data.dut_list[0] data.dut2 = data.dut_list[1] data.d1_d2_ports = [vars.D1D2P1, vars.D1D2P2, vars.D1D2P3, vars.D1D2P4] data.d2_d1_ports = [vars.D2D1P1, vars.D2D1P2, vars.D2D1P3, vars.D2D1P4] #DUT-TG topology variables data.dut1_tg_ports = [vars.D1T1P1, vars.D1T1P2] data.dut2_tg_ports = [vars.D2T1P1, vars.D2T1P2] data.tg_dut1_ports = [vars.T1D1P1, vars.T1D1P2] data.tg_dut2_ports = [vars.T1D2P1, vars.T1D2P2] data.tg = tgen_obj_dict[vars['tgen_list'][0]] data.tg_dut1_p1 = data.tg.get_port_handle(vars.T1D1P1) data.tg_dut2_p1 = data.tg.get_port_handle(vars.T1D2P1) data.tg_dut1_p2 = data.tg.get_port_handle(vars.T1D1P2) data.tg_dut2_p2 = data.tg.get_port_handle(vars.T1D2P2) data.d1_stream_list = {} data.d2_stream_list = {} data.d1_gateway_mac = mac_obj.get_sbin_intf_mac(data.dut1, data.dut1_tg_ports[0]) #TGEN delay if 'ixia' in vars['tgen_list'][0]: data.tgen_type = 'ixia' data.delay_factor = 2 else: data.tgen_type = 'stc' data.delay_factor = 1
def lldp_snmp_module_hooks(request): global vars vars = st.ensure_min_topology("D1D2:2") global_vars() lldp_snmp_pre_config() yield lldp_snmp_post_config()
def bgp_fast_reboot_module_hooks(request): global vars vars = st.ensure_min_topology("D1D2:1", "D1T1:2") if not st.is_feature_supported("bgp-neighbotship-performance", vars.D1): data.neighborship_wait = 30 st.log("Enabling IPv6 mode globally") ip_obj.config_ipv6(vars.D1, action='enable') ip_obj.config_ipv6(vars.D2, action='enable') st.log("Configuring ipv4 addresses on routing interfaces") ipv4_ip_address_config() st.log("Verifying ipv4 addresses on routing interfaces") verify_ipv4_address_config() if data.ipv6_support: st.log("Configuring ipv6 addresses on routing interfaces") ipv6_address_config() st.log("Verifying ipv6 addresses on routing interfaces") verify_ipv6_address_config() st.log( "Configuring IPV6 eBGP config between DUT1 and DUT2,iBGP config between DUT1 and TG2" ) ipv6_bgp_config() st.log( "Configuring IPV4 eBGP config between DUT1 and DUT2,iBGP config between DUT1 and TG1" ) ipv4_bgp_config() if data.ipv6_support: st.log("Configuring TG2 V6 iBGP config") tg_bgpv6_config(vars, data.local_asn4, data.remote_asn4) st.log("Configuring TG1 V4 iBGP config") tg_bgp_config(vars, data.local_asn4, data.remote_asn4) st.log( "Verify IPV4 eBGP neighborship between D1 and D2 and iBGP neighborship between D1 and TG1" ) verify_v4_bgp_neigborship() if data.ipv6_support: st.log( "Verify IPV6 eBGP neighborship between D1 and D2 and iBGP neighborship between D1 and TG2" ) verify_v6_bgp_neigborship() yield bgp_obj.cleanup_router_bgp(st.get_dut_names()) ip_obj.clear_ip_configuration(st.get_dut_names()) if data.ipv6_support: ip_obj.clear_ip_configuration(st.get_dut_names(), 'ipv6') vlan_obj.clear_vlan_configuration(st.get_dut_names()) portchannel_obj.clear_portchannel_configuration(st.get_dut_names())
def test_ft_ztp_install_docker_package(ztp_func_hooks): # ################ Author Details ################ # Name: Chaitanya Vella # Email: [email protected] # ################################################ # ############## Test bed details ################ # D1 ---- DHCP Server # ft_ztp_install_docker_package : Verify that ZTP can install a docker package using pre-defined firmware plugin. vars = st.ensure_min_topology("D1") #hostname = basic_obj.get_hostname(vars.D1) config_params.config_file = "ztp_docker.json" config_params.static_ip = ztp_params.dhcp.static_ip config_params.config_path = ztp_params.config_path config_params.dhcp_config_file = ztp_params.dhcp.config_file config_params.type = "http" config_params.dhcp_service_name = data.dhcp_service_name config_params.action = 'restart' config_params.device = 'server' config_params.device_action = "run" config_params.reboot_type = "normal" config_params.ztp_log_path = data.ztp_log_path config_params.file_names = ["02-configdb-json", "03-firmware"] config_params.log_msg = "Checking configuration section {} result: SUCCESS" config_params.ztp_log_string = "ZTP successfully completed" config_params.option_type = "67" config_params.result = "" config_params.config_db_path = data.config_db_path config_params.config_db_temp = data.config_db_temp config_params.json_config_path = "http://{}{}/".format( ztp_params.dhcp.static_ip, ztp_params.config_path) config_params.docker_path = "http://{}{}/{}".format( ztp_params.dhcp.static_ip, ztp_params.docker_path, ztp_params.docker_image) config_params.json_content = { "ztp": { "02-configdb-json": { "url": { "source": "file://{}".format(config_params.config_db_temp), "timeout": 300 } }, "03-firmware": { "upgrade-docker": { "url": config_params.docker_path, "container-name": ztp_params.docker_component_name } } } } ztp_obj.config_and_verify_dhcp_option(ssh_conn_obj, vars.D1, ztp_params, config_params) ztp_status = ztp_obj.show_ztp_status(vars.D1) if "dhcp-opt67" not in ztp_status["source"]: st.log( "ZTP source verification failed with {} against dhcp-opt67".format( ztp_status["source"])) st.report_fail("ztp_source_verification_failed", "dhcp-opt67", ztp_status["source"]) st.report_pass("test_case_passed")
def test_ft_ntp_disable_enable_with_message_log(): """ Author: Anil Kumar Kacharla <*****@*****.**> Referrence Topology : Test bed ID:4 D1--Mgmt network Verify that Ntp synchronization is successful after doing NTP server on and off and the message log display the correct time based upon the system up time. """ st.log("Ensuring minimum topology") vars = st.ensure_min_topology("D1") data.string_generate = 'Iam Testing NTP' data.lines = 1 data.time_date = time.strftime('%a %B %d %H:%M:%S %Z %Y') ntp_obj.config_date(vars.D1, data.time_date) st.log("checking time in message log without ntp ") log_message_1 = syslog_obj.show_logging(vars.D1, severity=None, filter_list=[], lines=data.lines) if not log_message_1: st.log("log message_1 not created") st.report_fail("operation_failed") clock = common_obj.log_parser(log_message_1[0]) config_ntp_server_on_config_db_file(vars.D1, data.servers) st.log("Generating log messages") syslog_obj.clear_logging(vars.D1) syslog_obj.write_logging(vars.D1, data.string_generate) log_message = syslog_obj.show_logging(vars.D1, severity=None, filter_list=[data.string_generate]) if not log_message: st.log("log message not created") st.report_fail("operation_failed") st.log("printing system clock") ntp_obj.show_clock(vars.D1) out = common_obj.log_parser(log_message[0]) if not (clock[0]['month'] == out[0]['month'] and clock[0]['hours'] == out[0]['hours'] and clock[0]['date'] == out[0]['date'] and clock[0]['minutes'] <= out[0]['minutes'] or clock[0]['seconds'] >= out[0]['seconds']): st.log("time not updated") st.report_fail("operation_failed") st.log("message log displaying correct timed based on system up time") st.log("disabling ntp") basic_obj.service_operations(vars.D1, data.ntp_service, action="stop") if not ntp_obj.verify_ntp_service_status(vars.D1, 'inactive (dead)'): st.log("ntp disabled failed") st.report_fail("operation_failed") st.log("Enabling NTP") basic_obj.service_operations(vars.D1, data.ntp_service, action="restart") if not ntp_obj.verify_ntp_service_status( vars.D1, 'active (running)', iteration=65, delay=2): st.log("ntp is exited after enable and disable ntp") st.report_fail("operation_failed") if not ntp_obj.verify_ntp_status( vars.D1, iteration=65, delay=2, server=data.servers): st.log("ntp syncronization failed after enable and disable ntp") st.report_fail("operation_failed") st.report_pass("test_case_passed")
def config_mgmt_func_hooks(request): # add things at the start every test case # use 'st.get_func_name(request)' to compare # if any thing specific a particular test case global vars vars = st.get_testbed_vars() st.log("Ensuring minimum topology") vars = st.ensure_min_topology("D1") data.gmin = "100" data.gmax = "1000" data.rmin = "100" data.rmax = "1000" data.ymin = "100" data.ymax = "1000" data.ECN_profile_name = "ECN" data.cos_name = "COS" data.acl_ipv4_table_name = 'acl_table_v4' data.acl_ipv6_table_name = 'acl_table_v6' data.src_ip = '192.168.11.1' data.src_ipv6 = '2001::10' data.mask = '24' data.mask_ipv6 = '128' data.description = 'INGRESS_drop' data.acl_rule = 'ipv4_acl_rule' data.acl_rule_v6 = 'ipv6_acl_rule' data.priority = '55' data.type = 'L3' data.type_ipv6 = 'L3V6' data.packet_action = 'drop' data.stage = 'INGRESS' data.mode_high = 'high' data.mode_low = 'low' data.polling_interval = '1' data.threshold_percentage_type = 'percentage' data.threshold_used_type = 'used' data.threshold_free_type = 'free' data.ipv4_route_family = "ipv4_route" data.ipv6_route_family = "ipv6_route" data.fdb_family = "fdb" data.ipv4_neighbor_family = "ipv4_neighbor" data.ipv6_neighbor_family = "ipv6_neighbor" data.acl_group_entry_family = 'acl_group_entry' data.acl_group_counter_family = 'acl_group_counter' data.ipv6_nexthop_family = 'ipv6_nexthop' data.ipv4_nexthop_family = 'ipv4_nexthop' data.acl_table_family = "acl_table" data.mode_high_percentage = 50 data.mode_low_percentage = 20 data.mode_high_used = 1000 data.mode_low_used = 10 data.mode_high_free = 1000 data.mode_low_free = 10 data.mtu = "9216" data.eth = "Ethernet4" data.property = "mtu" data.mtu_default = "9100" yield
def mclag_stp_interaction_module_hooks(request): global vars vars = st.ensure_min_topology("D1D2:4", "D1D3:3", "D1D4:1", "D1D5:1", "D2D4:3", "D2D3:1", "D3D4:3", "D3D5:1", "D4D5:1", "D1T1:1", "D2T1:1", "D3T1:1", "D4T1:1", "D5T1:1") lib_stp.module_config(vars, stp_protocol, topology_2_tier) yield lib_stp.module_unconfig(stp_protocol)
def arp_module_hooks(request): global vars, tg_handler, tg, dut1, d1_mac_addr, h1, h2 # Min topology verification vars = st.ensure_min_topology("D1T1:2") # Initialize TG and TG port handlers tg_handler = tgapi.get_handles_byname("T1D1P1", "T1D1P2") tg = tg_handler["tg"] # Test setup details data.my_dut_list = st.get_dut_names() dut1 = data.my_dut_list[0] # Test variables d1_mac_addr = mac.get_sbin_intf_mac(dut1, "eth0") # ARP module configuration st.log("ARP module configuration.") ip_obj.config_ip_addr_interface(dut1, vars.D1T1P1, data.d1t1_ip_addr, data.mask) vlan_obj.create_vlan(dut1, data.vlan_1) vlan_obj.add_vlan_member(dut1, data.vlan_1, vars.D1T1P2, True) ip_obj.config_ip_addr_interface(dut1, data.vlan_int_1, data.d1t2_ip_addr, data.mask) # TG ports reset st.log("Resetting the TG ports") tg.tg_traffic_control(action="reset", port_handle=tg_handler["tg_ph_list"]) # TG protocol interface creation st.log("TG protocol interface creation") h1 = tg.tg_interface_config(port_handle=tg_handler["tg_ph_1"], mode='config', intf_ip_addr=data.t1d1_ip_addr, gateway=data.d1t1_ip_addr, src_mac_addr=data.t1d1_mac_addr, arp_send_req='1') st.log("INTFCONF: " + str(h1)) h2 = tg.tg_interface_config(port_handle=tg_handler["tg_ph_2"], mode='config', intf_ip_addr=data.t2d1_ip_addr, gateway=data.d1t2_ip_addr, src_mac_addr=data.t2d1_mac_addr, arp_send_req='1', vlan_id=data.vlan_1, vlan=1) st.log("INTFCONF: " + str(h2)) yield # ARP module cleanup st.log("ARP module cleanup.") ip_obj.clear_ip_configuration(dut1, family="ipv4", thread=data.clear_parallel) vlan_obj.clear_vlan_configuration(dut1, thread=data.clear_parallel)
def test_ft_ztp_firmware_install_uninstall(ztp_func_hooks): # ################ Author Details ################ # Name: Chaitanya Vella # Email: [email protected] # ################################################ # ############## Test bed details ################ # D1 ---- DHCP Server # ft_ztp_firmware_install: Verify that SONiC ZTP successfully installs firmware image # ################################################# vars = st.ensure_min_topology("D1") config_params.config_file = "ztp_firmware.json" config_params.static_ip = ztp_params.dhcp.static_ip config_params.config_path = ztp_params.config_path config_params.dhcp_config_file = ztp_params.dhcp.config_file config_params.type = "http" config_params.dhcp_service_name = data.dhcp_service_name config_params.action = "restart" config_params.device = 'server' config_params.device_action = "run" config_params.ztp_log_path = data.ztp_log_path config_params.file_names = ["firmware", "01-configdb-json"] config_params.option_type = "67" config_params.result = "pass" config_params.config_db_path = data.config_db_path config_params.config_db_temp = data.config_db_temp firmware_url = "http://{}{}/{}".format(ztp_params.dhcp.static_ip, ztp_params.firmware_path, ztp_params.build_file_name) config_params.json_content = { "ztp": { "firmware": { "install": { "url": firmware_url, "set-default": True }, "remove": { "version": ztp_params.uninstall_image }, "plugin": "firmware", "reboot-on-failure": "false", "reboot-on-success": "true" }, "01-configdb-json": { "url": { "source": "file://{}".format(data.config_db_temp), "timeout": 300 } } } } ztp_obj.config_and_verify_dhcp_option(ssh_conn_obj, vars.D1, ztp_params, config_params, expect_reboot=True, reboot_on_success=["firmware"])
def rbac_module_hooks(): global vars vars = st.ensure_min_topology("D1 D2") rbac_variables_init() rbac_module_prolog() rbac_variables() st.log("Getting IP address of the DUT") ensure_device_ipaddress() yield rbac_module_epilog()
def bootup_module_hooks(request): global vars vars = st.ensure_min_topology("D1") st.log("Ensure HTTP server details") data.http_ip = mutils.ensure_service_params(vars.D1, 'http', 'ip') data.build_path = mutils.ensure_service_params(vars.D1, 'http', 'path') data.build_name = mutils.ensure_service_params(vars.D1, 'http', 'image1') st.log("Fetching Present build(Current active build)") data.build_details_list = bootup_obj.sonic_installer_list(vars.D1) data.initial_build = data.build_details_list['Current'][0] yield
def vlan_module_hooks(request): global vars vars = st.ensure_min_topology("D1D2:2", "D1T1:2", "D2T1:2") sc_data.version_data = basic_obj.show_version(vars.D1) vlan_variables() if not st.is_feature_supported("vlan-range", vars.D1): sc_data.max_vlan = 100 [_, exceptions] = exec_all(True, [[config_tg_stream], [vlan_module_prolog]], first_on_main=True) ensure_no_exception(exceptions) yield vlan.clear_vlan_configuration(st.get_dut_names(), thread=False)