def load_path_json(self, path_login_testdata): """ Retrieves data from json file. Returns None if exception occurs.""" result = False data = None try: with open(path_login_testdata) as json_file: data = json.load(json_file) result = True except Exception as exception: pNote(exception, "error") return result, data
def _execute_step_list(self): """ """ goto_stepnum = False step_num = 0 while step_num < len(self.step_list): index = step_num step = self.step_list[step_num] step_num += 1 self.system_executed = self._get_system_executed(index) if self.stop_after_current_step: break # when there is no goto if not goto_stepnum: result = self._execute_step(self.system_executed, step_num, index, goto_stepnum) # when goto is triggered and matches the current step number elif (goto_stepnum and goto_stepnum == str(step_num)): result = self._execute_step(self.system_executed, step_num, index, goto_stepnum) goto_stepnum = False # when goto is triggered and does not match current step... skip elif goto_stepnum and goto_stepnum != str(step_num): result = self._update_skip_results(step, self.system_executed, step_num) self.kw_resultfile_list.append(result[1]) continue step_status = result[0] kw_resultfile = result[1] step_impact = result[2] exec_type_onerror = result[3] self._update_status_items(step_status, kw_resultfile, step_impact) goto_stepnum, step_num = self._compute_runmode_goto_operations(step, step_status, exec_type_onerror, goto_stepnum, step_num) if (goto_stepnum == 'ABORT'): if any([self.iter_type_list[index] == "once_per_tc", self.iter_type_list[index] == "end_of_tc"]): pNote("step iter_type={0}, and onerror action=ABORT hence aborting execution" "compeletely".format(self.iter_type_list[index]), "debug") self.stop_after_current_iteration = True self.stop_after_current_step = True goto_stepnum = False break return
def just_a_tuple(element): """ This function evaluates the value of the files tag and returned validated data. input: string (path/to/file4.txt;content_type), (path/to/file1.txt;content_type) output: dict { file4.txt: (file4.txt, open file4.txt (in binary mode), content_type) file1.txt: (file1.txt, open file1.txt (in binary mode), content_type) } """ final_dict = {} temp_list = [] element = element.strip(")") element = element.strip("(") if element is not None and element is not False and element != "": element = element.split(";") for i in range(0, len(element)): element[i] = element[i].strip() if element[0] is not None and element[0] is not False \ and element[0] != "": abs_path = file_Utils.getAbsPath(element[0], sys.path[0]) if os.path.exists(abs_path): temp_list.append(os.path.basename(os.path.normpath( element[0]))) temp_list.append(open(abs_path, 'rb')) if len(element) > 1: if element[1] is not None and element[1] is not False \ and element[1] != "": temp_list.append(element[1]) else: pNote("{0} doesn't exist!".format(element[0]), "error") else: if element == "": pNote("File path cannot be empty!", "error") else: pNote("File path cannot be {0}!".format(element[0]), "error") if temp_list != []: if len(temp_list) > 2: final_dict[temp_list[0]] = (temp_list[0], temp_list[1], temp_list[2]) else: final_dict[temp_list[0]] = (temp_list[0], temp_list[1]) else: if element == "": pNote("File path cannot be empty!", "error") else: pNote("File path cannot be {0}!".format(element), "error") return final_dict
def import_requests(self): """Import the requests module """ try: import requests except ImportError: pNote("Requests module is not installed"\ "Please install requests module to"\ "perform any activities related to REST interfaces", "error") else: self.req = requests
def check_type(var, varname, datatype): """check that vars are of correct datatype """ vartype = type(var) status = True if vartype is not datatype: pNote( '{} is expected to be {} type, but found to be of ' '{} type'.format(varname, datatype, vartype), "error") status = False return status
def warrior_framework_details(): """This gets framework details such the executing framework path, release & version details. """ #The logic uses relative file path to locate Warrior framework and its\ # release notes.Assumes the relative structure remains constant. release = False version = False version_file_path = os.path.normpath( os.path.join(__file__, "..{0}..{0}..".format(os.sep))) version_file = os.path.join(version_file_path, "version.txt") version_file_exists = file_Utils.fileExists(version_file) if version_file_exists: release_notes = open(version_file, "r") for line in release_notes: line = line.strip() #pattern matching Release:<> if re.match('(Release.*):(.*)', line): match = re.match(r'(Release.*):(.*)', line) release = match.group(2) #pattern matching Version:<> if re.match('(Version.*):(.*)', line): match = re.match(r'(Version.*):(.*)', line) version = match.group(2) user = getpass.getuser() proc1 = subprocess.Popen(['git', 'branch'], stdout=subprocess.PIPE) proc2 = subprocess.Popen(['grep', '*'], stdin=proc1.stdout, stdout=subprocess.PIPE, stderr=None) proc1.stdout.close() # Allow proc1 to receive a SIGPIPE if proc2 exits. branch = proc2.communicate()[0] if release and version and version_file_path: pNote( "========================== WARRIOR FRAMEWORK DETAILS ==========================", 'notype') print_info( 'The Warrior framework used is {0}'.format(version_file_path)) print_info('The Warrior framework user is {0}'.format(user)) print_info('The Warrior framework Release is{0}'.format(release)) print_info('The Warrior framework version is{0}'.format(version)) print_info('The Warrior framework branch is{0}'.format( branch.strip('*'))) print_info( 'The Warrior framework running on python version: {0} with OS: {1}' .format(platform.python_version(), platform.platform())) pNote( "========================== WARRIOR FRAMEWORK DETAILS ==========================", 'notype') #Sleep for the user to view the console for a second on the framework detail time.sleep(2) return None
def check_tmp_file_exists(self, system_name="", filename=""): """ check if temp folder exist in the parallel execution result tmp dir """ if system_name != "" and filename == "": filename = data_Utils.getSystemData(self.datafile, system_name, "filename") elif system_name == "" and filename == "": pNote("No system or filename found, needs to provide at least one", "error") path = data_Utils.get_object_from_datarepository( "parallel_exec_tmp_dir") path = os.path.join(path, filename) return file_Utils.fileExists(path)
def edit_config_from_string(self, datastore, config, system_name, session_name=None, default_operation=None, test_option=None, error_option=None): """ Loads all or part of the specified config(not file) to the datastore :Arguments: 1. datastore(string) = Name of datastore being edited 2. config(string) = The configuration xml string. 3. system_name(string) = Name of the system from the input datafile 4. session_name(string) = Name of the session to the system 5. default_operation(string) = [merge | replace | none (default)] 6. test_option(string) = [test_then_set | set | test-only | none (default)] 7. error_option(string) = [stop-on-error | continue-on-error | rollback-on-error | none (default)] rollback-on-error depends on :rollback-on-error capability :Returns: 1. status(bool)= True / False 2. Edit Response in the data repository {data:reply(xml)} """ wdesc = "Edit system configuration data" pSubStep(wdesc) pNote(system_name) pNote(self.datafile) self.clear_notification_buffer_all(system_name, session_name) session_id = Utils.data_Utils.get_session_id(system_name, session_name) netconf_object = Utils.data_Utils.get_object_from_datarepository( session_id) reply = netconf_object.edit_config(datastore, config, default_operation=default_operation, test_option=test_option, error_option=error_option) if netconf_object.isCOMPLD: status = True if reply: reply = parseString(reply).toprettyxml(indent=" ", encoding="UTF-8") pNote('edit-config: Reply= {}'.format(reply)) else: pNote('edit-config: Reply= {}'.format(reply)) pNote('edit-config: Failed {}'.format(netconf_object.ErrorMessage), "error") status = False report_substep_status(status) reply_key = '{}_edit_config_reply'.format(system_name) return status, {reply_key: reply}
def remove(self, filename): """remove the filename from the system :Arguments: filename - filename path to be removed from system :Returns: True if successful otherwise False """ wdesc = "remove the filename from the system" pNote(wdesc) status = file_Utils.remove(filename) pStep('removing {!r}'.format(filename)) file_Utils.log_result("remove", status) return status
def clear_notification_buffer_for_print(self, system_name, session_name=None): """clear the notification print buffer :Arguments: 1. system_name (string) = system name 2. session_name (string) = session name :Returns: 1. status (bool) """ wdesc = "clear the notification print buffer" pNote(wdesc) session_id = Utils.data_Utils.get_session_id(system_name, session_name) netconf_object = Utils.data_Utils.get_object_from_datarepository(session_id) return netconf_object.clear_notification_buffer_for_print()
def instantiate_list_key_in_data_repository(self, key): """ This will create a key in the data_repository :param key: name of the key that should be created in the data_repository. The data type of it's value will be list. :return: status (bool), output_dict (dict) """ wdesc = "This keyword will create a key in the data repository" pNote(wdesc) status = True output_dict = {key: []} pNote("Updating Data Repository with key: {0}".format(key)) return status, output_dict
def close_trap_listner_job(cls, port): """ Close the trap listner job :param transportDispatcher: :return:None """ snmpEngine = cls.get_asyncoredispatcher(port) snmpEngine.transportDispatcher.jobFinished(1) try : snmpEngine.transportDispatcher.unregisterTransport(udp.domainName) except: testcase_Utils.pNote("Can not unregister udp Transport domain", 'warning')
def close(self): ''' #session close ''' try: self.__chan.close() self.__t.close() except Exception as e: pNote(str(e), "error") traceback.print_exc() self.__isOpen = False pNote("netconf: port closed") return True
def cs_get_topo_details(self, topology_path): """To get the Cloudshell topology details for a given path :Datafile usage: NA :Arguments: 1. topology_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 """ wdesc = "To get the Cloudshell topology details for a given path" testcase_Utils.pSubStep(wdesc) testcase_Utils.pNote(file_Utils.getDateTime()) status = False testcase_Utils.pNote("cs_get_topo_details, cs obj-{}".\ format(cloud_shell), "info") try: xml_resp = cloud_shell.GetTopologyDetails(topology_path) if xml_resp is not None: testcase_Utils.pNote("\n\n *** Get Topolopy \"%s\" successfull\n"\ % (topology_path), "info") status = True else: testcase_Utils.pNote("\n\n *** Get Topolopy \"%s\" failed\n"\ % (topology_path), "warning") except Exception as exception: print_exception(exception) testcase_Utils.report_substep_status(status) return status
def cs_logoff(self): """To logoff from CS :Datafile usage: NA :Arguments: NA :Returns: 1. status(bool)= True/False """ wdesc = "To logoff from CS" testcase_Utils.pSubStep(wdesc) testcase_Utils.pNote(file_Utils.getDateTime()) status = False testcase_Utils.pNote("cs_logoff, cs obj-{}".format(cloud_shell), "info") xml_resp = cloud_shell.Logoff() if xml_resp is not None: testcase_Utils.pNote( "\n\n *** Cloudshell LogOff successfull-%s" % (cloud_shell.host), "info") status = True else: testcase_Utils.pNote( "\n\n *** Cloudshell LogOff failed-%s" % (cloud_shell.host), "warning") testcase_Utils.report_substep_status(status) return status
def connect_to_cs(self, system_name): """Logs in to API host using passed user credentials and domain :Datafile usage: NA :Arguments: 1. system_name(string) = Name of the system from the datafile :Returns: 1. status(bool)= True/False """ wdesc = "Logon to CloudShell API Host" testcase_Utils.pSubStep(wdesc) testcase_Utils.pNote(file_Utils.getDateTime()) global cloud_shell cloud_shell = self._create_cs_obj(system_name) testcase_Utils.pNote("Login, cs obj-{}".format(cloud_shell), "info") status = False if cloud_shell is not None: testcase_Utils.pNote("\n\n *** Login to Cloudshell System-{}" " successfull, domain-{}\n".\ format(cloud_shell.host,\ cloud_shell.domain), "info") status = True else: testcase_Utils.pNote( "\n\n *** Login to Cloudshell System" " failed\n", "warning") testcase_Utils.report_substep_status(status) return status
def discard_changes(self, system_name, session_name=None): """Revert the candidate configuration to the currently running configuration. Uncommitted changes will be discarded. :Arguments: 1. system_name(string) = Name of the system from the input datafile 2. session_name(string) = Name of the session to the system :Returns: 1. status(bool)= True / False 2. Discard Response in the data repository {data:reply(xml)} """ wdesc = "Discard any uncommitted changes to the candidate configuration" pSubStep(wdesc) pNote(system_name) pNote(self.datafile) self.clear_notification_buffer_all(system_name, session_name) session_id = Utils.data_Utils.get_session_id(system_name, session_name) netconf_object = Utils.data_Utils.get_object_from_datarepository( session_id) reply = netconf_object.discard_changes() if reply: reply = parseString(reply).toprettyxml(indent=" ") pNote('discard-changes: Reply= {}'.format(reply)) if netconf_object.isCOMPLD: status = True else: pNote( 'discard-changes: Failed {}'.format( netconf_object.ErrorMessage), "error") status = False report_substep_status(status) reply_key = '{}_discard_changes_reply'.format(system_name) return status, {reply_key: reply}
def copy(self, filename, newname): """copy filename to newname :Arguments: filename - filename path to be copied newname - new file name or path to which the file has to be copied :Returns: True if successful otherwise False """ wdesc = "copy filename to newname" pNote(wdesc) status = file_Utils.copy(filename, newname) pStep('Copying {!r} to {!r}'.format(filename, newname)) file_Utils.log_result("copy", status) return status
def lock(self, datastore, system_name, session_name=None): """Lock the configuration system :Arguments: 1. datastore(string) = name of the configuration datastore to be locked 2. system_name(string) = Name of the system from the input datafile 3. session_name(string) = Name of the session to the system :Returns: 1. status(bool)= True / False 2. Lock Response in the data repository {data:reply(xml)} """ wdesc = "Lock the configuration datastore" pSubStep(wdesc) pNote(system_name) pNote(self.datafile) session_id = Utils.data_Utils.get_session_id(system_name, session_name) netconf_object = Utils.data_Utils.get_object_from_datarepository(session_id) reply = netconf_object.lock(datastore) pNote('Lock Reply= {}'.format(reply)) if netconf_object.isCOMPLD: status = True else: pNote('Lock Failed {}'.format(netconf_object.ErrorMessage), "error") status = False report_substep_status(status) reply_key = '{}_lock_reply'.format(system_name) return status, {reply_key: reply}
def testfor_killsession(self, system_name, session_name=None): """kill-session test keyword create another session to same NE and kills it. :Arguments: 1. system_name(string) = Name of the system from the input datafile 2. session_name(string) = Name of the session to the system :Returns: 1. status(bool)= True / False """ wdesc = "kill-session, create another session and kill it" pSubStep(wdesc) pNote(system_name) pNote(self.datafile) test_netconf = WNetConf() session_parameters = [ 'ip', 'nc_port', 'username', 'password', 'allow_agent', 'hostkey_verify', 'look_for_keys', 'timeout', 'device_name' ] session_credentials = Utils.data_Utils.get_credentials( self.datafile, system_name, session_parameters) session_credentials["password"] = decrypt( session_credentials["password"]) if test_netconf.open(session_credentials): time.sleep(1) sid = test_netconf.session_id status, reply = self.kill_session(system_name, sid, session_name) else: status = False if status: pNote("kill-session PASS") else: pNote("kill-session FAIL", "error") report_substep_status(status) return status
def kill_session(self, system_name, netconf_session_id=None, session_name=None): """Force the termination of a NETCONF session (not the current one!) :Arguments: 1. system_name(string) = Name of the system from the input datafile 2. netconf_session_id(string) = session-id of netconf 3. session_name(string) = Name of the session to the system :Returns: 1. status(bool)= True / False 2. Kill Response in the data repository {data:reply(xml)} """ wdesc = "Force the termination of a NETCONF session (not the current one!)" pSubStep(wdesc) pNote(system_name) pNote(self.datafile) self.clear_notification_buffer_all(system_name, session_name) session_id = Utils.data_Utils.get_session_id(system_name, session_name) netconf_object = Utils.data_Utils.get_object_from_datarepository( session_id) if not netconf_session_id: netconf_session_id = "0" reply = netconf_object.kill_session(netconf_session_id) if reply: reply = parseString(reply).toprettyxml( indent=" ", encoding="UTF-8") pNote('kill-session: Reply= {}'.format(reply)) if netconf_object.isCOMPLD: status = True else: pNote('kill-session: Failed {}'.format(netconf_object.ErrorMessage), "error") status = False report_substep_status(status) reply_key = '{}_kill_session_netconf_reply'.format(system_name) return status, {reply_key: reply}
def get(self, system_name, session_name=None, filter_string=None, filter_type=None): """Retrieve operational state information. :Arguments: 1. system_name(string) = Name of the system from the input datafile 2. session_name(string) = Name of the session to the system 3. filter_string(string) = specifies the portion of the state information to retrieve (by default entire state information is retrieved) 4. filter_type(string) = subtree or xpath :Returns: 1. status(bool)= True / False 2. Retrieve Response in the data repository {data:reply(xml)} """ wdesc = "Retrieve operational state information (get rpc)." pSubStep(wdesc) pNote(system_name) pNote(self.datafile) self.clear_notification_buffer_all(system_name, session_name) session_id = Utils.data_Utils.get_session_id(system_name, session_name) netconf_object = Utils.data_Utils.get_object_from_datarepository( session_id) reply = netconf_object.get(filter_string, filter_type) if reply: reply = parseString(reply).toprettyxml( indent=" ", encoding="UTF-8") pNote('get: Reply= {}'.format(reply)) if netconf_object.isCOMPLD: status = True else: pNote('get: Failed {}'.format(netconf_object.ErrorMessage), "error") status = False report_substep_status(status) reply_key = '{}_get_config_reply'.format(system_name) return status, {reply_key: reply}
def unlock(self, datastore, system_name, session_name=None): """Release the configuration lock :Arguments: 1. datastore(string) = name of the configuration datastore to be unlocked 2. system_name(string) = Name of the system from the input datafile 3. session_name(string) = Name of the session to the system :Returns: 1. status(bool)= True / False 2. Unlock Response in the data repository {data:reply(xml)} """ wdesc = "Unlock the configuration datastore" pSubStep(wdesc) pNote(system_name) pNote(self.datafile) self.clear_notification_buffer_all(system_name, session_name) session_id = Utils.data_Utils.get_session_id(system_name, session_name) netconf_object = Utils.data_Utils.get_object_from_datarepository( session_id) reply = netconf_object.unlock(datastore) if reply: reply = parseString(reply).toprettyxml( indent=" ", encoding="UTF-8") pNote('unlock: Reply= {}'.format(reply)) if netconf_object.isCOMPLD: status = True else: pNote('unlock: Failed {}'.format( netconf_object.ErrorMessage), "error") status = False report_substep_status(status) reply_key = '{}_unlock_reply'.format(system_name) return status, {reply_key: reply}
def end_of_tc_with_system_name_not_given(self, system_name, step_num): """ It is used to test the functionality of end of tc with no system name given in the test case Arguments: system_name: Name of the system on which it needs to be run step_num: It is the step_num in the test case file Returns: Returns True """ wdesc = "End of testcase with system name not given" pNote(wdesc) key = 'end_of_tc_with_system_name_not_given_' + str(step_num) self.write_to_file(key, system_name) return True
def commit(self, system_name, confirmed=False, timeout=None, persist=None, persist_id=None, session_name=None): """Commit the candidate datastore as the device's new current configuration :Arguments: 1. system_name(string) = Name of the system from the input datafile 2. confirmed(bool) = Commit is reverted if there is no followup commit within the timeout interval. 3. timeout(int seconds) = The confirm timeout (Default=600 seconds) 4. persist(string) = persist-id 5. persist_id(string) = persist-id which specified in previous confirmed commit 6. session_name(string) = Name of the session to the system :Returns: 1. status(bool)= True / False 2. Commit Response in the data repository {data:reply(xml)} """ wdesc = "Commit the candidate datastore" pSubStep(wdesc) pNote(system_name) pNote(self.datafile) session_id = Utils.data_Utils.get_session_id(system_name, session_name) netconf_object = Utils.data_Utils.get_object_from_datarepository(session_id) reply = netconf_object.commit(confirmed, timeout, persist, persist_id) pNote('Commit Reply= {}'.format(reply)) if netconf_object.isCOMPLD: status = True else: pNote('Commit Failed {}'.format(netconf_object.ErrorMessage), "error") status = False report_substep_status(status) reply_key = '{}_commit_reply'.format(system_name) return status, {reply_key: reply}
def copystat(self, filename, newname): """copy only stats of filename to newname and not its contents :Arguments: filename - stats of the filename path to be copied newname - new file name or path to which the stats has to be copied :Returns: True if successful otherwise False """ wdesc = "copy stats of filename to newname" pNote(wdesc) status = file_Utils.copystat(filename, newname) pStep('Copying stat of {!r} to {!r}'.format(filename, newname)) file_Utils.log_result("copystat", status) return status
def validate(self, datastore, system_name, session_name=None): """"Validate the contents of the specified configuration. :Arguments: 1. datastore(string) = Name of the configuration datastore to be validated 2. system_name(string) = Name of the system from the input datafile 3. session_name(string) = Name of the session to the system :Returns: 1. status(bool)= True / False 2. Validation Response in the data repository {data:reply(xml)} """ wdesc = "Validate the contents of the specified configuration." pSubStep(wdesc) pNote(system_name) pNote(self.datafile) self.clear_notification_buffer_all(system_name, session_name) session_id = Utils.data_Utils.get_session_id(system_name, session_name) netconf_object = Utils.data_Utils.get_object_from_datarepository( session_id) reply = netconf_object.validate(datastore) if reply: reply = parseString(reply).toprettyxml(indent=" ") pNote('validate: Reply= {}'.format(reply)) if netconf_object.isCOMPLD: status = True else: pNote('validate: Failed {}'.format(netconf_object.ErrorMessage), "error") status = False report_substep_status(status) reply_key = '{}_validate_netconf_reply'.format(system_name) return status, {reply_key: reply}
def __send(self, data): ''' #send data to host # data = data to send (xml string) ''' ret = True if self.__isOpen: pNote("netconf send:\n" + parseString(data).toprettyxml()) self.__send_data = data self.__response_buffer = "" self.__notification_buffer = "" try: data = XML_HEADER + data + NETCONF_DELIM while data: n = self.__chan.send(data) if n <= 0: pNote("netconf: send data failed.", "error") ret = False break data = data[n:] except socket.error as e: pNote(str(e.__class__) + ': ' + str(e), "error") traceback.print_exc() ret = False else: pNote("netconf: port not opened", "warning") ret = False return ret
def cancel_commit(self, system_name, persist_id=None, session_name=None): """cancel-commit :Arguments: 1. system_name(string) = Name of the system from the input datafile 2. persist_id(string) = persist-id which specified in confirm-commit 3. session_name(string) = name of the session to the system :Returns: 1. command_status(bool) 2. {data:reply.data(xml)} """ wdesc = "cancel-commit" pSubStep(wdesc) pNote(system_name) pNote(self.datafile) self.clear_notification_buffer_all(system_name, session_name) session_id = Utils.data_Utils.get_session_id(system_name, session_name) netconf_object = Utils.data_Utils.get_object_from_datarepository( session_id) reply = netconf_object.cancel_commit(persist_id) if reply: reply = parseString(reply).toprettyxml(indent=" ") pNote('cancel-commit: Reply= {}'.format(reply)) if netconf_object.isCOMPLD: status = True else: pNote( 'cancel-commit: Failed {}'.format(netconf_object.ErrorMessage), "error") status = False report_substep_status(status) reply_key = '{}_request_rpc_reply'.format(system_name) return status, {reply_key: reply}
def rename(self, filename, newname): """rename or move filename to newname :Arguments: filename - filename path to be renamed or moved newname - new file name or path to which the file has to be moved :Returns: True if successful otherwise False """ wdesc = "rename or move a file" pNote(wdesc) status = file_Utils.move(filename, newname) pStep('renaming {!r} to {!r}'.format(filename, newname)) file_Utils.log_result("rename", status) return status