def snmp_pre_config(): """ SNMP pre config """ global ipaddress ipaddress_list = basic_obj.get_ifconfig_inet(vars.D1, data.mgmt_int) st.log("Checking Ip address of the Device ") if not ipaddress_list: st.report_env_fail("ip_verification_fail") ipaddress = ipaddress_list[0] st.log("Device ip addresse - {}".format(ipaddress)) snmp_obj.set_snmp_config(vars.D1, snmp_rocommunity=data.ro_community, snmp_location=data.location) if not st.is_community_build(): ipfeature.configure_loopback(vars.D1, loopback_name="Loopback0", config="yes") ipfeature.config_ip_addr_interface(vars.D1, data.loopback0, data.loopback_addr, 32, family=data.af_ipv4) if not ipfeature.ping(vars.D1, ipaddress, family='ipv4', external=True): st.error("Ping reachability is failed between SNMP server and Device.") if not snmp_obj.poll_for_snmp(vars.D1, data.wait_time, 1, ipaddress=ipaddress, oid=data.oid_sysName, community_name=data.ro_community): st.log("Post SNMP config , snmp is not working") st.report_fail("operation_failed")
def get_dut_ip(dut): chef_server.mgmt_intf = util_obj.ensure_service_params(dut, chef_server.name, "mgmt_intf") ip_addr = basic_obj.get_ifconfig_inet(dut, chef_server.mgmt_intf) if not ip_addr: st.log("IP Address not found on eth0") st.report_env_fail("test_case_not_executeds") return ip_addr[0]
def chef_pre_config(dut, dut_ip): st.log("Installing CHEF on the Sonic device") basic_obj.deploy_package(dut, mode='update') basic_obj.deploy_package(dut, packane_name='sshpass', mode='install') if not chef_evpn_obj.chef_package_install(dut, chef_server.url, dut_ip, 'admin', 'broadcom', 'YourPaSsWoRd'): st.report_env_fail("test_case_not_executeds") st.log("Done Installing the dependents packages if not installed.") '''
def get_params(): pddf_data.base_mac_address = baapi.get_ifconfig_ether(vars.D1, "eth0") pddf_data.platform_name_summary = baapi.get_platform_summary(vars.D1) pddf_data.platform_hwsku = pddf_data.platform_name_summary["hwsku"].lower() platform_check() pddf_data.platform_name = pddf_data.platform_name_summary["platform"] pddf_data.serial_number = baapi.show_version(vars.D1)['serial_number'] pddf_data.platform_constants = st.get_datastore(vars.D1, "constants", pddf_data.platform_hwsku) pddf_data.fan_list = pddf_data.platform_constants.get( "PDDF_FANS_LIST", None) pddf_data.psu_list = pddf_data.platform_constants.get( "PDDF_PSU_LIST", None) pddf_data.thermal_list = pddf_data.platform_constants.get( "PDDF_THERMAL_LIST", None) pddf_data.manufacturer = pddf_data.platform_constants.get( "Manufacturer", None) if not all([ pddf_data.fan_list, pddf_data.psu_list, pddf_data.thermal_list, pddf_data.manufacturer ]): st.report_env_fail("pddf_get_constanc_fail", pddf_data.feature, pddf_data.platform_hwsku) pddf_data.up_port_list = intapi.get_up_interfaces(vars.D1) if not pddf_data.up_port_list: st.report_env_fail("up_interface_not_found", pddf_data.feature) pddf_data.up_port = get_sfpytils_supported_up_interface() if any("/" in interface for interface in make_list(pddf_data.up_port_list)): pddf_data.up_port_list = st.get_other_names( vars.D1, make_list(pddf_data.up_port_list)) pddf_data.alias_up_port = st.get_other_names( vars.D1, make_list(pddf_data.up_port))[0] else: pddf_data.alias_up_port = pddf_data.up_port #Removed Warm reboot as it's not supported in Buzznik+ pddf_data.reboot_cause_dict = { 'warm': 'warm-reboot', 'fast': 'fast-reboot', 'normal': "issued 'reboot'" } pddf_data.reboot_type = random.sample(pddf_data.reboot_cause_dict.keys(), k=1)[0] if pddf_data.platform_hwsku not in pddf_data.hw_constants[ 'WARM_REBOOT_SUPPORTED_PLATFORMS']: pddf_data.reboot_cause_dict.pop('warm') pddf_data.reboot_type = random.sample( pddf_data.reboot_cause_dict.keys(), k=1)[0]
def chef_pre_config_in_parallel(thread=True): [out, exceptions] = utils.exec_foreach(thread, vars.dut_list, chef_pre_config) st.log(exceptions) if False in out: st.report_env_fail("test_case_not_executeds") st.log("Fetching Chef config params from sonic services file") chef_params.ip = util_obj.ensure_service_params(vars.D1, "chef", "ip") chef_params.username = util_obj.ensure_service_params( vars.D1, "chef", "username") chef_params.password = util_obj.ensure_service_params( vars.D1, "chef", "password") chef_params.path = util_obj.ensure_service_params(vars.D1, "chef", "path") chef_params.roles = util_obj.ensure_service_params(vars.D1, "chef", "roles") chef_params.cookbook_path = util_obj.ensure_service_params( vars.D1, "chef", "cookbook_path") chef_params.client_path = util_obj.ensure_service_params( vars.D1, "chef", "client_path") chef_params.validation_file = util_obj.ensure_service_params( vars.D1, "chef", "validation_file") chef_params.client_rb = util_obj.ensure_service_params( vars.D1, "chef", "client_rb") chef_params.client_log = util_obj.ensure_service_params( vars.D1, "chef", "client_log") chef_params.default_rb = util_obj.ensure_service_params( vars.D1, "chef", "default_rb") chef_params.mgmt_intf = util_obj.ensure_service_params( vars.D1, "chef", "mgmt_intf") st.log("Logging in to chef server with the params from config file.") global ssh_conn_obj ssh_conn_obj = con_obj.connect_to_device(chef_params.ip, chef_params.username, chef_params.password) if not ssh_conn_obj: st.error("SSH connetion object not found.") st.report_env_fail("ssh_connection_failed", chef_params.ip) ip_addr = basic_obj.get_ifconfig_inet(vars.D1, chef_params.mgmt_intf) ssh_obj = con_obj.connect_to_device(ip_addr[0], 'admin', 'YourPaSsWoRd') if ssh_obj: chef_obj.bootstrap_chef_node(ssh_conn_obj, ip_addr[0], 'admin', 'YourPaSsWoRd', node_name) else: chef_obj.bootstrap_chef_node(ssh_conn_obj, ip_addr[0], 'admin', 'broadcom', node_name) st.log("CHEF pre-config Done")
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 test_ft_snmp_max_vlan_scale(): ''' Author: Prasad Darnasi <*****@*****.**> verify The BRIDGE-MIB requirements functionality by scaling DUT with max Vlans ''' vlan_module_config(config='yes') st.log("Checking VLAN config after reboot") max_vlan_verify() global ipaddress ipaddress_list = basic_obj.get_ifconfig_inet(vars.D1, sc_data.mgmt_int) st.log("Checking Ip address of the Device ") if not ipaddress_list: st.report_env_fail("ip_verification_fail") ipaddress = ipaddress_list[0] st.log("Device ip addresse - {}".format(ipaddress)) snmp_obj.set_snmp_config(vars.D1, snmp_rocommunity=sc_data.ro_community, snmp_location=sc_data.location) if not snmp_obj.poll_for_snmp(vars.D1, 30, 1, ipaddress=ipaddress, oid=sc_data.oid_sysName, community_name=sc_data.ro_community): st.log("Post SNMP config , snmp is not working") st.report_fail("operation_failed") basic_obj.get_top_info(vars.D1, proc_name='snmpd') get_snmp_output = snmp_obj.poll_for_snmp_walk( vars.D1, 15, 1, ipaddress=ipaddress, oid=sc_data.oid_dot1qBase, community_name=sc_data.ro_community) if not get_snmp_output: st.report_fail("get_snmp_output_fail") st.report_pass("test_case_passed")
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 chef_pre_config(dut): st.log("CHEF pre-config Start") ip_addr = basic_obj.get_ifconfig_inet(dut, 'eth0') if not ip_addr: st.log("IP Address not found on eth0") st.report_env_fail("test_case_not_executeds") basic_obj.deploy_package(dut, mode='update') basic_obj.deploy_package(dut, packane_name='sshpass', mode='install') ip = util_obj.ensure_service_params(dut, "chef", "ip") username = util_obj.ensure_service_params(dut, "chef", "username") password = util_obj.ensure_service_params(dut, "chef", "password") st.log("Chef Server IP : {}".format(ip)) url = "https://{}:443".format(ip) st.log("Chef server url used : {}".format(url)) if not chef_obj.chef_package_install(dut, url, ip_addr[0], 'admin', 'broadcom', 'YourPaSsWoRd'): st.report_env_fail("test_case_not_executeds") st.log("Done Installing the dependents packages if not installed.") if not chef_obj.sync_with_server_time(dut, ip, username, password): st.report_env_fail("test_case_not_executeds")
def config_and_verify_dhcp_option(ssh_conn_obj, dut, ztp_params, data, expect_reboot=False, reboot_on_success=list(), cli_type=""): """ Common function to configure DHCP option along with status / logs verification Author: Chaitanya Vella ([email protected]) :param ssh_conn_obj: :param dut: :param ztp_params: :param data: :return: """ cli_type = st.get_ui_type(dut,cli_type=cli_type) cli_type = "klish" if cli_type in ["rest-put", "rest-patch"] else cli_type retry_count = data.retry_count if "retry_count" in data and data.retry_count else 0 iteration = data.iteration if "iteration" in data and data.iteration else 300 delay = data.delay if "delay" in data and data.delay else 3 if "func_name" in data: syslog_file_names = ["syslog_1_{}".format(data.func_name), "syslog_{}".format(data.func_name)] # basic_obj.copy_config_db_to_temp(dut, data.config_db_path, data.config_db_temp) if "config_file_type" in data and data.config_file_type == "text": file_path = "/tmp/file_temp.json" basic_obj.write_to_file(ssh_conn_obj, data.json_content, file_path, device="server") elif "config_file_type" in data and data.config_file_type == "EoL": file_path = "" else: file_path = basic_obj.write_to_json_file(data.json_content) if file_path: destination_path = "{}{}/{}".format(ztp_params.home_path, ztp_params.config_path, data.config_file) basic_obj.copy_file_from_client_to_server(ssh_conn_obj, src_path=file_path, dst_path=destination_path) if "config_db_location" in data and data.config_db_location == "json": st.download_file_from_dut(dut, data.config_db_temp, file_path) destination_path = "{}{}/{}".format(ztp_params.home_path, ztp_params.config_path, data.config_db_file_name) basic_obj.copy_file_from_client_to_server(ssh_conn_obj, src_path=file_path, dst_path=destination_path) if "scenario" in data and data.scenario == "invalid-json": st.log("Writing invalid content to make invalid json ...") basic_obj.write_to_file_to_line(ssh_conn_obj, ",", 5, destination_path, "server") if data.option_type == "67": st.log("Creating {} file on DHCP server ...".format(data.config_file)) data.search_pattern = r'\s*option\s+bootfile-name\s*\S*\s*"\S+";' data.option_string = "option bootfile-name" if data.type == "http": data.option_url = "http://{}{}/{}".format(data.static_ip, data.config_path, data.config_file) elif data.type == "tftp": data.option_url = "tftp://{}/{}/{}".format(data.static_ip, data.config_path, data.config_file) elif data.type == "ftp": data.option_url = "ftp://{}/{}/{}".format(data.static_ip, data.config_path, data.config_file) write_option_to_dhcp_server(ssh_conn_obj, data) basic_obj.service_operations(ssh_conn_obj, data.dhcp_service_name, data.action, data.device) if not verify_dhcpd_service_status(ssh_conn_obj, data.dhcpd_pid): st.log("{} service not running".format(data.dhcp_service_name)) st.report_fail("service_not_running", data.dhcp_service_name) # write_option_67_to_dhcp_server(ssh_conn_obj, data) data.device_action = "reboot" if cli_type == "klish" else data.device_action if data.device_action == "reboot": reboot_type = data.reboot_type if "reboot_type" in data and data.reboot_type else "normal" basic_obj.remove_file(dut, data.config_db_path) st.reboot(dut, reboot_type, skip_port_wait=True) st.wait_system_status(dut, 500) elif data.device_action == "run": ztp_operations(dut, data.device_action) if "band_type" in data and data.band_type=="inband": if not basic_obj.poll_for_system_status(dut): st.log("Sytem is not ready ..") st.report_env_fail("system_not_ready") if not basic_obj.check_interface_status(dut, ztp_params.oob_port,"up"): basic_obj.ifconfig_operation(dut, ztp_params.oob_port, "down") interface_status = basic_obj.check_interface_status(dut, ztp_params.inband_port, "up") if interface_status is not None: if not interface_status: intf_obj.interface_noshutdown(dut, ztp_params.inband_port, cli_type=cli_type) if "service" in data and data.service == "disable": basic_obj.service_operations_by_systemctl(dut, "ztp", "stop") if basic_obj.verify_service_status(dut, "ztp"): st.log("ZTP status is not stopped") st.report_fail("service_not_stopped", "ztp") basic_obj.service_operations_by_systemctl(dut, "ztp", "start") if not poll_ztp_status(dut, ["IN-PROGRESS", "Not Started", "SUCCESS"], cli_type=cli_type): st.report_fail("ztp_max_polling_interval") if "check" in data and data.check == "not": if verify_ztp_status(dut, retry_count, iteration, delay, cli_type=cli_type): if "logs_path" in data and "func_name" in data: capture_syslogs(dut, data.logs_path, syslog_file_names) st.log("ZTP status verification failed") st.report_fail("ztp_status_verification_failed") else: st.log("Iteration count {}".format(iteration)) st.log("REBOOT ON SUCCESS - {}".format(reboot_on_success)) if reboot_on_success: if "configdb-json" in reboot_on_success: st.wait_system_reboot(dut) st.wait_system_status(dut, 300) result = verify_ztp_status(dut, retry_count, iteration, delay, expect_reboot=expect_reboot, reboot_on_success=reboot_on_success, cli_type=cli_type) else: result = verify_ztp_status(dut, retry_count, iteration, delay, expect_reboot=expect_reboot, cli_type=cli_type) if not result: if "logs_path" in data and "func_name" in data: capture_syslogs(dut, data.logs_path, syslog_file_names) st.log("ZTP status verification failed") st.report_fail("ztp_status_verification_failed") if reboot_on_success: output = show_ztp_status(dut, cli_type=cli_type) if output["status"] != "SUCCESS": st.wait(300, "Waiting for device to reboot after success...") st.wait_system_status(dut, 300) # st.wait_system_reboot(dut) if not verify_ztp_status(dut, retry_count, iteration, delay, cli_type=cli_type): if "logs_path" in data and "func_name" in data: capture_syslogs(dut, data.logs_path, syslog_file_names) st.log("ZTP status verification failed") st.report_fail("ztp_status_verification_failed") st.banner(boot_up_obj.sonic_installer_list(dut)) verify_ztp_filename_logs(dut, data) if "ztp_log_string" in data and data.ztp_log_string: if not basic_obj.poll_for_error_logs(dut, data.ztp_log_path, data.ztp_log_string): st.log("ZTP log {} verification failed for message {}".format(data.ztp_log_path, data.ztp_log_string)) if not basic_obj.poll_for_error_logs(dut, data.ztp_log_path_1, data.ztp_log_string): st.log("ZTP log {} verification failed for message {}".format(data.ztp_log_path_1, data.ztp_log_string)) st.report_fail("ztp_log_verification_failed", data.ztp_log_path_1, data.ztp_log_string) if "result" in data and data.result == "pass": st.report_pass("test_case_passed")
def initialize_topology(): # code for ensuring min topology vars = st.ensure_min_topology("D1D2:2", "D1D3:1", "D2D3:1", "D2CHIP:TD3", "D3CHIP:TD3") data.my_dut_list = st.get_dut_names() data.d1 = vars.D1 data.d2 = vars.D2 data.d3 = vars.D3 data.wait = 10 data.clear_parallel = True data.portChannelName = 'PortChannel001' data.peerlinkintf = 'PortChannel002' data.mclag_domain = 1 data.d1d2p1 = vars.D1D2P1 data.d2d1p1 = vars.D2D1P1 data.d1d2p2 = vars.D1D2P2 data.d2d1p2 = vars.D2D1P2 data.d3d1p1 = vars.D3D1P1 data.d3d2p1 = vars.D3D2P1 data.d3d1p2 = vars.D3D1P2 data.d1_d2_intf_1 = vars.D1D2P1 data.d2_d1_intf_1 = vars.D2D1P1 data.d1_d2_intf_2 = vars.D1D2P2 data.d2_d1_intf_2 = vars.D2D1P2 data.d1_d3_intf_1 = vars.D1D3P1 data.d3_d1_intf_1 = vars.D3D1P1 data.d3_d1_intf_2 = vars.D3D1P2 data.d2_d3_intf_1 = vars.D2D3P1 data.d3_d2_intf_1 = vars.D3D2P1 data.d1d2_ip = '11.11.11.1' data.d2d1_ip = '11.11.11.2' [res, _] = putils.exec_foreach(True, data.my_dut_list, loc_lib.get_dut_ip) data.d1_ip = res[0] data.d2_ip = res[1] data.d3_ip = res[2] data.cli_type = "click" data.role_path = os.path.join(os.path.dirname(__file__), data.role_dir) st.log('#####################{}'.format(data.role_path)) chef_param_list = [ 'ip', 'username', 'password', 'cookbook_path', 'path', 'client_path', 'validation_file', 'client_rb', 'client_log', 'user_home_folder' ] for chef_param in chef_param_list: chef_server[chef_param] = mutils.ensure_service_params( data.d1, chef_server.name, chef_param) chef_server.url = "https://{}:443".format(chef_server.ip) st.log("Chef server url used : {}".format(chef_server.url)) st.log("Logging in to chef server with the params from config file.") chef_server.ssh_obj = con_obj.connect_to_device(chef_server.ip, chef_server.username, chef_server.password) if not chef_server.ssh_obj: st.error("SSH connetion object not found.") st.report_env_fail("ssh_connection_failed", chef_server.ip)
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 get_dut_ports_dict_from_topo(min_req_topo): """ :param : None :return: a dict of all dut-ports Returned dict will map all port connections in globals()['vars'] with some additional details. key : dut val : list of intf_properties_tuple intf_properties_tuple : ( ifname, destination_dut, linkno, speed) More interface specific details shall be added to the intf_tuple as and when required Example: For the below given topology in testbed.yaml topology: DUT1: interfaces: Ethernet0: {EndDevice: DUT2, EndPort: Ethernet0, params: def_link} Ethernet4: {EndDevice: DUT2, EndPort: Ethernet4, params: def_link} Ethernet8: {EndDevice: DUT3, EndPort: Ethernet8, params: def_link} Ethernet12: {EndDevice: DUT4, EndPort: Ethernet12, params: def_link} DUT2: interfaces: Ethernet16: {EndDevice: DUT3, EndPort: Ethernet16, params: def_link} Ethernet20: {EndDevice: DUT4, EndPort: Ethernet20, params: def_link} This api will return the following dictionary. This output was captured on vsonic. topology = {'D101': [('Ethernet0', 'D102', '1', 'N/A'), ('Ethernet4', 'D102', '2', 'N/A'), ('Ethernet8', 'D103', '1', 'N/A'), ('Ethernet12', 'D104', '1', 'N/A')], 'D102': [('Ethernet0', 'D101', '1', 'N/A'), ('Ethernet4', 'D101', '2', 'N/A'), ('Ethernet16', 'D103', '1', 'N/A'), ('Ethernet20', 'D104', '1', 'N/A')], 'D103': [('Ethernet8', 'D101', '1', 'N/A'), ('Ethernet16', 'D102', '1', 'N/A')], 'D104': [('Ethernet12', 'D101', '1', 'N/A'), ('Ethernet20', 'D102', '1', 'N/A')]} """ import apis.system.interface as intf_obj sys_vars = st.ensure_min_topology(*min_req_topo) topology = {} service_string = ' -> '.join("Build topology dictionary") for key in sys_vars.keys(): port_info = re.match(r'D([\d+])([DT])([\d+])P([\d+])', key) if port_info: ifname = '' dest_dut = '' link_no = '' intf_speed = '' (src_dut_no, dst_dut_or_tg, dest_dut_no, link_no) = port_info.groups() src_dut = 'D' + str(src_dut_no) src_dut = sys_vars[src_dut] dest_dut = dst_dut_or_tg + str(dest_dut_no) if dst_dut_or_tg == 'D': dest_dut = sys_vars[dest_dut] ifname = sys_vars[key] if (not ifname) or (not ifname.startswith("Ethernet")): st.error("'{}' is not a Valid Interface name.".format(ifname)) st.report_env_fail("test_case_not_executed_s_service", service_string) intf_status = intf_obj.interface_status_show(src_dut, ifname) if not intf_status: st.error("'{}' Interface Speed not Available.".format(ifname)) st.report_env_fail("test_case_not_executed_s_service", service_string) intf_speed = intf_status[0]['speed'] topology.setdefault(src_dut, []).append( (ifname, dest_dut, link_no, intf_speed)) return topology
def ensure_service_params(dut, *argv): """ Author : Prudvi Mangadu ([email protected]) :param dut: :param argv: Service Name, follower by keys or list index. :return: How to use?: # Importing module: import utilities.utils as utils_obj # Below API call will check and get the tftp ip addresses from "sonic_services.yaml". # Also it first check weather "tftp" service is present in "sonic_services.yaml" or not , # if present then checks for "ip" and return the ip addresses. # If any of "tftp" or "ip" no present in "sonic_services.yaml" file, then test case aborted and # moved to the "NES" state " saying "Test case Not Executed(s) - Required service parameters # is not defined " tftp->ip." tftp_ip = utils_obj.ensure_service_params(dut,"tftp","ip") tftp_path = utils_obj.ensure_service_params(dut,"tftp","path") tacacs_first_server = utils_obj.ensure_service_params(dut, "tacacs", "hosts",0,"ip") tacacs_first_username = utils_obj.ensure_service_params(dut, "tacacs", "hosts",0,"username") tacacs_first_password = utils_obj.ensure_service_params(dut, "tacacs", "hosts",0,"password") tacacs_second_server = utils_obj.ensure_service_params(dut, "tacacs", "hosts",1,"ip") tacacs_second_username = utils_obj.ensure_service_params(dut, "tacacs", "hosts",1,"username") tacacs_second_password = utils_obj.ensure_service_params(dut, "tacacs", "hosts",1,"password") """ if not argv: st.error("Provide atleast one service to ensure") return None service_string = ' -> '.join([str(e) for e in argv]) st.log("Ensure service parameter(s) - {}".format(service_string)) output = st.get_service_info(dut, argv[0]) if not output: st.error("'{}' is not specified in services/default.".format(argv[0])) st.report_env_fail("test_case_not_executed_s_service", service_string) for each in argv[1:]: try: output = output[each] except KeyError as e1: st.log(e1) st.error( "Inside key '{}' : parameter {} is not specified in services/default." .format(argv[0], e1)) st.report_env_fail("test_case_not_executed_s_service", service_string) except IndexError as e2: st.log(e2) st.error( "Inside Key '{}' : list index '{}' is not specified in services/default." .format(argv[0], each)) st.report_env_fail("test_case_not_executed_s_service", service_string) except Exception as e3: st.log(e3) st.error("Service or Parm '{}' not found.".format(each)) st.report_env_fail("test_case_not_executed_s_service", service_string) st.log("Return : {}".format(output)) return output
def pre_config_ztp(): global vars global ssh_conn_obj global outofband_conn_obj global ssh_conn_obj_oob_v6 global ssh_conn_obj_inb_v6 vars = st.get_testbed_vars() # DHCPV4 out of band params ztp_params.dhcp.ip = utils_obj.ensure_service_params(vars.D1, "ztp", "dhcp", "outofband", "ip") ztp_params.dhcp.username = utils_obj.ensure_service_params(vars.D1, "ztp", "dhcp", "outofband", "username") ztp_params.dhcp.password = utils_obj.ensure_service_params(vars.D1, "ztp", "dhcp", "outofband", "password") ztp_params.oob_port = utils_obj.ensure_service_params(vars.D1, "ztp", "dhcp", "outofband", "interface") # DHCPV4 in band params ztp_params.dhcp.inband_ip = utils_obj.ensure_service_params(vars.D1, "ztp", "dhcp", "inband", "ip") ztp_params.dhcp.inband_username = utils_obj.ensure_service_params(vars.D1, "ztp", "dhcp", "inband", "username") ztp_params.dhcp.inband_password = utils_obj.ensure_service_params(vars.D1, "ztp", "dhcp", "inband", "password") ztp_params.dhcp.inband_config_file = utils_obj.ensure_service_params(vars.D1, "ztp", "dhcp", "inband", "config_file") ztp_params.dhcp.inband_static_ip = utils_obj.ensure_service_params(vars.D1, "ztp", "dhcp", "inband", "static_ip") ztp_params.inband_port = utils_obj.ensure_service_params(vars.D1, "ztp", "dhcp", "inband", "interface") ztp_params.config_path = utils_obj.ensure_service_params(vars.D1, "ztp", "config_path") ztp_params.firmware_path = utils_obj.ensure_service_params(vars.D1, "ztp", "firmware_path") ztp_params.home_path = utils_obj.ensure_service_params(vars.D1, "ztp", "dhcp", "inband", "home_path") ztp_params.port = utils_obj.ensure_service_params(vars.D1, "ztp", "dhcp", "inband", "port") ztp_params.build_file_name = utils_obj.ensure_service_params(vars.D1, "ztp", "build_file_name") ztp_params.uninstall_image = utils_obj.ensure_service_params(vars.D1, "ztp", "uninstall_image") ztp_params.dut_path = utils_obj.ensure_service_params(vars.D1, "ztp", "dut_path") ztp_params.ztp_cfg_file_name = utils_obj.ensure_service_params(vars.D1, "ztp", "ztp_cfg_file_name") ztp_params.provision_script_path = utils_obj.ensure_service_params(vars.D1, "ztp", "provision_script_path") ztp_params.docker_path = utils_obj.ensure_service_params(vars.D1, "ztp", "docker_path") ztp_params.docker_image = utils_obj.ensure_service_params(vars.D1, "ztp", "docker_image") ztp_params.docker_component_name = utils_obj.ensure_service_params(vars.D1, "ztp", "docker_component_name") ztp_params.inband_port = utils_obj.ensure_service_params(vars.D1, "ztp", "dhcp", "inband", "interface") ztp_params.minigraph_file = utils_obj.ensure_service_params(vars.D1, "ztp", "minigraph_file") ztp_params.xml_path = utils_obj.ensure_service_params(vars.D1, "ztp", "xml_path") # DHCPV6 out of band params ztp_params.dhcp6.ip = utils_obj.ensure_service_params(vars.D1, "ztp", "dhcpv6", "outofband", "ip") ztp_params.dhcp6.username = utils_obj.ensure_service_params(vars.D1, "ztp", "dhcpv6", "outofband", "username") ztp_params.dhcp6.password = utils_obj.ensure_service_params(vars.D1, "ztp", "dhcpv6", "outofband", "password") ztp_params.dhcp6.oob_port = utils_obj.ensure_service_params(vars.D1, "ztp", "dhcpv6", "outofband", "interface") ztp_params.dhcp6.oob_static_ip = utils_obj.ensure_service_params(vars.D1, "ztp", "dhcpv6", "outofband", "static_ip") # DHCPV6 IN band params ztp_params.dhcp6.inband_ip = utils_obj.ensure_service_params(vars.D1, "ztp", "dhcpv6", "inband", "ip") ztp_params.dhcp6.inband_username = utils_obj.ensure_service_params(vars.D1, "ztp", "dhcpv6", "inband", "username") ztp_params.dhcp6.inband_password = utils_obj.ensure_service_params(vars.D1, "ztp", "dhcpv6", "inband", "password") ztp_params.dhcp6.inband_static_ip = utils_obj.ensure_service_params(vars.D1, "ztp", "dhcpv6", "inband", "static_ip") ztp_params.dhcp6.inband_port = utils_obj.ensure_service_params(vars.D1, "ztp", "dhcpv6", "inband", "interface") ztp_params.dhcp.inband_v4_subnet = utils_obj.ensure_service_params(vars.D1, "ztp", "dhcp", "inband", "subnet") ztp_params.dhcp.oob_v4_subnet= utils_obj.ensure_service_params(vars.D1, "ztp", "dhcp", "outofband", "subnet") ztp_params.dhcp6.inband_v6_subnet = utils_obj.ensure_service_params(vars.D1, "ztp", "dhcpv6", "inband", "subnet") ztp_params.dhcp6.oob_v6_subnet = utils_obj.ensure_service_params(vars.D1, "ztp", "dhcpv6", "outofband", "subnet") ztp_params.dhcp.client_ip_inband = utils_obj.ensure_service_params(vars.D1, "ztp", "dhcp", "inband", "client_ip") ztp_params.breakout = utils_obj.ensure_service_params(vars.D1, "ztp", "breakout") ztp_params.cli_type = st.get_ui_type(vars.D1) st.log("Clearing V4/V6 lease database from DUT ...") basic_obj.delete_directory_contents(vars.D1, config_params.lease_db_path) st.log("################# Logging in to DHCPV4 server ---- IN BAND ...#################") ssh_conn_obj = con_obj.connect_to_device(ztp_params.dhcp.inband_ip, ztp_params.dhcp.inband_username, ztp_params.dhcp.inband_password) if not ssh_conn_obj: st.error("SSH connetion object not found for DHCPV4 server IN BAND.") reset_module_config() st.report_env_fail("ssh_connection_failed", ztp_params.dhcp.inband_ip) st.log("########Restarting DHCPV4 service##########") basic_obj.service_operations(ssh_conn_obj, config_params.dhcp_service_name, "restart", "server") st.log("########Verifying DHCPV4 service status##########") if not ztp_obj.verify_dhcpd_service_status(ssh_conn_obj, config_params.dhcpd_pid): st.log("{} service is not running ".format(config_params.dhcp_service_name)) reset_module_config() st.report_fail("service_running_not_expected", config_params.dhcp_service_name) st.log("################# Logging in to DHCPV4 server ---- OUT OF BAND ... #################") outofband_conn_obj = con_obj.connect_to_device(ztp_params.dhcp.ip, ztp_params.dhcp.username, ztp_params.dhcp.password) if not outofband_conn_obj: st.error("OUT OF BAND SSH connetion object not found.") else: basic_obj.service_operations(outofband_conn_obj, config_params.dhcp_service_name, "stop", "server") if ztp_obj.verify_dhcpd_service_status(outofband_conn_obj, config_params.dhcpd_pid): st.log("{} service is running which is not expected".format(config_params.dhcp_service_name)) reset_module_config() st.report_fail("service_running_not_expected", config_params.dhcp_service_name) # st.report_env_fail("ssh_connection_failed", ztp_params.dhcp.ip) st.log("################# Logging in to DHCPV6 server -- OUT OF BAND ... #################") ssh_conn_obj_oob_v6 = con_obj.connect_to_device(ztp_params.dhcp6.ip, ztp_params.dhcp6.username, ztp_params.dhcp6.password) if not ssh_conn_obj_oob_v6: st.error("SSH connection object not found for DHCPV6 server OUT OF BAND.") st.log("################# Logging in to DHCPV6 server ---- IN BAND ... ##################") ssh_conn_obj_inb_v6 = con_obj.connect_to_device(ztp_params.dhcp6.inband_ip, ztp_params.dhcp6.inband_username, ztp_params.dhcp6.inband_password) if not ssh_conn_obj_inb_v6: st.error("SSH connection object not found for DHCPV6 server IN BAND.") st.log("Stopping V4/V6 services to avoid the DHCP option conflict .. ") v6_connection_objs = [ssh_conn_obj_inb_v6, ssh_conn_obj_oob_v6] for connection_obj in v6_connection_objs: if connection_obj: basic_obj.service_operations(connection_obj, config_params.dhcp6_service_name, "stop", "server") if ztp_obj.verify_dhcpd_service_status(connection_obj, config_params.dhcpd6_pid): st.log("{} service is running which is not expected".format(config_params.dhcp6_service_name)) reset_module_config() st.report_fail("service_running_not_expected", config_params.dhcp6_service_name) basic_obj.poll_for_system_status(vars.D1) st.log("Shutting down the out of band interface ...") basic_obj.ifconfig_operation(vars.D1, ztp_params.oob_port, "down") ztp_cfg = {"admin-mode": True, "restart-ztp-interval": 30, "feat-console-logging": feat_logging_console} ztp_obj.config_ztp_backdoor_options(vars.D1, ztp_cfg)
def pre_config_ztp(): global vars global ssh_conn_obj_oob_v6 global ssh_conn_obj global ssh_conn_obj_oob_v4 global ssh_conn_obj_inb_v4 global ssh_conn_obj_inb_v6 vars = st.get_testbed_vars() # DHCPV6 out of band params ztp_params.dhcp6.ip = utils_obj.ensure_service_params( vars.D1, "ztp", "dhcpv6", "outofband", "ip") ztp_params.dhcp6.username = utils_obj.ensure_service_params( vars.D1, "ztp", "dhcpv6", "outofband", "username") ztp_params.dhcp6.password = utils_obj.ensure_service_params( vars.D1, "ztp", "dhcpv6", "outofband", "password") ztp_params.dhcp6.oob_port = utils_obj.ensure_service_params( vars.D1, "ztp", "dhcpv6", "outofband", "interface") ztp_params.dhcp6.oob_static_ip = utils_obj.ensure_service_params( vars.D1, "ztp", "dhcpv6", "outofband", "static_ip") # DHCPV4 out of band params ztp_params.dhcp.ip = utils_obj.ensure_service_params( vars.D1, "ztp", "dhcp", "outofband", "ip") ztp_params.dhcp.username = utils_obj.ensure_service_params( vars.D1, "ztp", "dhcp", "outofband", "username") ztp_params.dhcp.password = utils_obj.ensure_service_params( vars.D1, "ztp", "dhcp", "outofband", "password") ztp_params.oob_port = utils_obj.ensure_service_params( vars.D1, "ztp", "dhcp", "outofband", "interface") ztp_params.static_ip = utils_obj.ensure_service_params( vars.D1, "ztp", "dhcp", "outofband", "static_ip") #DHCPV6 in band params ztp_params.dhcp6.inband_ip = utils_obj.ensure_service_params( vars.D1, "ztp", "dhcpv6", "inband", "ip") ztp_params.dhcp6.inband_username = utils_obj.ensure_service_params( vars.D1, "ztp", "dhcpv6", "inband", "username") ztp_params.dhcp6.inband_password = utils_obj.ensure_service_params( vars.D1, "ztp", "dhcpv6", "inband", "password") ztp_params.dhcp6.inband_static_ip = utils_obj.ensure_service_params( vars.D1, "ztp", "dhcpv6", "inband", "static_ip") ztp_params.dhcp6.inband_port = utils_obj.ensure_service_params( vars.D1, "ztp", "dhcpv6", "inband", "interface") # DHCPV4 in band params ztp_params.dhcp.inband_ip = utils_obj.ensure_service_params( vars.D1, "ztp", "dhcp", "inband", "ip") ztp_params.dhcp.inband_username = utils_obj.ensure_service_params( vars.D1, "ztp", "dhcp", "inband", "username") ztp_params.dhcp.inband_password = utils_obj.ensure_service_params( vars.D1, "ztp", "dhcp", "inband", "password") ztp_params.dhcp.inband_static_ip = utils_obj.ensure_service_params( vars.D1, "ztp", "dhcp", "inband", "static_ip") ztp_params.inband_port = utils_obj.ensure_service_params( vars.D1, "ztp", "dhcp", "inband", "interface") ztp_params.dhcp6.oob_config_file = utils_obj.ensure_service_params( vars.D1, "ztp", "dhcpv6", "outofband", "config_file") ztp_params.dhcp6.inband_config_file = utils_obj.ensure_service_params( vars.D1, "ztp", "dhcpv6", "inband", "config_file") ztp_params.config_path = utils_obj.ensure_service_params( vars.D1, "ztp", "config_path") ztp_params.dhcp6.oob_home_path = utils_obj.ensure_service_params( vars.D1, "ztp", "dhcpv6", "outofband", "home_path") ztp_params.dhcp6.inband_home_path = utils_obj.ensure_service_params( vars.D1, "ztp", "dhcpv6", "inband", "home_path") ztp_params.port = utils_obj.ensure_service_params(vars.D1, "ztp", "dhcp", "inband", "port") ztp_params.dut_path = utils_obj.ensure_service_params( vars.D1, "ztp", "dut_path") ztp_params.ztp_cfg_file_name = utils_obj.ensure_service_params( vars.D1, "ztp", "ztp_cfg_file_name") ztp_params.provision_script_path = utils_obj.ensure_service_params( vars.D1, "ztp", "provision_script_path") st.log("Clearing V4/V6 lease database from DUT ...") basic_obj.delete_directory_contents(vars.D1, config_params.lease_db_path) st.log("####### Connecting to DHCPV6 server -- OUT OF BAND ...###########") ssh_conn_obj_oob_v6 = con_obj.connect_to_device(ztp_params.dhcp6.ip, ztp_params.dhcp6.username, ztp_params.dhcp6.password) if not ssh_conn_obj_oob_v6: st.error( "SSH connection object not found for DHCPV6 server OUT OF BAND.") if network_flag != "inband": reset_module_config() st.report_env_fail("ssh_connection_failed", ztp_params.dhcp6.ip) st.log( "############Connecting to DHCPV4 server -- OUT OF BAND ...#############" ) ssh_conn_obj_oob_v4 = con_obj.connect_to_device(ztp_params.dhcp.ip, ztp_params.dhcp.username, ztp_params.dhcp.password) if not ssh_conn_obj_oob_v4: st.error( "SSH connection object not found for DHCPV4 server OUT OF BAND.") # st.report_env_fail("ssh_connection_failed", ztp_params.dhcp6.ip) st.log( "###########Connecting to DHCPV4 server -- IN BAND ...##############") ssh_conn_obj_inb_v4 = con_obj.connect_to_device( ztp_params.dhcp.inband_ip, ztp_params.dhcp.inband_username, ztp_params.dhcp.inband_password) if not ssh_conn_obj_inb_v4: st.error( "SSH connection object not found for DHCPV4 server OUT OF BAND.") # st.report_env_fail("ssh_connection_failed", ztp_params.dhcp6.ip) ssh_conn_obj_inb_v6 = con_obj.connect_to_device( ztp_params.dhcp6.inband_ip, ztp_params.dhcp6.inband_username, ztp_params.dhcp6.inband_password) if not ssh_conn_obj_inb_v6: st.error( "SSH connection object not found for DHCPV4 server OUT OF BAND.") if network_flag == "inband": reset_module_config() st.report_env_fail("ssh_connection_failed", ztp_params.dhcp6.inband_ip) st.log( "###########Stopping V4/V6 services to avoid the DHCP option conflict .. ###########" ) v4_connection_objs = [ssh_conn_obj_oob_v4, ssh_conn_obj_inb_v4] for connection_obj in v4_connection_objs: if connection_obj: basic_obj.service_operations(connection_obj, config_params.dhcp_service_name, "stop", "server") if ztp_obj.verify_dhcpd_service_status(connection_obj, config_params.dhcpd_pid): st.log("{} service is running which is not expected".format( config_params.dhcp_service_name)) reset_module_config() st.report_fail("service_running_not_expected", config_params.dhcp_service_name) st.log("Restarting V6 services on required server .. ") if network_flag != "inband": ssh_conn_obj = ssh_conn_obj_oob_v6 st.log("Using OUT OF BAND V6 ssh object ... ") if ssh_conn_obj_inb_v6: basic_obj.service_operations(ssh_conn_obj_inb_v6, config_params.dhcp6_service_name, "stop", "server") if ztp_obj.verify_dhcpd_service_status(ssh_conn_obj_inb_v6, config_params.dhcpd6_pid): st.log("{} service is running which is not expected".format( config_params.dhcp6_service_name)) reset_module_config() st.report_fail("service_running_not_expected", config_params.dhcp6_service_name) else: st.log("SSH object for INB V6 server is not found ...") else: st.log("Using INBAND V6 ssh object ... ") ssh_conn_obj = ssh_conn_obj_inb_v6 if ssh_conn_obj_oob_v6: basic_obj.service_operations(ssh_conn_obj_oob_v6, config_params.dhcp6_service_name, "stop", "server") if ztp_obj.verify_dhcpd_service_status(ssh_conn_obj_oob_v6, config_params.dhcpd6_pid): st.log("{} service is running which is not expected".format( config_params.dhcp6_service_name)) reset_module_config() st.report_fail("service_running_not_expected", config_params.dhcp6_service_name) else: st.log("SSH object for OOB V6 server is not found ...") basic_obj.service_operations(ssh_conn_obj, config_params.dhcp6_service_name, "restart", "server") if not ztp_obj.verify_dhcpd_service_status(ssh_conn_obj, config_params.dhcpd6_pid): st.log("{} service is not running ".format( config_params.dhcp6_service_name)) reset_module_config() st.report_fail("service_running_not_expected", config_params.dhcp6_service_name) global dhcp6_port global dhcp6_static_ip global dhcp6_home_path global dhcp6_config_file if network_flag != "inband": dhcp6_port = ztp_params.dhcp6.oob_port dhcp6_static_ip = ztp_params.dhcp6.oob_static_ip dhcp6_home_path = ztp_params.dhcp6.oob_home_path dhcp6_config_file = ztp_params.dhcp6.oob_config_file ztp_params.home_path = ztp_params.dhcp6.oob_home_path else: dhcp6_port = ztp_params.dhcp6.inband_port dhcp6_static_ip = ztp_params.dhcp6.inband_static_ip dhcp6_home_path = ztp_params.dhcp6.inband_home_path dhcp6_config_file = ztp_params.dhcp6.inband_config_file ztp_params.home_path = ztp_params.dhcp6.inband_home_path basic_obj.ifconfig_operation(vars.D1, ztp_params.dhcp6.oob_port, "down") basic_obj.poll_for_system_status(vars.D1) ztp_cfg = { "admin-mode": True, "restart-ztp-interval": 30, "feat-console-logging": feat_logging_console } ztp_obj.config_ztp_backdoor_options(vars.D1, ztp_cfg)
def pre_config_ztp(): global vars global ssh_conn_obj global inband_ssh_conn_obj global ssh_conn_obj_oob_v6 global ssh_conn_obj_inb_v6 vars = st.get_testbed_vars() # DHCPV4 out of band params ztp_params.dhcp.ip = mutils.ensure_service_params(vars.D1, "ztp", "dhcp", "outofband", "ip") ztp_params.dhcp.username = mutils.ensure_service_params( vars.D1, "ztp", "dhcp", "outofband", "username") ztp_params.dhcp.password = mutils.ensure_service_params( vars.D1, "ztp", "dhcp", "outofband", "password") ztp_params.dhcp.config_file = mutils.ensure_service_params( vars.D1, "ztp", "dhcp", "outofband", "config_file") ztp_params.dhcp.static_ip = mutils.ensure_service_params( vars.D1, "ztp", "dhcp", "outofband", "static_ip") ztp_params.oob_port = mutils.ensure_service_params(vars.D1, "ztp", "dhcp", "outofband", "interface") # DHCPV4 in band params ztp_params.dhcp.inband_ip = mutils.ensure_service_params( vars.D1, "ztp", "dhcp", "inband", "ip") ztp_params.dhcp.inband_username = mutils.ensure_service_params( vars.D1, "ztp", "dhcp", "inband", "username") ztp_params.dhcp.inband_password = mutils.ensure_service_params( vars.D1, "ztp", "dhcp", "inband", "password") ztp_params.config_path = mutils.ensure_service_params( vars.D1, "ztp", "config_path") ztp_params.firmware_path = mutils.ensure_service_params( vars.D1, "ztp", "firmware_path") ztp_params.home_path = mutils.ensure_service_params( vars.D1, "ztp", "dhcp", "outofband", "home_path") ztp_params.build_file_name = mutils.ensure_service_params( vars.D1, "ztp", "build_file_name") ztp_params.uninstall_image = mutils.ensure_service_params( vars.D1, "ztp", "uninstall_image") ztp_params.dut_path = mutils.ensure_service_params(vars.D1, "ztp", "dut_path") ztp_params.ztp_cfg_file_name = mutils.ensure_service_params( vars.D1, "ztp", "ztp_cfg_file_name") ztp_params.provision_script_path = mutils.ensure_service_params( vars.D1, "ztp", "provision_script_path") ztp_params.docker_path = mutils.ensure_service_params( vars.D1, "ztp", "docker_path") ztp_params.docker_image = mutils.ensure_service_params( vars.D1, "ztp", "docker_image") ztp_params.docker_component_name = mutils.ensure_service_params( vars.D1, "ztp", "docker_component_name") ztp_params.inband_port = mutils.ensure_service_params( vars.D1, "ztp", "dhcp", "inband", "interface") ztp_params.minigraph_file = mutils.ensure_service_params( vars.D1, "ztp", "minigraph_file") ztp_params.xml_path = mutils.ensure_service_params(vars.D1, "ztp", "xml_path") # DHCPV6 out of band params ztp_params.dhcp6.ip = mutils.ensure_service_params(vars.D1, "ztp", "dhcpv6", "outofband", "ip") ztp_params.dhcp6.username = mutils.ensure_service_params( vars.D1, "ztp", "dhcpv6", "outofband", "username") ztp_params.dhcp6.password = mutils.ensure_service_params( vars.D1, "ztp", "dhcpv6", "outofband", "password") ztp_params.dhcp6.oob_port = mutils.ensure_service_params( vars.D1, "ztp", "dhcpv6", "outofband", "interface") ztp_params.dhcp6.oob_static_ip = mutils.ensure_service_params( vars.D1, "ztp", "dhcpv6", "outofband", "static_ip") # DHCPV6 IN band params ztp_params.dhcp6.inband_ip = mutils.ensure_service_params( vars.D1, "ztp", "dhcpv6", "inband", "ip") ztp_params.dhcp6.inband_username = mutils.ensure_service_params( vars.D1, "ztp", "dhcpv6", "inband", "username") ztp_params.dhcp6.inband_password = mutils.ensure_service_params( vars.D1, "ztp", "dhcpv6", "inband", "password") ztp_params.dhcp6.inband_static_ip = mutils.ensure_service_params( vars.D1, "ztp", "dhcpv6", "inband", "static_ip") ztp_params.dhcp6.inband_port = mutils.ensure_service_params( vars.D1, "ztp", "dhcpv6", "inband", "interface") ztp_params.cli_type = st.get_ui_type(vars.D1) st.log("Clearing V4/V6 lease database from DUT ...") basic_obj.delete_directory_contents(vars.D1, config_params.lease_db_path) st.log("####### Connecting to DHCPV4 server -- OUT OF BAND ...###########") ssh_conn_obj = con_obj.connect_to_device(ztp_params.dhcp.ip, ztp_params.dhcp.username, ztp_params.dhcp.password) if not ssh_conn_obj: st.error("SSH connetion object not found.") reset_module_config() st.report_env_fail("ssh_connection_failed", ztp_params.dhcp.ip) inband_ssh_conn_obj = con_obj.connect_to_device( ztp_params.dhcp.inband_ip, ztp_params.dhcp.inband_username, ztp_params.dhcp.inband_password) if not inband_ssh_conn_obj: st.log("SSH connection to inband DHCP server is not successfull") # st.report_env_fail("ssh_connection_failed", ztp_params.dhcp.inband_ip) st.log( "############Connecting to DHCPV6 server -- OUT OF BAND ...#########") ssh_conn_obj_oob_v6 = con_obj.connect_to_device(ztp_params.dhcp6.ip, ztp_params.dhcp6.username, ztp_params.dhcp6.password) if not ssh_conn_obj_oob_v6: st.error( "SSH connection object not found for DHCPV6 server OUT OF BAND.") ssh_conn_obj_inb_v6 = con_obj.connect_to_device( ztp_params.dhcp6.inband_ip, ztp_params.dhcp6.inband_username, ztp_params.dhcp6.inband_password) if not ssh_conn_obj_inb_v6: st.error( "SSH connection object not found for DHCPV4 server OUT OF BAND.") st.log("Stopping V4/V6 services on unwanted servers .. ") v6_connection_objs = [ssh_conn_obj_inb_v6, ssh_conn_obj_oob_v6] for connection_obj in v6_connection_objs: if connection_obj: basic_obj.service_operations(connection_obj, config_params.dhcp6_service_name, "stop", "server") if ztp_obj.verify_dhcpd_service_status(connection_obj, config_params.dhcpd6_pid): st.log("{} service is running which is not expected".format( config_params.dhcp6_service_name)) reset_module_config() st.report_fail("service_running_not_expected", config_params.dhcp6_service_name) basic_obj.service_operations(ssh_conn_obj, config_params.dhcp_service_name, "restart", "server") if not ztp_obj.verify_dhcpd_service_status(ssh_conn_obj, config_params.dhcpd_pid): st.log("{} service is not running ".format( config_params.dhcp_service_name)) reset_module_config() st.report_fail("service_running_not_expected", config_params.dhcp_service_name) st.wait(5) if not basic_obj.check_interface_status(vars.D1, ztp_params.oob_port, "up"): basic_obj.ifconfig_operation(vars.D1, ztp_params.oob_port, "up") intf_obj.enable_dhcp_on_interface(vars.D1, ztp_params.oob_port) if not ip_obj.ping(vars.D1, ztp_params.dhcp.static_ip): st.log( "Pinging to DHCP server failed from DUT, issue either with DUT or server" ) reset_module_config() st.report_fail("ping_fail", ztp_params.dhcp.static_ip) ztp_cfg = { "admin-mode": True, "restart-ztp-interval": 30, "feat-console-logging": feat_logging_console } ztp_obj.config_ztp_backdoor_options(vars.D1, ztp_cfg) lines = basic_obj.get_number_of_lines_in_file(ssh_conn_obj, ztp_params.dhcp.config_file) st.log("###########LINES -- {}##############".format(lines))
def test_ft_ssh_add_user_verify(): """ Author : Prudvi Mangadu ([email protected]) """ user_ssh = 0 acl_sshv4 = 0 acl_sshv6 = 0 acl_snmp = 0 if not snmp_config(config='add'): acl_snmp = +1 ipaddress = st.get_mgmt_ip(vars.D1) if not ipaddress: st.report_env_fail("ip_verification_fail") snmp_cmd = "snmpget -Oqv -v 2c -c {} {} {}".format(ssh_data.ro_community, ipaddress, ssh_data.oid_sysName) out = config_nondefault_user() if not out: user_ssh = +1 st.log("connecting to device with username={},password={}".format( ssh_data.usr_default, ssh_data.pwd_final)) if not st.exec_ssh(vars.D1, ssh_data.usr_default, ssh_data.pwd_final, ssh_data.commands_to_verify): st.error('Cannot SSH into Device with default credentials') user_ssh = +1 st.log('connecting to device with username={},password={}'.format( ssh_data.usr_non_default, ssh_data.pwd_non_default)) if not st.exec_ssh(vars.D1, ssh_data.usr_non_default, ssh_data.pwd_non_default, ssh_data.commands_to_verify): st.error('Cannot SSH into Device with non-default credentials') user_ssh = +1 output = verify_ssh_connection(vars.D2, ssh_data.ipv4_address_D1D2P2, ssh_data.usr_default, ssh_data.pwd_final) if not output: user_ssh = +1 IPAddr = ensure_service_params(vars.D1, "snmptrap", "ip") + "/32" change_acl_rules(acl_data.acl_json_config_control_plane, "SNMP_SSH|RULE_1", "SRC_IP", IPAddr) change_acl_rules(acl_data.acl_json_config_control_plane, "SNMP_SSH|RULE_2", "SRC_IP", IPAddr) change_acl_rules(acl_data.acl_json_config_control_plane, "SNMP_SSH|RULE_3", "SRC_IP", ssh_data.ipv4_network) change_acl_rules(acl_data.acl_json_config_control_plane, "V6_SSH_ONLY|RULE_1", "SRC_IPV6", ssh_data.ipv6_network_D1) acl_config = acl_data.acl_json_config_control_plane st.log("ACL_DATA: {}".format(acl_config)) acl_obj.apply_acl_config(vars.D1, acl_config) acl_obj.show_acl_table(vars.D1) acl_obj.show_acl_rule(vars.D1) if not poll_wait(acl_obj.verify_acl_table_rule, 5, vars.D1, "SNMP_SSH", "RULE_1"): st.error("Failed to create ACL rule '{}' ".format("SNMP_SSH")) acl_snmp = +1 if not poll_wait(acl_obj.verify_acl_table_rule, 5, vars.D1, "SNMP_SSH", "RULE_2"): st.error("Failed to create ACL rule '{}' ".format("SNMP_SSH")) acl_sshv4 = +1 if not poll_wait(acl_obj.verify_acl_table_rule, 5, vars.D1, "V6_SSH_ONLY", "RULE_1"): st.error("Failed to create ACL rule '{}' ".format("V6_SSH_ONLY")) acl_sshv6 = +1 hostname = get_hostname(vars.D1) st.log("HOSTNAME: {}".format(hostname)) snmp_out = execute_command(ssh_conn_obj, snmp_cmd) if hostname not in snmp_out: st.error("SNMP walk operation is failed") acl_snmp = +1 st.log("connecting to device with default username={},password={}".format( ssh_data.usr_default, ssh_data.pwd_final)) output = verify_ssh_connection(vars.D2, ssh_data.ipv4_address_D1D2P2, ssh_data.usr_default, ssh_data.pwd_final) if output: acl_sshv4 = +1 output = verify_ssh_connection(vars.D2, ssh_data.ipv6_address_D1D2P2, ssh_data.usr_default, ssh_data.pwd_final) if output: acl_sshv6 = +1 output = verify_ssh_connection(vars.D2, ssh_data.ipv4_address_D1D2P1, ssh_data.usr_default, ssh_data.pwd_final) if not output: acl_sshv4 = +1 output = verify_ssh_connection(vars.D2, ssh_data.ipv6_address_D1D2P1, ssh_data.usr_default, ssh_data.pwd_final) if not output: acl_sshv6 = +1 st.log( "connecting to device with non default username={},password={}".format( ssh_data.usr_non_default, ssh_data.pwd_non_default)) output = verify_ssh_connection(vars.D2, ssh_data.ipv4_address_D1D2P1, ssh_data.usr_non_default, ssh_data.pwd_non_default) if not output: acl_sshv4 = +1 output = verify_ssh_connection(vars.D2, ssh_data.ipv6_address_D1D2P1, ssh_data.usr_non_default, ssh_data.pwd_non_default) if not output: acl_sshv6 = +1 config_save(vars.D1) st.log('rebooting the device.') st.reboot(vars.D1, 'fast') acl_obj.show_acl_table(vars.D1) acl_obj.show_acl_rule(vars.D1) if not poll_wait(acl_obj.verify_acl_table_rule, 5, vars.D1, "SNMP_SSH", "RULE_2"): st.log("Failed to create ACL rule '{}' ".format("SSH_SSH")) acl_sshv4 = +1 if not poll_wait(acl_obj.verify_acl_table_rule, 5, vars.D1, "V6_SSH_ONLY", "RULE_1"): st.log("Failed to create ACL rule '{}' ".format("V6_SSH_ONLY")) acl_sshv4 = +1 if not poll_wait(acl_obj.verify_acl_table_rule, 5, vars.D1, "SNMP_SSH", "RULE_1"): st.error("Failed to create ACL rule '{}' ".format("SNMP_SSH")) acl_snmp = +1 ipaddress = st.get_mgmt_ip(vars.D1) if not ipaddress or not ip_obj.ping(vars.D1, IPAddr.strip('/32')): st.error( "Ping to SNMP server or getting ip address to the dut is failed after reload" ) acl_obj.acl_delete(vars.D1) config_nondefault_user(config='remove') st.report_fail("ip_verification_fail") snmp_cmd = "snmpget -Oqv -v 2c -c {} {} {}".format(ssh_data.ro_community, ipaddress, ssh_data.oid_sysName) hostname = get_hostname(vars.D1) snmp_out = execute_command(ssh_conn_obj, snmp_cmd) if hostname not in snmp_out: st.error("SNMP walk operation is failed after reload") acl_snmp = +1 st.log('Verifying SNMP ACL with invalid source address') change_acl_rules(acl_data.acl_json_config_control_plane, "SNMP_SSH|RULE_1", "SRC_IP", "2.2.2.0/24") acl_config = acl_data.acl_json_config_control_plane acl_obj.acl_delete(vars.D1) acl_obj.apply_acl_config(vars.D1, acl_config) st.wait(3, "Waiting to apply acl rules") snmp_out = execute_command(ssh_conn_obj, snmp_cmd) if "Timeout" not in snmp_out: acl_snmp = +1 st.log("connecting to device with default username={},password={}".format( ssh_data.usr_default, ssh_data.pwd_final)) output = verify_ssh_connection(vars.D2, ssh_data.ipv4_address_D1D2P2, ssh_data.usr_default, ssh_data.pwd_final) if output: acl_sshv4 = +1 output = verify_ssh_connection(vars.D2, ssh_data.ipv6_address_D1D2P2, ssh_data.usr_default, ssh_data.pwd_final) if output: acl_sshv6 = +1 output = verify_ssh_connection(vars.D2, ssh_data.ipv4_address_D1D2P1, ssh_data.usr_default, ssh_data.pwd_final) if not output: acl_sshv4 = +1 output = verify_ssh_connection(vars.D2, ssh_data.ipv6_address_D1D2P1, ssh_data.usr_default, ssh_data.pwd_final) if not output: acl_sshv6 = +1 if acl_sshv4: st.report_tc_fail("test_ft_controlplane_acl_service_sshv4", "ssh_failed", "with control plane ACL service SSHv4 after reboot") else: st.report_tc_pass("test_ft_controlplane_acl_service_sshv4", "ssh_failed", "with control plane ACL service SSHv4 after reboot") if acl_sshv6: st.report_tc_fail("test_ft_controlplane_acl_service_sshv6", "ssh_failed", "with control plane ACL service SSHv6 after reboot") else: st.report_tc_pass("test_ft_controlplane_acl_service_sshv6", "ssh_failed", "with control plane ACL service SSHv6 after reboot") if acl_snmp: st.report_tc_fail("test_ft_controlplane_acl_service_snmp", "snmp_output_failed", "with control plane ACL service SNMP after reboot") else: st.report_tc_pass("test_ft_controlplane_acl_service_snmp", "snmp_output_failed", "with control plane ACL service SNMP after reboot") acl_obj.acl_delete(vars.D1) if acl_sshv4 or acl_sshv6 or acl_snmp: st.generate_tech_support(vars.D1, "controlplane_acl_services_after_reboot") st.log('Verifying SSH connection after removing control plane ACLs') st.log("connecting to device with username={},password={}".format( ssh_data.usr_default, ssh_data.pwd_final)) if not st.exec_ssh(vars.D1, ssh_data.usr_default, ssh_data.pwd_final, ssh_data.commands_to_verify): st.error( 'Cannot SSH into Device with default credentials after reboot') user_ssh = +1 st.log('connecting to device with username={},password={}'.format( ssh_data.usr_non_default, ssh_data.pwd_non_default)) if not st.exec_ssh(vars.D1, ssh_data.usr_non_default, ssh_data.pwd_non_default, ssh_data.commands_to_verify): st.error( 'Cannot SSH into Device with non-default credentials after reboot') user_ssh = +1 config_nondefault_user(config='remove') if (user_ssh or acl_snmp or acl_sshv4 or acl_sshv6): st.report_fail("test_case_failed") st.report_pass("test_case_passed")
def initialize_topology(): # code for ensuring min topology vars = st.ensure_min_topology('D1D2:2', 'D1D3:0', 'D1D4:2', 'D3D4:2', 'D3D2:2', 'D2D4:0') data.my_dut_list = st.get_dut_names() data.d1 = data.my_dut_list[0] data.d2 = data.my_dut_list[1] data.d3 = data.my_dut_list[2] data.d4 = data.my_dut_list[3] data.d1_d2_intf_1 = vars.D1D2P1 data.d2_d1_intf_1 = vars.D2D1P1 data.d1_d2_intf_2 = vars.D1D2P2 data.d2_d1_intf_2 = vars.D2D1P2 data.d1_d4_intf_1 = vars.D1D4P1 data.d4_d1_intf_1 = vars.D4D1P1 data.d1_d4_intf_2 = vars.D1D4P2 data.d4_d1_intf_2 = vars.D4D1P2 data.d3_d4_intf_1 = vars.D3D4P1 data.d4_d3_intf_1 = vars.D4D3P1 data.d3_d4_intf_2 = vars.D3D4P2 data.d4_d3_intf_2 = vars.D4D3P2 data.d3_d2_intf_1 = vars.D3D2P1 data.d2_d3_intf_1 = vars.D2D3P1 data.d3_d2_intf_2 = vars.D3D2P2 data.d2_d3_intf_2 = vars.D2D3P2 data.wait = 120 def f1(): ip = loc_lib.get_dut_ip(data.d1) return ip def f2(): ip = loc_lib.get_dut_ip(data.d2) return ip def f3(): ip = loc_lib.get_dut_ip(data.d3) return ip def f4(): ip = loc_lib.get_dut_ip(data.d4) return ip [res, _] = putils.exec_all(True, [[f1], [f2], [f3], [f4]]) data.d1_ip = res[0] data.d2_ip = res[1] data.d3_ip = res[2] data.d4_ip = res[3] data.role_path = os.path.join(os.path.dirname(__file__), data.role_dir) st.log('#####################{}'.format(data.role_path)) chef_param_list = [ 'ip', 'username', 'password', 'cookbook_path', 'path', 'client_path', 'validation_file', 'client_rb', 'client_log', 'user_home_folder' ] for chef_param in chef_param_list: chef_server[chef_param] = mutils.ensure_service_params( data.d1, chef_server.name, chef_param) chef_server.url = "https://{}:443".format(chef_server.ip) st.log("Chef server url used : {}".format(chef_server.url)) st.log("Logging in to chef server with the params from config file.") chef_server.ssh_obj = con_obj.connect_to_device(chef_server.ip, chef_server.username, chef_server.password) if not chef_server.ssh_obj: st.error("SSH connetion object not found.") st.report_env_fail("ssh_connection_failed", chef_server.ip) for key, value in data.items(): st.log('{} - {}'.format(key, value))