def createDir_addtimestamp(path, dirname): """Creates a new directory with name = dirname under the provided path, if directory with same name already exists adds date+timestamp to the name and creates a new directory with name = dirname+date×tamp Arguments: 1. path = (string) full path of an existing directory where a new directory need to be created 2. dirname = (string) name of the new directory to be created """ if dirExists(path): dirpath = os.path.abspath(path) + os.sep + dirname if dirExists(dirpath): dirpath = addTimeDate(dirpath) try: os.makedirs(dirpath) except Exception as exception: # print_exception(exception) print_info( "Add date time and try to create directory one more time") dirpath = addTimeDate(dirpath) os.makedirs(dirpath) #print_info("A new '%s' directory created : '%s'" % (dirname, dirpath)) return dirpath else: print_warning( "Directory does not exist in provided path: {0}".format(path)) return False
def move_to_text(fd, pattern, n=1): """ seek to a text in the file :Arguments: pattern - the regular expression pattern to search for in the file n - seek to the nth occurrence from beginning, default first occurrence use negative indices for from the end :Return: True/False - based success or failure of seeking """ pos = -1 fd.seek(0, 0) data = fd.read() try: data_pos = string_Utils.seek_next(pattern, data)[n] pos = fd.seek(data_pos) print_info("moving to {}th pattern {} in file {} successful".format( n, pattern, fd.name)) except IndexError: print_error("pattern {} not found in {}".format(pattern, fd)) except ValueError: print_error("file is already closed...") except Exception as e: print_error( "exception {} occurred while seeking pattern {} in {}".format( str(e), pattern, fd)) return pos
def get_elements_by_tagname_ignore_ns(filename, element_tag): """"Parses an xml using minidom and gets all the elements with matching tag names in the file, ignores namespaces in the tag names """ doc = minidom.parse(filename) element_list = doc.getElementsByTagNameNS('*', element_tag) if len(element_list) == 0: print_info('element with tagname "%s" not found in file' % element_tag) return False return element_list
def put_file_to_remote_server(remote_ip, remote_uname, remote_passwd, src, dest, logfile=None): """ use scp to put file from remote server """ cmd = 'scp %s %s@%s:%s' % (dest, remote_uname, remote_ip, src) print_info("Running cmd: %s" % cmd) child = pexpect.spawn(cmd) try: child.logfile = open(logfile, "a") except Exception, e: child.logfile = None
def getRoot(filename): """ Get the Root of the xml file""" try: tree = ElementTree.parse(filename) root = tree.getroot() except ElementTree.ParseError, msg: print_error("The xml file: {0} is {1}".format(filename, msg)) print_info("DONE 1") sys.exit(0)
def log_result(oper, result): """the methods in file_actions class use this to log the result of its operation """ resmsg = "completed successfully" if result else "failed" msg = "file {} operation {}".format(oper, resmsg) if result: print_info(msg) else: print_error(msg)
def deleteMatchingFileLines(origfile, newfile, arrValues): fin = open(origfile, 'r') fout = open(newfile, 'w') for line in fin: if any(v in line for v in arrValues): print_info("The following was deleted: '%s'" % line) else: fout.write(line) fout.close()
def deleteMatchingFileLines(origfile, newfile, arrValues): """ Searches existing file for text and creates new file without the lines containing the text.""" fin = open(origfile, 'r') fout = open(newfile, 'w') for line in fin: if any(v in line for v in arrValues): print_info("The following was deleted: '%s'" % line) else: fout.write(line) fout.close()
def remove(nfile): """ removes the file from the filesystem :Arguments: nfile - filepath to be removed :Return: True/False - based on the success/failure of the operation """ status = False try: os.remove(nfile) print_info(nfile + " removed from filesystem") status = True except Exception as e: print_error("removing file {} raised exception {}".format( nfile, str(e))) return status
def write(fd, string): """ Writes a string to the file. :Arguments: fd - file descriptor got from open_file str - string to write :Return: True/False - based on the success/failure of the operation """ status = False try: fd.write(string) print_info("written to file " + fd.name) status = True except ValueError: print_error("file is already closed...") except Exception as e: print_error("found exception {} while writing {}".format(str(e), fd)) return status
def copyfile(src, dst): """ Copy the contents (no metadata) of the file named src to a file named dst. dst must be the complete target file name. :Arguments: src - file to be copied dst - file on which to be copied :Return: True/False - based on the success/failure of the operation """ status = False try: shutil.copyfile(src, dst) print_info("src {} copied to dst {} successfully".format(src, dst)) status = True except Exception as e: print_error("copying file {} to file {} raised exception {}".format( src, dst, str(e))) return status
def readline(fd, **kwargs): """ Reads one entire line from the file. A trailing newline character is kept in the string. :Arguments: fd - file descriptor got from open_file :Return: the line read """ try: line = fd.readline(**kwargs) print_info("read a line from file " + fd.name) except ValueError: print_error("file is already closed...") line = False except Exception as e: print_error("found exception {} while reading line in {}".format( str(e), fd)) line = False return line
def close(fd): """ Close the file. A closed file cannot be read or written any more. :Arguments: fd - file descriptor got from open_file :Return: True/False - based on the success/failure of the operation """ try: name = fd.name status = fd.close() print_info("file {} closed successfully".format(name)) except ValueError: print_warning("file is already closed...") status = True except Exception as e: print_error("found exception {} while closing {}".format(str(e), fd)) status = False return status
def writelines(fd, seq): """ Writes a sequence of strings to the file. The sequence can be any iterable object producing strings, typically a list of strings. :Arguments: fd - file descriptor got from open_file sequence - sequence of lines to be written :Return: True/False - based on the success/failure of the operation """ status = False try: fd.writelines(seq) print_info("written seq to the file " + fd.name) status = True except ValueError: print_error("file is already closed...") except Exception as e: print_error("found exception {} while writing {}".format(str(e), fd)) return status
def copymode(src, dst): """ Copy the permission bits from src to dst. The file contents, owner, and group are unaffected. src and dst are path names given as strings. :Arguments: src - mode of the file to be copied dst - file on which mode has to be copied :Return: True/False - based on the success/failure of the operation """ status = False try: shutil.copymode(src, dst) print_info("mode of src {} copied to dst {} successfully". format(src, dst)) status = True except Exception as e: print_error("copying file mode from {} to file {} raised exception {}". format(src, dst, str(e))) return status
def read(fd, **kwargs): """ Reads at most size bytes from the file (less if the read hits EOF before obtaining size bytes). :Arguments: fd - file descriptor got from open_file :Optional: size - number of bytes to be read :Return: the string read from the file, None if not able to read """ try: readsize = fd.read(**kwargs) print_info("read {} bytes from file {}".format(readsize, fd.name)) except ValueError: print_error("file is already closed...") readsize = 0 except Exception as e: print_error("found exception {} while reading {}".format(str(e), fd)) readsize = 0 return readsize
def copy2(src, dst): """ Similar to shutil.copy(), but metadata (permissions etc., as mentioned in copy_stat above) is copied as well in fact, this is just shutil.copy() followed by copystat(). This is similar to the Unix command cp -p. :Arguments: src - file and metadata to be copied dst - file/dir on which to be copied :Return: True/False - based on the success/failure of the operation """ status = False try: shutil.copy2(src, dst) print_info("src {} copied to dst {} successfully along with metadata". format(src, dst)) status = True except Exception as e: print_error("copying file {} with metadata to file {} raised exception" " {}".format(src, dst, str(e))) return status
def check_and_create_dir(dirpath): """Checks if dir exists in provided path. If dir exists returns True Elseif dir does not exists, tries to create a directory - If dir created successfully, returns True. - If dir creation failed returns false """ status = False if pathExists(dirpath): print_info("Directory exists in provided path '{0}': ".format(dirpath)) status = True elif not pathExists(dirpath): try: os.makedirs(dirpath) except Exception as exception: print_warning("Creating directory at '{0}' failed.".format(dirpath)) print_exception(exception) status = False else: status = True return status
def copy(src, dst): """ Copy the file src to the file or directory dst. If dst is a directory, a file with the same basename as src is created (or overwritten) in the directory specified. Permission bits are copied. src and dst are path names given as strings. :Arguments: src - file to be copied dst - file/dir on which to be copied :Return: True/False - based on the success/failure of the operation """ status = False try: shutil.copy(src, dst) print_info("src {} copied to dst {} successfully".format(src, dst)) status = True except Exception as e: print_error("copying file {} to file {} raised exception {}".format( src, dst, str(e))) return status
def truncate(fd, **kwargs): """ Truncates the file's size. If the optional size argument is present, the file is truncated to (at most) that size. :Arguments: fd - file descriptor got from open_file :Optional: size - size up to which to truncate :Return: True/False - based on the success/failure of the operation """ status = False try: fd.truncate(**kwargs) print_info("truncated the file " + fd.name) status = True except ValueError: print_error("file is already closed...") except Exception as e: print_error("found exception {} while truncating {}".format( str(e), fd)) return status
def readlines(fd, **kwargs): """ Reads until EOF using readline() and return a list containing the lines. If the optional sizehint argument is present, instead of reading up to EOF, whole lines totalling approximately sizehint bytes (possibly after rounding up to an internal buffer size) are read. :Arguments: fd - file descriptor got from open_file :Return: list of lines from the file """ try: lines = fd.readlines(**kwargs) print_info("read all lines from file " + fd.name) except ValueError: print_error("file is already closed...") lines = False except Exception as e: print_error("found exception {} while reading lines in {}".format( str(e), fd)) lines = False return lines
def move(src, dst): """ Recursively move a file or directory (src) to another location (dst). If the destination is an existing directory, then src is moved inside that directory. If the destination already exists but is not a directory, it may be overwritten depending on os.rename() semantics.If the destination is on the current filesystem, then os.rename() is used. Otherwise, src is copied (using shutil.copy2()) to dst and then removed. :Arguments: src - source file to be moved dst - target file/directory on which to be moved :Return: True/False - based on the success/failure of the operation """ status = False try: shutil.move(src, dst) print_info("move of src {} to dst {} successful".format(src, dst)) status = True except Exception as e: print_error("moving file {} to file {} raised exception {}".format( src, dst, str(e))) return status
def open_target(self): ''' Connects to a NE using telnet protocol with provided login credentials''' print_info('telnet Target open') host = self.target port = self.port print_info("OPENING TELNET Connection...\n") print_info("HOST: {0} PORT: {1}".format(host, port)) try: self.tnet.open(host, port) self.log = open(self.logfile, 'w') except socket.error, err: print_warning("Login failed {0}".format(str(err))) return False
def getXMLDataFile(filename, path): """Get the xml Datafile for '.py' testcases """ path = path.replace ('Testcases','Data') filename = filename.replace(".py", "") print_info(path + os.sep + filename + os.sep + filename + '.xml') return path + os.sep + filename + os.sep + filename + '.xml'
# import standard python libraries import datetime import time import os import sys import string import shutil import string_Utils from print_Utils import print_info, print_error, print_warning, print_exception try: if 'linux' in sys.platform: mod = 'pexpect' import pexpect except Exception: print_info("{0}: {1} module is not installed".format( os.path.abspath(__file__), mod)) # Return the last line of a file def findLastString(filename, searchterm): fd = open(filename, "r") linenum = -1 for i, line in enumerate(fd, 1): if searchterm in line: linenum = i return linenum # search file for text, return True or False def searchFile(filename, searchterm): fd = open(filename, 'r')
def open_file(newfile, mode): """ Opens the newfile in the mode specified and returns the filedescriptor which would be used by all the other file util operations. :Arguments: newfile - name of the file to be opened mode - mode determines the mode in which the file has to be opened, i.e., read, write, append, etc. r - Opens a file for reading only. The file pointer is placed at the beginning of the file. This is the default mode. rb - Opens a file for reading only in binary format. The file pointer is placed at the beginning of the file. This is the default mode. r+ - Opens a file for both reading and writing. The file pointer placed at the beginning of the file. rb+ - Opens a file for both reading and writing in binary format. The file pointer placed at the beginning of the file. w - Opens a file for writing only. Overwrites the file if the file exists. If the file does not exist, creates a new file for writing. wb - Opens a file for writing only in binary format. Overwrites the file if the file exists. If the file does not exist, creates a new file for writing. w+ - Opens a file for both writing and reading. Overwrites the existing file if the file exists. If the file does not exist, creates a new file for reading and writing. wb+ - Opens a file for both writing and reading in binary format. Overwrites the existing file if the file exists. If the file does not exist, creates a new file for reading and writing. a - Opens a file for appending. The file pointer is at the end of the file if the file exists. That is, the file is in the append mode. If the file does not exist, it creates a new file for writing. ab - Opens a file for appending in binary format. The file pointer is at the end of the file if the file exists. That is, the file is in the append mode. If the file does not exist, it creates a new file for writing. a+ - Opens a file for both appending and reading. The file pointer is at the end of the file if the file exists. The file opens in the append mode. If the file does not exist, it creates a new file for reading and writing. ab+ - Opens a file for both appending and reading in binary format. The file pointer is at the end of the file if the file exists. The file opens in the append mode. If the file does not exist, it creates a new file for reading and writing. :Return: fd - file descriptor of the new file opened """ try: fd = open(newfile, mode) print_info("file {} opened successfully with mode {}".format( newfile, mode)) except IOError as e: print_error( "found io exception {} while opening file {} in mode {}".format( str(e), newfile, mode)) return None except Exception as e: print_error( "found exception {} while opening file {} in mode {}".format( str(e), newfile, mode)) return None return fd