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))
