# YASARA BioTools
# Visit www.yasara.org for more...
# Copyright by Elmar Krieger

# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
# 
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
# 
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA


import os,string,shutil,fnmatch,zipfile

#  ======================================================================
#                  D I S C   F U N C T I O N   G R O U P
#  ======================================================================

# MAKE PATH ABSOLUTE
# ==================
def abspath(path):
  return(os.path.abspath(path))

# CALCULATE FILE CHECKSUM
# =======================
def checksum(path):
  checksum=0
  file=open(path)
  pos=1
  a=0
  b=0  
  while (1):
    data=file.read(1000000)
    datalen=len(data)
    i=0
    while (i<datalen):
      ch=ord(data[i])
      a=(a+ch)&0xffff
      b=(b+pos*ch)&0xffff
      #print "%08x %08x"%(a,b)
      i+=1
      pos+=1
    if (datalen<1000000): break
  return(a|(b<<16))

# COPY FILE
# =========
def copy(srcfilename,dstfilename,timespreserved=1,mod=None):
  if (timespreserved):
    # copy2 CAN FAIL ON FAT PARTITIONS
    try: shutil.copy2(srcfilename,dstfilename)
    except: timespreserved=0
  if (not timespreserved):
    try: shutil.copy(srcfilename,dstfilename)
    except: shutil.copyfile(srcfilename,dstfilename)
  if (mod!=None): chmod(dstfilename,mod)

# COPY DIRECTORY
# ==============
# - srcpath IS A WILDCARD MATCHING THE FILES TO COPY
# - dstpath IS THE NAME OF THE DESTINATION DIRECTORY
def copydir(srcpath,dstpath,mod=None):
  filelist=dirlist(srcpath)
  for srcfilename in filelist:
    dstfilename=os.path.join(dstpath,os.path.basename(srcfilename))
    copy(srcfilename,dstfilename)
    if (mod!=None): chmod(dstfilename,mod)

# GET THE LAST ELEMENTS IN A PATH
# ===============================
def lastpathelements(path,elements):
  result=None
  for i in range(elements):
    if (result==None): result=os.path.basename(path)
    else: result=os.path.join(os.path.basename(path),result)
    path=os.path.dirname(path)
  return(result)

# GET ALL FILES MATCHING A PATH+WILDCARD
# ======================================
def matchfilelist(path):
  path=os.path.split(path)
  wildcard=path[1]
  path=path[0]
  if (path==""): path="."
  try: files=os.listdir(path)
  except: return(None)
  matchfilelist=[]
  # CYCLE THROUGH ALL THE FILES
  for name in files:
    # CHECK IF FILENAME MATCHES WILDCARD
    filename=os.path.join(path,name)
    if (fnmatch.fnmatch(name,wildcard) and os.path.isfile(filename)):
      matchfilelist.append(filename)
  return(matchfilelist)

# REPLACE FILE
# ============
# dstfilename IS REPLACED WITH srcfilename, PERMISSIONS ARE SET TO mod.
def replace(srcfilename,dstfilename,mod):
  remove(dstfilename)
  copy(srcfilename,dstfilename)
  chmod(dstfilename,mod)
  remove(srcfilename)

# GET SIZE OF FILE
# ================
def filesize(filename):
  if (not os.path.exists(filename)): return(0)
  return(os.stat(filename)[6])

# INCREASE FILE NAME
# ==================
def incfilename(filename):
  i=len(filename)-1
  while (i>0 and filename[i] not in string.digits): i=i-1
  while (i>=0):
    num=ord(filename[i])
    if (num<48 or num>57): break
    num=num+1
    if (num==58): num=48
    filename=filename[:i]+chr(num)+filename[i+1:]
    if (num!=48): break
    i=i-1
  return(filename)

# MAKE DIRECTORY CHAIN
# ====================
def makedirs(path,permissions=0755):
  if (not os.path.exists(path)):
    os.makedirs(path,permissions)
  # THE PERMISSIONS ARE NOT ALWAYS SET CORRECTLY, DO IT AGAIN
  chmod(path,permissions)

# GET MD5SUM
# ==========
def md5sum(filename):
  content=open(filename).read()
  md5sum=md5.new(content).digest()
  md5str=""
  for ch in md5sum:
    hexstr=hex(ord(ch))
    if (len(hexstr)==3): md5str+='0'+hexstr[-1]
    else: md5str+=hexstr[-2:]
  return(md5str)

# GET THE MODIFICATION TIME OF A FILE
# ===================================
def modtime(filename):
  if (not os.path.exists(filename)): return(0)
  else: return(os.path.getmtime(filename))

# GET ALL MODIFICATION TIMES FOR A LIST OF FILES
# ==============================================
def modtimes(filelist):
  timelist=[]
  for filename in filelist:
    if (not os.path.exists(filename)): timelist.append(0)
    else: timelist.append(os.path.getmtime(filename))
  return(timelist)

# CHECK IF TWO FILES ARE THE SAME
# ===============================
def havesamecontent(filename1,filename2):
  if (not os.path.exists(filename1) or not os.path.exists(filename2)): return(0)
  content1=open(filename1,"r").read()
  content2=open(filename2,"r").read()
  return (content1==content2)

# BUILD TEMPORARY FILE NAME
# =========================
def tmpfilename(filename):
  dotpos=string.rfind(filename,".")
  slashpos=string.rfind(filename,os.sep)
  if (dotpos==-1 or dotpos<slashpos): dotpos=len(filename)
  filename=filename[:dotpos]+"_tmp%d"%os.getpid()+filename[dotpos:]
  return(filename)

# CHECK IF FILE(S) EXIST(S)
# =========================
def pathexists(path):
  # NORMALIZE PATH, IMPORTANT TO CONVERT UNIX FORWARD TO WINDOWS BACKWARD SLASHES
  path=os.path.normpath(os.path.normcase(path))
  # CREATE LIST OF ALL THE FILENAMES IN THE DIRECTORY SPECIFIED BY PATH
  path=os.path.split(path)
  wildcard=path[1]
  path=path[0]
  if (path==""): path="."
  try: files=os.listdir(path)
  except: return(0)
  # DELETE ALL LIST ENTRIES THAT DO NOT MATCH THE WILDCARD GIVEN IN PATH
  for name in files:
    # CHECK IF FILENAME MATCHES WILDCARD
    #   INCLUDING A POSSIBLE _MOD APPENDIX (LIKE EMBL DSSP FILES)
    if (fnmatch.fnmatch(name,wildcard)): return(1)
  return(0)

# CREATE DIRECTORY LISTING INCLUDING FULL PATH NAMES
# ==================================================
# all==0: ONLY FILES WILL BE RETURNED
# all==1: ALL ENTRIES WILL BE RETURNED
# all==-1: ONLY DIRECTORIES WILL BE RETURNED
def dirlist(path,all=0):
  # NORMALIZE PATH, IMPORTANT TO CONVERT UNIX FORWARD TO WINDOWS BACKWARD SLASHES
  path=os.path.normpath(os.path.normcase(path))
  # CREATE LIST OF ALL THE FILENAMES IN THE DIRECTORY SPECIFIED BY PATH
  (path,wildcard)=os.path.split(path)
  if (path==""): path="."
  try: filelist=os.listdir(path)
  except: return([])
  # CYCLE THROUGH ALL FILES AND CHECK IF THEY MATCH WILDCARD
  i=0
  while (i<len(filelist)):
    if (fnmatch.fnmatch(filelist[i],wildcard)):
      filelist[i]=os.path.join(path,filelist[i])
      if (all==1 or 
          (all==0 and os.path.isfile(filelist[i])) or
          (all==-1 and os.path.isdir(filelist[i]))):
        i=i+1
        continue
    # NO MATCH
    del filelist[i]
  filelist.sort()
  return(filelist)

# CREATE RECURSIVE DIRECTORY LISTING INCLUDING FULL PATH NAMES
# ============================================================
def recursivedirlist(path):
  # NORMALIZE PATH, IMPORTANT TO CONVERT UNIX FORWARD TO WINDOWS BACKWARD SLASHES
  path=os.path.normpath(os.path.normcase(path))
  # LIST OF COMPLETE PATHS
  pathlist=[]
  # CREATE LIST OF ALL THE FILENAMES IN THE DIRECTORY SPECIFIED BY PATH
  (dir,wildcard)=os.path.split(path)
  if (dir==""): dir="."
  try: filenamelist=os.listdir(dir)
  except: return([])
  # CYCLE THROUGH ALL FILES AND CHECK IF THEY MATCH WILDCARD
  for filename in filenamelist:
    path=os.path.join(dir,filename)
    if (os.path.isfile(path)):
      if (fnmatch.fnmatch(filename,wildcard)):
        pathlist.append(path)
    else:
      # RECURSE DIRECTORY
      if (filename!="." and filename!=".."):
        subdirlist=recursivedirlist(os.path.join(path,wildcard))
        if (subdirlist==[]):
          # EMPTY SUBDIRECTORY
          pathlist.append(path)
        else:
          pathlist=pathlist+subdirlist
  pathlist.sort()
  return(pathlist)

# DELETE A FILE
# =============
def remove(filename):
  if (type(filename)==type([])):
    for filename2 in filename: remove(filename2)
  else:
    if (filename!=None and os.path.exists(filename)): os.remove(filename)

# RENAME A FILE
# =============
def rename(srcfilename,dstfilename):
  if (srcfilename and dstfilename and os.path.exists(srcfilename)):
    os.rename(srcfilename,dstfilename)

# DELETE ALL MATCHING FILES
# =========================
def removematch(path):
  if (type(path)==type([])):
    for pathname in path: removematch(pathname)
  else:
    # NORMALIZE PATH, IMPORTANT TO CONVERT UNIX FORWARD TO WINDOWS BACKWARD SLASHES
    path=os.path.normpath(os.path.normcase(path))
    # CREATE LIST OF ALL THE FILENAMES IN THE DIRECTORY SPECIFIED BY PATH
    path=os.path.split(path)
    wildcard=path[1]
    dir=path[0]
    if (dir==""): dir="."
    try: files=os.listdir(dir)
    except: return(0)
    # DELETE ALL LIST ENTRIES THAT DO NOT MATCH THE WILDCARD GIVEN IN PATH
    for name in files:
      # CHECK IF FILENAME MATCHES WILDCARD
      #   INCLUDING A POSSIBLE _MOD APPENDIX (LIKE EMBL DSSP FILES)
      if (fnmatch.fnmatch(name,wildcard)): remove(os.path.join(dir,name))
  return(0)

# SET MODIFICATION TIME
# =====================
def setmodtime(filename,modtime):
  os.utime(filename,(modtime,modtime))
  
# COPY MODIFICATION TIME
# ======================
def copymodtime(srcfilename,dstfilename):
  setmodtime(dstfilename,modtime(srcfilename))

# CHMOD A FILE
# ============
def chmod(path,mods):
  if (type(path)==type([])):
    for pathname in path: chmod(pathname,mods)
  else:
    try: os.chmod(path,mods)
    except: print "Could not change permissions for ",path

# DELETE AN ENTIRE DIRECTORY INCLUDING ALL THE FILES
# ==================================================
def rmdir(path):
  if (os.path.exists(path)): shutil.rmtree(path,1)

# REMOVE FILE EXTENSION
# =====================
def rmext(filename):
  dotpos=string.rfind(filename,".")
  if (dotpos!=-1): filename=filename[:dotpos]
  return(filename)

# GET FILE EXTENSION
# ==================
def ext(filename):
  dotpos=string.rfind(filename,".")
  if (dotpos!=-1): return(filename[dotpos+1:])
  return("")

# COUNT NUMBER OF FILENAMES PRESENT
# =================================
def countpresent(filenamelist):
  count=0
  for filename in filenamelist:
    if (os.path.exists(filename)): count=count+1
  return(count)

# UPDATE DIRECTORY
# ================
# - srcpath IS A WILDCARD MATCHING THE FILES TO UPDATE
# - dstdir IS THE NAME OF THE DESTINATION DIRECTORY
def updatedir(srcpath,dstdir,contentchecked=1,recursive=0,obsoleted=0,mod=None,excludelist=[]):
  modfilelist=[]
  if (os.path.isdir(srcpath)): srcpath=os.path.join(srcpath,"*")
  srcfilelist=dirlist(srcpath,recursive)
  srcbaselist=[]
  for srcfilename in srcfilelist:
    srcbasename=os.path.basename(srcfilename)
    srcbaselist.append(srcbasename)
    if (srcbasename not in excludelist):
      dstfilename=os.path.join(dstdir,srcbasename)
      if (os.path.isdir(srcfilename)):
        if (recursive):
          updatedir(srcfilename,dstfilename,contentchecked,1,obsoleted,mod,excludelist)
      else:
        if ((contentchecked and not havesamecontent(srcfilename,dstfilename)) or
            (not contentchecked and modtime(srcfilename)>modtime(dstfilename))):
          copy(srcfilename,dstfilename,0,mod)
          modfilelist.append(dstfilename) 
  if (obsoleted):
    # ALSO DELETE OBSOLETE FILES
    dstfilelist=dirlist(os.path.join(dstdir,os.path.basename(srcpath)))
    for dstfilename in dstfilelist:
      dstbasename=os.path.basename(dstfilename)
      if (dstbasename not in srcbaselist): remove(dstfilename)
  return(modfilelist)

# ZIP A FILE
# ==========
def zip(filename):
  print "Deflating",filename
  zipfilename=filename+".zip"
  zip=zipfile.ZipFile(zipfilename,"w",zipfile.ZIP_DEFLATED)
  zip.write(filename,os.path.basename(filename))
  zip.close()
  remove(filename)

# RETURN AN UNZIPPED FILE
# =======================
def unzipped(filename):
  zipfilename=filename+".zip"
  zip=zipfile.ZipFile(zipfilename,"r",zipfile.ZIP_DEFLATED)
  data=zip.read(os.path.basename(filename))
  zip.close()
  return(data)


# ======================================================================
#                           J O B   C L A S S
# ======================================================================

class job_list:
  """
  This class is used to add jobs to the MODELS@HOME cluster job queue
  Create a class instance passing the filename of the job list and the name
  of an error-handling function.
  - Instance.error contains an error description if something went wrong
  - Instance.lock() locks the job list (done automatically by first call to add)
  - Instance.add() adds a job to the list
  - Instance.submit() submits the added jobs and removes the lock
  - Instance.waiting() returns the number of currently waiting jobs
  - Instance.waitresult() waits until the given list of result files have
    returned from the cluster

  Sample job list:

  JOB NUMB_S_P_CLIENT IP_______CLIENT NAME______TIME OF JOB SUBMISSION___CHECK____PROGRAM__OPTIONS|DIR|COPY|TEXT|RETURN|DONEFLAG
  00000000 W 0                                                                    WHATIF   |/mnt/home7/cc/elmar/client1|
  00000001 A 5 123.234.456.789 CMBIPC1          Tue May 21 13:46:22 1991 13fed734 YASARA   -nss -ncd -con -mcr|STARTUP.FIL=
  00000002 W 9                                                                    WHATMB   -step2 align.txt|

  Example:

  job=job_list(os.path.join(wmb_conf["CLUSTER_DIR"],wmb_conf["CLUSTER_JOB"]),error)
  whatifscript=job.convtext("STARTUP.FIL","build\n inibld\n ala\n %makmol\n\n ala.pdb\n all 0\n ONE ALANINE\n\nfullst y\n")
  for i in range(10):
    # ADD JOB
    job.add(8,"WHATIF",'|'+os.getcwd()+"||"+whatifscript+"|ala.pdb|")
  # SUBMIT THEM ALL
  job.submit()

  """

  # A JOB LIST FILENAME MUST ALWAYS END WITH .job
  #   IT IS RENAMED TO *.jupy (job update Python) BEFORE BEING ACCESSED (SO THAT NO OTHER
  #   PROGRAM CAN MODIFY THE FILE)

  # INITIALIZE
  # ==========
  # - listname IS THE PATH AND NAME OF cluster.job
  # - errorfunc IS AN ERROR HANDLING FUNCTION
  def __init__(self,listname,errorfunc=None):
    self.locked=0
    self.error=None
    self.errorfunc=errorfunc
    self.listname=listname
    self.lockname=listname[:-4]+".jupy"
    self.priority=5
    self.list=[]
    self.waitinglist=[]

  # LOCK THE JOB LIST
  # =================
  # THIS FUNCTION RETURNS AS SOON AS THE JOB LIST HAS BEEN LOCKED.
  # Instance.add CAN THEN BE USED TO ADD JOBS.
  def lock(self):
    if (not self.locked):
      # REMOVE THE LOCKED LIST, MIGHT BE A LEFTOVER
      if (os.path.exists(self.lockname)): os.remove(self.lockname)
      # IS THE LIST WITH JOBS PRESENT?
      while (1):
        # WAIT UNTIL LIST FILE IS ACCESSIBLE, THEN RENAME IT TO LOCK
        while (1):
          # TRY TO RENAME
          try: os.rename(self.listname,self.lockname)
          except:
            # SOMEONE ELSE IS USING THE FILE
            time.sleep(1)
            continue
          break
        if (os.path.exists(self.lockname)): break
        print "Job list was renamed to %s but cannot be found now. Trying again." % self.lockname
      # LOAD LIST
      self.list=open(self.lockname,"r").readlines()
      self.locked=1

  # RAISE AN ERROR
  # ==============
  # CALLS THE ERRORFUNCTION PROVIDED BY THE USER WITH THE GIVEN STRING
  def raiseerror(self,errormsg):
    errormsg=self.__class__.__name__+'.'+errormsg
    self.error=errormsg
    if (self.errorfunc!=None): apply(self.errorfunc,[errormsg])
    else:
      print errormsg
      raise SystemExit

  # ADD A JOB TO THE LIST
  # =====================
  # - priority RANGES FROM 0 TO 9
  # - program IS THE 6 LETTER PROGRAM ID
  # - options ARE PROGRAM OPTIONS, DATA FILES, RESULT FILES AND A DONE FILE.
  def add(self,priority,program,options):
    if (priority==None): priority=self.priority
    self.waitinglist.append([priority,program,options])

  # SUBMIT THE JOBS
  # ===============
  # THE JOBS ARE SUBMITTED TO THE CLUSTER, cluster.job IS UNLOCKED
  # IF WAITFLAG IS SET, THIS FUNCTION WILL ONLY RETURN AFTER ALL RESULTS HAVE
  # BEEN RECEIVED.
  def submit(self,waitflag=1):
    if (self.waitinglist!=[]):
      self.lock()
      # NUMBER OF JOB = NUMBER OF LAST JOB IN LIST+1 */
      if (len(self.list)==1):
        jobno=0
      else:
        jobno=int(self.list[-1][0:8])+1
      # ADD THE JOBS
      donefilelist=[]
      for i in range(len(self.waitinglist)):
        (priority,program,options)=self.waitinglist[i]
        options=string.rstrip(options)
        start=string.find(options,'|')+1
        end=string.find(options,'|',start)
        workdir=options[start:end]
        donefilepos=string.rfind(options,'|')+1
        donefilename=string.strip(options[donefilepos:])
        if (donefilename==""):
          # ADD DONE FILE
          donefilename=tmpfilename("donefile"+str(i))
          if (waitflag): options=options+donefilename
        if (waitflag):
          donefilename=os.path.join(workdir,donefilename)
          donefilelist.append(donefilename)
          remove(donefilename)
        if (priority<=0):
          # CHOOSE DEFAULT PRIORITY
          priority=self.priority+priority
        priority=max(0,priority)
        priority=min(9,priority)
        if (jobno>99999999): jobno=0
        self.list.append("%08d W %1d                              " % (jobno,priority) +\
                         "                                      %s   %s\n" % (program,options))
        jobno=jobno+1
      # SAVE LIST
      listfile=open(self.lockname,"w")
      listfile.writelines(self.list)
      listfile.close()
      self.unlock()
      self.waitinglist=[]
      if (waitflag):
        # WAIT FOR ALL JOBS
        starttime=time.time()
        for i in range(len(donefilelist)):
          donefilename=donefilelist[i]
          sys.stdout.write("\r%d of %d results arrived." % (i,len(donefilelist)))
          sys.stdout.flush()
          while (not os.path.exists(donefilename)): time.sleep(1)
          remove(donefilename)
        print "\rAll %d results arrived in %.2f minutes.                   " % (len(donefilelist),(time.time()-starttime)/60.0)

  # SUBMIT THE JOBS IN CHUNKS
  # =========================
  # THE JOBS ARE SUBMITTED IN CHUNKS, SO THAT NEVER MORE THAN jobs ARE IN THE
  # QUEUE TOGETHER. THIS IS HELPFUL IF DIFFERENT USERS WITH EQUAL PRIVILEGES
  # (AND THUS PRIORIRY) SHARE THE CLUSTER RESOURCES.
  def submitchunks(self,jobs):
    if (len(self.waitinglist)<=jobs or jobs==-1): self.submit(1)
    else:
      # PREPARE THE JOBS
      joblist=[]
      donefilelist=[]
      for i in range(len(self.waitinglist)):
        (priority,program,options)=self.waitinglist[i]
        options=string.rstrip(options)
        start=string.find(options,'|')+1
        end=string.find(options,'|',start)
        workdir=options[start:end]
        donefilepos=string.rfind(options,'|')+1
        donefilename=options[donefilepos:]
        if (donefilename==""):
          # ADD DONE FILE
          donefilename=tmpfilename("donefile"+str(i))
          options=options+donefilename
        donefilename=os.path.join(workdir,donefilename)
        donefilelist.append(donefilename)
        remove(donefilename)
        if (priority<=0):
          # CHOOSE DEFAULT PRIORITY
          priority=self.priority+priority
        priority=max(0,priority)
        priority=min(9,priority)
        joblist.append(" W %1d                              " % (priority) +\
                       "                                      %s   %s\n" % (program,options))
      # SUBMIT THEM IN JUNKS
      i=0
      while (i<len(self.waitinglist)):
        # COUNT DONE FILES
        donefiles=0
        for donefilename in donefilelist:
          if (os.path.exists(donefilename)): donefiles=donefiles+1
        if (i<donefiles+jobs):
          # SUBMIT JOBS
          self.lock()
          # NUMBER OF JOB = NUMBER OF LAST JOB IN LIST+1 */
          if (len(self.list)==1):
            jobno=0
          else:
            jobno=int(self.list[-1][0:8])+1
          while (i<donefiles+jobs and i<len(self.waitinglist)):
            if (jobno>99999999): jobno=0
            self.list.append("%08d" % jobno +joblist[i])
            jobno=jobno+1
            i=i+1
          # SAVE LIST
          listfile=open(self.lockname,"w")
          listfile.writelines(self.list)
          listfile.close()
          self.unlock()
          sys.stdout.write("\r%d of %d jobs submitted in chunks of %d." % (i,len(donefilelist),jobs))
          sys.stdout.flush()
        time.sleep(5)
      self.waitinglist=[]
      # WAIT FOR ALL JOBS
      for i in range(len(donefilelist)):
        donefilename=donefilelist[i]
        sys.stdout.write("\r%d of %d results arrived.                     " % (i,len(donefilelist)))
        sys.stdout.flush()
        while (not os.path.exists(donefilename)): time.sleep(1)
        remove(donefilename)
      print "\rAll %d results arrived.                   " % len(donefilelist)

  # UNLOCK THE JOBLIST
  # ==================
  # THE JOBLIST IS RENAMED BACK TO cluster.job AND BECOMES
  # VISIBLE FOR OTHER PROGRAMS.
  def unlock(self):
    os.rename(self.lockname,self.listname)
    self.locked=0

  # COUNT NUMBER OF WAITING JOBS IN LIST
  # ====================================
  def waiting(self):
    if (not self.locked):
      self.raiseerror("waiting: Waiting method can only be called after job list has been locked")
      return(None)
    wait=0
    for job in self.list:
      if (job[9]=='W'): wait=wait+1
    return(wait)

  # CONVERT NORMAL TEXT TO JOB LIST FORMAT (REPLACE \n WITH #)
  # ==========================================================
  def convtext(self,filename,text):
    # GET RID OF LINE FEEDS
    if (type(text)==types.ListType): text=string.join(text,"\n")
    if (filename=="STARTUP.FIL"):
      # HACK FOR WHAT IF: DISABLE DEBUGGING CRASHES ON THE CLUSTER, WHERE IT HANGS THE NODES
      text="setwif 1012 0\n"+text
    text=string.replace(text,'\n','#')
    # SEARCH FOR UNIQUE CHARACTERS TO QUOTE TEXT IN JOB LIST
    for i in range(34,126):
      if (string.find(text,chr(i))==-1): break
    else: return(None)
    if (string.find(text,'|')!=-1):
      self.raiseerror("convtext: Text to convert contains '|' - this character is reserved for use by Models@Home")
      return(None)
    return(filename+'='+chr(i)+text+chr(i))

  # WAIT FOR RESULTS
  # ================
  # resultfilelist IS A LIST OF RESULTFILES THAT MUST BE
  # RETURNED BY THE CLUSTER
  def waitresult(self,resultfilelist):
    results=len(resultfilelist)
    if (not results): return
    for i in range(results):
      resultfile=resultfilelist[i]
      sys.stdout.write("\r%d of %d results arrived." % (i,results))
      sys.stdout.flush()
      while (not os.path.exists(resultfile)): time.sleep(1)
    print "\rAll %d results arrived.                   " % results