def find_prompt(dut_name, username, pwd, ssh_obj, delay_factor=1):
try:
ssh_obj.clear_cached_read_data()
rv = super(sonic_obj.SonicBaseConnection,
ssh_obj).find_prompt(delay_factor)
rv = re.escape(rv)
ssh_obj.clear_cached_read_data()
st.log("read data1 : {}".format(rv))
return rv, ssh_obj
except Exception as exp:
st.log("getting error as {} while checking the prompt".format(exp))
if dut_name == "dut1":
ssh_obj = con_obj.connect_to_device(acl_dict["dut1_mgmt_ip"],
username, pwd)
acl_dict["dut1_ssh_obj"] = ssh_obj
elif dut_name == "dut3":
ssh_obj = con_obj.connect_to_device(acl_dict["dut3_mgmt_ip"],
username, pwd)
acl_dict["dut3_ssh_obj"] = ssh_obj
try:
ssh_obj.clear_cached_read_data()
rv = super(sonic_obj.SonicBaseConnection,
ssh_obj).find_prompt(delay_factor)
rv = re.escape(rv)
ssh_obj.clear_cached_read_data()
st.log("read data2 : {}".format(rv))
return rv, ssh_obj
except Exception as exp:
st.log(
"getting error again as {} while checking the prompt".format(
exp))
return False
def test_ft_tacacs_modify_server_parameters():
"""
Author: Karthik Kumar Goud Battula([email protected])
This Testcase covers the below scenarios
Scenario-1: Verify device behavior when TACACS+ application parameters (valid and invalid) are modified while traffic is running.
Scenario-2: Verify that the key and timeout options default to global but may be specified to unique values on a per Server basis.
Scenario-3: Verify that the NAS will stop communicating with the current server is the server is down after the duration of the configured server timeout or the default timeout value
Scenario-4: Verify that Taccacs server key can be configured with more that 4 special characters
"""
invalid_l4_port = '59'
invalid_pass_key = "key123"
invalid_timeout = '10'
invalid_ip_addr = '10.10.10.1'
tacacs_obj.set_tacacs_properties(vars.D1, 'passkey', 'secretstring')
st.log("Configuring global tacacs server key with special characters")
tacacs_obj.set_tacacs_properties(vars.D1, 'passkey', data.passkey)
st.log("Check client authentication by modifing ip address,timeout,passkey")
tacacs_obj.set_tacacs_server(vars.D1, 'add', invalid_ip_addr, invalid_l4_port, invalid_timeout, invalid_pass_key,
data.auth_type, data.priority_server2)
st.log("Trying to SSH to the device when TACACS+ server is configured with invalid parameters")
if ssh_obj.connect_to_device(data.ip_address, data.username, data.password, data.protocol, data.ssh_port):
st.report_fail("Login_to_DUT_via_SSH_is_failed")
st.log("Deleting the TACACS+ server which is invalid")
tacacs_obj.set_tacacs_server(vars.D1, 'delete', invalid_ip_addr)
st.log("Creating valid TACACS+ server")
tacacs_obj.set_tacacs_server(vars.D1, 'add', data.tacacs_ser_ip_1, data.tcp_port, data.timeout, data.passkey,
data.auth_type, data.priority)
st.log("Trying to SSH to the device with TACACS+ server which is configured with the valid parameters")
if not ssh_obj.connect_to_device(data.ip_address, data.username, data.password, data.protocol, data.ssh_port):
debug_info("test_ft_tacacs_modify_server_parameters", data.tacacs_ser_ip_1)
st.report_fail("Login_to_DUT_via_SSH_is_failed")
st.report_pass("test_case_passed")
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 sync_with_server_time(dut_list, ip, username, password):
"""
To Sync DUT with the CHEF server time.
Author : Prudvi Mangadu ([email protected])
:param dut:
:param ip:
:param username:
:param password:
:return:
"""
ssh_obj = con_obj.connect_to_device(ip, username, password, 'ssh')
if ssh_obj:
prompt = ssh_obj.find_prompt()
command = "date"
output = ssh_obj.send_command(command,
expect_string="{}|#|$".format(prompt))
if not output:
return False
st.log(output)
date = utils_obj.remove_last_line_from_string(output)
con_obj.ssh_disconnect(ssh_obj)
st.log("Server Time : {}".format(date))
for dut in dut_list:
ntp_obj.config_date(dut, date)
return True
else:
con_obj.ssh_disconnect(ssh_obj)
st.log(
"SSH to Server is failed - failed to sync time between DUT and CHEF Server"
)
return False
def test_mgmt_vrf_bind():
report_flag = 0
#intf = ['mgmt','eth0']
intf = ['eth0']
if not mvrf.verify(vars.D1, mvrfstate='Enabled', interfaces=intf):
st.log("FAILED")
report_flag = 1
if report_flag:
st.report_tc_fail("ft_mgmtVrf_bind", "mgmt_vrf_eth0_bind_fail")
else:
st.report_tc_pass("ft_mgmtVrf_bind", "mgmt_vrf_eth0_bind_success")
report_flag = 0
intf_li = get_all_interfaces(vars.D1)
if not mvrf.verify(
vars.D1, mvrfstate='Enabled', interfaces=intf_li, dataport=True):
report_flag = 1
if report_flag:
st.report_tc_fail("ft_mgmtVrf_dataport", "mgmt_vrf_dataport_bind")
else:
st.report_tc_pass("ft_mgmtVrf_dataport", "mgmt_vrf_dataport_nobind")
report_flag = 0
ip_addr = get_ifconfig_inet(vars.D1, 'eth0')
if not ip_addr:
st.log("IP Address not found on eth0")
report_flag = 1
ssh_conn_obj = connect_to_device(ip_addr[0], mgmt_vrf.username_default,
mgmt_vrf.password_default)
if not ssh_conn_obj:
if not connect_to_device(ip_addr[0], mgmt_vrf.username_default,
mgmt_vrf.password_alt):
report_flag = 1
if report_flag:
st.report_tc_fail("ft_mgmtVrf_ssh", "mgmt_vrf_ssh_fail")
else:
st.report_tc_pass("ft_mgmtVrf_ssh", "mgmt_vrf_ssh_pass")
if report_flag:
st.report_fail("mgmt_vrf_eth0_bind_fail")
else:
st.report_pass("mgmt_vrf_eth0_bind_success")
def test_ft_tacacs_ssh_login_highest_priorityserver():
"""
Author:Karthik Kumar Goud Battula([email protected]
This test case covers the below Scenarios
Scenario-1: verify if DUT is configured with more than one tacacs server with priority configured client can login do dut via heightest priority tacacs server
Scenario-2: Verify user login with multiple TACACS server when nondefault priority is configured for all server.
Scenario-3: Verify that if the current TACACS server is unresponsive the NAS will failover to the next configured TACACS server according to configured server priorities and so on.
"""
st.log("Login to the device via SSH using the credentials of highest priority server")
if not ssh_obj.connect_to_device(data.ip_address, data.username1, data.password1, data.protocol):
debug_info("test_ft_tacacs_ssh_login_highest_priorityserver", data.tacacs_ser_ip_2)
st.report_fail("Login_to_DUT_via_SSH_is_failed")
tacacs_obj.set_tacacs_server(vars.D1, 'delete', data.tacacs_ser_ip_1)
st.report_pass("test_case_passed")
def chef_package_install(dut,
url,
ip,
username='******',
password='******',
altpassword='******'):
"""
Install CHEF package to the DUT with CHEF server url.
Author : Prudvi Mangadu ([email protected])
:param dut:
:param url:
:param ip:
:param username:
:param password:
:return:
"""
if basic_obj.verify_package(dut, 'chef'):
return True
ssh_obj = con_obj.connect_to_device(ip, username, password, 'ssh')
if not ssh_obj:
ssh_obj = con_obj.connect_to_device(ip, username, altpassword, 'ssh')
if ssh_obj:
prompt = ssh_obj.find_prompt()
command = "apt-get install chef -y"
st.log(
ssh_obj.send_command(command,
expect_string=r"URL of Chef server:\s*"))
command = "{}".format(url)
st.log(
ssh_obj.send_command(command,
expect_string="{}|#|$".format(prompt)))
con_obj.ssh_disconnect(ssh_obj)
return True
else:
con_obj.ssh_disconnect(ssh_obj)
st.log("SSH to DUT is failed - Failed to install the chef package ")
return False
def test_ft_radius_login_rest():
"""
Verify that aaa authentication can be configured to radius and login authentication is successful.
"""
data1 = json.loads("""
{
"openconfig-system-ext:auth-type": "pap"
}
""")
data2 = json.loads("""
{
"openconfig-system:config": {
"auth-port": 1812,
"secret-key": "Lvl7india"
}
}
""")
data3 = json.loads("""
{
"openconfig-system:authentication-method": [
"radius",
"local"
]
}
""")
rest_url1 = "/restconf/data/openconfig-system:system/aaa/server-groups/server-group={}/servers/server={}/config/openconfig-system-ext:auth-type".format(
rbac.feature, rbac.host_ip)
rest_url2 = "/restconf/data/openconfig-system:system/aaa/server-groups/server-group={}/servers/server={}/radius/config".format(
rbac.feature, rbac.host_ip)
rest_url3 = "/restconf/data/openconfig-system:system/aaa/authentication/config/authentication-method"
st.log("Configuring Radius server configuration with REST")
if not config_rest(
vars.D1, http_method='put', rest_url=rest_url1, json_data=data1):
st.report_fail("rest_call_failed", "PUT")
if not config_rest(
vars.D1, http_method='patch', rest_url=rest_url2, json_data=data2):
st.report_fail("rest_call_failed", "PATCH")
st.log("Setting login authentication to radius and local")
if not config_rest(
vars.D1, http_method='put', rest_url=rest_url3, json_data=data3):
st.report_fail("rest_call_failed", "PUT")
st.log("SSH to device using radius credentials with auth_type pap")
if not ssh.connect_to_device(rbac.ip_address, rbac.host_username,
rbac.host_password):
st.report_fail("ssh_login_failed", rbac.global_auth_type)
st.report_pass("ssh_login_with_radius_successful", rbac.global_auth_type)
def snmp_config(config='add'):
global ssh_conn_obj
if config == 'add':
ip = ensure_service_params(vars.D1, "snmptrap", "ip")
username = ensure_service_params(vars.D1, "snmptrap", "username")
password = ensure_service_params(vars.D1, "snmptrap", "password")
snmp_obj.set_snmp_config(vars.D1,
snmp_rocommunity=ssh_data.ro_community,
snmp_location=ssh_data.location)
# Connect to the linux machine and check
ssh_conn_obj = connect_to_device(ip, username, password)
if not ssh_conn_obj:
return False
else:
snmp_obj.restore_snmp_config(vars.D1)
return True
def clear_syslog_from_remote_server(dut):
"""
Clear the logs from the syslog server
Author: Chaitanya Lohith Bollapragada ([email protected])
:param dut:
:return:
"""
syslog_ip = utils.ensure_service_params(dut, "syslog", "ip")
syslog_port = utils.ensure_service_params(dut, "syslog", "port")
syslog_username = utils.ensure_service_params(dut, "syslog", "username")
syslog_password = utils.ensure_service_params(dut, "syslog", "password")
syslog_path = utils.ensure_service_params(dut, "syslog", "path")
command = "sudo truncate -s 0 {}".format(syslog_path)
syslog_con_obj = conf_obj.connect_to_device(syslog_ip,
syslog_username,
syslog_password,
port=syslog_port)
conf_obj.execute_command(syslog_con_obj, command)
return True
def snmp_trap_pre_config():
global capture_file, ssh_conn_obj
ip = ensure_service_params(vars.D1, "snmptrap", "ip")
username = ensure_service_params(vars.D1, "snmptrap", "username")
password = ensure_service_params(vars.D1, "snmptrap", "password")
path = ensure_service_params(vars.D1, "snmptrap", "path")
# Connect to the linux machine and check
ssh_conn_obj = connect_to_device(ip, username, password)
if not ssh_conn_obj:
st.report_tc_fail("ssh_connection_failed", ip)
# enable traps on DUT
snmp_obj.config_snmp_trap(vars.D1,
version=2,
ip_addr=ip,
community=data.ro_community)
# start capture on the linux machine
capture_file = path
def bootstrap_chef_node(chef_conn_obj, repo_path, device_ip, uname, password,
node_name):
"""
:param chef_conn_obj:
:param file_name:
:return:
"""
if not chef_conn_obj:
return False
ssh_obj = con_obj.connect_to_device(device_ip, uname, password)
if not ssh_obj:
password = '******'
command = "cd {}".format(repo_path)
st.log("Remote Command: {}".format(command))
con_obj.execute_command(chef_conn_obj, command)
command = "sudo knife bootstrap {} -x {} -P {} --sudo --ssh-verify-host-key never --node-ssl-verify-mode none -N {}"\
.format(device_ip, uname, password ,node_name)
st.log("Remote Command: {}".format(command))
return con_obj.execute_command(chef_conn_obj, command)
def get_syslog_from_remote_server(dut,
severity=None,
filter_list=None,
lines=None):
"""
Get the logs from the syslog server
Author: Chaitanya Lohith Bollapragada ([email protected])
:param dut:
:param severity:
:param filter_list:
:param lines:
:return:
"""
syslog_ip = utils.ensure_service_params(dut, "syslog", "ip")
syslog_port = utils.ensure_service_params(dut, "syslog", "port")
syslog_username = utils.ensure_service_params(dut, "syslog", "username")
syslog_password = utils.ensure_service_params(dut, "syslog", "password")
syslog_path = utils.ensure_service_params(dut, "syslog", "path")
if filter_list is None:
filter_list = []
filter_list = list(filter_list) if isinstance(filter_list,
list) else [filter_list]
command = "cat {}".format(syslog_path)
if severity:
command += " | grep '{}'".format(severity)
for each_filter in filter_list:
command += " | grep '{}'".format(each_filter)
if lines:
command += "| tail -n {} ".format(lines)
syslog_con_obj = conf_obj.connect_to_device(syslog_ip,
syslog_username,
syslog_password,
port=syslog_port)
syslog_file_contents = conf_obj.execute_command(syslog_con_obj, command)
return syslog_file_contents
def test_ft_tacacs_enable_disable_failthrough():
"""
Author: Karthik Kumar Goud Battula(karthikkumargoud,[email protected])
This test case covers the below Scenarios
Scenario-1: Verify the functionality of failthrough mechanism by changing the login authentication order
Scenario-2: Verify the functionality of failthrough mechanism when DUT have multiple server with default priority.
"""
tacacs_obj.set_tacacs_server(vars.D1, 'add', data.tacacs_ser_ip_2, data.tcp_port, data.timeout, data.passkey,
data.auth_type, data.priority_server2)
st.log(
"Trying to SSH to the device using local credetails when login method set to TACACS+ and local and fail through mode is not enabled")
if ssh_obj.connect_to_device(data.ip_address, data.local_username, data.local_password, data.protocol,
data.ssh_port, alt_password=data.local_password2):
st.report_fail("Login_to_DUT_via_SSH_is_failed")
st.log(
"Trying to SSH to the device using TACACS+ credetails when login method set to TACACS+ and local and fail through mode is not enabled")
if not ssh_obj.connect_to_device(data.ip_address, data.username, data.password, data.protocol):
debug_info("test_ft_tacacs_enable_disable_failthrough", data.tacacs_ser_ip_1)
st.report_fail("Login_to_DUT_via_SSH_is_failed")
st.log("Setting login authentication to local and tacacs+")
tacacs_obj.set_aaa_authentication_properties(vars.D1, 'login', 'local tacacs+')
st.log(
"Trying to SSH to the device using local credetails when login method set to local and TACACS+ and fail through mode is not enabled")
if not ssh_obj.connect_to_device(data.ip_address, data.local_username, data.local_password,
alt_password=data.local_password2):
st.report_fail("Login_to_DUT_via_SSH_is_failed")
st.log(
"Trying to SSH to the device using TACACS+ credetails when login method set to local and TACACS+ and fail through mode is not enabled")
if ssh_obj.connect_to_device(data.ip_address, data.username, data.password, data.protocol, data.ssh_port):
st.report_fail("Login_to_DUT_via_SSH_is_failed")
st.log("Configuring AAA login to tacacs+ and local and enabling failthrough mode")
tacacs_obj.set_aaa_authentication_properties(vars.D1, 'login', 'tacacs+ local')
tacacs_obj.set_aaa_authentication_properties(vars.D1, 'failthrough', 'enable')
st.log(
"Trying to SSH to the device using local credetails when login method set to TACACS+ and local and fail through mode is enabled")
if not ssh_obj.connect_to_device(data.ip_address, data.local_username, data.local_password,
alt_password=data.local_password2):
st.report_fail("Login_to_DUT_via_SSH_is_failed")
st.log(
"Trying to SSH to the device using TACACS+ credetails when login method set to TACACS+ and local and fail through mode is enabled")
if not ssh_obj.connect_to_device(data.ip_address, data.username, data.password, data.protocol, data.ssh_port):
debug_info("test_ft_tacacs_enable_disable_failthrough", data.tacacs_ser_ip_1)
st.report_fail("Login_to_DUT_via_SSH_is_failed")
st.report_pass("test_case_passed")
def test_ft_ssh_config_reload_docker():
"""
Author : Prudvi Mangadu ([email protected])
"""
result = True
get_docker_ps(vars.D1)
count = get_and_match_docker_count(vars.D1)
ssh_d1 = connect_to_device(st.get_mgmt_ip(vars.D1), ssh_data.usr_default,
ssh_data.pwd_final)
if ssh_d1:
st.log(
"Executing command - 'sudo config reload -y &' in to the SSH session."
)
st.log(execute_command(ssh_d1, 'sudo config reload -y &'))
st.wait(5, 'After executing "config reload" cmd on SSH session.')
st.log("Forcefully disconnecting the SSH session..")
ssh_disconnect(ssh_d1)
else:
st.error('Cannot SSH into Device with default credentials')
st.report_fail("ssh_failed")
if not poll_wait(verify_docker_status, 180, vars.D1, 'Exited'):
st.error(
"Post 'config reload' from SSH, dockers are not auto recovered.")
result = False
if result:
if not poll_wait(get_and_match_docker_count, 180, vars.D1, count):
st.error("Post 'config reload' from SSH, ALL dockers are not UP.")
result = False
if not result:
st.log("Test Failed: So recovering the device by reboot.")
st.reboot(vars.D1)
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))
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 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 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 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))
