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 %s\n" % \
  63                     (offlineimap.version.productname,
  64                      offlineimap.version.versionstr,
  65                      offlineimap.version.revstr))
  66         logfd.write("Python: %s\n" % sys.version)
  67         logfd.write("Platform: %s\n" % sys.platform)
  68         logfd.write("Args: %s\n" % sys.argv)
  69
  70     def _display(s, msg):
  71         """Display a message."""
  72         raise NotImplementedError
  73
  74     def warn(s, msg, minor = 0):
  75         if minor:
  76             s._msg("warning: " + msg)
  77         else:
  78             s._msg("WARNING: " + msg)
  79
  80     def registerthread(s, account):
  81         """Provides a hint to UIs about which account this particular
  82         thread is processing."""
  83         if s.threadaccounts.has_key(threading.currentThread()):
  84             raise ValueError, "Thread %s already registered (old %s, new %s)" %\
  85                   (threading.currentThread().getName(),
  86                    s.getthreadaccount(s), account)
  87         s.threadaccounts[threading.currentThread()] = account
  88
  89     def unregisterthread(s, thr):
  90         """Recognizes a thread has exited."""
  91         if s.threadaccounts.has_key(thr):
  92             del s.threadaccounts[thr]
  93
  94     def getthreadaccount(s, thr = None):
  95         if not thr:
  96             thr = threading.currentThread()
  97         if s.threadaccounts.has_key(thr):
  98             return s.threadaccounts[thr]
  99         return '*Control'
 100
 101     def debug(s, debugtype, msg):
 102         thisthread = threading.currentThread()
 103         if s.debugmessages.has_key(thisthread):
 104             s.debugmessages[thisthread].append("%s: %s" % (debugtype, msg))
 105         else:
 106             s.debugmessages[thisthread] = ["%s: %s" % (debugtype, msg)]
 107
 108         while len(s.debugmessages[thisthread]) > s.debugmsglen:
 109             s.debugmessages[thisthread] = s.debugmessages[thisthread][1:]
 110
 111         if debugtype in s.debuglist:
 112             if not s._log("DEBUG[%s]: %s" % (debugtype, msg)):
 113                 s._display("DEBUG[%s]: %s" % (debugtype, msg))
 114
 115     def add_debug(s, debugtype):
 116         global debugtypes
 117         if debugtype in debugtypes:
 118             if not debugtype in s.debuglist:
 119                 s.debuglist.append(debugtype)
 120                 s.debugging(debugtype)
 121         else:
 122             s.invaliddebug(debugtype)
 123
 124     def debugging(s, debugtype):
 125         global debugtypes
 126         s._msg("Now debugging for %s: %s" % (debugtype, debugtypes[debugtype]))
 127
 128     def invaliddebug(s, debugtype):
 129         s.warn("Invalid debug type: %s" % debugtype)
 130
 131     def locked(s):
 132         raise Exception, "Another OfflineIMAP is running with the same metadatadir; exiting."
 133
 134     def getnicename(s, object):
 135         prelimname = str(object.__class__).split('.')[-1]
 136         # Strip off extra stuff.
 137         return re.sub('(Folder|Repository)', '', prelimname)
 138
 139     def isusable(s):
 140         """Returns true if this UI object is usable in the current
 141         environment.  For instance, an X GUI would return true if it's
 142         being run in X with a valid DISPLAY setting, and false otherwise."""
 143         return 1
 144
 145     ################################################## INPUT
 146
 147     def getpass(s, accountname, config, errmsg = None):
 148         raise NotImplementedError
 149
 150     def folderlist(s, list):
 151         return ', '.join(["%s[%s]" % (s.getnicename(x), x.getname()) for x in list])
 152
 153     ################################################## WARNINGS
 154     def msgtoreadonly(s, destfolder, uid, content, flags):
 155         if not (config.has_option('general', 'ignore-readonly') and config.getboolean("general", "ignore-readonly")):
 156             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." % \
 157                    (uid, s.getnicename(destfolder), destfolder.getname()))
 158
 159     def flagstoreadonly(s, destfolder, uidlist, flags):
 160         if not (config.has_option('general', 'ignore-readonly') and config.getboolean("general", "ignore-readonly")):
 161             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." % \
 162                    (str(uidlist), s.getnicename(destfolder), destfolder.getname()))
 163
 164     def deletereadonly(s, destfolder, uidlist):
 165         if not (config.has_option('general', 'ignore-readonly') and config.getboolean("general", "ignore-readonly")):
 166             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." % \
 167                    (str(uidlist), s.getnicename(destfolder), destfolder.getname()))
 168
 169     ################################################## MESSAGES
 170
 171     def init_banner(s):
 172         """Called when the UI starts.  Must be called before any other UI
 173         call except isusable().  Displays the copyright banner.  This is
 174         where the UI should do its setup -- TK, for instance, would
 175         create the application window here."""
 176         if s.verbose >= 0:
 177             s._msg(offlineimap.version.banner)
 178
 179     def connecting(s, hostname, port):
 180         if s.verbose < 0:
 181             return
 182         if hostname == None:
 183             hostname = ''
 184         if port != None:
 185             port = ":%s" % str(port)
 186         displaystr = ' to %s%s.' % (hostname, port)
 187         if hostname == '' and port == None:
 188             displaystr = '.'
 189         s._msg("Establishing connection" + displaystr)
 190
 191     def acct(s, accountname):
 192         if s.verbose >= 0:
 193             s._msg("***** Processing account %s" % accountname)
 194
 195     def acctdone(s, accountname):
 196         if s.verbose >= 0:
 197             s._msg("***** Finished processing account " + accountname)
 198
 199     def syncfolders(s, srcrepos, destrepos):
 200         if s.verbose >= 0:
 201             s._msg("Copying folder structure from %s to %s" % \
 202                    (s.getnicename(srcrepos), s.getnicename(destrepos)))
 203
 204     ############################## Folder syncing
 205     def syncingfolder(s, srcrepos, srcfolder, destrepos, destfolder):
 206         """Called when a folder sync operation is started."""
 207         if s.verbose >= 0:
 208             s._msg("Syncing %s: %s -> %s" % (srcfolder.getname(),
 209                                              s.getnicename(srcrepos),
 210                                              s.getnicename(destrepos)))
 211
 212     def validityproblem(s, folder, saved, new):
 213         s.warn("UID validity problem for folder %s (saved %d; got %d); skipping it" % \
 214                (folder.getname(), saved, new))
 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):
 306         """Called to terminate the application."""
 307         sys.exit(exitstatus)
 308
 309     def threadExited(s, thread):
 310         """Called when a thread has exited normally.  Many UIs will
 311         just ignore this."""
 312         s.delThreadDebugLog(thread)
 313         s.unregisterthread(thread)
 314
 315     ################################################## Other
 316
 317     def sleep(s, sleepsecs):
 318         """This function does not actually output anything, but handles
 319         the overall sleep, dealing with updates as necessary.  It will,
 320         however, call sleeping() which DOES output something.
 321
 322         Returns 0 if timeout expired, 1 if there is a request to cancel
 323         the timer, and 2 if there is a request to abort the program."""
 324
 325         abortsleep = 0
 326         while sleepsecs > 0 and not abortsleep:
 327             abortsleep = s.sleeping(1, sleepsecs)
 328             sleepsecs -= 1
 329         s.sleeping(0, 0)               # Done sleeping.
 330         return abortsleep
 331
 332     def sleeping(s, sleepsecs, remainingsecs):
 333         """Sleep for sleepsecs, remainingsecs to go.
 334         If sleepsecs is 0, indicates we're done sleeping.
 335
 336         Return 0 for normal sleep, or 1 to indicate a request
 337         to sync immediately."""
 338         s._msg("Next refresh in %d seconds" % remainingsecs)
 339         if sleepsecs > 0:
 340             time.sleep(sleepsecs)
 341         return 0