text: #!/usr/bin/python
  #####################################################################################################################################
  # THIS FILE CONTAINS ALL THE FUNCTIONS USED IN PYTHON TEST FILES... HANDLE WITH CARE...
  # FOR ANY QUERY - V-SHISAV@MICROSOFT.COM
  # DO NOT DELETE ANY STATEMENT FROM THE FUNCTION EVEN IF IT IS COMMENTED!!! BECAUSE I'M TRACKING, WHAT I'M DOING...
  #####################################################################################################################################
  
  import subprocess
  import logging
  import string
  import os
  import time
  import os.path
  import array
  import linecache
  import sys
  import re
  
  try:
      import commands
  except ImportError:
      import subprocess as commands
  
  py_ver_str = sys.version
  print(sys.version)
  
  #THIS LOG WILL COLLECT ALL THE LOGS THAT ARE RUN WHILE THE TEST IS GOING ON...
  RunLog = logging.getLogger("RuntimeLog : ")
  WRunLog = logging.FileHandler('Runtime.log','w')
  RunFormatter = logging.Formatter('%(asctime)s : %(levelname)s : %(message)s', datefmt='%m/%d/%Y %I:%M:%S %p')
  WRunLog.setFormatter(RunFormatter)
  RunLog.setLevel(logging.DEBUG)
  RunScreen = logging.StreamHandler()
  RunScreen.setFormatter(RunFormatter)
  #RunLog.addHandler(RunScreen)
  RunLog.addHandler(WRunLog)
  
  #This will collect Result from every test case :
  ResultLog = logging.getLogger("Result : ")
  WResultLog = logging.FileHandler('Summary.log','w')
  #ResultFormatter = logging.Formatter('%(asctime)s : %(levelname)s : %(message)s', datefmt='%m/%d/%Y %I:%M:%S %p')
  ResultFormatter = logging.Formatter('%(message)s')
  WResultLog.setFormatter(ResultFormatter)
  ResultLog.setLevel(logging.DEBUG)
  ResultScreen = logging.StreamHandler()
  ResultScreen.setFormatter(ResultFormatter)
  #ResultLog.addHandler(ResultScreen)
  ResultLog.addHandler(WResultLog)
  
  def UpdateRepos(current_distro):
      RunLog.info ("\nUpdating the repositoriy information...")
      if (current_distro.find("ubuntu") != -1) or (current_distro.find("debian") != -1): 
          #method 'RunUpdate': fix deadlock when using stdout=PIPE and/or stderr=PIPE and the child process generates enough output to a pipe
          RunUpdate("apt-get update")
      elif (current_distro.find("rhel") != -1) or (current_distro.find("Oracle") != -1) or (current_distro.find('centos') != -1):
          RunUpdate("yum -y update")
      elif (current_distro.find("opensuse") != -1) or (current_distro.find("SUSE") != -1) or (current_distro.find("sles") != -1):
          RunUpdate("zypper --non-interactive --gpg-auto-import-keys update")
      else:
          RunLog.info("Repo upgradation failed on:"+current_distro)
          return False
  
      RunLog.info ("Updating the repositoriy information... [done]")
      return True
  
  def DownloadUrl(url, destination_folder, output_file=None):
      cmd = "wget -P "+destination_folder+" "+url+ " 2>&1"
      if output_file is not None:
          cmd = "wget {0} -O {1} 2>&1".format(url, output_file)
  
      rtrn = Run(cmd)
  
      if(rtrn.rfind("wget: command not found") != -1):
          InstallPackage("wget")
          rtrn = Run(cmd)
  
      if( rtrn.rfind("100%") != -1):
          return True
      else:
          RunLog.info (rtrn)
          return False
  
  def DetectDistro():
      distribution = 'unknown'
      version = 'unknown'
  
      RunLog.info("Detecting Distro ")
      output = Run("cat /etc/*-release")
      outputlist = re.split("\n", output)
  
      for line in outputlist:
          line = re.sub('"', '', line)
          if (re.match(r'^ID=(.*)',line,re.M|re.I) ):
              matchObj = re.match( r'^ID=(.*)', line, re.M|re.I)
              distribution  = matchObj.group(1)
          elif (re.match(r'^VERSION_ID=(.*)',line,re.M|re.I) ):
              matchObj = re.match( r'^VERSION_ID=(.*)', line, re.M|re.I)
              version = matchObj.group(1)
  
      if(distribution.strip() == "ol"):
          distribution = 'Oracle'
  
      if(distribution == 'unknown'):
          # Finding the Distro
          for line in outputlist:
              if (re.match(r'.*Ubuntu.*',line,re.M|re.I) ):
                  distribution = 'ubuntu'
                  break
              elif (re.match(r'.*SUSE Linux.*',line,re.M|re.I)):
                  distribution = 'SUSE'
                  break
              elif (re.match(r'.*openSUSE.*',line,re.M|re.I)):
                  distribution = 'opensuse'
                  break
              elif (re.match(r'.*centos.*',line,re.M|re.I)):
                  distribution = 'centos'
                  break
              elif (re.match(r'.*Oracle.*',line,re.M|re.I)):
                  distribution = 'Oracle'
                  break
              elif (re.match(r'.*Red Hat.*',line,re.M|re.I)):
                  distribution = 'rhel'
                  break
              elif (re.match(r'.*Fedora.*',line,re.M|re.I)):
                  distribution = 'fedora'
                  break
      return [distribution, version]
  
  def FileGetContents(filename):
      with open(filename) as f:
          return f.read()
  
  def ExecMultiCmdsLocalSudo(cmd_list):
      f = open('/tmp/temp_script.sh','w')
      for line in cmd_list:
              f.write(line+'\n')
      f.close()
      Run ("chmod +x /tmp/temp_script.sh")
      Run ("/tmp/temp_script.sh 2>&1 > /tmp/exec_multi_cmds_local_sudo.log")
      return FileGetContents("/tmp/exec_multi_cmds_local_sudo.log")
  
  def DetectLinuxDistro():
      if os.path.isfile("/etc/redhat-release"):
          return (True, "RedHat")
      if os.path.isfile("/etc/lsb-release") and "Ubuntu" in GetFileContents("/etc/lsb-release"):
          return (True, "Ubuntu")
      if os.path.isfile("/etc/debian_version"):
          return (True, "Debian")
      if os.path.isfile("/etc/SuSE-release"):
          return (True, "Suse")
      return (False, "Unknown")
  
  def IsUbuntu():
          cmd = "cat /etc/issue"
          tmp=Run(cmd)
          return ("Ubuntu" in tmp)
  
  def ParseWalaConf2Dict(walaconfpath):
      d = None
      if os.path.exists(walaconfpath):
          d={}
          lines = GetFileContentsByLines(walaconfpath)
          configs_list = [x.strip().split()[0] for x in lines if not x.startswith('#') and not x.startswith('\n')]
          for x in configs_list:
              try:
                  k,v=x.split('=')
                  d.setdefault(k,v)
              except Exception as e:
                  pass
      else:
          RunLog.error("%s is not exists, please check." % walaconfpath)
      return d
  
  def GetWalaConfPath():
      if os.path.exists("/etc/lsb-release") and int(Run("cat /etc/lsb-release | grep -i coreos | wc -l")) > 0:
          return "/usr/share/oem/waagent.conf"
      else:
          return "/etc/waagent.conf"
  
  def GetResourceDiskMountPoint():
      walacfg_path = GetWalaConfPath()
      walacfg_dict = ParseWalaConf2Dict(walacfg_path)
  
      if os.path.exists('/var/log/cloud-init.log') and os.path.islink('/var/lib/cloud/instance'):
          RunLog.info('ResourceDisk handled by cloud-init.')
          return '/mnt'
      else:
          RunLog.info("ResourceDisk handled by waagent.")
          return walacfg_dict['ResourceDisk.MountPoint']
  
  def RunGetOutput(cmd):
      try:
          proc = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE)
          retval = proc.communicate()
          output = retval[0]
  
          output = unicode(output,
                           encoding='utf-8',
                           errors="backslashreplace")
      except subprocess.CalledProcessError as e:
          output = unicode(e.output,
                           encoding='utf-8',
                           errors="backslashreplace")
          return e.returncode, output
      return 0, output
  
  def Run(cmd):
          proc=subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE)
          proc.wait()
          op = proc.stdout.read()
          RunLog.debug(op)
          code=proc.returncode
          if int(code) !=0:
              exception = 1
          else:
              #ensure type str return
              if py_ver_str[0] == '3':
                  op = op.decode('utf-8')
              return op
          if exception == 1:
              str_code = str(code)
              return op
  #use method communicate() instead of wait()
  #This will deadlock when using stdout=PIPE and/or stderr=PIPE and the child process generates enough output to a pipe
  #such that it blocks waiting for the OS pipe buffer to accept more data. Use communicate() to avoid that.
  def RunUpdate(cmd):
          proc = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE)
          retval = proc.communicate()
          op = retval[0]
          RunLog.debug(op)
          code = proc.returncode
          if int(code) !=0:
              exception = 1
          else:
              if py_ver_str[0] == '3':
                  op = op.decode('utf-8')
              return op
          if exception == 1:
              str_code = str(code)
              return op
  
  def JustRun(cmd):
      return commands.getoutput(cmd)
  
  def UpdateState(testState):
      stateFile = open('state.txt', 'w')
      stateFile.write(testState)
      stateFile.close()
  
  def GetFileContents(filepath):
      file = None
      try:
          file = open(filepath)
      except:
          return None
      if file == None:
          return None
      try:
          return file.read()
      finally:
          file.close()
  
  
  #-----------------------------------------------------------------------------------------------------------------------------------------------------
  # Instlaltion routines
  
  def YumPackageInstall(package):
      RunLog.info(("\nyum_package_install: " + package))
      output = Run("yum install -y "+package)
      outputlist = re.split("\n", output)
  
      for line in outputlist:
          #Package installed successfully
          if (re.match(r'Complete!', line, re.M|re.I)):
              RunLog.info((package+": package installed successfully.\n"+line))
              return True
          #package is already installed
          elif (re.match(r'.* already installed and latest version', line, re.M|re.I)):
              RunLog.info((package + ": package is already installed.\n"+line))
              return True
          elif (re.match(r'^Nothing to do', line, re.M|re.I)):
              RunLog.info((package + ": package already installed.\n"+line))
              return True
          #Package installation failed
          elif (re.match(r'^Error: Nothing to do', line, re.M|re.I)):
              break
          #package is not found on the repository
          elif (re.match(r'^No package '+ re.escape(package)+ r' available', line, re.M|re.I)):
              break
  
      #Consider package installation failed if non of the above matches.
      RunLog.error((package + ": package installation failed!\n" +output))
      return False
  
  def AptgetPackageInstall(package,dbpasswd = "root"):
  	RunLog.info("Installing Package: " + package)
  	# Identify the package for Ubuntu
  	# We Haven't installed mysql-secure_installation for Ubuntu Distro
  	if (package == 'mysql-server'):
  		RunLog.info( "apt-get function package:" + package) 		
  		cmds = ("export DEBIAN_FRONTEND=noninteractive","echo mysql-server mysql-server/root_password select " + dbpasswd + " | debconf-set-selections", "echo mysql-server mysql-server/root_password_again select " + dbpasswd  + "| debconf-set-selections", "apt-get install -y mysql-server")
  		output = ExecMultiCmdsLocalSudo(cmds)
  	else:
  		cmds = ("export DEBIAN_FRONTEND=noninteractive", "apt-get install -y "+package)
  		output = ExecMultiCmdsLocalSudo(cmds)
  	
  	outputlist = re.split("\n", output)	
   
  	unpacking = False
  	setting_up = False
  
  	for line in outputlist:
  		#package is already installed
  		if (re.match(re.escape(package) + r' is already the newest version', line, re.M|re.I)):
  			RunLog.info(package + ": package is already installed."+line)
  			return True
  		#package installation check 1	
  		elif (re.match(r'Unpacking.*'+ re.escape(package) + r'.*', line, re.M|re.I)):
  			unpacking = True
  		#package installation check 2
  		elif (re.match(r'Setting up '+ re.escape(package) + r" \(.*" , line, re.M|re.I)):
  			setting_up = True
  		#Package installed successfully
  		if (setting_up and unpacking):
  			RunLog.info(package+": package installed successfully.")
  			return True
  		#package is not found on the repository
  		elif (re.match(r'E: Unable to locate package '+ re.escape(package), line, re.M|re.I)):
  			break
  		#package installation failed due to server unavailability
  		elif (re.match(r'E: Unable to fetch some archives', line, re.M|re.I)):
  			break
  		
  	#Consider package installation failed if non of the above matches.
  	RunLog.info(package + ": package installation failed!\n")
  	RunLog.info("Error log: "+output)
  	return False
  
  def ZypperPackageInstall(package):
  	RunLog.info( "\nzypper_package_install: " + package)
  
  	output = Run("zypper --non-interactive in "+package)
  	outputlist = re.split("\n", output)
  		
  	for line in outputlist:
  		#Package or package dependencies installed successfully
  		if (re.match(r'.*Installing: '+r'.*done', line, re.M|re.I)):
  			RunLog.info((package+": package installed successfully.\n"+line))
  			return True
  		#package or provider of package is already installed
  		elif (re.match(r'.*\''+re.escape(package)+r'\' is already installed', line, re.M|re.I)):
  			RunLog.info((package + ": package is already installed.\n"+line))
  			return True
  		#package is not found on the repository
  		elif (re.match(r'^No provider of \''+ re.escape(package) + r'\' found', line, re.M|re.I)):
  			break
  
  	#Consider package installation failed if non of the above matches.
  	RunLog.error((package + ": package installation failed!\n"+output))
  	return False
  
  def ZypperPackageRemove(package):
  	RunLog.info( "\nzypper_package_remove: " + package)
  
  	output = Run("zypper --non-interactive remove "+package)
  	outputlist = re.split("\n", output)
  		
  	for line in outputlist:
  		#Package removed successfully
  		if (re.match(r'.*Removing '+re.escape(package)+r'.*done', line, re.M|re.I)):
  			RunLog.info((package+": package removed successfully.\n"+line))
  			return True
  		#package is not installed
  		elif (re.match(r'\''+re.escape(package)+r'\' is not installed', line, re.M|re.I)):
  			RunLog.info((package + ": package is not installed.\n"+line))
  			return True
  		#package is not found on the repository
  		elif (re.match(r'\''+re.escape(package)+r'\' not found in package names', line, re.M|re.I)):
  			return True
  
  	#Consider package remove failed if non of the above matches.
  	RunLog.error((package + ": package remove failed!\n"+output))
  	return False
  	
  def InstallPackage(package):
  	RunLog.info( "\nInstall_package: "+package)
  	[current_distro, distro_version] = DetectDistro()
  	if (("ubuntu" in current_distro) or  ("Debian" in current_distro)):
  		return AptgetPackageInstall(package)
  	elif (("rhel" in current_distro) or ("Oracle" in current_distro) or ("centos" in current_distro) or ("fedora" in current_distro)):
  		return YumPackageInstall(package)
  	elif (("SUSE" in current_distro) or ("opensuse" in current_distro) or ("sles" in current_distro)):
  		return ZypperPackageInstall(package)
  	else:
  		RunLog.error((package + ": package installation failed!"))
  		RunLog.info((current_distro + ": Unrecognised Distribution OS Linux found!"))
  		return False
  
  def InstallDeb(file_path):
  	RunLog.info( "\nInstalling package: "+file_path)
  	output = Run("dpkg -i "+file_path+" 2>&1")
  	RunLog.info(output)
  	outputlist = re.split("\n", output)
  
  	for line in outputlist:
  		#package is already installed
  		if(re.match("installation successfully completed", line, re.M|re.I)):
  			RunLog.info(file_path + ": package installed successfully."+line)
  			return True			
  			
  	RunLog.info(file_path+": Installation failed"+output)
  	return False
  
  def InstallRpm(file_path, package_name):
  	RunLog.info( "\nInstalling package: "+file_path)
  	output = Run("rpm -ivh --nodeps "+file_path+" 2>&1")
  	RunLog.info(output)
  	outputlist = re.split("\n", output)
  	package = re.split("/", file_path )[-1]
  	matchObj = re.match( r'(.*?)\.rpm', package, re.M|re.I)
  	package = matchObj.group(1)
  	
  	for line in outputlist:
  		#package is already installed
  		if (re.match(r'.*package'+re.escape(package) + r'.*is already installed', line, re.M|re.I)):
  			RunLog.info(file_path + ": package is already installed."+line)
  			return True
  		elif(re.match(re.escape(package) + r'.*######', line, re.M|re.I)):
  			RunLog.info(package + ": package installed successfully."+line)
  			return True
  		elif(re.match(re.escape(package_name) + r'.*######', line, re.M|re.I)): 
  			RunLog.info(package + ": package installed successfully."+line) 
  			return True 
  			
  	RunLog.info(file_path+": Installation failed"+output)
  	return False
  
  #-----------------------------------------------------------------------------------------------------------------------------------------------------
  
  # iperf server
  
  def GetServerCommand():
          import argparse
          import sys
                  #for error checking
          validPlatformValues = ["532","540","541", "542", "550"]
          parser = argparse.ArgumentParser()
  
          parser.add_argument('-u', '--udp', help='switch : starts the server in udp data packets listening mode.', choices=['yes', 'no'] )
          parser.add_argument('-p', '--port', help='specifies which port should be used', required=True, type= int)
          parser.add_argument('-m', '--maxsegdisplay', help='Maximum Segment Size display ', choices=['yes', 'no'])
          parser.add_argument('-M', '--maxsegset', help='Maximum Segment Size Settings', type = int)
          parser.add_argument('-i', '--interval', help='specifies frequency of the output to be displyed on screen', type= int, required = True)
          args = parser.parse_args()
                  #if no value specified then stop
          command = 'iperf -s' + ' -i' + str(args.interval) + ' -p' + str(args.port)
          if args.udp == 'yes':
                  command = command + ' -u'
          if args.maxsegset != None:
                  command = command + ' -M' + str(args.maxsegset)
          if args.maxsegdisplay == 'yes':
                  command = command + ' -m'
  
          finalCommand = 'nohup ' + command + ' >  iperf-server.txt &'
          return finalCommand
  
  #_________________________________________________________________________________________________________________________________________________
  
  def StopServer():
      RunLog.info("Killing iperf server if running ..")
      temp = Run("killall iperf")
  
  def StartServer(server):
      StopServer()
      RunLog.info("Starting iperf server..")
      temp = Run(server)
      tmp = Run("sleep 1")
      #print(output)
      iperfstatus = open('iperf-server.txt', 'r')
      output = iperfstatus.read()
      #print output
      RunLog.info("Checking if server is started..")
      if ("listening" in output) :
          str_out = str.split(output)
          #len_out = len(str_out)
          for each in str_out :
              #print(each)
              if each == "listening" :
                  iperfPID = Run('pidof iperf')
                  RunLog.info("Server started successfully. PID : %s", iperfPID)
                  Run('echo "yes" > isServerStarted.txt')
          #UpdateState('TestCompleted')
  
      else :
          RunLog.error('Server Failed to start..')
          Run("echo yes > isServerStarted.txt")
          UpdateState('Aborted')
  
  #_______________________________________________________________________________________________________________________________________________
  
  def AnalyseClientUpdateResult():
          iperfstatus = open('iperf-client.txt', 'r')
          output = iperfstatus.read()
          #print output
          Failure = 0
          RunLog.info("Checking if client was connected to server..")
          if ("connected" in output) :
                  if ("TestInComplete" in output):
                          RunLog.error('Client was successfully connected but, iperf process failed to exit.')
                          Failure = Failure + 1
                  if("failed" in output):
                          RunLog.error("Client connected with some failed connections!")
                          Failure = Failure + 1
                  if("error" in output):
                          RunLog.error("There were some errors in the connections.")
                          Failure = Failure + 1
  
                  if("refused" in output):
                          RunLog.error("some connections were refused.")
                          Failure = Failure + 1
  
                  if(Failure == 0):
                          RunLog.info("Client was successfully connected to server")
                          ResultLog.info("PASS")
                          UpdateState("TestCompleted")
                  else:
                          ResultLog.info("FAIL")
                          UpdateState("TestCompleted")
  
          else:
                  if("No address associated" in output):
                      RunLog.error('Client was not connected to server.')
                      RunLog.error("No address associated with hostname")
                      ResultLog.info('FAIL')
                      UpdateState("TestCompleted")
  
                  elif("Connection refused" in output):
                          RunLog.error('Client was not connected to server.')
                          RunLog.error("Connection refused by the server.")
                          ResultLog.info('FAIL')
                          UpdateState("TestCompleted")
  
  
  
                  elif("Name or service not known" in output):
                          RunLog.error('Client was not connected to server.')
                          RunLog.error("Name or service not known.")
                          ResultLog.info('FAIL')
                          UpdateState("TestCompleted")
  
  
                  else:
                          RunLog.error('Client was not connected to server.')
                          RunLog.error("Unlisted error. Check logs for more information...!")
                          ResultLog.info('FAIL')
                          UpdateState("TestCompleted")
  
  
  #________________________________________________________________________________________________________________________________________________
  
  def isProcessRunning(processName):
          temp = 'ps -ef'
          outProcess = Run(temp)
          ProcessCount = outProcess.count('iperf -c')
          if (ProcessCount > 0):
                  return "True"
          else:
                  return "False"
  
  #________________________________________________________________________________________________________________________________________________
  #
  #
  # VNET Library..
  
  
  #DECLARE GLOBAL VARIBALES HERE FIRST AND THEN ADD THEM TO SetVnetGlobalParametesrs()
  vnetDomain_db_filepath = ''
  vnetDomain_rev_filepath = ''
  dns_server_ip = ''
  resolv_conf_filepath = ''
  hosts_filepath = ''
  def SetVnetGlobalParameters():
      import argparse
      import sys
      parser = argparse.ArgumentParser()
      parser.add_argument('-d', '--dns_server_ip', help='DNS server IP address',required=True)
      parser.add_argument('-D', '--vnetDomain_db_filepath', help='VNET Domain db filepath', required=True)
      parser.add_argument('-r', '--vnetDomain_rev_filepath', help='VNET rev filepath',required=True)
      parser.add_argument('-R', '--resolv_conf_filepath', help='resolv.conf filepath', required=True)
      parser.add_argument('-h', '--hosts_filepath', help='hosts filepath',required = True)
      args = parser.parse_args()
      global dns_server_ip
      global vnetDomain_db_filepath
      global vnetDomain_rev_filepath
      global resolv_conf_filepath
      global hosts_filepath
      vnetDomain_db_filepath =  str(args.vnetDomain_db_filepath)
      vnetDomain_rev_filepath = str(args.vnetDomain_rev_filepath)
      dns_server_ip = str(args.dns_server_ip)
      resolv_conf_filepath = str(args.resolv_conf_filepath)
      hosts_filepath = str(args.hosts_filepath)
  
  def GetFileContentsByLines(filepath):
      file = None
      try:
          file = open(filepath, 'r')
      except:
          return None
      if file == None:
          return None
      try:
          file_lines =  file.readlines()
          return file_lines
      finally:
          file.close()
  
  def RemoveStringMatchLinesFromFile(filepath, matchString):
      try:
          old_file_lines = GetFileContentsByLines(filepath)
          NewFile =  open(filepath,'w')
          for eachLine in old_file_lines:
              if not matchString in eachLine :
                  NewFile.writelines(eachLine)
  #By the end of this for loop, Selected lines will be removed.
              else:
                  print("removed %s from %s" % ( eachLine.replace('\n',''), filepath))
          NewFile.close()
      except:
          print ('File : %s not found.' % filepath)
  
  def ReplaceStringMatchLinesFromFile(filepath, matchString, newLine):
      try:
          old_file_lines = GetFileContentsByLines(filepath)
          NewFile =  open(filepath,'w')
          for eachLine in old_file_lines:
              if matchString in eachLine :
                  if '\n' in newLine:
                      NewFile.writelines(newLine)
                  else :
                      NewFile.writelines('%s\n' % newLine)
              else :
                  NewFile.writelines(eachLine)
          NewFile.close()
      except:
          print ('File : %s not found.' % filepath)
  
  def GetStringMatchCount(filepath, matchString):
      #try:
          NewFile =  open(filepath,'r')
          NewFile.close()
          matchCount = 0
          file_lines = GetFileContentsByLines(filepath)
          for eachLine in file_lines:
              if matchString in eachLine :
                  matchCount = matchCount + 1
          return matchCount
      #except:
          print ('File : %s not found.' % filepath)
  
  def RemoveICAVMsFromDBfile(vnetDomain_db_filepath):
      matchString = 'ICA-'
      RemoveStringMatchLinesFromFile(vnetDomain_db_filepath,matchString)
  
  def RemoveICAVMsFromREVfile(vnetDomain_rev_filepath):
      matchString = 'ICA-'
      RemoveStringMatchLinesFromFile(vnetDomain_rev_filepath,matchString)
  
  
  def RetryOperation(operation, description, expectResult=None, maxRetryCount=18, retryInterval=10):
      retryCount = 1
  
      while True:
          RunLog.info("Attempt : %s : %s", retryCount, description)
          ret = None
  
          try:
              ret = Run(operation)
              if (expectResult and (ret.strip() == expectResult)) or (expectResult == None):
                  return ret
          except:
              RunLog.info("Retrying Operation")
  
          if retryCount >= maxRetryCount:
              break
          retryCount += 1
          time.sleep(retryInterval)
      if(expectResult != None):
          return ret
      return None
  
  def AppendTextToFile(filepath,textString):
      #THIS FUNCTION DONES NOT CREATES ANY FILE. THE FILE MUST PRESENT AT THE SPECIFIED LOCATION.
      try:
          fileToEdit = open ( filepath , 'r' )
          fileToEdit.close()
          fileToEdit = open ( filepath , 'a' )
          if not '\n' in textString:
              fileToEdit.write(textString)
          else:
              fileToEdit.writelines(textString)
          fileToEdit.close()
      except:
          print('File %s not found' % filepath)
  
  
  def AddICAVMsToDnsServer(HostnameDIP,vnetDomain_db_filepath,vnetDomain_rev_filepath):
      #SetVnetGlobalParameters()
      vnetDomain=(vnetDomain_db_filepath.split("/"))[len((vnetDomain_db_filepath.split("/")))-1].replace(".db","")
      #PARSE THE VM DETAILS FIRST.
      separatedVMs = HostnameDIP.split('^')
      vmCounter = 0
      successCount = 0
      for eachVM in separatedVMs:
          vmCounter = vmCounter + 1
          eachVMdata = eachVM.split(':')
          eachVMHostname = eachVMdata[0]
          eachVMDIP = eachVMdata[1]
          lastDigitofVMDIP = eachVMDIP.split('.')[3]
          vnetDomainDBstring = '%s\tIN\tA\t%s\n' % (eachVMHostname,eachVMDIP)
          print(vnetDomainDBstring.replace('\n',''))
          AppendTextToFile(vnetDomain_db_filepath,vnetDomainDBstring)
          vnetDomainREVstring = '%s\tIN\tPTR\t%s.%s.\n' % (lastDigitofVMDIP,eachVMHostname,vnetDomain)
          AppendTextToFile(vnetDomain_rev_filepath,vnetDomainREVstring)
          print(vnetDomainREVstring.replace('\n',''))
          isDBFileEntry =  GetStringMatchCount(vnetDomain_db_filepath,vnetDomainDBstring)
          isREVFileEntry =  GetStringMatchCount(vnetDomain_rev_filepath,vnetDomainREVstring)
          if isDBFileEntry >= 1 and isREVFileEntry >= 1:
              print (vnetDomain_db_filepath + " file edited for " + eachVMDIP + " : " + eachVMHostname)
              print (vnetDomain_rev_filepath + " file edited for " + eachVMDIP + " : " + eachVMHostname)
              successCount = successCount + 1
          else:
              if isDBFileEntry != 1:
                  print ("Failed to edit " + vnetDomain_db_filepath + " for " + eachVMDIP + " : " + eachVMHostname)
              if isREVFileEntry != 1:
                  print ("Failed to edit " + vnetDomain_rev_filepath + " for " + eachVMDIP + " : " + eachVMHostname)
      if successCount == vmCounter:
          return 0
      else:
          return 1
  
  def RemoteUpload(hostIP, hostPassword, hostUsername, hostPort, filesToUpload, remoteLocation):
      import paramiko
  #    print ('%s %s' % (hostIP,hostPort))
      transport = paramiko.Transport((hostIP,int(hostPort)))
      try:
          print('Connecting to %s'% hostIP),
          transport.connect(username = hostUsername, password = hostPassword)
          print('...Connected.')
          try:
              sftp = paramiko.SFTPClient.from_transport(transport)
              filesToUpload =  filesToUpload.split(',')
              for eachFile in filesToUpload :
                  eachFileName = eachFile.split('/')
  #                print eachFileName
                  eachFileNameLength = len(eachFileName)
  #                print eachFileNameLength
                  exactFileName = eachFileName[eachFileNameLength-1]
  #                print exactFileName
                  if remoteLocation[-1] == '/':
                      newFile = "%s%s" % (remoteLocation,exactFileName)
                  else:
                      newFile = "%s/%s" % (remoteLocation,exactFileName)
  #                print ("%s - %s" % (eachFile, newFile))
                  try:
                      print ("Uploading %s to %s" % (eachFile, newFile)),
                      sftp.put(eachFile, newFile)
                      print ('...OK!')
                  except:
                      print('...Error!')
              transport.close()
          except:
              print("Failed to upload to %s" % hostIP)
  
      except:
          print("...Failed!")
  
  def RemoteDownload(hostIP, hostPassword, hostUsername, hostPort, filesToDownload, localLocation):
      import paramiko
  #    print ('%s %s' % (hostIP,hostPort))
      transport = paramiko.Transport((hostIP,int(hostPort)))
      try:
          print('Connecting to %s'% hostIP),
          transport.connect(username = hostUsername, password = hostPassword)
          print('...Connected.')
          try:
              sftp = paramiko.SFTPClient.from_transport(transport)
              filesToDownload =  filesToDownload.split(',')
              for eachFile in filesToDownload :
                  eachFileName = eachFile.split('/')
  #                print eachFileName
                  eachFileNameLength = len(eachFileName)
  #                print eachFileNameLength
                  exactFileName = eachFileName[eachFileNameLength-1]
  #                print exactFileName
                  if localLocation[-1] == '/':
                      newFile = "%s%s" % (localLocation,exactFileName)
                  else:
                      newFile = "%s/%s" % (localLocation,exactFileName)
  #                print ("%s - %s" % (eachFile, newFile))
                  try:
                      print ("Downloading %s to %s" % (eachFile, newFile)),
                      sftp.get(eachFile, newFile)
                      print ('...OK!')
                  except:
                      print('...Error!')
              transport.close()
          except:
              print("Failed to Download to %s" % hostIP)
  
      except:
          print("...Failed!")
  
  
  def ConfigureResolvConf(resolv_conf_filepath,dns_server_ip,vnetDomain):
      isDnsEntry =  GetStringMatchCount(resolv_conf_filepath,dns_server_ip)
      hostName = JustRun('hostname')
      if isDnsEntry == 1:
          domainReplaceString="search " + vnetDomain
          ReplaceStringMatchLinesFromFile(resolv_conf_filepath,'search',domainReplaceString)
          isDnsNameEntry =  GetStringMatchCount(resolv_conf_filepath,domainReplaceString)
          if isDnsNameEntry == 1:
              print('Added string "search ' + vnetDomain + '" to ' + resolv_conf_filepath)
              return 0
          else :
              print('Failed to add string "search ' + vnetDomain + '" to ' + resolv_conf_filepath)
              return 1
      else:
          print('DNS server IP is not present in ' + resolv_conf_filepath + ' file')
          return 2
  
  def ConfigureHostsFile(hosts_filepath):
      hostName = JustRun('hostname')
      AppendTextToFile(hosts_filepath,"127.0.0.1 %s\n" % hostName)
      isHostsEdited = GetStringMatchCount(hosts_filepath, hostName)
      if isHostsEdited >= 1:
          print('Added string "127.0.0.1 ' + hostName + '" to ' + hosts_filepath)
          return 0
      else :
          print('Failed to Add string "127.0.0.1 ' + hostName + '" to ' + hosts_filepath)
          return 1
  
  def GetOSDisk():
      resourceDiskPartition = JustRun("grep -i '%s' /etc/mtab | awk '{print $1;}' | tr -d '\n'" % GetResourceDiskMountPoint())
      if 'sda' in resourceDiskPartition:
          return 'sdb'
      else :
          return 'sda'
  