tobias/docker-offlineimap
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Rework UI system to make use of the logging module

Browse Source 
Logging was flawed as the output was e.g. heavily buffered and people
complained about missing log entries. Fix this by making use of the
standard logging facilities that offlineimap offers.

This is one big ugly patch that does many things. It fixes the
Blinkenlights backend to work again with the logging facilities.

Resize windows and hotkeys are still not handled absolut correctly, this
is left for future fixing. THe rest of the backends should be working fine.

Signed-off-by: Sebastian Spaeth <Sebastian@SSpaeth.de>
This commit is contained in:
Sebastian Spaeth 2011-10-26 16:47:21 +02:00
parent d4a11c62ea
commit cbec8bb5b2
12 changed files with 829 additions and 945 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
offlineimap/__init__.py
View File

@ -8,15 +8,11 @@ __author_email__= "john@complete.org"
__description__ = "Disconnected Universal IMAP Mail Synchronization/Reader Support" __description__ = "Disconnected Universal IMAP Mail Synchronization/Reader Support"
__license__ = "Licensed under the GNU GPL v2+ (v2 or any later version)" __license__ = "Licensed under the GNU GPL v2+ (v2 or any later version)"
__bigcopyright__ = """%(__productname__)s %(__version__)s __bigcopyright__ = """%(__productname__)s %(__version__)s
%(__copyright__)s. %(__license__)s""" % locals()
%(__license__)s.
""" % locals()
__homepage__ = "http://github.com/nicolas33/offlineimap" __homepage__ = "http://github.com/nicolas33/offlineimap"
banner = __bigcopyright__ banner = __bigcopyright__
from offlineimap.error import OfflineImapError from offlineimap.error import OfflineImapError
# put this last, so we don't run into circular dependencies using # put this last, so we don't run into circular dependencies using
# e.g. offlineimap.__version__. # e.g. offlineimap.__version__.

1
offlineimap/accounts.py
View File

@ -167,6 +167,7 @@ class Account(CustomConfig.ConfigHelperMixin):
self.ui.serverdiagnostics(local_repo, 'Local') self.ui.serverdiagnostics(local_repo, 'Local')
#self.ui.serverdiagnostics(statusrepos, 'Status') #self.ui.serverdiagnostics(statusrepos, 'Status')
class SyncableAccount(Account): class SyncableAccount(Account):
"""A syncable email account connecting 2 repositories """A syncable email account connecting 2 repositories

15
offlineimap/init.py
View File

@ -160,6 +160,7 @@ class OfflineImap:
config = CustomConfigParser() config = CustomConfigParser()
if not os.path.exists(configfilename): if not os.path.exists(configfilename):
# TODO, initialize and make use of chosen ui for logging
logging.error(" *** Config file '%s' does not exist; aborting!" % logging.error(" *** Config file '%s' does not exist; aborting!" %
configfilename) configfilename)
sys.exit(1) sys.exit(1)
@ -168,14 +169,17 @@ class OfflineImap:
#profile mode chosen? #profile mode chosen?
if options.profiledir: if options.profiledir:
if not options.singlethreading: if not options.singlethreading:
# TODO, make use of chosen ui for logging
logging.warn("Profile mode: Forcing to singlethreaded.") logging.warn("Profile mode: Forcing to singlethreaded.")
options.singlethreading = True options.singlethreading = True
if os.path.exists(options.profiledir): if os.path.exists(options.profiledir):
# TODO, make use of chosen ui for logging
logging.warn("Profile mode: Directory '%s' already exists!" % logging.warn("Profile mode: Directory '%s' already exists!" %
options.profiledir) options.profiledir)
else: else:
os.mkdir(options.profiledir) os.mkdir(options.profiledir)
threadutil.ExitNotifyThread.set_profiledir(options.profiledir) threadutil.ExitNotifyThread.set_profiledir(options.profiledir)
# TODO, make use of chosen ui for logging
logging.warn("Profile mode: Potentially large data will be " logging.warn("Profile mode: Potentially large data will be "
"created in '%s'" % options.profiledir) "created in '%s'" % options.profiledir)
@ -197,6 +201,7 @@ class OfflineImap:
if '.' in ui_type: if '.' in ui_type:
#transform Curses.Blinkenlights -> Blinkenlights #transform Curses.Blinkenlights -> Blinkenlights
ui_type = ui_type.split('.')[-1] ui_type = ui_type.split('.')[-1]
# TODO, make use of chosen ui for logging
logging.warning('Using old interface name, consider using one ' logging.warning('Using old interface name, consider using one '
'of %s' % ', '.join(UI_LIST.keys())) 'of %s' % ', '.join(UI_LIST.keys()))
try: try:
@ -210,12 +215,13 @@ class OfflineImap:
#set up additional log files #set up additional log files
if options.logfile: if options.logfile:
self.ui.setlogfd(open(options.logfile, 'wt')) self.ui.setlogfile(options.logfile)
#welcome blurb #welcome blurb
self.ui.init_banner() self.ui.init_banner()
if options.debugtype: if options.debugtype:
self.ui.logger.setLevel(logging.DEBUG)
if options.debugtype.lower() == 'all': if options.debugtype.lower() == 'all':
options.debugtype = 'imap,maildir,thread' options.debugtype = 'imap,maildir,thread'
#force single threading? #force single threading?
@ -352,10 +358,9 @@ class OfflineImap:
name='Sync Runner', name='Sync Runner',
kwargs = {'accounts': syncaccounts, kwargs = {'accounts': syncaccounts,
'config': self.config}) 'config': self.config})
t.setDaemon(1) t.setDaemon(True)
t.start() t.start()
threadutil.exitnotifymonitorloop(threadutil.threadexited) threadutil.exitnotifymonitorloop(threadutil.threadexited)
self.ui.terminate() self.ui.terminate()
except KeyboardInterrupt: except KeyboardInterrupt:
self.ui.terminate(1, errormsg = 'CTRL-C pressed, aborting...') self.ui.terminate(1, errormsg = 'CTRL-C pressed, aborting...')
@ -363,8 +368,8 @@ class OfflineImap:
except (SystemExit): except (SystemExit):
raise raise
except Exception, e: except Exception, e:
ui.error(e) self.ui.error(e)
ui.terminate() self.ui.terminate()
def sync_singlethreaded(self, accs): def sync_singlethreaded(self, accs):
"""Executed if we do not want a separate syncmaster thread """Executed if we do not want a separate syncmaster thread

3
offlineimap/syncmaster.py
View File

@ -25,12 +25,11 @@ def syncaccount(threads, config, accountname):
thread = InstanceLimitedThread(instancename = 'ACCOUNTLIMIT', thread = InstanceLimitedThread(instancename = 'ACCOUNTLIMIT',
target = account.syncrunner, target = account.syncrunner,
name = "Account sync %s" % accountname) name = "Account sync %s" % accountname)
thread.setDaemon(1) thread.setDaemon(True)
thread.start() thread.start()
threads.add(thread) threads.add(thread)
def syncitall(accounts, config): def syncitall(accounts, config):
currentThread().setExitMessage('SYNC_WITH_TIMER_TERMINATE')
threads = threadlist() threads = threadlist()
for accountname in accounts: for accountname in accounts:
syncaccount(threads, config, accountname) syncaccount(threads, config, accountname)

13
offlineimap/threadutil.py
View File

@ -81,6 +81,7 @@ exitthreads = Queue(100)
def exitnotifymonitorloop(callback): def exitnotifymonitorloop(callback):
"""An infinite "monitoring" loop watching for finished ExitNotifyThread's. """An infinite "monitoring" loop watching for finished ExitNotifyThread's.
This one is supposed to run in the main thread.
:param callback: the function to call when a thread terminated. That :param callback: the function to call when a thread terminated. That
function is called with a single argument -- the function is called with a single argument -- the
ExitNotifyThread that has terminated. The monitor will ExitNotifyThread that has terminated. The monitor will
@ -124,11 +125,19 @@ def threadexited(thread):
ui.threadExited(thread) ui.threadExited(thread)
class ExitNotifyThread(Thread): class ExitNotifyThread(Thread):
"""This class is designed to alert a "monitor" to the fact that a thread has """This class is designed to alert a "monitor" to the fact that a
exited and to provide for the ability for it to find out why.""" thread has exited and to provide for the ability for it to find out
why. All instances are made daemon threads (setDaemon(True), so we
bail out when the mainloop dies."""
profiledir = None profiledir = None
"""class variable that is set to the profile directory if required""" """class variable that is set to the profile directory if required"""
def __init__(self, *args, **kwargs):
super(ExitNotifyThread, self).__init__(*args, **kwargs)
# These are all child threads that are supposed to go away when
# the main thread is killed.
self.setDaemon(True)
def run(self): def run(self):
global exitthreads global exitthreads
self.threadid = get_ident() self.threadid = get_ident()

148
offlineimap/ui/Blinkenlights.py
View File

@ -1,148 +0,0 @@
# Blinkenlights base classes
# Copyright (C) 2003 John Goerzen
# <jgoerzen@complete.org>
#
# 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
from threading import RLock, currentThread
from offlineimap.ui.UIBase import UIBase
from thread import get_ident # python < 2.6 support
class BlinkenBase:
"""This is a mix-in class that should be mixed in with either UIBase
or another appropriate base class. The Tk interface, for instance,
will probably mix it in with VerboseUI."""
def acct(s, accountname):
s.gettf().setcolor('purple')
s.__class__.__bases__[-1].acct(s, accountname)
def connecting(s, hostname, port):
s.gettf().setcolor('gray')
s.__class__.__bases__[-1].connecting(s, hostname, port)
def syncfolders(s, srcrepos, destrepos):
s.gettf().setcolor('blue')
s.__class__.__bases__[-1].syncfolders(s, srcrepos, destrepos)
def syncingfolder(s, srcrepos, srcfolder, destrepos, destfolder):
s.gettf().setcolor('cyan')
s.__class__.__bases__[-1].syncingfolder(s, srcrepos, srcfolder, destrepos, destfolder)
def skippingfolder(s, folder):
s.gettf().setcolor('cyan')
s.__class__.__bases__[-1].skippingfolder(s, folder)
def loadmessagelist(s, repos, folder):
s.gettf().setcolor('green')
s._msg("Scanning folder [%s/%s]" % (s.getnicename(repos),
folder.getvisiblename()))
def syncingmessages(s, sr, sf, dr, df):
s.gettf().setcolor('blue')
s.__class__.__bases__[-1].syncingmessages(s, sr, sf, dr, df)
def copyingmessage(s, uid, num, num_to_copy, src, destfolder):
s.gettf().setcolor('orange')
s.__class__.__bases__[-1].copyingmessage(s, uid, num, num_to_copy, src,
destfolder)
def deletingmessages(s, uidlist, destlist):
s.gettf().setcolor('red')
s.__class__.__bases__[-1].deletingmessages(s, uidlist, destlist)
def deletingmessage(s, uid, destlist):
s.gettf().setcolor('red')
s.__class__.__bases__[-1].deletingmessage(s, uid, destlist)
def addingflags(s, uidlist, flags, dest):
s.gettf().setcolor('yellow')
s.__class__.__bases__[-1].addingflags(s, uidlist, flags, dest)
def deletingflags(s, uidlist, flags, dest):
s.gettf().setcolor('pink')
s.__class__.__bases__[-1].deletingflags(s, uidlist, flags, dest)
def warn(s, msg, minor = 0):
if minor:
s.gettf().setcolor('pink')
else:
s.gettf().setcolor('red')
s.__class__.__bases__[-1].warn(s, msg, minor)
def init_banner(s):
s.availablethreadframes = {}
s.threadframes = {}
#tflock protects the s.threadframes manipulation to only happen from 1 thread
s.tflock = RLock()
def threadExited(s, thread):
threadid = thread.threadid
accountname = s.getthreadaccount(thread)
s.tflock.acquire()
try:
if threadid in s.threadframes[accountname]:
tf = s.threadframes[accountname][threadid]
del s.threadframes[accountname][threadid]
s.availablethreadframes[accountname].append(tf)
tf.setthread(None)
finally:
s.tflock.release()
UIBase.threadExited(s, thread)
def gettf(s):
threadid = get_ident()
accountname = s.getthreadaccount()
s.tflock.acquire()
try:
if not accountname in s.threadframes:
s.threadframes[accountname] = {}
if threadid in s.threadframes[accountname]:
return s.threadframes[accountname][threadid]
if not accountname in s.availablethreadframes:
s.availablethreadframes[accountname] = []
if len(s.availablethreadframes[accountname]):
tf = s.availablethreadframes[accountname].pop(0)
tf.setthread(currentThread())
else:
tf = s.getaccountframe().getnewthreadframe()
s.threadframes[accountname][threadid] = tf
return tf
finally:
s.tflock.release()
def callhook(s, msg):
s.gettf().setcolor('white')
s.__class__.__bases__[-1].callhook(s, msg)
def sleep(s, sleepsecs, account):
s.gettf().setcolor('red')
s.getaccountframe().startsleep(sleepsecs)
return UIBase.sleep(s, sleepsecs, account)
def sleeping(s, sleepsecs, remainingsecs):
if remainingsecs and s.gettf().getcolor() == 'black':
s.gettf().setcolor('red')
else:
s.gettf().setcolor('black')
return s.getaccountframe().sleeping(sleepsecs, remainingsecs)

952
offlineimap/ui/Curses.py
View File

File diff suppressed because it is too large Load Diff

76
offlineimap/ui/Machine.py
View File

@ -1,5 +1,4 @@
# Copyright (C) 2007 John Goerzen # Copyright (C) 2007-2011 John Goerzen & contributors
# <jgoerzen@complete.org>
# #
# This program is free software; you can redistribute it and/or modify # 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 # it under the terms of the GNU General Public License as published by
@ -18,48 +17,30 @@
import urllib import urllib
import sys import sys
import time import time
import logging
from UIBase import UIBase from UIBase import UIBase
from threading import currentThread, Lock from threading import currentThread
import offlineimap import offlineimap
protocol = '6.0.0' protocol = '7.0.0'
class MachineUI(UIBase): class MachineUI(UIBase):
def __init__(s, config, verbose = 0): def __init__(self, config, loglevel = logging.INFO):
UIBase.__init__(s, config, verbose) super(MachineUI, self).__init__(config, loglevel)
s.safechars=" ;,./-_=+()[]" self._log_con_handler.createLock()
s.iswaiting = 0 """lock needed to block on password input"""
s.outputlock = Lock()
s._printData('__init__', protocol)
def isusable(s): def _printData(self, command, msg):
return True self.logger.info("%s:%s:%s:%s" % (
'msg', command, currentThread().getName(), msg))
def _printData(s, command, data, dolock = True): def _msg(s, msg):
s._printDataOut('msg', command, data, dolock)
def _printWarn(s, command, data, dolock = True):
s._printDataOut('warn', command, data, dolock)
def _printDataOut(s, datatype, command, data, dolock = True):
if dolock:
s.outputlock.acquire()
try:
print "%s:%s:%s:%s" % \
(datatype,
urllib.quote(command, s.safechars),
urllib.quote(currentThread().getName(), s.safechars),
urllib.quote(data, s.safechars))
sys.stdout.flush()
finally:
if dolock:
s.outputlock.release()
def _display(s, msg):
s._printData('_display', msg) s._printData('_display', msg)
def warn(s, msg, minor = 0): def warn(s, msg, minor = 0):
s._printData('warn', '%s\n%d' % (msg, int(minor))) # TODO, remove and cleanup the unused minor stuff
self.logger.warning("%s:%s:%s:%s" % (
'warn', '', currentThread().getName(), msg))
def registerthread(s, account): def registerthread(s, account):
UIBase.registerthread(s, account) UIBase.registerthread(s, account)
@ -116,9 +97,6 @@ class MachineUI(UIBase):
def folderlist(s, list): def folderlist(s, list):
return ("\f".join(["%s\t%s" % (s.getnicename(x), x.getname()) for x in list])) return ("\f".join(["%s\t%s" % (s.getnicename(x), x.getname()) for x in list]))
def deletingmessage(s, uid, destlist):
s.deletingmessages(s, [uid], destlist)
def uidlist(s, list): def uidlist(s, list):
return ("\f".join([str(u) for u in list])) return ("\f".join([str(u) for u in list]))
@ -161,19 +139,21 @@ class MachineUI(UIBase):
return 0 return 0
def getpass(s, accountname, config, errmsg = None): def getpass(self, accountname, config, errmsg = None):
s.outputlock.acquire() if errmsg:
self._printData('getpasserror', "%s\n%s" % (accountname, errmsg),
False)
self._log_con_handler.acquire() # lock the console output
try: try:
if errmsg: self._printData('getpass', accountname, False)
s._printData('getpasserror', "%s\n%s" % (accountname, errmsg),
False)
s._printData('getpass', accountname, False)
return (sys.stdin.readline()[:-1]) return (sys.stdin.readline()[:-1])
finally: finally:
s.outputlock.release() self._log_con_handler.release()
def init_banner(s): def init_banner(self):
s._printData('initbanner', offlineimap.banner) self._printData('protocol', protocol)
self._printData('initbanner', offlineimap.banner)
def callhook(s, msg): def callhook(self, msg):
s._printData('callhook', msg) self._printData('callhook', msg)

41
offlineimap/ui/Noninteractive.py
View File

@ -1,6 +1,5 @@
# Noninteractive UI # Noninteractive UI
# Copyright (C) 2002 John Goerzen # Copyright (C) 2002-2011 John Goerzen & contributors
# <jgoerzen@complete.org>
# #
# This program is free software; you can redistribute it and/or modify # 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 # it under the terms of the GNU General Public License as published by
@ -16,37 +15,15 @@
# along with this program; if not, write to the Free Software # along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
import sys import logging
import time
from UIBase import UIBase from UIBase import UIBase
class Basic(UIBase): class Basic(UIBase):
def getpass(s, accountname, config, errmsg = None): """'Quiet' simply sets log level to INFO"""
raise NotImplementedError, "Prompting for a password is not supported in noninteractive mode." def __init__(self, config, loglevel = logging.INFO):
return super(Basic, self).__init__(config, loglevel)
def _display(s, msg): class Quiet(UIBase):
print msg """'Quiet' simply sets log level to WARNING"""
sys.stdout.flush() def __init__(self, config, loglevel = logging.WARNING):
return super(Quiet, self).__init__(config, loglevel)
def warn(s, msg, minor = 0):
warntxt = 'WARNING'
if minor:
warntxt = 'warning'
sys.stderr.write(warntxt + ": " + str(msg) + "\n")
def sleep(s, sleepsecs, siglistener):
if s.verbose >= 0:
s._msg("Sleeping for %d:%02d" % (sleepsecs / 60, sleepsecs % 60))
return UIBase.sleep(s, sleepsecs, siglistener)
def sleeping(s, sleepsecs, remainingsecs):
if sleepsecs > 0:
time.sleep(sleepsecs)
return 0
def locked(s):
s.warn("Another OfflineIMAP is running with the same metadatadir; exiting.")
class Quiet(Basic):
def __init__(s, config, verbose = -1):
Basic.__init__(s, config, verbose)

99
offlineimap/ui/TTY.py
View File

@ -1,6 +1,5 @@
# TTY UI # TTY UI
# Copyright (C) 2002 John Goerzen # Copyright (C) 2002-2011 John Goerzen & contributors
# <jgoerzen@complete.org>
# #
# This program is free software; you can redistribute it and/or modify # 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 # it under the terms of the GNU General Public License as published by
@ -15,53 +14,73 @@
# You should have received a copy of the GNU General Public License # You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software # along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
from UIBase import UIBase
from getpass import getpass import logging
import sys import sys
from threading import Lock, currentThread from getpass import getpass
from offlineimap import banner
from offlineimap.ui.UIBase import UIBase
class TTYFormatter(logging.Formatter):
"""Specific Formatter that adds thread information to the log output"""
def __init__(self, *args, **kwargs):
super(TTYFormatter, self).__init__(*args, **kwargs)
self._last_log_thread = None
def format(self, record):
"""Override format to add thread information"""
log_str = super(TTYFormatter, self).format(record)
# If msg comes from a different thread than our last, prepend
# thread info. Most look like 'Account sync foo' or 'Folder
# sync foo'.
t_name = record.threadName
if t_name == 'MainThread':
return log_str # main thread doesn't get things prepended
if t_name != self._last_log_thread:
self._last_log_thread = t_name
log_str = "%s:\n %s" % (t_name, log_str)
else:
log_str = " %s" % log_str
return log_str
class TTYUI(UIBase): class TTYUI(UIBase):
def __init__(s, config, verbose = 0): def setup_consolehandler(self):
UIBase.__init__(s, config, verbose) """Backend specific console handler
s.iswaiting = 0
s.outputlock = Lock()
s._lastThreaddisplay = None
def isusable(s): Sets up things and adds them to self.logger.
:returns: The logging.Handler() for console output"""
# create console handler with a higher log level
ch = logging.StreamHandler()
#ch.setLevel(logging.DEBUG)
# create formatter and add it to the handlers
self.formatter = TTYFormatter("%(message)s")
ch.setFormatter(self.formatter)
# add the handlers to the logger
self.logger.addHandler(ch)
self.logger.info(banner)
# init lock for console output
ch.createLock()
return ch
def isusable(self):
"""TTYUI is reported as usable when invoked on a terminal"""
return sys.stdout.isatty() and sys.stdin.isatty() return sys.stdout.isatty() and sys.stdin.isatty()
def _display(s, msg): def getpass(self, accountname, config, errmsg = None):
s.outputlock.acquire() """TTYUI backend is capable of querying the password"""
try:
#if the next output comes from a different thread than our last one
#add the info.
#Most look like 'account sync foo' or 'Folder sync foo'.
threadname = currentThread().getName()
if (threadname == s._lastThreaddisplay \
or threadname == 'MainThread'):
print " %s" % msg
else:
print "%s:\n %s" % (threadname, msg)
s._lastThreaddisplay = threadname
sys.stdout.flush()
finally:
s.outputlock.release()
def getpass(s, accountname, config, errmsg = None):
if errmsg: if errmsg:
s._msg("%s: %s" % (accountname, errmsg)) self.warn("%s: %s" % (accountname, errmsg))
s.outputlock.acquire() self._log_con_handler.acquire() # lock the console output
try: try:
return getpass("%s: Enter password: " % accountname) return getpass("Enter password for account '%s': " % accountname)
finally: finally:
s.outputlock.release() self._log_con_handler.release()
def mainException(s): def mainException(self):
if isinstance(sys.exc_info()[1], KeyboardInterrupt) and \ if isinstance(sys.exc_info()[1], KeyboardInterrupt):
s.iswaiting: self.logger.warn("Timer interrupted at user request; program "
sys.stdout.write("Timer interrupted at user request; program terminating. \n") "terminating.\n")
s.terminate() self.terminate()
else: else:
UIBase.mainException(s) UIBase.mainException(self)

356
offlineimap/ui/UIBase.py
View File

@ -15,12 +15,15 @@
# along with this program; if not, write to the Free Software # along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
import logging
import re import re
import time import time
import sys import sys
import os
import traceback import traceback
import threading import threading
from Queue import Queue from Queue import Queue
from collections import deque
import offlineimap import offlineimap
debugtypes = {'':'Other offlineimap related sync messages', debugtypes = {'':'Other offlineimap related sync messages',
@ -38,54 +41,72 @@ def getglobalui():
global globalui global globalui
return globalui return globalui
class UIBase: class UIBase(object):
def __init__(s, config, verbose = 0): def __init__(self, config, loglevel = logging.INFO):
s.verbose = verbose self.config = config
s.config = config self.debuglist = []
s.debuglist = [] """list of debugtypes we are supposed to log"""
s.debugmessages = {} self.debugmessages = {}
s.debugmsglen = 50 """debugmessages in a deque(v) per thread(k)"""
s.threadaccounts = {} self.debugmsglen = 50
self.threadaccounts = {}
"""dict linking active threads (k) to account names (v)""" """dict linking active threads (k) to account names (v)"""
s.acct_startimes = {} self.acct_startimes = {}
"""linking active accounts with the time.time() when sync started""" """linking active accounts with the time.time() when sync started"""
s.logfile = None self.logfile = None
s.exc_queue = Queue() self.exc_queue = Queue()
"""saves all occuring exceptions, so we can output them at the end""" """saves all occuring exceptions, so we can output them at the end"""
# create logger with 'OfflineImap' app
self.logger = logging.getLogger('OfflineImap')
self.logger.setLevel(loglevel)
self._log_con_handler = self.setup_consolehandler()
"""The console handler (we need access to be able to lock it)"""
################################################## UTILS ################################################## UTILS
def _msg(s, msg): def setup_consolehandler(self):
"""Generic tool called when no other works.""" """Backend specific console handler
s._log(msg)
s._display(msg)
def _log(s, msg): Sets up things and adds them to self.logger.
"""Log it to disk. Returns true if it wrote something; false :returns: The logging.Handler() for console output"""
otherwise.""" # create console handler with a higher log level
if s.logfile: ch = logging.StreamHandler()
s.logfile.write("%s: %s\n" % (threading.currentThread().getName(), #ch.setLevel(logging.DEBUG)
msg)) # create formatter and add it to the handlers
return 1 self.formatter = logging.Formatter("%(message)s")
return 0 ch.setFormatter(self.formatter)
# add the handlers to the logger
self.logger.addHandler(ch)
self.logger.info(offlineimap.banner)
return ch
def setlogfd(s, logfd): def setlogfile(self, logfile):
s.logfile = logfd """Create file handler which logs to file"""
logfd.write("This is %s %s\n" % \ fh = logging.FileHandler(logfile, 'wt')
(offlineimap.__productname__, #fh.setLevel(logging.DEBUG)
offlineimap.__version__)) file_formatter = logging.Formatter("%(asctime)s %(levelname)s: "
logfd.write("Python: %s\n" % sys.version) "%(message)s", '%Y-%m-%d %H:%M:%S')
logfd.write("Platform: %s\n" % sys.platform) fh.setFormatter(file_formatter)
logfd.write("Args: %s\n" % sys.argv) self.logger.addHandler(fh)
# write out more verbose initial info blurb on the log file
p_ver = ".".join([str(x) for x in sys.version_info[0:3]])
msg = "OfflineImap %s starting...\n Python: %s Platform: %s\n "\
"Args: %s" % (offlineimap.__version__, p_ver, sys.platform,
" ".join(sys.argv))
record = logging.LogRecord('OfflineImap', logging.INFO, __file__,
None, msg, None, None)
fh.emit(record)
def _display(s, msg): def _msg(self, msg):
"""Display a message.""" """Display a message."""
raise NotImplementedError # TODO: legacy function, rip out.
self.info(msg)
def warn(s, msg, minor = 0): def info(self, msg):
if minor: """Display a message."""
s._msg("warning: " + msg) self.logger.info(msg)
else:
s._msg("WARNING: " + msg) def warn(self, msg, minor = 0):
self.logger.warning(msg)
def error(self, exc, exc_traceback=None, msg=None): def error(self, exc, exc_traceback=None, msg=None):
"""Log a message at severity level ERROR """Log a message at severity level ERROR
@ -146,40 +167,43 @@ class UIBase:
return self.threadaccounts[thr] return self.threadaccounts[thr]
return '*Control' # unregistered thread is '*Control' return '*Control' # unregistered thread is '*Control'
def debug(s, debugtype, msg): def debug(self, debugtype, msg):
thisthread = threading.currentThread() cur_thread = threading.currentThread()
if s.debugmessages.has_key(thisthread): if not self.debugmessages.has_key(cur_thread):
s.debugmessages[thisthread].append("%s: %s" % (debugtype, msg)) # deque(..., self.debugmsglen) would be handy but was
else: # introduced in p2.6 only, so we'll need to work around and
s.debugmessages[thisthread] = ["%s: %s" % (debugtype, msg)] # shorten our debugmsg list manually :-(
self.debugmessages[cur_thread] = deque()
self.debugmessages[cur_thread].append("%s: %s" % (debugtype, msg))
while len(s.debugmessages[thisthread]) > s.debugmsglen: # Shorten queue if needed
s.debugmessages[thisthread] = s.debugmessages[thisthread][1:] if len(self.debugmessages[cur_thread]) > self.debugmsglen:
self.debugmessages[cur_thread].popleft()
if debugtype in s.debuglist: if debugtype in self.debuglist: # log if we are supposed to do so
if not s._log("DEBUG[%s]: %s" % (debugtype, msg)): self.logger.debug("[%s]: %s" % (debugtype, msg))
s._display("DEBUG[%s]: %s" % (debugtype, msg))
def add_debug(s, debugtype): def add_debug(self, debugtype):
global debugtypes global debugtypes
if debugtype in debugtypes: if debugtype in debugtypes:
if not debugtype in s.debuglist: if not debugtype in self.debuglist:
s.debuglist.append(debugtype) self.debuglist.append(debugtype)
s.debugging(debugtype) self.debugging(debugtype)
else: else:
s.invaliddebug(debugtype) self.invaliddebug(debugtype)
def debugging(s, debugtype): def debugging(self, debugtype):
global debugtypes global debugtypes
s._msg("Now debugging for %s: %s" % (debugtype, debugtypes[debugtype])) self.logger.debug("Now debugging for %s: %s" % (debugtype,
debugtypes[debugtype]))
def invaliddebug(s, debugtype): def invaliddebug(self, debugtype):
s.warn("Invalid debug type: %s" % debugtype) self.warn("Invalid debug type: %s" % debugtype)
def locked(s): def locked(s):
raise Exception, "Another OfflineIMAP is running with the same metadatadir; exiting." raise Exception, "Another OfflineIMAP is running with the same metadatadir; exiting."
def getnicename(s, object): def getnicename(self, object):
"""Return the type of a repository or Folder as string """Return the type of a repository or Folder as string
(IMAP, Gmail, Maildir, etc...)""" (IMAP, Gmail, Maildir, etc...)"""
@ -187,61 +211,73 @@ class UIBase:
# Strip off extra stuff. # Strip off extra stuff.
return re.sub('(Folder|Repository)', '', prelimname) return re.sub('(Folder|Repository)', '', prelimname)
def isusable(s): def isusable(self):
"""Returns true if this UI object is usable in the current """Returns true if this UI object is usable in the current
environment. For instance, an X GUI would return true if it's environment. For instance, an X GUI would return true if it's
being run in X with a valid DISPLAY setting, and false otherwise.""" being run in X with a valid DISPLAY setting, and false otherwise."""
return 1 return True
################################################## INPUT ################################################## INPUT
def getpass(s, accountname, config, errmsg = None): def getpass(self, accountname, config, errmsg = None):
raise NotImplementedError raise NotImplementedError("Prompting for a password is not supported"\
" in this UI backend.")
def folderlist(s, list): def folderlist(self, list):
return ', '.join(["%s[%s]" % (s.getnicename(x), x.getname()) for x in list]) return ', '.join(["%s[%s]" % \
(self.getnicename(x), x.getname()) for x in list])
################################################## WARNINGS ################################################## WARNINGS
def msgtoreadonly(s, destfolder, uid, content, flags): def msgtoreadonly(self, destfolder, uid, content, flags):
if not (s.config.has_option('general', 'ignore-readonly') and s.config.getboolean("general", "ignore-readonly")): if self.config.has_option('general', 'ignore-readonly') and \
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." % \ self.config.getboolean('general', 'ignore-readonly'):
(uid, s.getnicename(destfolder), destfolder.getname())) return
self.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." % (
uid, self.getnicename(destfolder), destfolder))
def flagstoreadonly(s, destfolder, uidlist, flags): def flagstoreadonly(self, destfolder, uidlist, flags):
if not (s.config.has_option('general', 'ignore-readonly') and s.config.getboolean("general", "ignore-readonly")): if self.config.has_option('general', 'ignore-readonly') and \
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." % \ self.config.getboolean('general', 'ignore-readonly'):
(str(uidlist), s.getnicename(destfolder), destfolder.getname())) return
self.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." % (
str(uidlist), self.getnicename(destfolder), destfolder))
def deletereadonly(s, destfolder, uidlist): def deletereadonly(self, destfolder, uidlist):
if not (s.config.has_option('general', 'ignore-readonly') and s.config.getboolean("general", "ignore-readonly")): if self.config.has_option('general', 'ignore-readonly') and \
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." % \ self.config.getboolean('general', 'ignore-readonly'):
(str(uidlist), s.getnicename(destfolder), destfolder.getname())) return
self.warn("Attempted to delete messages %s in folder %s[%s], but that "
"folder is read-only. No messages have been deleted in that "
"folder." % (str(uidlist), self.getnicename(destfolder),
destfolder))
################################################## MESSAGES ################################################## MESSAGES
def init_banner(s): def init_banner(self):
"""Called when the UI starts. Must be called before any other UI """Called when the UI starts. Must be called before any other UI
call except isusable(). Displays the copyright banner. This is call except isusable(). Displays the copyright banner. This is
where the UI should do its setup -- TK, for instance, would where the UI should do its setup -- TK, for instance, would
create the application window here.""" create the application window here."""
if s.verbose >= 0: pass
s._msg(offlineimap.banner)
def connecting(s, hostname, port): def connecting(self, hostname, port):
"""Log 'Establishing connection to'""" """Log 'Establishing connection to'"""
if s.verbose < 0: return if not self.logger.isEnabledFor(logging.info): return
displaystr = '' displaystr = ''
hostname = hostname if hostname else '' hostname = hostname if hostname else ''
port = "%s" % port if port else '' port = "%s" % port if port else ''
if hostname: if hostname:
displaystr = ' to %s:%s' % (hostname, port) displaystr = ' to %s:%s' % (hostname, port)
s._msg("Establishing connection%s" % displaystr) self.logger.info("Establishing connection%s" % displaystr)
def acct(self, account): def acct(self, account):
"""Output that we start syncing an account (and start counting)""" """Output that we start syncing an account (and start counting)"""
self.acct_startimes[account] = time.time() self.acct_startimes[account] = time.time()
if self.verbose >= 0: self.logger.info("*** Processing account %s" % account)
self._msg("*** Processing account %s" % account)
def acctdone(self, account): def acctdone(self, account):
"""Output that we finished syncing an account (in which time)""" """Output that we finished syncing an account (in which time)"""
@ -252,75 +288,63 @@ class UIBase:
def syncfolders(self, src_repo, dst_repo): def syncfolders(self, src_repo, dst_repo):
"""Log 'Copying folder structure...'""" """Log 'Copying folder structure...'"""
if self.verbose < 0: return if self.logger.isEnabledFor(logging.DEBUG):
self.debug('', "Copying folder structure from %s to %s" % \ self.debug('', "Copying folder structure from %s to %s" %\
(src_repo, dst_repo)) (src_repo, dst_repo))
############################## Folder syncing ############################## Folder syncing
def syncingfolder(s, srcrepos, srcfolder, destrepos, destfolder): def syncingfolder(self, srcrepos, srcfolder, destrepos, destfolder):
"""Called when a folder sync operation is started.""" """Called when a folder sync operation is started."""
if s.verbose >= 0: self.logger.info("Syncing %s: %s -> %s" % (srcfolder,
s._msg("Syncing %s: %s -> %s" % (srcfolder.getname(), self.getnicename(srcrepos),
s.getnicename(srcrepos), self.getnicename(destrepos)))
s.getnicename(destrepos)))
def skippingfolder(s, folder): def skippingfolder(self, folder):
"""Called when a folder sync operation is started.""" """Called when a folder sync operation is started."""
if s.verbose >= 0: self.logger.info("Skipping %s (not changed)" % folder)
s._msg("Skipping %s (not changed)" % folder.getname())
def validityproblem(s, folder): def validityproblem(self, folder):
s.warn("UID validity problem for folder %s (repo %s) (saved %d; got %d); skipping it" % \ self.logger.warning("UID validity problem for folder %s (repo %s) "
(folder.getname(), folder.getrepository().getname(), "(saved %d; got %d); skipping it. Please see FAQ "
"and manual how to handle this." % \
(folder, folder.getrepository(),
folder.getsaveduidvalidity(), folder.getuidvalidity())) folder.getsaveduidvalidity(), folder.getuidvalidity()))
def loadmessagelist(s, repos, folder): def loadmessagelist(self, repos, folder):
if s.verbose > 0: self.logger.debug("Loading message list for %s[%s]" % (
s._msg("Loading message list for %s[%s]" % (s.getnicename(repos), self.getnicename(repos),
folder.getname())) folder))
def messagelistloaded(s, repos, folder, count): def messagelistloaded(self, repos, folder, count):
if s.verbose > 0: self.logger.debug("Message list for %s[%s] loaded: %d messages" % (
s._msg("Message list for %s[%s] loaded: %d messages" % \ self.getnicename(repos), folder, count))
(s.getnicename(repos), folder.getname(), count))
############################## Message syncing ############################## Message syncing
def syncingmessages(s, sr, sf, dr, df): def syncingmessages(self, sr, srcfolder, dr, dstfolder):
if s.verbose > 0: self.logger.debug("Syncing messages %s[%s] -> %s[%s]" % (
s._msg("Syncing messages %s[%s] -> %s[%s]" % (s.getnicename(sr), self.getnicename(sr), srcfolder,
sf.getname(), self.getnicename(dr), dstfolder))
s.getnicename(dr),
df.getname()))
def copyingmessage(self, uid, num, num_to_copy, src, destfolder): def copyingmessage(self, uid, num, num_to_copy, src, destfolder):
"""Output a log line stating which message we copy""" """Output a log line stating which message we copy"""
if self.verbose < 0: return self.logger.info("Copy message %s (%d of %d) %s:%s -> %s" % (
self._msg("Copy message %s (%d of %d) %s:%s -> %s" % (uid, num, uid, num, num_to_copy, src.repository, src,
num_to_copy, src.repository, src, destfolder.repository)) destfolder.repository))
def deletingmessage(s, uid, destlist): def deletingmessages(self, uidlist, destlist):
if s.verbose >= 0: ds = self.folderlist(destlist)
ds = s.folderlist(destlist) self.logger.info("Deleting %d messages (%s) in %s" % (
s._msg("Deleting message %d in %s" % (uid, ds)) len(uidlist),
offlineimap.imaputil.uid_sequence(uidlist), ds))
def deletingmessages(s, uidlist, destlist): def addingflags(self, uidlist, flags, dest):
if s.verbose >= 0: self.logger.info("Adding flag %s to %d messages on %s" % (
ds = s.folderlist(destlist) ", ".join(flags), len(uidlist), dest))
s._msg("Deleting %d messages (%s) in %s" % \
(len(uidlist),
offlineimap.imaputil.uid_sequence(uidlist),
ds))
def addingflags(s, uidlist, flags, dest): def deletingflags(self, uidlist, flags, dest):
if s.verbose >= 0: self.logger.info("Deleting flag %s from %d messages on %s" % (
s._msg("Adding flag %s to %d messages on %s" % \ ", ".join(flags), len(uidlist), dest))
(", ".join(flags), len(uidlist), dest))
def deletingflags(s, uidlist, flags, dest):
if s.verbose >= 0:
s._msg("Deleting flag %s from %d messages on %s" % \
(", ".join(flags), len(uidlist), dest))
def serverdiagnostics(self, repository, type): def serverdiagnostics(self, repository, type):
"""Connect to repository and output useful information for debugging""" """Connect to repository and output useful information for debugging"""
@ -371,69 +395,68 @@ class UIBase:
################################################## Threads ################################################## Threads
def getThreadDebugLog(s, thread): def getThreadDebugLog(self, thread):
if s.debugmessages.has_key(thread): if self.debugmessages.has_key(thread):
message = "\nLast %d debug messages logged for %s prior to exception:\n"\ message = "\nLast %d debug messages logged for %s prior to exception:\n"\
% (len(s.debugmessages[thread]), thread.getName()) % (len(self.debugmessages[thread]), thread.getName())
message += "\n".join(s.debugmessages[thread]) message += "\n".join(self.debugmessages[thread])
else: else:
message = "\nNo debug messages were logged for %s." % \ message = "\nNo debug messages were logged for %s." % \
thread.getName() thread.getName()
return message return message
def delThreadDebugLog(s, thread): def delThreadDebugLog(self, thread):
if s.debugmessages.has_key(thread): if thread in self.debugmessages:
del s.debugmessages[thread] del self.debugmessages[thread]
def getThreadExceptionString(s, thread): def getThreadExceptionString(self, thread):
message = "Thread '%s' terminated with exception:\n%s" % \ message = "Thread '%s' terminated with exception:\n%s" % \
(thread.getName(), thread.getExitStackTrace()) (thread.getName(), thread.getExitStackTrace())
message += "\n" + s.getThreadDebugLog(thread) message += "\n" + self.getThreadDebugLog(thread)
return message return message
def threadException(s, thread): def threadException(self, thread):
"""Called when a thread has terminated with an exception. """Called when a thread has terminated with an exception.
The argument is the ExitNotifyThread that has so terminated.""" The argument is the ExitNotifyThread that has so terminated."""
s._msg(s.getThreadExceptionString(thread)) self.warn(self.getThreadExceptionString(thread))
s.delThreadDebugLog(thread) self.delThreadDebugLog(thread)
s.terminate(100) self.terminate(100)
def terminate(self, exitstatus = 0, errortitle = None, errormsg = None): def terminate(self, exitstatus = 0, errortitle = None, errormsg = None):
"""Called to terminate the application.""" """Called to terminate the application."""
#print any exceptions that have occurred over the run #print any exceptions that have occurred over the run
if not self.exc_queue.empty(): if not self.exc_queue.empty():
self._msg("\nERROR: Exceptions occurred during the run!") self.warn("ERROR: Exceptions occurred during the run!")
while not self.exc_queue.empty(): while not self.exc_queue.empty():
msg, exc, exc_traceback = self.exc_queue.get() msg, exc, exc_traceback = self.exc_queue.get()
if msg: if msg:
self._msg("ERROR: %s\n %s" % (msg, exc)) self.warn("ERROR: %s\n %s" % (msg, exc))
else: else:
self._msg("ERROR: %s" % (exc)) self.warn("ERROR: %s" % (exc))
if exc_traceback: if exc_traceback:
self._msg("\nTraceback:\n%s" %"".join( self.warn("\nTraceback:\n%s" %"".join(
traceback.format_tb(exc_traceback))) traceback.format_tb(exc_traceback)))
if errormsg and errortitle: if errormsg and errortitle:
sys.stderr.write('ERROR: %s\n\n%s\n'%(errortitle, errormsg)) self.warn('ERROR: %s\n\n%s\n'%(errortitle, errormsg))
elif errormsg: elif errormsg:
sys.stderr.write('%s\n' % errormsg) self.warn('%s\n' % errormsg)
sys.exit(exitstatus) sys.exit(exitstatus)
def threadExited(s, thread): def threadExited(self, thread):
"""Called when a thread has exited normally. Many UIs will """Called when a thread has exited normally. Many UIs will
just ignore this.""" just ignore this."""
s.delThreadDebugLog(thread) self.delThreadDebugLog(thread)
s.unregisterthread(thread) self.unregisterthread(thread)
################################################## Hooks ################################################## Hooks
def callhook(s, msg): def callhook(self, msg):
if s.verbose >= 0: self.info(msg)
s._msg(msg)
################################################## Other ################################################## Other
def sleep(s, sleepsecs, account): def sleep(self, sleepsecs, account):
"""This function does not actually output anything, but handles """This function does not actually output anything, but handles
the overall sleep, dealing with updates as necessary. It will, the overall sleep, dealing with updates as necessary. It will,
however, call sleeping() which DOES output something. however, call sleeping() which DOES output something.
@ -446,12 +469,12 @@ class UIBase:
if account.get_abort_event(): if account.get_abort_event():
abortsleep = True abortsleep = True
else: else:
abortsleep = s.sleeping(10, sleepsecs) abortsleep = self.sleeping(10, sleepsecs)
sleepsecs -= 10 sleepsecs -= 10
s.sleeping(0, 0) # Done sleeping. self.sleeping(0, 0) # Done sleeping.
return abortsleep return abortsleep
def sleeping(s, sleepsecs, remainingsecs): def sleeping(self, sleepsecs, remainingsecs):
"""Sleep for sleepsecs, display remainingsecs to go. """Sleep for sleepsecs, display remainingsecs to go.
Does nothing if sleepsecs <= 0. Does nothing if sleepsecs <= 0.
@ -463,6 +486,7 @@ class UIBase:
""" """
if sleepsecs > 0: if sleepsecs > 0:
if remainingsecs//60 != (remainingsecs-sleepsecs)//60: if remainingsecs//60 != (remainingsecs-sleepsecs)//60:
s._msg("Next refresh in %.1f minutes" % (remainingsecs/60.0)) self.logger.info("Next refresh in %.1f minutes" % (
remainingsecs/60.0))
time.sleep(sleepsecs) time.sleep(sleepsecs)
return 0 return 0

2
offlineimap/ui/__init__.py
View File

@ -1,5 +1,5 @@
# UI module # UI module
# Copyright (C) 2010 Sebastian Spaeth <Sebastian@SSpaeth.de> # Copyright (C) 2010-2011 Sebastian Spaeth & contributors
# #
# This program is free software; you can redistribute it and/or modify # 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 # it under the terms of the GNU General Public License as published by