def get_log_files(self):
"""Get execution logs dir and results """
if self.logs_startdir is not None:
if self.logs_startdir == self.res_startdir:
logs_execdir = self.results_execdir
else:
logs_execdir = file_Utils.createDir_addtimestamp(
self.logs_startdir, self.nameonly)
logfile = self.get_exec_file_by_type("Logs", logs_execdir)
elif self.logs_startdir is None:
colocate = False
logs_location = xml_Utils.getChildTextbyParentTag(
self.filepath, 'Details', 'Logsdir')
results_location = xml_Utils.getChildTextbyParentTag(
self.filepath, 'Details', 'Resultsdir')
#get default logs and results directory
default_xml = Tools.__path__[0] + os.sep + 'w_settings.xml'
default_logsdir = get_credentials(default_xml, 'def_dir',
['Logsdir'], 'Setting')
default_resultsdir = get_credentials(default_xml, 'def_dir',
['Resultsdir'], 'Setting')
#use the default directory if user didn't define it in test case/test suite/project
if results_location is None or results_location is False:
if default_resultsdir['Resultsdir'] is not None:
results_location = default_resultsdir['Resultsdir']
if logs_location is None or logs_location is False:
if default_logsdir['Logsdir'] is not None:
logs_location = default_logsdir['Logsdir']
if logs_location is None or logs_location is False\
or str(logs_location).strip() == "":
logs_execdir = self.create_def_exec_dir()
logfile = self.get_exec_file_by_type('Logs', logs_execdir)
elif logs_location is not None and logs_location is not False:
logs_location_rel = str(logs_location).strip()
logs_location = file_Utils.getAbsPath(
logs_location_rel, os.path.dirname(self.filepath))
results_location_rel = str(results_location).strip()
results_location = file_Utils.getAbsPath(
results_location_rel, os.path.dirname(self.filepath))
if logs_location == results_location:
colocate = True
logfile, logs_execdir = self.checkdir_create_file(
logs_location, 'Logs', colocate)
# print "printing logs_execdir: ", logs_execdir
logsdir = os.path.dirname(logfile)
return logfile, logsdir, logs_execdir
def get_result_files(self):
"""Get execution results dir and files """
if self.res_startdir is not None:
results_execdir = file_Utils.createDir_addtimestamp(self.res_startdir, self.nameonly)
rfile = self.get_exec_file_by_type("Results", results_execdir)
elif self.res_startdir is None:
results_location = xml_Utils.getChildTextbyParentTag(self.filepath,
'Details', 'Resultsdir')
#get default results directory
default_xml = Tools.__path__[0] + os.sep + 'w_settings.xml'
default_resultsdir = get_credentials(default_xml, 'def_dir', ['Resultsdir'], 'Setting')
#use the default directory if user didn't define it in test case/test suite/project
if results_location is None or results_location is False:
if default_resultsdir['Resultsdir'] is not None:
results_location = default_resultsdir['Resultsdir']
if results_location is None or results_location is False\
or str(results_location).strip() == "":
results_execdir = self.create_def_exec_dir() #proj_exec_dir
rfile = self.get_exec_file_by_type("Results", results_execdir)
elif results_location is not None and results_location is not False:
results_location_rel = str(results_location).strip()
results_location = file_Utils.getAbsPath(results_location_rel,
os.path.dirname(self.filepath))
rfile, results_execdir = self.checkdir_create_file(results_location, "Results")
# print "printing results_execdir: ", results_execdir
resultfile = file_Utils.getNewExtension(rfile, "xml")
resultsdir = os.path.dirname(resultfile)
return resultfile, resultsdir, results_execdir
def convert_xml_to_csv(input_file,
mapping_file=None,
output_csv_file_path=None,
overwrite="yes"):
"""
It takes xml file path as input and converts to csv.
Arguments:
1. input_file: Takes xml file path as input
2. mapping_file: If a mapping file path is given, it is used to map
columns with the meaningful name as recognized by the user else
the tags in the xml file will be used as column names in
the csv file.
3. output_csv_file_path: If user gives the output_csv_file_path,
creating an csv file in that path else creating
csv file in the path from where he have given xml file.
Returns:
Returns output csv file path.
"""
count = 0
try:
dict_response = xml_Utils.convert_xml_to_list_of_dict(input_file)
if mapping_file:
mapping_dict = data_Utils.get_credentials(mapping_file,
'mapping_scheme')
mapping_dictionary = {v: k for k, v in mapping_dict.items()}
else:
mapping_dictionary = {}
if output_csv_file_path:
output_csv_file = output_csv_file_path
else:
output_csv_file = input_file.replace(".xml", ".csv")
if overwrite == "no":
output_csv_file = file_Utils.addTimeDate(output_csv_file)
f = open(output_csv_file, 'wb+')
csvwriter = csv.writer(f)
for element in dict_response:
if count == 0:
header = list(element.keys())
for index, val in enumerate(header):
for key, value in mapping_dictionary.items():
if val == value:
header[index] = key
csvwriter.writerow(header)
count += 1
csvwriter.writerow(list(element.values()))
f.close()
except Exception as exception:
print_exception(exception)
output_csv_file = None
return output_csv_file
def _create_cs_obj(self, system_name):
'''Initializes the CloudShell object and logons to cloudshell
returns the cloudshell object
'''
keys_for_credentials = ['ip', 'cloudshell_port', 'username',
'password', 'domain']
credentials = data_Utils.get_credentials(self.datafile, system_name,
keys_for_credentials)
return cs(credentials['ip'], credentials['username'],
credentials['password'], credentials['domain'])
def testset_calibration(self, system_name):
"""
Check if the test set calibration is current if less than 1 year old,
otherwise, re-calibration is required.
"""
wdesc = "Check if Lab Test set calibration is current."
#Resolve system_name and subsystem_list
system_name, subsystem_list = Utils.data_Utils.resolve_system_subsystem_list(
self.datafile, system_name)
output_dict = {}
status = True
attempt = 1 if subsystem_list == None else len(subsystem_list)
for i in range(attempt):
Utils.testcase_Utils.pSubStep(wdesc)
#Get name from the list when it's not 'None', otherwise, set it to 'None'
subsystem_name = subsystem_list[
i] if subsystem_list != None else None
call_system_name = system_name if subsystem_name is None \
else "{0}[{1}]".format(system_name, subsystem_name)
credentials = get_credentials(
self.datafile, call_system_name,
['calibration', 'user', 'location', 'testdata'])
pNote("system={0}".format(call_system_name))
#Demo Framework testdata capability
testdatafile = file_Utils.getAbsPath(
credentials["testdata"], os.path.dirname(self.datafile))
add_info = Utils.xml_Utils.getElementWithTagAttribValueMatch(
testdatafile, 'add_info', 'name', 'testdata')
if add_info is not None:
info_text = Utils.xml_Utils.get_text_from_direct_child(
add_info, 'info')
pNote(info_text)
pNote(testdatafile)
if credentials is not None and credentials is not False:
calibrated_date = credentials["calibration"]
num_of_year = 1
pass_msg = "Lab Test set {0} calibration is current, "\
"re-calibration is NOT required."\
.format(call_system_name)
fail_msg = "Lab Test set {0} calibration is NOT current, it's "\
"more than than 1 year old. Re-calibration is "\
"required".format(call_system_name)
result = Utils.demo_utils.lab_eqpt_status(
calibrated_date, num_of_year, pass_msg, fail_msg)
Utils.data_Utils.update_datarepository(output_dict)
Utils.testcase_Utils.report_substep_status(result)
status = status and result
return status, output_dict
def pc_replacement(self, system_name):
"""
Verify lab PC is current if less than 4 years old, otherwise
a replacement is required.
"""
wdesc = "Check if lab PC is current or need replacement"
#Resolve system_name and subsystem_list
system_name, subsystem_list = Utils.data_Utils.resolve_system_subsystem_list(
self.datafile, system_name)
output_dict = {}
status = True
attempt = 1 if subsystem_list == None else len(subsystem_list)
for i in range(attempt):
Utils.testcase_Utils.pSubStep(wdesc)
#Get name from the list when it's not 'None', otherwise, set it to 'None'
subsystem_name = subsystem_list[
i] if subsystem_list != None else None
call_system_name = system_name if subsystem_name is None \
else "{0}[{1}]".format(system_name, subsystem_name)
credentials = get_credentials(self.datafile, call_system_name,
['dom', 'user', 'os', 'testdata'])
pNote("system={0}".format(call_system_name))
#Demo Framework testdata capability
testdatafile = file_Utils.getAbsPath(
credentials["testdata"], os.path.dirname(self.datafile))
add_info = Utils.xml_Utils.getElementWithTagAttribValueMatch(
testdatafile, 'add_info', 'name', 'testdata')
if add_info is not None:
info_text = Utils.xml_Utils.get_text_from_direct_child(
add_info, 'info')
pNote(info_text)
pNote(testdatafile)
if credentials is not None and credentials is not False:
num_of_year = 4
date_of_mfg = credentials["dom"]
pass_msg = "Lab PC {0} is current, it's less than 4 years old."\
" A replacement is NOT required."\
.format(call_system_name)
fail_msg = "Lab PC {0} is NOT current, it's more than than 4 "\
"years old. Please schedule for a replacement."\
.format(call_system_name)
result = Utils.demo_utils.lab_eqpt_status(
date_of_mfg, num_of_year, pass_msg, fail_msg)
Utils.data_Utils.update_datarepository(output_dict)
Utils.testcase_Utils.report_substep_status(result)
status = status and result
return status, output_dict
def get_credential_value(self, arg, system):
"""get the value of arg in data file corresponding to system
"""
datafile = self.data_repository['wt_datafile']
var = arg
if not hasattr(self, 'tag_dict'):
self.tag_dict = data_Utils.get_credentials(datafile, system)
if isinstance(arg, str) and arg.startswith("wtag"):
var = arg.split("=")[1].strip()
if var in self.tag_dict:
value = self.tag_dict[var]
# substitute environment/datarepo variables in the value and return
if isinstance(value, (str, list, dict)):
return data_Utils.substitute_var_patterns(value)
else:
return value
return var
def decide_overwrite_var(namespace):
"""options provided in cli get preference over the ones provided inside tests
"""
overwrite = {}
if namespace.datafile:
if namespace.datafile[0] != os.sep:
namespace.datafile = os.getcwd() + os.sep + namespace.datafile
overwrite['ow_datafile'] = namespace.datafile
#namespace for random tc execution
if namespace.random_tc_execution:
overwrite['random_tc_execution'] = namespace.random_tc_execution
#namespace for wrapperfile
if namespace.wrapperfile:
if namespace.wrapperfile[0] != os.sep:
namespace.wrapperfile = os.getcwd(
) + os.sep + namespace.wrapperfile
overwrite['ow_testwrapperfile'] = namespace.wrapperfile
if namespace.resultdir:
if namespace.resultdir[0] != os.sep:
namespace.resultdir = os.getcwd() + os.sep + namespace.resultdir
overwrite['ow_resultdir'] = namespace.resultdir
if namespace.logdir:
if namespace.logdir[0] != os.sep:
namespace.logdir = os.getcwd() + os.sep + namespace.logdir
overwrite['ow_logdir'] = namespace.logdir
if namespace.outputdir:
if namespace.outputdir[0] != os.sep:
namespace.outputdir = os.getcwd() + os.sep + namespace.outputdir
overwrite['ow_resultdir'] = namespace.outputdir
overwrite['ow_logdir'] = namespace.outputdir
if all([namespace.outputdir,
any([namespace.resultdir, namespace.logdir])]):
print_error("outputdir shouldn't be used with resultdir or logdir")
exit(1)
if namespace.jobid:
settings_xml = Tools.__path__[0] + os.sep + 'w_settings.xml'
job_url = get_credentials(settings_xml, 'job_url', ['url'], 'Setting')
if job_url['url'] is not None:
url = job_url['url']
else:
print_info("jobid is specified but no job url found in w_settings")
print_info("Using jobid only in JUnit file")
url = ""
overwrite['jobid'] = url + str(namespace.jobid)
return overwrite
def cs_create_topology_reservation(self, system_name, reservation_name,
duration_in_mins, notify_on_start,
notify_on_end, notify_mins_before_end,
topology_full_path):
"""Defines a reservation to be started immediately
:Datafile usage:
Tags or attributes to be used in input datafile for the system
or subsystem.If both tag and attribute is provided the attribute
will be used.
1. username = name of the cloudshell user
:Arguments:
1. system_name(string) = Name of the UAP system from the datafile
2. reservation_name(string) = Specify the name of the reservation.
3. duration_in_mins(int) = Specify the length of the reservation.
4. notify_on_start(bool) = Indicate whether to notify the
reservation owner when the reservation starts.
5. notify_on_end(bool) = Indicate whether to notify the reservation
owner when the reservation ends.
6. notify_mins_before_end(int) = Notification Minutes Before End -
Indicate the number of minutes before the end of the reservation
to send out a Notify On End alert to the reservation owner.
(0 = disabled)
7. topology_full_path(string) = Specify the full topology name. Include
the full path from the root to the topology, separated by slashes.
For example: FolderName/Topologies/TopologyName
:Returns:
1. status(bool)= True/False
2. output_dict = consists of following key value pairs:
1. domain_id: Domain Id returned after login to cloudshell.
2. reservation_id: Reservation Id returned after successful
creation of resources.
"""
wdesc = "Create Topology Reservation in CloudShell API Host"
testcase_Utils.pSubStep(wdesc)
testcase_Utils.pNote(file_Utils.getDateTime())
testcase_Utils.pNote("cs_create_topology_reservation, cs obj-{}".\
format(cloud_shell), "info")
keys_for_credentials = ['username']
credentials = data_Utils.get_credentials(self.datafile, system_name,
keys_for_credentials)
status = False
output_dict = {}
try:
xml_resp = cloud_shell.CreateImmediateTopologyReservation(
reservation_name, credentials['username'],
int(duration_in_mins), notify_on_start, notify_on_end,
int(notify_mins_before_end), topology_full_path)
if xml_resp is not None:
reservation_id = xml_resp.Reservation.Id
output_dict = {
'domain_id':
cloud_shell.domain,
'{0}_{1}_reservationId'.format(system_name, reservation_name):
reservation_id
}
testcase_Utils.pNote("\n\n *** Cloudshell CreateTopologyReservation"
" successfull for ResName-\"{}\" ResId-{}\n".\
format(reservation_name,
output_dict['{0}_{1}_reservationId'.\
format(system_name, reservation_name)]),
"info")
status = True
else:
testcase_Utils.pNote(
"\n\n *** Cloudshell CreateTopologyReservation"
" failed for \"{}\"".format(reservation_name), "warning")
except Exception as exception:
print_exception(exception)
testcase_Utils.report_substep_status(status)
return status, output_dict
def cs_create_reservation(self, system_name, reservation_name,
duration_in_mins, notify_on_start, notify_on_end,
notify_mins_before_end):
"""
Defines a reservation to be created.
This keyword only defines the reservation with all its details by saving
the details in the data repository. Actual creation is done by using the
cs_add_topology_to_reservation keyword by providing the reservation name
to it.
:Datafile usage:
Tags or attributes to be used in input datafile for the system
or subsystem.If both tag and attribute is provided the attribute
will be used.
1. username = name of the cloudshell user
:Arguments:
1. system_name(string) = Name of the UAP system from the datafile
2. reservation_name(string) = Specify the name of the reservation.
3. duration_in_mins(int) = Specify the length of the reservation.
4. notify_on_start(bool) = Indicate whether to notify the
reservation owner when the reservation starts.
5. notify_on_end(bool) = Indicate whether to notify the reservation
owner when the reservation ends.
6. notify_mins_before_end(int) = Notification Minutes Before End -
Indicate the number of minutes before the end of the reservation
to send out a Notify On End alert to the reservation owner.
(0 = disabled)
:Returns:
1. status(bool)= True/False
2. output_dict = consists of following key value pairs:
1. domain_id: Domain Id returned after login to cloudshell.
2. reservation_id: Reservation Id returned after successful
creation of resources.
"""
wdesc = "Save reservation details for the reservation name provided"
testcase_Utils.pSubStep(wdesc)
testcase_Utils.pNote(file_Utils.getDateTime())
testcase_Utils.pNote("save reservation, cs obj-{}".\
format(cloud_shell), "info")
keys_for_credentials = ['username']
credentials = data_Utils.get_credentials(self.datafile, system_name,
keys_for_credentials)
status = True
output_dict = {}
try:
pNote("This keyword will only collect the reservation information "\
"and save the details in data repository.\n")
pNote("In order to create reservation in cloudshell, execute this keyword and then "\
"use the keyword 'cs_add_topology_to_reservation' and provide the "\
"reservation_name to it, 'cs_add_topology_to_reservation' keyword will use "\
"the reservation details for he reservation_name provided, create a "\
"reservation and add topology to the reservation.")
res_key = "{0}_{1}_cs_rsrv_details".format(system_name,
reservation_name)
output_dict = {
res_key: {
"reservation_name": reservation_name,
"username": credentials['username'],
"duration": duration_in_mins,
"notify_on_start": notify_on_start,
"notify_on_end": notify_on_end,
"notify_mins_before_end": notify_mins_before_end
}
}
except Exception as exception:
pNote("Saving reservation details for reservation_name={0} failed!!"\
.format(reservation_name))
print_exception(exception)
status = False
else:
pNote("Sucessfully saved reservation details for reservation_name={0}"\
.format(reservation_name))
testcase_Utils.report_substep_status(status)
return status, output_dict
def gnmi_subscribe(self, system_name, option, q_query, qt_querytype="once",
polling_interval="30s", stop_after=None, verify=None,
external_system=None, external_system_session=None,
streaming_duration="0s", timestamp="''", user_arg=""):
"""
gnmi Subscribe Keyword Will perform get(subscribe once is get), Polling
operation and store the output json in data dictionary.
:param system_name: server System name as in data file, server where gnmi client
will send out its request.
:param q_query: query xpath as string e.g. "/system/services/sftp/sftp-server"
can have multiple query separated by ","
e.g. "/system/services/sftp/sftp-server,/interfaces/interface"
:param qt_querytype: Tyep of query as string.
qt_querytype must be one of: once, polling or streaming.
(default "once")
:param polling_interval: Interval at which to poll in seconds if polling
is specified for query_type.(default 30s)
:param stop_after: User can specify a time after that polling or streaming
will be stopped. (default None)
:param verify: user provided string to verify can provide multiple sting separated by ","
e.g. '"sftp-server-port": "2202", "sftp-server-enabled": "true"'.
Verify string also has regular expression support.
:param external_system: External system name mentioned as in data file.
This is optional if user want to execute gnmi from a different
server other than the warrior framework host machine.
:param external_system_session: External system system session.
:param streaming_duration: Length of time to collect streaming queries (0 is infinite).
(default 0s)
:param timestamp: Specify timestamp formatting in output.
One of (<empty string>, on, raw, <FORMAT>)
where <empty string> is disabled,
on is human readable,
raw is int64 nanos since epoch,
and <FORMAT> is according to golang time.Format(<FORMAT>)
:param user_arg: Extra argument place for feature use
if any new argument user wants to pass on.
:return: True or False and dictionary containing output string and gnmi session
in case of streaming or polling
"""
wdesc = "Executing gnmi Subscribe"
testcase_Utils.pSubStep(wdesc)
status = False
result = None
outputdict = {}
gnmi_execute = gnmi()
gnmi_param = ['ip', 'gnmi_port', 'username', 'password', 'prompt',
'ca_crt', 'client_crt', 'client_key']
gnmi_param_dic = data_Utils.get_credentials(self.datafile,
system_name,
gnmi_param)
__gnmi_obj = Utils.data_Utils.get_object_from_datarepository(str(system_name)+"_gnmi_session")
file_dir = os.path.dirname(os.path.abspath(__file__))
war_dir = os.path.abspath(os.path.join(file_dir, '../..'))
binary = os.path.join(war_dir, 'Framework/Gnmi/gnmi_cli')
testcase_Utils.pNote("***** Binary path: {0} *****".format(binary))
if __gnmi_obj:
gnmi_obj = __gnmi_obj
else:
gnmi_obj = None
if external_system:
ext_gnmi_param_dic = data_Utils.get_credentials(self.datafile,
external_system,
['ca_crt', 'client_crt', 'client_key'])
if external_system == None:
ca_crt, client_crt, client_key = data_Utils.set_gnmi_cert_params(gnmi_param_dic)
else:
ca_crt, client_crt, client_key = data_Utils.set_gnmi_cert_params(ext_gnmi_param_dic)
username = gnmi_param_dic.get('username')
password = gnmi_param_dic.get('password')
prompt = gnmi_param_dic.get('prompt')
cmd_string = gnmi_execute.get_cmd_string(ip=gnmi_param_dic['ip'],
gnmi_port=gnmi_param_dic['gnmi_port'],
ca_crt=ca_crt,
client_crt_path=client_crt,
client_key=client_key,
option=option,
qt_querytype=qt_querytype,
q_query=q_query,
polling_interval=polling_interval,
timestamp=timestamp,
streaming_duration=streaming_duration,
user_arg=user_arg)
status, result, child = gnmi_execute.execute(binary, cmd_string, username,
password, prompt, external_system,
external_system_session, stop_after, gnmi_obj)
if status and verify and result:
status = gnmi_execute.verify(result, verify)
if external_system or qt_querytype not in ['polling', 'streaming']:
outputdict = {'{}_gnmi_result'.format(system_name): result}
else:
outputdict = {'{}_gnmi_result'.format(system_name): result,
'{}_gnmi_session'.format(system_name):child}
return status, outputdict
def gnmi_operations(self, system_name, q_query, operation, verify=None,
external_system=None, external_system_session=None,
timestamp="''", user_arg=""):
"""
will perform the following operations:
1. Get
2. Set operation(types: delete/replace/update)
3. Capabilities
and store the output JSON in a data dictionary.
:param system_name: server System name as in data file, server where gnmi client will
send out its request.
:param q_query: query xpath as string
e.g. "/system/services/sftp/sftp-server[sftp-server-port=2202]"
:param operation: Type of operation(get/set/capabilities).
:param verify: user provided string to verify can provide multiple sting separated by ","
e.g. '"sftp-server-port": "2202", "sftp-server-enabled": "true"'.
Verify string also has regular expression support.
:param external_system_session: External system system session.
e.g. '"sftp-server-port": "2202", "sftp-server-enabled": "true"'.
Verify string also has regular expression support.
:param timestamp: Specify timestamp formatting in output.
One of (<empty string>, on, raw, <FORMAT>)
where <empty string> is disabled,
on is human readable,
raw is int64 nanos since epoch,
and <FORMAT> is according to golang time.Format(<FORMAT>)
:param user_arg: Extra argument place for feature use
if any new argument user wants to pass on.
:return: True or False and dictionary containing output string
"""
wdesc = "***** Executing gnmi " + operation + " operation *****"
testcase_Utils.pSubStep(wdesc)
status = False
result = None
outputdict = {}
gnmi_execute = gnmi()
gnmi_param = ['ip', 'gnmi_port', 'username',
'password', 'prompt', 'ca_crt', 'client_crt', 'client_key']
gnmi_param_dic = data_Utils.get_credentials(self.datafile,
system_name,
gnmi_param)
__gnmi_obj = Utils.data_Utils.get_object_from_datarepository(str(system_name)+
"_gnmi_session")
file_dir = os.path.dirname(os.path.abspath(__file__))
war_dir = os.path.abspath(os.path.join(file_dir, '../..'))
binary = os.path.join(war_dir, 'Framework/Gnmi/gnmi_cli')
testcase_Utils.pNote("***** Binary path: {0} *****".format(binary))
if __gnmi_obj:
gnmi_obj = __gnmi_obj
else:
gnmi_obj = None
if external_system:
ext_gnmi_param_dic = data_Utils.get_credentials(self.datafile,
external_system,
['ca_crt', 'client_crt', 'client_key'])
if external_system == None:
ca_crt, client_crt, client_key = data_Utils.set_gnmi_cert_params(gnmi_param_dic)
else:
ca_crt, client_crt, client_key = data_Utils.set_gnmi_cert_params(ext_gnmi_param_dic)
username = gnmi_param_dic.get('username')
password = gnmi_param_dic.get('password')
prompt = gnmi_param_dic.get('prompt')
if operation in "get":
cmd_string = gnmi_execute.get_cmd_string(ip=gnmi_param_dic['ip'],
gnmi_port=gnmi_param_dic['gnmi_port'],
username=username, password=password,
ca_crt=ca_crt,
client_crt_path=client_crt,
client_key=client_key,
operation=operation, q_query=q_query,
timestamp=timestamp, user_arg=user_arg)
else:
cmd_string = gnmi_execute.get_cmd_string(ip=gnmi_param_dic['ip'],
gnmi_port=gnmi_param_dic['gnmi_port'],
username=username, password=password,
ca_crt=ca_crt,
client_crt_path=client_crt,
client_key=client_key,
operation=operation, q_query=q_query)
print_info("** {0} Operation in progress **".format(operation))
if cmd_string:
status, result, child = gnmi_execute.execute(binary, cmd_string, username,
password, prompt, external_system,
external_system_session, None,
gnmi_obj)
if status and verify:
status = gnmi_execute.verify(result, verify)
outputdict = {'{}_gnmi_result'.format(system_name): result}
return status, outputdict
def build_server(self, datafile, system_name):
"""
Take in a system and read all its routes
Load the routes into Bottle server object
Start a thread with the bottle server
return the bottle server adapter and server thread
"""
app = Bottle()
# Get system and routes
system_data = data_Utils.get_credentials(datafile, system_name)
self.datafile = datafile
route_file = system_data['mapping_file']
if route_file:
route_file = getAbsPath(route_file, getDirName(datafile))
# Loop through each route
for route in data_Utils.get_all_system_or_subsystem(route_file):
route_name = route.get('name')
if route_name[0] != '/':
route_name = '/' + route_name
# Group request condition with the same method together
route_methods = {}
for request in route:
request_method = request.find('request_method').text.upper()
if request_method not in route_methods:
route_methods[request_method] = [request]
else:
route_methods[request_method].append(request)
# Build route with the grouped conditions
for method_type, same_type_methods in route_methods.items():
# A route can have general response and conditional response
specific_res = []
general_res = {}
for method in same_type_methods:
dict_of_info = {}
method_req = {}
method_res = {}
# Get all info from the condition
for info in iter(method):
if info.tag in dict_of_info:
dict_of_info[info.tag].append(info.text)
else:
dict_of_info[info.tag] = [info.text]
# Extract request/response related info
for key, value in dict_of_info.items():
if key in request_verify_list:
method_req = {key: value}
elif key in response_list:
method_res[key] = value
if any([
key in request_verify_list
for key in dict_of_info.keys()
]):
# this condition has request/response pair
method_combine = method_req
method_combine.update(method_res)
specific_res.append(method_req)
# this ensure when all verification fail and no general response given
# there will be some responses
if any([
key in on_fail_response_list
for key in dict_of_info.keys()
]):
general_res.update(method_res)
else:
# this condition only has general response
general_res.update(method_res)
app.route(
route_name, method_type,
self.build_route(route_name, method_type, specific_res,
general_res))
# Build a class to hold the server so it can be closed easily
port = 5000 if "port" not in system_data else int(system_data["port"])
server = ServerHandler(host="0.0.0.0", port=port)
server_thread = threading.Thread(target=run,
kwargs={
"app": app,
"server": server,
"debug": True
})
server_thread.daemon = True
server_thread.start()
sleep(2)
if server_thread.is_alive():
return True, {"server": server, "server_thread": server_thread}
else:
return False, {}
def execute_robot_wrapper(self, system_name, session_name=None):
"""
This keyword is to execute python scripts which internally calls robot scripts.
:Arguments:
1. system_name(string) - Name of the system/subsystem in the datafile
2. session_name(string) - name of the session to the system
:Returns:
1. status(bool)= True/False
:Datafile usage:
Tags or attributes to be used in input datafile for the system/subsystem
If both tag and attribute is provided the attribute will be used
1. ip = IP address of the system where the python script will be executed
Default value for ip type is ip, it can take any type of ip's
to connect to (like ipv4, ipv6, dns etc)
Users can provide tag/attribute for any ip_type under the
system in the input datafile and specify the tag/attribute name
as the value for ip_type argument, then the connection will be
established using that value
2. username = username for the session
3. password = password for the session
4. end_prompt = prompt expected when the command(python script) execution
is successful, default value: .*(%|#|\$).
5. remote = 'yes' when executed in remote system & 'no'(default)
when executed in local system
6. file_path = path of the python script to be executed
7. output_dir = directory path used as outputdir for robot scripts
available in the python script(in execution machine). All the
Robot tests listed in the Python script should have same output directory.
8. local_output_dir = path of the directory in the local system
where the robot output files from remote system will be copied.
If this tag is not available or left empty, results will be
stored in 'home/<username>/robot_wrapper_opdir' directory.
Note: Tags 1,2,3 & 8 are only required to copy the results from
remote to local system when remote(5) argument is set to 'yes'.
"""
session_id = get_session_id(system_name, session_name)
session_object = get_object_from_datarepository(session_id)
credentials = get_credentials(self.datafile, system_name, [
'ip', 'username', 'password', 'end_prompt', 'remote', 'file_path',
'output_dir', 'local_output_dir'
])
if not credentials['file_path'] or not credentials['output_dir']:
pNote(
"Please provide values for 'file_path & output_dir' "
"tags in input data_file", 'warning')
return False
if credentials['end_prompt']:
prompt = credentials['end_prompt']
else:
prompt = ".*(%|#|\$)"
data_directory = os.path.dirname(self.datafile)
abs_filepath = getAbsPath(credentials['file_path'], data_directory)
abs_output_dir = getAbsPath(credentials['output_dir'], data_directory)
current_time = time.time()
if os.path.isfile(abs_filepath):
command = "python " + abs_filepath
status = session_object.send_command(".*", prompt, command)[0]
if status is True:
pNote("Robot_wrapper script: '{}' execution is successful".
format(abs_filepath))
else:
pNote(
"Robot_wrapper script: '{}' execution failed".format(
abs_filepath), 'warning')
else:
pNote(
"Robot_wrapper script: '{}' does not exist".format(
abs_filepath), 'warning')
status = False
# When executed in remote machine
if credentials['remote'] and credentials['remote'].upper() == "YES":
if credentials['local_output_dir']:
local_output_dir = getAbsPath(credentials['local_output_dir'],
data_directory)
else:
local_output_dir = "~/robot_wrapper_opdir"
get_file_from_remote_server(credentials['ip'],
credentials['username'],
credentials['password'],
abs_output_dir, local_output_dir)
abs_output_dir = local_output_dir + os.sep + os.path.basename(
abs_output_dir)
# Get the modified xml files in the output_dir
modified_list = get_modified_files(abs_output_dir, current_time,
".xml")
# Get the robot xml files from the modified list of files
robot_xml_list = robot_wrapper_utils.get_robot_xml_files(modified_list)
# Get results from robot xml files
robot_test_results = robot_wrapper_utils.get_results_from_robot_xml(
robot_xml_list)
# Create junit for robot tests
robot_wrapper_utils.create_case_junit(robot_test_results)
return status
def convert_csv_or_excel_to_xml(input_file,
mapping_file=None,
output_xml_file_path=None,
overwrite="yes"):
"""
Takes file path as input
1. If it is excel file, converts to csv and then converts
csv file to xml
2. If it is csv file, converts to xml file.
3. Mapping file is used to map the column names in the excel sheet to
a meaningful name as recognized by the code.
Arguments:
1. input_file: input_file which is either
csv file path or excel file path
2. mapping_file: If a mapping file path is given, it is used to map
columns with the meaningful name as recognized by the user else
the spaces in the column names will be replaced by "_" in
the output xml
3. output_xml_file_path: If user gives the output_xml_file_path,
creating an xml file in that path else creating
xml file in the path from where he have given csv or excel file.
Returns:
1. output_xml_file_path: Returns the output xml file path
2 output_dict: Updates the output_dict with
json string and with output xml.
"""
output_dict = {}
generate_csv = False
try:
if ".xls" in input_file:
input_file = convert_excel_to_csv(input_file)
generate_csv = True
dict_response = convert_csv_to_list_of_dict(input_file)
json_response = json.dumps(dict_response,
sort_keys=False,
indent=4,
separators=(',', ': '),
encoding="utf-8")
if mapping_file:
mapping_dict = data_Utils.get_credentials(mapping_file,
'mapping_scheme')
mapping_dictionary = {v: k for k, v in mapping_dict.items()}
else:
mapping_dictionary = {}
result = []
result.append(
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<systems>\n")
for i in range(len(dict_response)):
result.append(" <system name=" + "\"" + str(i + 1) + "\">\n")
for key, value in dict_response[i].items():
if mapping_dictionary:
if key in mapping_dictionary and mapping_dictionary[key]:
result.append((" <{0}>{1}</{0}>\n").format(
mapping_dictionary[key], value))
else:
result.append(
(" <{0}>{1}</{0}>\n").format(key, value))
else:
result.append((" <{0}>{1}</{0}>\n").format(
"_".join(key.split()), value))
result.append(" </system>\n")
result.append("</systems>")
xml_res = ''.join(result)
if type(input_file) == file:
input_file = input_file.name
if generate_csv:
os.remove(input_file)
output_dict["{0}_json_response".format(input_file.replace(
".csv", ''))] = json_response
output_dict["{0}_xml_response".format(input_file.replace(
".csv", ''))] = xml_res
if output_xml_file_path:
output_xml_file = output_xml_file_path
else:
output_xml_file = input_file.replace(".csv", ".xml")
if overwrite == "no":
output_xml_file = file_Utils.addTimeDate(output_xml_file)
f = open(output_xml_file, "wb+")
f.write(xml_res)
f.close()
except Exception as exception:
print_exception(exception)
output_xml_file = None
return output_xml_file, output_dict
