def create_glob_vars():
global vars
vars = st.ensure_min_topology("D1D2:2", "D2D3:2", "D1T1:1", "D3T1:1")
tg_dict["tg"], tg_dict["d1_tg_ph1"] = tgapi.get_handle_byname("T1D1P1")
tg_dict["tg"], tg_dict["d3_tg_ph1"] = tgapi.get_handle_byname("T1D3P1")
tg_dict["d1_tg_port1"], tg_dict["d3_tg_port1"] = vars.T1D1P1, vars.T1D3P1
tg_dict["tgen_rate_pps"] = '1000'
tg_dict["l3_len"] = '512'
tg_dict["duration"] = 5
acl_dict["dut_list"] = [vars.D1, vars.D2, vars.D3]
acl_dict["dut1"]["intf_list_tg"] = [vars.D1T1P1]
acl_dict["dut1"]["intf_list_dut2"] = [vars.D1D2P1, vars.D1D2P2]
acl_dict["dut2"]["intf_list_tg"] = [vars.D2T1P1]
acl_dict["dut2"]["intf_list_dut1"] = [vars.D2D1P1, vars.D2D1P2]
acl_dict["dut2"]["intf_list_dut3"] = [vars.D2D3P1, vars.D2D3P2]
acl_dict["dut3"]["intf_list_tg"] = [vars.D3T1P1]
acl_dict["dut3"]["intf_list_dut2"] = [vars.D3D2P1, vars.D3D2P2]
acl_dict["dut1_gw_mac"] = basic.get_ifconfig(vars.D1,
vars.D1T1P1)[0]['mac']
acl_dict["dut3_gw_mac"] = basic.get_ifconfig(vars.D3,
vars.D3T1P1)[0]['mac']
d1_out = st.get_credentials(vars.D1)
d3_out = st.get_credentials(vars.D3)
acl_dict["d1_uname"] = d1_out[0]
acl_dict["d3_uname"] = d3_out[0]
acl_dict["d1_pwd"] = d1_out[3]
acl_dict["d3_pwd"] = d3_out[3]
tg_dict["live_stream"] = ""
def gnmi_get(dut, xpath, **kwargs):
"""
API to do GNMI get operations
Author: Chaitanya Vella ([email protected])
:param dut:
:param xpath:
:param kwargs:
:return:
"""
gnmi_debug(dut)
credentails = st.get_credentials(dut)
ip_address = kwargs.get('ip_address', '127.0.0.1')
port = kwargs.get('port', '8080')
insecure = kwargs.get('insecure', '')
skip_tmpl = kwargs.get('skip_tmpl', False)
username = kwargs.get('username', credentails[0])
password = kwargs.get('password', credentails[3])
cert = kwargs.get('cert')
target_name = kwargs.get('target_name')
result = dict()
try:
docker_command = get_docker_command()
if not docker_command:
st.log("Docker command not found ..")
return False
gnmi_command = 'gnmi_get -xpath {} -target_addr {}:{}'.format(
xpath, ip_address, port)
if username:
gnmi_command += " -username {}".format(username)
if password:
gnmi_command += " -password {}".format(password)
if cert:
gnmi_command += " -cert {}".format(cert)
if target_name:
gnmi_command += " -target_name {}".format(target_name)
if insecure != 'none':
gnmi_command += " -insecure {}".format(insecure)
command = '{} -c "{}"'.format(docker_command, gnmi_command)
output = st.show(dut, command, skip_tmpl=skip_tmpl)
st.log("OUTPUT : {}".format(output))
if not output:
return result
if skip_tmpl:
if "data" in output[0]:
data = json.dumps(output[0]["data"])
if not data:
return result
return json.loads(
json.loads(json.loads(json.dumps(data[0]["data"]))))
return result
else:
response = output[0]["data"]
while True:
if not isinstance(response, dict):
response = json.loads(response)
else:
return response
except Exception as e:
st.log(e)
return result
def _prepare_gnmi_command(dut, xpath, **kwargs):
credentials = st.get_credentials(dut)
ip_address = kwargs.get('ip_address', '127.0.0.1')
port = kwargs.get('port', '8080')
insecure = kwargs.get('insecure', '')
username = kwargs.get('username', credentials[0])
password = kwargs.get('password', credentials[3])
gnmi_utils_path = kwargs.get("gnmi_utils_path", "/tmp")
cert = kwargs.get('cert')
action = kwargs.get("action", "get")
pretty = kwargs.get('pretty')
mode = kwargs.get('mode', '-update')
target_name = kwargs.get('target_name')
if action == "get":
gnmi_command = 'gnmi_get -xpath {} -target_addr {}:{}'.format(xpath, ip_address, port)
elif action == "set":
gnmi_command = 'gnmi_set {} {}:@{} -target_addr {}:{}'.format(mode, xpath, kwargs.get("data_file_path"), ip_address, port)
if pretty:
gnmi_command += " --pretty"
elif action == "delete":
gnmi_command = 'gnmi_set --delete {} --target_addr {}:{}'.format(xpath, ip_address, port)
if username:
gnmi_command += " --username {}".format(username)
if password:
gnmi_command += " --password {}".format(password)
if cert:
gnmi_command += " -cert {}".format(cert)
if target_name:
gnmi_command += " -target_name {}".format(target_name)
if insecure:
gnmi_command += " -insecure {}".format(insecure)
gnmi_command += " -insecure -alsologtostderr"
command = '{}/{}'.format(gnmi_utils_path, gnmi_command)
return command
def rbac_module_epilog():
sshapi.ssh_keygen(vars.D2, mode='destroy', path=rbac.client_keygen_path)
rbac_config_user(1)
rest_client_auth(vars.D1, auth_type='')
gnmi_client_auth(vars.D1, auth_type='')
password = st.get_credentials(vars.D1)[3]
st.debug("The password for user: {} is: {}".format(
rbac.default_user['username'], password))
def rbac_module_prolog():
ping_validation()
sshapi.enable_ssh(vars.D1)
rbac.default_user['password'] = st.get_credentials(vars.D1)[3]
sshapi.ssh_keygen(vars.D2, mode='create', path=rbac.client_keygen_path)
rbac_config_user(0)
generating_certificates_to_dut()
rest_client_auth(vars.D1, auth_type=rbac.rest_auth)
gnmi_client_auth(vars.D1, auth_type=rbac.gnmi_auth)
def copy_files_to_dut(dut_ip, username='******', password='******'):
ssh = SSHClient()
ssh.load_system_host_keys()
ssh.set_missing_host_key_policy(AutoAddPolicy())
ssh.connect(dut_ip,
username=username,
password=st.get_credentials(data.dut1)[3])
#ssh.connect(dut_ip, username=username, password='******')
ssh.exec_command('sudo -i')
scp = SCPClient(ssh.get_transport())
for dhcp_conf_file in data.dhcp_files_path:
scp.put(dhcp_conf_file, "/tmp")
scp.close()
def oc_yang_ver_module_hooks(request):
global vars
vars = st.ensure_min_topology("D1")
credentials = st.get_credentials(vars.D1)
oc_yang_data.username = credentials[0]
oc_yang_data.password = credentials[3]
oc_yang_data.dut_ip_addr = st.get_mgmt_ip(vars.D1)
oc_yang_data.base_url = "restconf/data/"
oc_yang_data.version = get_version(vars.D1)
oc_yang_data.new_major_version = new_version(oc_yang_data.version)
oc_yang_data.new_minor_version = new_version(oc_yang_data.version,
flag="minor")
oc_yang_data.new_patch_version = new_version(oc_yang_data.version,
flag="patch")
yield
def copy_files_to_server():
st.log(
"Scp the resyslog.conf file from the current location to /tmp on the server"
)
ssh = SSHClient()
ssh.load_system_host_keys()
ssh.set_missing_host_key_policy(AutoAddPolicy())
#ssh.connect(dut_ip, username='******', password='******')
ssh.connect(st.get_mgmt_ip(data.dut2_server),
username='******',
password=st.get_credentials(data.dut2_server)[3])
ssh.exec_command('sudo -i')
scp = SCPClient(ssh.get_transport())
for file in data.syslog_file_path:
scp.put(file, "/tmp")
scp.close()
def gnmi_delete(dut, xpath, **kwargs):
"""
API to do GNMI get operations
Author: Chaitanya Vella ([email protected])
:param dut:
:param xpath:
:param kwargs:
:return:
"""
gnmi_debug(dut)
st.log("Performing GNMI DELETE OPERATION ...")
ip_address = kwargs.get('ip_address', '127.0.0.1')
port = kwargs.get('port', '8080')
insecure = kwargs.get('insecure', '')
credentails = st.get_credentials(dut)
username = kwargs.get('username', credentails[0])
password = kwargs.get('password', credentails[3])
cert = kwargs.get('cert')
docker_command = get_docker_command()
try:
gnmi_command = 'gnmi_set --delete {} --target_addr {}:{}'.format(
xpath, ip_address, port)
if username:
gnmi_command += " --username {}".format(username)
if password:
gnmi_command += " --password {}".format(password)
if cert:
gnmi_command += " --cert {}".format(cert)
gnmi_command += " --insecure {}".format(insecure)
command = '{} -c "{}"'.format(docker_command, gnmi_command)
output = st.config(dut, command)
st.log("OUTPUT : {}".format(output))
if not output:
st.log("Observed empty OUTPUT")
return False
error_strings = [
"Error response", "rpc error", "gnmi_set.go", "Set failed",
"Unknown desc", "failed"
]
for err_code in error_strings:
if err_code in util_obj.remove_last_line_from_string(output):
st.log(output)
return False
return output
except Exception as e:
st.error(e)
return False
def initialize_topology_vars():
vars = st.ensure_min_topology("D1D3:1", "D2D3:1","D2D4:3")
data.dut_list = st.get_dut_names()
data.dut1 = data.dut_list[0]
data.dut2 = data.dut_list[1]
data.dut3 = data.dut_list[2]
data.dut4 = data.dut_list[3]
for dut in data.dut_list:
bgp_api.enable_docker_routing_config_mode(dut)
data.d1d3_ports = [vars.D1D3P1]
data.d3d1_ports = [vars.D3D1P1]
data.d2d3_ports = [vars.D2D3P1]
data.d3d2_ports = [vars.D3D2P1]
data.d2d4_ports = [vars.D2D4P1, vars.D2D4P2, vars.D2D4P3]
data.d4d2_ports = [vars.D4D2P1, vars.D4D2P2, vars.D4D2P3]
# DUT as dhcp server
data.dhcp_server_port = data.d3d1_ports[0]
data.server_d3_port = data.d1d3_ports[0]
#dhcp_server_vxlan_param_list = ['server_mgmt_ip', 'dhcp_server_ip', 'dhcp_server_ipv6', 'username', 'password']
#for server_param in dhcp_server_vxlan_param_list:
# data[server_param] = util_obj.ensure_service_params(data.dut1, 'dhcp_server_vxlan', server_param)
data.dhcp_server_ip = '172.16.40.210'
data.dhcp_server_ipv6 = '2072::210'
data.username = '******'
data.password = st.get_credentials(data.dut1)[3]
temp_list = data.dhcp_server_ip.split('.')
temp_list[3] = '1'
data.dut3_server_ip_list = ['.'.join(temp_list)]
data.dut3_server_ipv6_list = [data.dhcp_server_ipv6.split('::')[0] + "::1"]
data.relay_port = ['Vlan100',data.d2d4_ports[1],'PortChannel12']
data.client_port = ['Vlan100', 'Vlan200', 'Vlan300']
data.client_port_ip = ['192.168.0.1','20.20.20.1','30.30.30.1']
data.server_pool = ['192.168.0.','20.20.20.','30.30.30.']
data.client_port_ipv6 = ['2092::1','2020::1','2030::1']
data.server_pool_ipv6 = ['2092::','2020::','2030::']
data.lb_src_intf_list = ['Loopback1','Loopback1','Loopback1']
data.dhcp_files = ['dhcp-server-interface','dhcpd.conf','dhcpd6.conf']
data.dhcp_files_path = [os.path.join(os.path.dirname(__file__),data.dhcp_files[0]),os.path.join(os.path.dirname(__file__),data.dhcp_files[1]),os.path.join(os.path.dirname(__file__),data.dhcp_files[2])]
data.dhcp_files_path = []
for file in data.dhcp_files: data.dhcp_files_path.append(os.path.join(os.path.dirname(__file__),file))
def gnmi_set(dut, xpath, json_content, **kwargs):
"""
API to set GNMI configuration
Author: Chaitanya Vella ([email protected])
:param dut:
:param xpath:
:param json_content:
:param kwargs:
:return:
"""
gnmi_debug(dut)
credentails = st.get_credentials(dut)
ip_address = kwargs.get('ip_address', '127.0.0.1')
port = kwargs.get('port', '8080')
insecure = kwargs.get('insecure', '')
username = kwargs.get('username', credentails[0])
password = kwargs.get('password', credentails[3])
cert = kwargs.get('cert')
target_name = kwargs.get('target_name')
pretty = kwargs.get('pretty')
logstostderr = kwargs.get('logstostderr')
mode = kwargs.get('mode', '-update')
docker_command = get_docker_command()
if not docker_command:
st.log("Docker command not found ..")
return False
if json_content:
temp_dir = tempfile.gettempdir()
current_datetime = util_obj.get_current_datetime()
file_name = "sonic_gnmi_{}.json".format(current_datetime)
tmp_path = "{}/{}".format(temp_dir, file_name)
docker_path = '/{}'.format(file_name)
cp_cmd = 'docker cp {} telemetry:{}'.format(tmp_path, docker_path)
rm_cmds = ['rm {}'.format(tmp_path), '{} -c "rm {}"'.format(docker_command, docker_path)]
file_operation = util_obj.write_to_json_file(json_content, tmp_path)
if not file_operation:
st.log("File operation failed.")
return False
st.upload_file_to_dut(dut, tmp_path, tmp_path)
st.config(dut, cp_cmd)
gnmi_command = 'gnmi_set {} {}:@{} -target_addr {}:{}'.format(mode, xpath, docker_path, ip_address, port)
if username:
gnmi_command += " -username {}".format(username)
if password:
gnmi_command += " -password {}".format(password)
if cert:
gnmi_command += " -cert {}".format(cert)
if target_name:
gnmi_command += " -target_name {}".format(target_name)
if pretty:
gnmi_command += " -pretty"
if logstostderr:
gnmi_command += " -alsologstostderr"
if insecure != 'none':
gnmi_command += " -insecure {}".format(insecure)
command = '{} -c "{}"'.format(docker_command, gnmi_command)
output = st.config(dut, command)
for rm_cmd in rm_cmds:
st.config(dut, rm_cmd)
error_strings = ["Error response", "rpc error", "Set failed", "Unknown desc", "failed"]
for err_code in error_strings:
if err_code in util_obj.remove_last_line_from_string(output):
st.log(output)
return False
return output
else:
return False
def rest_data_refresh(dut_list):
for dut in dut_list:
credentials = st.get_credentials(dut)
st.rest_init(dut, credentials[0], credentials[1], credentials[2])
def rest_operation(dut, **kwargs):
op = kwargs.get("http_method")
url = kwargs.get("rest_url")
data = kwargs.get("json_data")
timeout = kwargs.get("timeout", 5)
log_msg = []
status_map = {200 : "Rest operation successful", 201 : "Rest operation successful", 204 : "Rest operation successful", 400 : "Bad Request", 401 : "Unauthorized", 403 : "Forbidden", 404 : "Page not found", 405 : "Method not allowed", 409 : "Conflict", 415 : "Unsupported Media Type", 500 : "Internal Server Error"}
retval = {}
rest_result = True
log_msg.append("[{}] -- HTTP METHOD : {}".format(dut, op.upper()))
log_msg.append("URL : {}".format(url))
if data:
log_msg.append("PAYLOAD : {}".format(data))
if not op or not url:
st.log("Please provide http_method: {} or rest_url: {}".format(op,url))
return False
op = op.lower()
if op in ["get","delete"]:
params = {"path":url, "rest_timeout":timeout}
elif op in ["post", "put", "patch"]:
params = {"path": url, "data":data,"rest_timeout": timeout}
else:
st.log("Please provide valid Http method")
return False
if kwargs.get("username"):
params.update({"rest_username":kwargs.get("username")})
if kwargs.get("password"):
params.update({"rest_password":kwargs.get("password")})
for iteration in range(1,5):
try:
if op == "get":
retval = st.rest_read(dut, **params)
elif op == "post":
retval = st.rest_create(dut, **params)
elif op == "put":
retval = st.rest_update(dut, **params)
elif op == "delete":
retval = st.rest_delete(dut, **params)
elif op == "patch":
retval = st.rest_modify(dut, **params)
else:
st.log("Please provide valid Http method")
return False
break
except Exception as e:
if iteration > 2:
credentials = st.get_credentials(dut)
st.rest_init(dut, credentials[0], credentials[1], credentials[2])
if op == "get":
tout = 180 if int(timeout) < 180 else timeout
st.log("Setting timeout to {} sec".format(tout))
params.update({"rest_timeout": tout})
st.error(e)
if "url" in retval.keys():
host_ip = re.findall(r'([0-9]+(?:\.[0-9]+){3})', retval["url"])
if host_ip:
log_msg.insert(1, "HOST IP : {}".format(host_ip[0]))
if "status" in retval.keys():
log_msg.append("STATUS : {} - {}".format(retval["status"], status_map[retval["status"]]))
rest_result = True if retval["status"] in [200, 201, 204] else False
if op == "get":
if "output" in retval.keys():
log_msg.append("OUTPUT : {}".format(retval["output"]))
if rest_result:
st.log("{}".format(", ".join(log_msg)))
else:
st.error("{}".format(", ".join(log_msg)))
return retval
