def test_ft_lldp_docker_restart():
"""
Author : Karthikeya Kumar CH<*****@*****.**>
Verify the LLDP functionality after docker restart.
Reference Test Bed : D1 <--2--> D2
"""
st.log("Checking the LLDP functionality with docker restart")
service_name = "lldp"
basic_obj.service_operations_by_systemctl(vars.D1, service_name, 'stop')
basic_obj.service_operations_by_systemctl(vars.D1, service_name, 'restart')
if not basic_obj.poll_for_system_status(vars.D1, service_name, 30, 1):
st.report_fail("service_not_running", service_name)
if not basic_obj.verify_service_status(vars.D1, service_name):
st.report_fail("lldp_service_not_up")
if not intf_obj.poll_for_interfaces(vars.D1, iteration_count=30, delay=1):
st.report_fail("interfaces_not_up_after_poll")
if not lldp_obj.poll_lldp_neighbors(
vars.D1, iteration_count=30, delay=1, interface=vars.D1D2P1):
st.report_fail("lldp_neighbors_info_not_found_after_poll")
lldp_info = lldp_obj.get_lldp_neighbors(vars.D1, interface=vars.D1D2P1)
if not lldp_info:
st.error("No lldp entries are available")
st.report_fail("operation_failed")
lldp_value_dut1 = lldp_info[0]
lldp_output_dut1 = lldp_value_dut1['chassis_name']
hostname_cli_output = basic_obj.get_hostname(vars.D2)
if lldp_output_dut1 != hostname_cli_output:
st.report_fail("lldp_cli_not_matching")
st.log("LLDP and CLI output values are : LLDP:{} , CLI:{} ".format(
lldp_output_dut1, hostname_cli_output))
st.report_pass("test_case_passed")
def test_ft_snmp_sysName():
"""
Author : Karthikeya Kumar CH<*****@*****.**>
Verify that the sysName MIB object functions properly.
Reference Test Bed : D1 --- Mgmt Network
"""
st.log("Ensuring minimum topology")
hostname = basic_obj.get_hostname(vars.D1)
get_snmp_output = snmp_obj.get_snmp_operation(
ipaddress=ipaddress,
oid=data.oid_sysName,
community_name=data.ro_community)
st.log("hostname Device('{}') and SNMP('{}')".format(
hostname, get_snmp_output[0]))
if not get_snmp_output[0] == hostname:
st.report_fail("sysName_verification_fail")
st.report_pass("test_case_passed")
def test_ft_snmp_docker_restart():
"""
Author : Karthikeya Kumar CH<*****@*****.**>
Verify that the sysName MIB object functions properly after docker restart
Reference Test Bed : D1--- Mgmt Network
"""
basic_obj.service_operations_by_systemctl(vars.D1, 'snmp', 'restart')
if not basic_obj.poll_for_system_status(vars.D1, 'snmp', 30, 1):
st.report_fail("service_not_running".format('snmp'))
if not basic_obj.verify_service_status(vars.D1, 'snmp'):
st.report_fail("snmp_service_not_up")
hostname = basic_obj.get_hostname(vars.D1)
get_snmp_output = snmp_obj.get_snmp_operation(
ipaddress=ipaddress,
oid=data.oid_sysName,
community_name=data.ro_community)
st.log("hostname Device('{}') and SNMP('{}')".format(
hostname, get_snmp_output[0]))
if not get_snmp_output[0] == hostname:
st.report_fail("sysName_verification_fail_after_docker_restart")
st.report_pass("test_case_passed")
def ansible_st_module_hooks(request):
global dut_dict, dut_ip_dict, host_name_dict, host_name_dict1
dut_dict, dut_ip_dict, host_name_dict, host_name_dict1 = {}, {}, {}, {}
st.ensure_min_topology("D1T1:2")
dut_list = st.get_dut_names()
for index in range(len(dut_list)):
dut_name = "dut" + str(index)
dut_dict[dut_name] = dut_list[index]
dut = dut_list[index]
st.log("get host name from DUTs")
host_name = basic.get_hostname(dut)
host_name_dict[dut_name] = host_name
dut_ip_dict[dut_name] = st.get_mgmt_ip(dut)
new_host_name = "dut" + str(index) + str(index) + str(index)
host_name_dict1[dut_name] = new_host_name
st.log("create new host name in DUTs")
basic.set_hostname(dut,host_name_dict1[dut_name])
yield
st.log("revert host name in DUTs")
for key in dut_dict.keys():
basic.set_hostname(dut_dict[key], host_name_dict[key])
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 chef_func_hooks(request):
global hostname
global_vars()
chef_obj.reset_cookbook_json()
hostname = basic_obj.get_hostname(vars.D1)
yield
def test_ft_ztp_config_section_check_with_option_67(ztp_func_hooks):
# ################ Author Details ################
# Name: Chaitanya Vella
# Email: [email protected]
# ################################################
# ############## Test bed details ################
# D1 ---- DHCP Server
# ft_ztp_config_section_check_with_option_67 : This test function cover over 18 scenarios using option 67
# #################################################
vars = st.ensure_min_topology("D1")
hostname = basic_obj.get_hostname(vars.D1)
config_params.config_file = "ztp_plugin_conf.json"
config_params.static_ip = ztp_params.dhcp.static_ip
config_params.config_path = ztp_params.config_path
config_params.dhcp_config_file = ztp_params.dhcp.config_file
config_params.type = "http"
config_params.dhcp_service_name = data.dhcp_service_name
config_params.action = 'restart'
config_params.device = 'server'
config_params.device_action = "run"
config_params.reboot_type = "normal"
config_params.ztp_log_path = data.ztp_log_path
config_params.file_names = [
"02-configdb-json", "03-provisioning-script", "04-connectivity-tests",
"05-test-plugin"
]
config_params.json_content = data.json_content
config_params.log_msg = "Checking configuration section {} result: SUCCESS"
config_params.ztp_log_string = "ZTP successfully completed"
config_params.option_type = "67"
config_params.result = ""
config_params.service = "disable"
config_params.config_db_path = data.config_db_path
config_params.config_db_temp = data.config_db_temp
config_params.config_file = "ztp_plugin_conf.json"
config_params.config_db_file_name = "{}_config_db.json".format(hostname)
config_params.featureconfig_file_name = "invalid_config.json"
config_params.json_config_path = "http://{}{}/".format(
ztp_params.dhcp.static_ip, ztp_params.config_path)
config_params.provision_script_path = "https://{}{}/{} -k".format(
ztp_params.dhcp.static_ip, ztp_params.provision_script_path,
data.option_239_sh_file)
config_params.ping_script_path = "http://{}{}/{}".format(
ztp_params.dhcp.static_ip, ztp_params.provision_script_path,
data.ping_script_file)
config_params.config_db_url = "http://{}{}/{}".format(
ztp_params.dhcp.static_ip, ztp_params.config_path,
config_params.config_db_file_name)
data.feature_config_url = "http://{}{}/{}".format(
ztp_params.dhcp.static_ip, ztp_params.config_path,
config_params.featureconfig_file_name)
config_params.json_content = {
"ztp": {
"02-configdb-json": {
"dynamic-url": {
"source": {
"prefix": config_params.json_config_path,
"identifier": "hostname",
"suffix": "_config_db.json"
},
"destination": "/etc/sonic/config_db.json"
}
},
"03-provisioning-script": {
"plugin": {
"url": config_params.provision_script_path
}
},
"04-connectivity-tests": {
"plugin": {
"url": config_params.ping_script_path
}
},
"05-test-plugin": {
"message": "Test-Plugin-Test",
"message-file": "/home/admin/test-file1",
"reboot-on-success": True
},
"06-snmp": {
"community-ro": "sonic",
"snmp-location": "Hyderabad",
"snmp-syscontact": "admin",
"ignore-result": "true",
"restart-agent": True
},
"07-configdb-json": {
"url": {
"source": data.feature_config_url,
"timeout": 300
},
"clear-config": "false",
"save-config": "true",
"ignore-result": True
}
}
}
ztp_obj.config_ztp_backdoor_options(vars.D1,
ztp_cfg={
"admin-mode":
True,
"restart-ztp-interval":
30,
"log-level":
"DEBUG",
"feat-console-logging":
feat_logging_console
})
source_path = "{}{}".format(data.local_provision_scripts_folder,
data.option_239_sh_file)
destination_path = "{}{}/{}".format(ztp_params.home_path,
ztp_params.provision_script_path,
data.option_239_sh_file)
basic_obj.copy_file_from_client_to_server(ssh_conn_obj,
src_path=source_path,
dst_path=destination_path,
persist=True)
options = SpyTestDict()
options.dhcp_config_file = ztp_params.dhcp.config_file
options.server_ip = config_params.static_ip
options.config_path = ztp_params.provision_script_path
options.provision_script = data.option_239_sh_file
options.search_pattern = r'\s*option\s+provision-url\s*\S*\s*"\S+";'
options.option_string = 'option provision-url '
options.option_url = "http://{}{}/{}".format(
ztp_params.dhcp.static_ip, ztp_params.provision_script_path,
data.option_239_sh_file)
ztp_obj.write_option_to_dhcp_server(ssh_conn_obj, options)
shell_scripts = [data.ping_script_file, data.option_239_sh_file]
for shell_script in shell_scripts:
source_path = "{}{}".format(data.local_provision_scripts_folder,
shell_script)
destination_path = "{}{}/{}".format(ztp_params.home_path,
ztp_params.provision_script_path,
shell_script)
basic_obj.copy_file_from_client_to_server(ssh_conn_obj,
src_path=source_path,
dst_path=destination_path,
persist=True)
st.log(
"Preparing invalid config JSON to check the gracefull handling of ZTP ..."
)
interface_name = random.choice(st.get_free_ports(vars.D1))
vlan_list = vlan_obj.get_non_existing_vlan(vars.D1, 1)
data.config_db_content = {
"VLAN": {
"Vlan{}".format(vlan_list[0]): {
"members": [interface_name],
"vlanid": vlan_list[0]
}
},
"VLAN_MEMBER": {
"Vlan{}|{}".format(vlan_list[0], interface_name): {
"tagging_mode": "tagged"
}
}
}
file_path = basic_obj.write_to_json_file(data.config_db_content)
destination_path = "{}{}/{}".format(ztp_params.home_path,
ztp_params.config_path,
config_params.featureconfig_file_name)
basic_obj.copy_file_from_client_to_server(ssh_conn_obj,
src_path=file_path,
dst_path=destination_path)
ztp_obj.config_and_verify_dhcp_option(ssh_conn_obj,
vars.D1,
ztp_params,
config_params,
expect_reboot=True,
reboot_on_success=["05-test-plugin"])
# if ztp_params.cli_type == "click":
# st.log("Verifying the ZTP DEBUG logs ..")
# ztp_log_string = "DEBUG sonic-ztp"
# st.log(st.log(ztp_log_string))
# if not basic_obj.poll_for_error_logs(vars.D1, data.ztp_log_path, ztp_log_string):
# if not basic_obj.poll_for_error_logs(vars.D1, data.syslog_path, ztp_log_string):
# st.log("ZTP log {} verification failed for message {}".format(data.ztp_log_path, ztp_log_string))
# st.report_fail("ztp_log_verification_failed", data.ztp_log_path, ztp_log_string)
ztp_status = ztp_obj.show_ztp_status(vars.D1)
if "dhcp-opt67" not in ztp_status["source"]:
st.log(
"ZTP source verification failed with {} against dhcp-opt67".format(
ztp_status["source"]))
st.report_fail("ztp_source_verification_failed", "dhcp-opt67",
ztp_status["source"])
st.log("Verifying the ZTP plugin chronological order ..")
if not ztp_obj.verify_plugin_chronological_order(vars.D1):
st.report_fail("ztp_chronoloigical_verification_failed")
st.log("Verifying ZTP admin disable operation ..")
if not ztp_obj.verify_dhclient_on_interface(vars.D1, "/sbin/dhclient",
ztp_params.oob_port):
st.report_fail("ztp_dhclient_error")
ztp_status = ztp_obj.show_ztp_status(vars.D1)
ztp_obj.ztp_operations(vars.D1, "disable")
if not ztp_obj.verify_ztp_attributes(vars.D1, "adminmode", "False"):
st.log("ZTP status verification failed")
st.report_fail("ztp_status_verification_failed")
ztp_status_after_disable = ztp_obj.show_ztp_status(vars.D1)
if ztp_status["status"] != ztp_status_after_disable["status"]:
st.log("ZTP status verification failed")
st.report_fail("ztp_status_verification_failed")
snmp_params = {"rocommunityv6": "sonic", "rocommunity": "sonic"}
if not verify_snmp_details_using_docker(vars.D1, **snmp_params):
st.report_fail("snmp_params_verification_failed")
snmp_params = {"syslocation": "Hyderabad"}
if not verify_snmp_details_using_docker(vars.D1, **snmp_params):
st.report_fail("snmp_params_verification_failed")
snmp_params = {"syscontact": "admin"}
if not verify_snmp_details_using_docker(vars.D1, **snmp_params):
st.report_fail("snmp_params_verification_failed")
st.report_pass("test_case_passed")
def test_ft_ztp_restart_no_config(ztp_func_hooks):
# ################ Author Details ################
# Name: Chaitanya Vella
# Email: [email protected]
# ################################################
# ############## Test bed details ################
# D1 ---- DHCP Server
# ft_ztp_restart_no_config : Verify that SONiC ZTP is successful even though we have not pushed config db json
# with and without ""restart-ztp-no-config": false" attribute in ztp.json
# YET TO BE DONE #
# #################################################
vars = st.ensure_min_topology("D1")
hostname = basic_obj.get_hostname(vars.D1)
config_params.config_file = "ztp_restart_no_config.json"
config_params.static_ip = ztp_params.dhcp.static_ip
config_params.config_path = ztp_params.config_path
config_params.dhcp_config_file = ztp_params.dhcp.config_file
config_params.type = "http"
config_params.dhcp_service_name = data.dhcp_service_name
config_params.action = 'restart'
config_params.device = 'server'
config_params.device_action = "reboot"
config_params.reboot_type = "normal"
config_params.ztp_log_path = data.ztp_log_path
config_params.file_names = [
"03-provisioning-script", "04-connectivity-tests"
]
config_params.json_content = data.json_content
config_params.log_msg = "Checking configuration section {} result: SUCCESS"
config_params.ztp_log_string = "ZTP successfully completed"
config_params.option_type = "67"
config_params.config_db_path = data.config_db_path
config_params.config_db_temp = data.config_db_temp
config_params.config_db_file_name = "{}_config_db.json".format(hostname)
config_params.json_config_path = "http://{}{}/".format(
ztp_params.dhcp.static_ip, ztp_params.config_path)
config_params.provision_script_path = "http://{}{}/{}".format(
ztp_params.dhcp.static_ip, ztp_params.provision_script_path,
data.option_239_sh_file)
config_params.ping_script_path = "http://{}{}/{}".format(
ztp_params.dhcp.static_ip, ztp_params.provision_script_path,
data.ping_script_file)
config_params.config_db_url = "http://{}{}/{}".format(
ztp_params.dhcp.static_ip, ztp_params.config_path,
config_params.config_db_file_name)
config_params.json_content = {
"ztp": {
"03-provisioning-script": {
"plugin": {
"url": config_params.provision_script_path
}
},
"04-connectivity-tests": {
"plugin": {
"url": config_params.ping_script_path
}
},
"restart-ztp-no-config": False
}
}
ztp_obj.ztp_operations(vars.D1, "disable")
if not ztp_obj.verify_ztp_attributes(vars.D1, "adminmode", "False"):
st.log("ZTP status verification failed")
st.report_fail("ztp_status_verification_failed")
st.reboot(vars.D1)
if not ztp_obj.verify_ztp_attributes(vars.D1, "adminmode", "False"):
st.log("ZTP status verification failed")
st.report_fail("ztp_status_verification_failed")
ztp_obj.enable_ztp_if_disabled(vars.D1)
if ztp_obj.verify_ztp_attributes(vars.D1, "adminmode", "False"):
st.log("ZTP status verification failed")
st.report_fail("ztp_status_verification_failed")
shell_scripts = [data.ping_script_file, data.option_239_sh_file]
for shell_script in shell_scripts:
source_path = "{}{}".format(data.local_provision_scripts_folder,
shell_script)
destination_path = "{}{}/{}".format(ztp_params.home_path,
ztp_params.provision_script_path,
shell_script)
basic_obj.copy_file_from_client_to_server(ssh_conn_obj,
src_path=source_path,
dst_path=destination_path,
persist=True)
ztp_obj.config_and_verify_dhcp_option(ssh_conn_obj, vars.D1, ztp_params,
config_params)
