code.delx.au - offlineimap/blob - offlineimap/ui/UIBase.py

   1 # UI base class
   2 # Copyright (C) 2002 John Goerzen
   3 # <jgoerzen@complete.org>
   4 #
   5 #    This program is free software; you can redistribute it and/or modify
   6 #    it under the terms of the GNU General Public License as published by
   7 #    the Free Software Foundation; either version 2 of the License, or
   8 #    (at your option) any later version.
   9 #
  10 #    This program is distributed in the hope that it will be useful,
  11 #    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 #    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 #    GNU General Public License for more details.
  14 #
  15 #    You should have received a copy of the GNU General Public License
  16 #    along with this program; if not, write to the Free Software
  17 #    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
  18
  19 import offlineimap.version
  20 import re, time, sys, traceback, threading, thread
  21 from StringIO import StringIO
  22
  23 debugtypes = {'imap': 'IMAP protocol debugging',
  24               'maildir': 'Maildir repository debugging',
  25               'thread': 'Threading debugging'}
  26
  27 globalui = None
  28 def setglobalui(newui):
  29     global globalui
  30     globalui = newui
  31 def getglobalui():
  32     global globalui
  33     return globalui
  34
  35 class UIBase:
  36     def __init__(s, config, verbose = 0):
  37         s.verbose = verbose
  38         s.config = config
  39         s.debuglist = []
  40         s.debugmessages = {}
  41         s.debugmsglen = 50
  42         s.threadaccounts = {}
  43         s.logfile = None
  44
  45     ################################################## UTILS
  46     def _msg(s, msg):
  47         """Generic tool called when no other works."""
  48         s._log(msg)
  49         s._display(msg)
  50
  51     def _log(s, msg):
  52         """Log it to disk.  Returns true if it wrote something; false
  53         otherwise."""
  54         if s.logfile:
  55             s.logfile.write("%s: %s\n" % (threading.currentThread().getName(),
  56                                           msg))
  57             return 1
  58         return 0
  59
  60     def setlogfd(s, logfd):
  61         s.logfile = logfd
  62         logfd.write("This is %s %s\n" % \
  63                     (offlineimap.version.productname,
  64                      offlineimap.version.versionstr))
  65         logfd.write("Python: %s\n" % sys.version)
  66         logfd.write("Platform: %s\n" % sys.platform)
  67         logfd.write("Args: %s\n" % sys.argv)
  68
  69     def _display(s, msg):
  70         """Display a message."""
  71         raise NotImplementedError
  72
  73     def warn(s, msg, minor = 0):
  74         if minor:
  75             s._msg("warning: " + msg)
  76         else:
  77             s._msg("WARNING: " + msg)
  78
  79     def registerthread(s, account):
  80         """Provides a hint to UIs about which account this particular
  81         thread is processing."""
  82         if s.threadaccounts.has_key(threading.currentThread()):
  83             raise ValueError, "Thread %s already registered (old %s, new %s)" %\
  84                   (threading.currentThread().getName(),
  85                    s.getthreadaccount(s), account)
  86         s.threadaccounts[threading.currentThread()] = account
  87
  88     def unregisterthread(s, thr):
  89         """Recognizes a thread has exited."""
  90         if s.threadaccounts.has_key(thr):
  91             del s.threadaccounts[thr]
  92
  93     def getthreadaccount(s, thr = None):
  94         if not thr:
  95             thr = threading.currentThread()
  96         if s.threadaccounts.has_key(thr):
  97             return s.threadaccounts[thr]
  98         return '*Control'
  99
 100     def debug(s, debugtype, msg):
 101         thisthread = threading.currentThread()
 102         if s.debugmessages.has_key(thisthread):
 103             s.debugmessages[thisthread].append("%s: %s" % (debugtype, msg))
 104         else:
 105             s.debugmessages[thisthread] = ["%s: %s" % (debugtype, msg)]
 106
 107         while len(s.debugmessages[thisthread]) > s.debugmsglen:
 108             s.debugmessages[thisthread] = s.debugmessages[thisthread][1:]
 109
 110         if debugtype in s.debuglist:
 111             if not s._log("DEBUG[%s]: %s" % (debugtype, msg)):
 112                 s._display("DEBUG[%s]: %s" % (debugtype, msg))
 113
 114     def add_debug(s, debugtype):
 115         global debugtypes
 116         if debugtype in debugtypes:
 117             if not debugtype in s.debuglist:
 118                 s.debuglist.append(debugtype)
 119                 s.debugging(debugtype)
 120         else:
 121             s.invaliddebug(debugtype)
 122
 123     def debugging(s, debugtype):
 124         global debugtypes
 125         s._msg("Now debugging for %s: %s" % (debugtype, debugtypes[debugtype]))
 126
 127     def invaliddebug(s, debugtype):
 128         s.warn("Invalid debug type: %s" % debugtype)
 129
 130     def locked(s):
 131         raise Exception, "Another OfflineIMAP is running with the same metadatadir; exiting."
 132
 133     def getnicename(s, object):
 134         prelimname = str(object.__class__).split('.')[-1]
 135         # Strip off extra stuff.
 136         return re.sub('(Folder|Repository)', '', prelimname)
 137
 138     def isusable(s):
 139         """Returns true if this UI object is usable in the current
 140         environment.  For instance, an X GUI would return true if it's
 141         being run in X with a valid DISPLAY setting, and false otherwise."""
 142         return 1
 143
 144     ################################################## INPUT
 145
 146     def getpass(s, accountname, config, errmsg = None):
 147         raise NotImplementedError
 148
 149     def folderlist(s, list):
 150         return ', '.join(["%s[%s]" % (s.getnicename(x), x.getname()) for x in list])
 151
 152     ################################################## WARNINGS
 153     def msgtoreadonly(s, destfolder, uid, content, flags):
 154         if not (config.has_option('general', 'ignore-readonly') and config.getboolean("general", "ignore-readonly")):
 155             s.warn("Attempted to synchronize message %d to folder %s[%s], but that folder is read-only.  The message will not be copied to that folder." % \
 156                    (uid, s.getnicename(destfolder), destfolder.getname()))
 157
 158     def flagstoreadonly(s, destfolder, uidlist, flags):
 159         if not (config.has_option('general', 'ignore-readonly') and config.getboolean("general", "ignore-readonly")):
 160             s.warn("Attempted to modify flags for messages %s in folder %s[%s], but that folder is read-only.  No flags have been modified for that message." % \
 161                    (str(uidlist), s.getnicename(destfolder), destfolder.getname()))
 162
 163     def deletereadonly(s, destfolder, uidlist):
 164         if not (config.has_option('general', 'ignore-readonly') and config.getboolean("general", "ignore-readonly")):
 165             s.warn("Attempted to delete messages %s in folder %s[%s], but that folder is read-only.  No messages have been deleted in that folder." % \
 166                    (str(uidlist), s.getnicename(destfolder), destfolder.getname()))
 167
 168     ################################################## MESSAGES
 169
 170     def init_banner(s):
 171         """Called when the UI starts.  Must be called before any other UI
 172         call except isusable().  Displays the copyright banner.  This is
 173         where the UI should do its setup -- TK, for instance, would
 174         create the application window here."""
 175         if s.verbose >= 0:
 176             s._msg(offlineimap.version.banner)
 177
 178     def connecting(s, hostname, port):
 179         if s.verbose < 0:
 180             return
 181         if hostname == None:
 182             hostname = ''
 183         if port != None:
 184             port = ":%s" % str(port)
 185         displaystr = ' to %s%s.' % (hostname, port)
 186         if hostname == '' and port == None:
 187             displaystr = '.'
 188         s._msg("Establishing connection" + displaystr)
 189
 190     def acct(s, accountname):
 191         if s.verbose >= 0:
 192             s._msg("***** Processing account %s" % accountname)
 193
 194     def acctdone(s, accountname):
 195         if s.verbose >= 0:
 196             s._msg("***** Finished processing account " + accountname)
 197
 198     def syncfolders(s, srcrepos, destrepos):
 199         if s.verbose >= 0:
 200             s._msg("Copying folder structure from %s to %s" % \
 201                    (s.getnicename(srcrepos), s.getnicename(destrepos)))
 202
 203     ############################## Folder syncing
 204     def syncingfolder(s, srcrepos, srcfolder, destrepos, destfolder):
 205         """Called when a folder sync operation is started."""
 206         if s.verbose >= 0:
 207             s._msg("Syncing %s: %s -> %s" % (srcfolder.getname(),
 208                                              s.getnicename(srcrepos),
 209                                              s.getnicename(destrepos)))
 210
 211     def validityproblem(s, folder):
 212         s.warn("UID validity problem for folder %s (repo %s) (saved %d; got %d); skipping it" % \
 213                (folder.getname(), folder.getrepository().getname(),
 214                 folder.getsaveduidvalidity(), folder.getuidvalidity()))
 215
 216     def loadmessagelist(s, repos, folder):
 217         if s.verbose > 0:
 218             s._msg("Loading message list for %s[%s]" % (s.getnicename(repos),
 219                                                         folder.getname()))
 220
 221     def messagelistloaded(s, repos, folder, count):
 222         if s.verbose > 0:
 223             s._msg("Message list for %s[%s] loaded: %d messages" % \
 224                    (s.getnicename(repos), folder.getname(), count))
 225
 226     ############################## Message syncing
 227
 228     def syncingmessages(s, sr, sf, dr, df):
 229         if s.verbose > 0:
 230             s._msg("Syncing messages %s[%s] -> %s[%s]" % (s.getnicename(sr),
 231                                                           sf.getname(),
 232                                                           s.getnicename(dr),
 233                                                           df.getname()))
 234
 235     def copyingmessage(s, uid, src, destlist):
 236         if s.verbose >= 0:
 237             ds = s.folderlist(destlist)
 238             s._msg("Copy message %d %s[%s] -> %s" % (uid, s.getnicename(src),
 239                                                      src.getname(), ds))
 240
 241     def deletingmessage(s, uid, destlist):
 242         if s.verbose >= 0:
 243             ds = s.folderlist(destlist)
 244             s._msg("Deleting message %d in %s" % (uid, ds))
 245
 246     def deletingmessages(s, uidlist, destlist):
 247         if s.verbose >= 0:
 248             ds = s.folderlist(destlist)
 249             s._msg("Deleting %d messages (%s) in %s" % \
 250                    (len(uidlist),
 251                     ", ".join([str(u) for u in uidlist]),
 252                     ds))
 253
 254     def addingflags(s, uidlist, flags, destlist):
 255         if s.verbose >= 0:
 256             ds = s.folderlist(destlist)
 257             s._msg("Adding flags %s to %d messages  on %s" % \
 258                    (", ".join(flags), len(uidlist), ds))
 259
 260     def deletingflags(s, uidlist, flags, destlist):
 261         if s.verbose >= 0:
 262             ds = s.folderlist(destlist)
 263             s._msg("Deleting flags %s to %d messages on %s" % \
 264                    (", ".join(flags), len(uidlist), ds))
 265
 266     ################################################## Threads
 267
 268     def getThreadDebugLog(s, thread):
 269         if s.debugmessages.has_key(thread):
 270             message = "\nLast %d debug messages logged for %s prior to exception:\n"\
 271                        % (len(s.debugmessages[thread]), thread.getName())
 272             message += "\n".join(s.debugmessages[thread])
 273         else:
 274             message = "\nNo debug messages were logged for %s." % \
 275                       thread.getName()
 276         return message
 277
 278     def delThreadDebugLog(s, thread):
 279         if s.debugmessages.has_key(thread):
 280             del s.debugmessages[thread]
 281
 282     def getThreadExceptionString(s, thread):
 283         message = "Thread '%s' terminated with exception:\n%s" % \
 284                   (thread.getName(), thread.getExitStackTrace())
 285         message += "\n" + s.getThreadDebugLog(thread)
 286         return message
 287
 288     def threadException(s, thread):
 289         """Called when a thread has terminated with an exception.
 290         The argument is the ExitNotifyThread that has so terminated."""
 291         s._msg(s.getThreadExceptionString(thread))
 292         s.delThreadDebugLog(thread)
 293         s.terminate(100)
 294
 295     def getMainExceptionString(s):
 296         sbuf = StringIO()
 297         traceback.print_exc(file = sbuf)
 298         return "Main program terminated with exception:\n" + \
 299                sbuf.getvalue() + "\n" + \
 300                s.getThreadDebugLog(threading.currentThread())
 301
 302     def mainException(s):
 303         s._msg(s.getMainExceptionString())
 304
 305     def terminate(s, exitstatus = 0, errortitle = None, errormsg = None):
 306         """Called to terminate the application."""
 307         if errormsg <> None:
 308             if errortitle <> None:
 309                 sys.stderr.write('ERROR: %s\n\n%s\n'%(errortitle, errormsg))
 310             else:
 311                 sys.stderr.write('%s\n' % errormsg)
 312         sys.exit(exitstatus)
 313
 314     def threadExited(s, thread):
 315         """Called when a thread has exited normally.  Many UIs will
 316         just ignore this."""
 317         s.delThreadDebugLog(thread)
 318         s.unregisterthread(thread)
 319
 320     ################################################## Other
 321
 322     def sleep(s, sleepsecs):
 323         """This function does not actually output anything, but handles
 324         the overall sleep, dealing with updates as necessary.  It will,
 325         however, call sleeping() which DOES output something.
 326
 327         Returns 0 if timeout expired, 1 if there is a request to cancel
 328         the timer, and 2 if there is a request to abort the program."""
 329
 330         abortsleep = 0
 331         while sleepsecs > 0 and not abortsleep:
 332             abortsleep = s.sleeping(1, sleepsecs)
 333             sleepsecs -= 1
 334         s.sleeping(0, 0)               # Done sleeping.
 335         return abortsleep
 336
 337     def sleeping(s, sleepsecs, remainingsecs):
 338         """Sleep for sleepsecs, remainingsecs to go.
 339         If sleepsecs is 0, indicates we're done sleeping.
 340
 341         Return 0 for normal sleep, or 1 to indicate a request
 342         to sync immediately."""
 343         s._msg("Next refresh in %d seconds" % remainingsecs)
 344         if sleepsecs > 0:
 345             time.sleep(sleepsecs)
 346         return 0