[PATCH 4/4] learn unicode support
Nicolas Sebrecht
nicolas.s-dev at laposte.net
Wed Feb 11 15:09:28 UTC 2015
This feature is NOT WORKING. This is EXPERIMENTAL WIP.
Also, such change is very intrusive/invasive by nature. While the full ASCII
mode is still the default, it is impossible to not impact legacy code when run
without unicode support.
Signed-off-by: Nicolas Sebrecht <nicolas.s-dev at laposte.net>
---
offlineimap.conf | 8 +-
offlineimap/CustomConfig.py | 61 ++++---
offlineimap/__init__.py | 2 +-
offlineimap/accounts.py | 173 +++++++++++--------
offlineimap/folder/Base.py | 198 +++++++++++++---------
offlineimap/folder/Gmail.py | 95 +++++++----
offlineimap/folder/GmailMaildir.py | 85 ++++++----
offlineimap/folder/IMAP.py | 190 ++++++++++++---------
offlineimap/folder/LocalStatus.py | 70 +++++---
offlineimap/folder/LocalStatusSQLite.py | 141 +++++++++-------
offlineimap/folder/Maildir.py | 174 +++++++++++--------
offlineimap/folder/UIDMaps.py | 56 ++++---
offlineimap/imaplibutil.py | 32 ++--
offlineimap/imapserver.py | 277 ++++++++++++++++++-------------
offlineimap/imaputil.py | 20 ++-
offlineimap/init.py | 272 +++++++++++++++++++-----------
offlineimap/localeval.py | 21 ++-
offlineimap/mbnames.py | 96 ++++++++---
offlineimap/repository/Base.py | 121 +++++++++-----
offlineimap/repository/Gmail.py | 24 ++-
offlineimap/repository/IMAP.py | 285 ++++++++++++++++++--------------
offlineimap/repository/LocalStatus.py | 61 ++++---
offlineimap/repository/Maildir.py | 175 +++++++++++++-------
offlineimap/repository/__init__.py | 35 ++--
offlineimap/syncmaster.py | 24 ++-
offlineimap/threadutil.py | 25 ++-
offlineimap/ui/Curses.py | 24 ++-
offlineimap/ui/Machine.py | 95 ++++++-----
offlineimap/ui/TTY.py | 47 ++++--
offlineimap/ui/UIBase.py | 251 ++++++++++++++++------------
offlineimap/ui/debuglock.py | 26 ++-
offlineimap/utils/const.py | 9 +-
offlineimap/utils/distro.py | 16 +-
33 files changed, 1968 insertions(+), 1221 deletions(-)
diff --git a/offlineimap.conf b/offlineimap.conf
index cfafb23..0ad3bcc 100644
--- a/offlineimap.conf
+++ b/offlineimap.conf
@@ -5,8 +5,14 @@
# More details can be found in the included user documention, which is
# also available at: http://docs.offlineimap.org/en/latest/
+# NOTE 0: This file is read with UTF-8 encoding when option is enabled from
+# command line. This means iso-8859-1 and ASCII charsets are natively
+# supported. Otherwise, this file is expected to be full ASCII.
+#
+# If any other charset is used somewhere with success, it's just because you're
+# lucky.
-# NOTE 1: Settings generally support python interpolation. This means
+# NOTE1: Settings generally support python interpolation. This means
# values can contain python format strings which refer to other values
# in the same section, or values in a special DEFAULT section. This
# allows you for example to use common settings for multiple accounts:
diff --git a/offlineimap/CustomConfig.py b/offlineimap/CustomConfig.py
index 44cfcab..6b5d780 100644
--- a/offlineimap/CustomConfig.py
+++ b/offlineimap/CustomConfig.py
@@ -20,9 +20,25 @@ from sys import exc_info
try:
from ConfigParser import SafeConfigParser, Error
-except ImportError: #python3
+except ImportError: # python3
from configparser import SafeConfigParser, Error
+
from offlineimap.localeval import LocalEval
+from offlineimap.utils.uni import uniString, noneString
+
+
+#
+# UNICODE: it would be much better to not use the uni module at all,
+# here. This way, we could consider the classes as a low-level driver.
+#
+# Sadly, the config classes make more than just config-related tasks and
+# supports hooks.
+#
+# Hence, the Unicode strategy here is to use the uni module for the tasks not
+# related to configuration parsing. In order to keep the whole thing consistent,
+# strings are returned with low-level Python types, NOT uni objects.
+#
+
class CustomConfigParser(SafeConfigParser):
def __init__(self):
@@ -75,7 +91,7 @@ class CustomConfigParser(SafeConfigParser):
val = self.get(section, option).strip()
return re.split(separator_re, val)
except re.error as e:
- raise Error("Bad split regexp '%s': %s" % \
+ raise Error("Bad split regexp '%s': %s"%
(separator_re, e)), None, exc_info()[2]
def getdefaultlist(self, section, option, default, separator_re):
@@ -88,12 +104,14 @@ class CustomConfigParser(SafeConfigParser):
return default
def getmetadatadir(self):
+ """Returns metadatadir."""
+
xforms = [os.path.expanduser, os.path.expandvars]
- d = self.getdefault("general", "metadata", "~/.offlineimap")
- metadatadir = self.apply_xforms(d, xforms)
- if not os.path.exists(metadatadir):
- os.mkdir(metadatadir, 0o700)
- return metadatadir
+ d = uniString(self.getdefault("general", "metadata", "~/.offlineimap"))
+ metadatadir = uniString(self.apply_xforms(d.uni, xforms))
+ if not os.path.exists(metadatadir.fs):
+ os.mkdir(metadatadir.fs, 0o700)
+ return metadatadir.uni
def getlocaleval(self):
# We already loaded pythonfile, so return this copy.
@@ -102,10 +120,10 @@ class CustomConfigParser(SafeConfigParser):
xforms = [os.path.expanduser, os.path.expandvars]
if self.has_option("general", "pythonfile"):
- path = self.get("general", "pythonfile")
- path = self.apply_xforms(path, xforms)
+ path = uniString(self.apply_xforms(
+ uniString(self.get("general", "pythonfile")).uni, xforms))
else:
- path = None
+ path = noneString()
self.localeval = LocalEval(path)
return self.localeval
@@ -118,7 +136,7 @@ class CustomConfigParser(SafeConfigParser):
For instance, for "Account Test", returns "Test"."""
- key = key + ' '
+ key = key + u' '
return [x[len(key):] for x in self.sections() \
if x.startswith(key)]
@@ -132,22 +150,27 @@ class CustomConfigParser(SafeConfigParser):
self.set(section, option, value)
- def apply_xforms(self, string, transforms):
- """Applies set of transformations to a string.
+ # FIXME: it could be possible that this method is used from outside, either
+ # today or later. That's why it currently fully works with the uni
+ # objects. The best would be to put this function outside of this module.
+ #
+ # TODO: use the '_' prefix in the name or move it outside.
+ def apply_xforms(self, s, transforms):
+ """Applies set of transformations to a uni object.
Arguments:
- - string: source string; if None, then no processing will
+ - s: source uni String; if None, then no processing will
take place.
- transforms: iterable that returns transformation function
on each turn.
- Returns transformed string."""
+ Returns (unicode) transformed string."""
- if string == None:
+ if s == None:
return None
for f in transforms:
- string = f(string)
- return string
+ s = f(s)
+ return s
@@ -247,7 +270,7 @@ class ConfigHelperMixin:
"""
value = self.getconf(option, default)
- return self.getconfig().apply_xforms(value, xforms)
+ return (self.getconfig().apply_xforms(value, xforms))
def getconfboolean(self, option, default = CustomConfigDefault):
diff --git a/offlineimap/__init__.py b/offlineimap/__init__.py
index 441af44..1126781 100644
--- a/offlineimap/__init__.py
+++ b/offlineimap/__init__.py
@@ -9,7 +9,7 @@ __author__ = "John Goerzen"
__author_email__= "john at complete.org"
__description__ = "Disconnected Universal IMAP Mail Synchronization/Reader Support"
__license__ = "Licensed under the GNU GPL v2 or any later version (with an OpenSSL exception)"
-__bigcopyright__ = """%(__productname__)s %(__bigversion__)s
+__bigcopyright__ = u"""%(__productname__)s %(__bigversion__)s
%(__license__)s""" % locals()
__homepage__ = "http://offlineimap.org"
diff --git a/offlineimap/accounts.py b/offlineimap/accounts.py
index 62ed5c3..b620bcf 100644
--- a/offlineimap/accounts.py
+++ b/offlineimap/accounts.py
@@ -14,6 +14,10 @@
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+#
+# FIXME: we are acutally working with CustomConfig.blah all over the place.
+# Change the filename and class name!
+#
from subprocess import Popen, PIPE
from threading import Event
import os
@@ -25,32 +29,39 @@ from offlineimap import globals
from offlineimap.repository import Repository
from offlineimap.ui import getglobalui
from offlineimap.threadutil import InstanceLimitedThread
+from offlineimap.utils.uni import uniString, fsString, isASCII
+from offlineimap.utils import hack
try:
import fcntl
except:
pass # ok if this fails, we can do without
-# FIXME: spaghetti code alert!
+# FIXME: Bip, Bip! spaghetti code alert!
def getaccountlist(customconfig):
- # Account names in a list.
- return customconfig.getsectionlist('Account')
-
-# FIXME: spaghetti code alert!
+ # Account sections in a list.
+ sections = customconfig.getsectionlist('Account')
+ for section in sections:
+ # section type is unicode and has ASCII restrictions.
+ isASCII(section, exception_msg="section names must be plain ASCII")
+ return sections
+
+# FIXME: Bip, Bip! spaghetti code alert!
def AccountListGenerator(customconfig):
"""Returns a list of instanciated Account class, one per account name."""
- return [Account(customconfig, accountname)
- for accountname in getaccountlist(customconfig)]
+ return [Account(customconfig, uniString(uni_accountname))
+ for uni_accountname in getaccountlist(customconfig)]
-# FIXME: spaghetti code alert!
+# FIXME: Bip, Bip! spaghetti code alert!
+# FIMXE: what a poor function name!
def AccountHashGenerator(customconfig):
- """Returns a dict of instanciated Account class with the account name as
- key."""
+ """Returns a dict of instanciated Account class with the account (unicode)
+ name as key."""
retval = {}
- for item in AccountListGenerator(customconfig):
- retval[item.getname()] = item
+ for inst_account in AccountListGenerator(customconfig):
+ retval[inst_account.getname().uni] = inst_account
return retval
@@ -71,13 +82,13 @@ class Account(CustomConfig.ConfigHelperMixin):
:param config: Representing the offlineimap configuration file.
:type config: :class:`offlineimap.CustomConfig.CustomConfigParser`
- :param name: A (str) string denoting the name of the Account
- as configured.
+ :param name: A (unicode encoded) string denoting the name of the
+ Account as configured.
"""
self.config = config
self.name = name
- self.metadatadir = config.getmetadatadir()
+ self.metadatadir = uniString(config.getmetadatadir())
self.localeval = config.getlocaleval()
# current :mod:`offlineimap.ui`, can be used for logging:
self.ui = getglobalui()
@@ -99,14 +110,19 @@ class Account(CustomConfig.ConfigHelperMixin):
return self.name
def __str__(self):
- return self.name
+ # We should warn to never use this.
+ return self.name.std
def getaccountmeta(self):
- return os.path.join(self.metadatadir, 'Account-' + self.name)
+ return fsString(os.path.join(
+ self.metadatadir.fs, 'Account-' + self.name.fs))
- # Interface from CustomConfig.ConfigHelperMixin
+ # Interface from CustomConfig.ConfigHelperMixin Return unicode string as
+ # CustomConfig.blah are doing. This is more consistent to return the same
+ # type/encoding when working on the same kind of data.
+ # FIXME: why this? Why having a method if it's used once?
def getsection(self):
- return 'Account ' + self.getname()
+ return u'Account ' + self.name.uni
@classmethod
def set_abort_event(cls, config, signum):
@@ -125,8 +141,8 @@ class Account(CustomConfig.ConfigHelperMixin):
if signum == 1:
# resync signal, set config option for all accounts
- for acctsection in getaccountlist(config):
- config.set('Account ' + acctsection, "skipsleep", '1')
+ for uni_acctsection in getaccountlist(config):
+ config.set('Account ' + uni_acctsection, "skipsleep", '1')
elif signum == 2:
# don't autorefresh anymore
cls.abort_soon_signal.set()
@@ -208,13 +224,14 @@ class SyncableAccount(Account):
def __init__(self, *args, **kwargs):
Account.__init__(self, *args, **kwargs)
self._lockfd = None
- self._lockfilepath = os.path.join(
- self.config.getmetadatadir(), "%s.lock"% self)
+ self._lockfilepath = fsString(os.path.join(
+ uniString(self.config.getmetadatadir()).fs,
+ "%s.lock"% self.name.fs))
def __lock(self):
"""Lock the account, throwing an exception if it is locked already."""
- self._lockfd = open(self._lockfilepath, 'w')
+ self._lockfd = open(self._lockfilepath.fs, 'w')
try:
fcntl.lockf(self._lockfd, fcntl.LOCK_EX|fcntl.LOCK_NB)
except NameError:
@@ -223,7 +240,7 @@ class SyncableAccount(Account):
except IOError:
self._lockfd.close()
raise OfflineImapError("Could not lock account %s. Is another "
- "instance using this account?"% self,
+ "instance using this account?"% self.name.fs,
OfflineImapError.ERROR.REPO), None, exc_info()[2]
def _unlock(self):
@@ -233,7 +250,7 @@ class SyncableAccount(Account):
if self._lockfd and not self._lockfd.closed:
self._lockfd.close()
try:
- os.unlink(self._lockfilepath)
+ os.unlink(self._lockfilepath.fs)
except OSError:
pass # Failed to delete for some reason.
@@ -241,8 +258,8 @@ class SyncableAccount(Account):
self.ui.registerthread(self)
try:
accountmetadata = self.getaccountmeta()
- if not os.path.exists(accountmetadata):
- os.mkdir(accountmetadata, 0o700)
+ if not os.path.exists(accountmetadata.fs):
+ os.mkdir(accountmetadata.fs, 0o700)
self.remoterepos = Repository(self, 'remote')
self.localrepos = Repository(self, 'local')
@@ -272,7 +289,7 @@ class SyncableAccount(Account):
self.ui.error(e, exc_info()[2])
except Exception as e:
self.ui.error(e, exc_info()[2], msg=
- "While attempting to sync account '%s'"% self)
+ "While attempting to sync account '%s'"% self.getname().fs)
else:
# after success sync, reset the looping counter to 3
if self.refreshperiod:
@@ -286,9 +303,10 @@ class SyncableAccount(Account):
def get_local_folder(self, remotefolder):
"""Return the corresponding local folder for a given remotefolder."""
- return self.localrepos.getfolder(
- remotefolder.getvisiblename().
- replace(self.remoterepos.getsep(), self.localrepos.getsep()))
+ visiblename = remotefolder.getvisiblename()
+ visiblename.uni = visiblename.uni.replace(
+ self.remoterepos.getsep().uni, self.localrepos.getsep().uni)
+ return self.localrepos.getfolder(visiblename)
def __sync(self):
"""Synchronize the account once, then return.
@@ -299,7 +317,7 @@ class SyncableAccount(Account):
folderthreads = []
- hook = self.getconf('presynchook', '')
+ hook = uniString(self.getconf('presynchook', ''))
self.callhook(hook)
quickconfig = self.getconfint('quick', 0)
@@ -336,20 +354,36 @@ class SyncableAccount(Account):
if Account.abort_NOW_signal.is_set(): break
if not remotefolder.sync_this:
- self.ui.debug('', "Not syncing filtered folder '%s'"
- "[%s]"% (remotefolder, remoterepos))
+ self.ui.debug('', u"Not syncing filtered folder '%s'[%s]"%
+ (remotefolder.getname().uni, remoterepos.getname().uni))
continue # Ignore filtered folder
localfolder = self.get_local_folder(remotefolder)
if not localfolder.sync_this:
- self.ui.debug('', "Not syncing filtered folder '%s'"
- "[%s]"% (localfolder, localfolder.repository))
+ self.ui.debug('', u"Not syncing filtered folder '%s'[%s]"%
+ (localfolder.getname().uni,
+ localfolder.getrepository().getname().uni))
continue # Ignore filtered folder
if not globals.options.singlethreading:
- thread = InstanceLimitedThread(\
- instancename = 'FOLDER_' + self.remoterepos.getname(),
- target = syncfolder,
- name = "Folder %s [acc: %s]"% (remotefolder.getexplainedname(), self),
- args = (self, remotefolder, quick))
+ reponame = self.remoterepos.getname()
+ remotefoldername = remotefolder.getexplainedname()
+ # UNICODE: we have to encode Unicode because Thread module
+ # has str/ASII type assumptions.
+ #
+ # Also, it wouldn't much be a problem if these strings were
+ # not used later for logging. As a consequence, encoding
+ # these variable here is wrong in the sense that we encode
+ # far too much early and the logging might suffer from
+ # replaced non-ASCII characters.
+ #
+ # To make it right, parameters for logging and those
+ # dedicated to the Thread class should be uncoupled from each
+ # other.
+ thread = InstanceLimitedThread(
+ instancename='FOLDER_%s'% reponame, # OK for uni object.
+ target=syncfolder,
+ name="Folder %s [acc: %s]"% (remotefoldername.std,
+ self.getname().std),
+ args=(self, remotefolder, quick))
thread.start()
folderthreads.append(thread)
else:
@@ -363,35 +397,37 @@ class SyncableAccount(Account):
localrepos.forgetfolders()
remoterepos.forgetfolders()
except:
- #error while syncing. Drop all connections that we have, they
- #might be bogus by now (e.g. after suspend)
+ # Error while syncing. Drop all connections that we have, they
+ # might be bogus by now (e.g. after suspend).
localrepos.dropconnections()
remoterepos.dropconnections()
raise
else:
- # sync went fine. Hold or drop depending on config
+ # Sync went fine. Hold or drop depending on config.
localrepos.holdordropconnections()
remoterepos.holdordropconnections()
- hook = self.getconf('postsynchook', '')
+ hook = uniString(self.getconf('postsynchook', ''))
self.callhook(hook)
def callhook(self, cmd):
# check for CTRL-C or SIGTERM and run postsynchook
if Account.abort_NOW_signal.is_set():
return
- if not cmd:
+ # TODO: improve: "not" operation does not makes sense. Explicitly say
+ # what value it could be.
+ if not cmd.uni:
return
try:
- self.ui.callhook("Calling hook: " + cmd)
+ self.ui.callhook(u"Calling hook: "+ cmd.uni)
if self.dryrun: # don't if we are in dry-run mode
return
- p = Popen(cmd, shell=True,
+ p = Popen(cmd.fs, shell=True,
stdin=PIPE, stdout=PIPE, stderr=PIPE,
close_fds=True)
- r = p.communicate()
- self.ui.callhook("Hook stdout: %s\nHook stderr:%s\n"% r)
- self.ui.callhook("Hook return code: %d"% p.returncode)
+ r = fsString(p.communicate())
+ self.ui.callhook(u"Hook stdout: %s\nHook stderr:%s\n"% r.uni)
+ self.ui.callhook(u"Hook return code: %d"% p.returncode)
except (KeyboardInterrupt, SystemExit):
raise
except Exception as e:
@@ -400,7 +436,8 @@ class SyncableAccount(Account):
def syncfolder(account, remotefolder, quick):
"""Synchronizes given remote folder for the specified account.
- Filtered folders on the remote side will not invoke this function."""
+ Filtered folders on the remote side will not invoke this function.
+ This method is called by each account thread."""
remoterepos = account.remoterepos
localrepos = account.localrepos
@@ -413,12 +450,13 @@ def syncfolder(account, remotefolder, quick):
localfolder = account.get_local_folder(remotefolder)
# Write the mailboxes
- mbnames.add(account.name, localfolder.getname(),
+ mbnames.add(account.getname(), localfolder.getname(),
localrepos.getlocalroot())
# Load status folder.
- statusfolder = statusrepos.getfolder(remotefolder.getvisiblename().
- replace(remoterepos.getsep(), statusrepos.getsep()))
+ statusfolder = statusrepos.getfolder(uniString(
+ remotefolder.getvisiblename().uni.replace(
+ remoterepos.getsep().uni, statusrepos.getsep().uni)))
if localfolder.get_uidvalidity() == None:
# This is a new folder, so delete the status cache to be
@@ -464,24 +502,24 @@ def syncfolder(account, remotefolder, quick):
# Load remote folder.
ui.loadmessagelist(remoterepos, remotefolder)
remotefolder.cachemessagelist()
- ui.messagelistloaded(remoterepos, remotefolder,
- remotefolder.getmessagecount())
+ ui.messagelistloaded(
+ remoterepos, remotefolder, remotefolder.getmessagecount())
# Synchronize remote changes.
if not localrepos.getconfboolean('readonly', False):
ui.syncingmessages(remoterepos, remotefolder, localrepos, localfolder)
remotefolder.syncmessagesto(localfolder, statusfolder)
else:
- ui.debug('imap', "Not syncing to read-only repository '%s'" \
- % localrepos.getname())
+ ui.debug('imap', u"Not syncing to read-only repository '%s'"%
+ localrepos.getname().uni)
# Synchronize local changes
if not remoterepos.getconfboolean('readonly', False):
ui.syncingmessages(localrepos, localfolder, remoterepos, remotefolder)
localfolder.syncmessagesto(remotefolder, statusfolder)
else:
- ui.debug('', "Not syncing to read-only repository '%s'" \
- % remoterepos.getname())
+ ui.debug('', u"Not syncing to read-only repository '%s'"%
+ remoterepos.getname().uni)
statusfolder.save()
localrepos.restore_atime()
@@ -492,11 +530,14 @@ def syncfolder(account, remotefolder, quick):
if e.severity > OfflineImapError.ERROR.FOLDER:
raise
else:
- ui.error(e, exc_info()[2], msg = "Aborting sync, folder '%s' "
- "[acc: '%s']" % (localfolder, account))
+ msg = (u"Aborting sync, folder '%s' [acc: '%s']"%
+ (localfolder.getname().uni, account.getname().uni))
+ ui.error(e, exc_info()[2], msg)
except Exception as e:
- ui.error(e, msg = "ERROR in syncfolder for %s folder %s: %s"%
- (account, remotefolder.getvisiblename(), traceback.format_exc()))
+ ui.error(e, msg=u"ERROR in syncfolder for %s folder %s: %s"% (
+ account.getname().fs,
+ remotefolder.getvisiblename().fs,
+ traceback.format_exc()))
finally:
for folder in ["statusfolder", "localfolder", "remotefolder"]:
if folder in locals():
diff --git a/offlineimap/folder/Base.py b/offlineimap/folder/Base.py
index 3a04ef6..c513857 100644
--- a/offlineimap/folder/Base.py
+++ b/offlineimap/folder/Base.py
@@ -23,13 +23,15 @@ from offlineimap import threadutil, emailutil
from offlineimap import globals
from offlineimap.ui import getglobalui
from offlineimap.error import OfflineImapError
+from offlineimap.utils.uni import noneString, uniString, fsString
import offlineimap.accounts
class BaseFolder(object):
def __init__(self, name, repository):
"""
- :param name: Path & name of folder minus root or reference
+ :param name: Path & name (unicode) of folder minus
+ root or reference
:param repository: Repository() in which the folder is.
"""
@@ -37,47 +39,55 @@ class BaseFolder(object):
# Save original name for folderfilter operations
self.ffilter_name = name
# Top level dir name is always ''
- self.root = None
- self.name = name if not name == self.getsep() else ''
+ self.root = noneString()
+ # XXX: Explain why we accept getsep() as folder name. root folder?
+ self.name = name if not name == self.getsep() else uniString(u'')
self.repository = repository
self.visiblename = repository.nametrans(name)
# In case the visiblename becomes '.' or '/' (top-level) we use
# '' as that is the name that e.g. the Maildir scanning will
# return for the top-level dir.
if self.visiblename == self.getsep():
- self.visiblename = ''
+ self.visiblename = uniString(u'')
self.config = repository.getconfig()
utime_from_message_global = self.config.getdefaultboolean(
"general", "utime_from_message", False)
- repo = "Repository " + repository.name
- self._utime_from_message = self.config.getdefaultboolean(repo,
+ repo = uniString(u"Repository ") + repository.getname()
+ self._utime_from_message = self.config.getdefaultboolean(repo.uni,
"utime_from_message", utime_from_message_global)
# Determine if we're running static or dynamic folder filtering
# and check filtering status
self._dynamic_folderfilter = self.config.getdefaultboolean(
- repo, "dynamic_folderfilter", False)
+ repo.uni, "dynamic_folderfilter", False)
self._sync_this = repository.should_sync_folder(self.ffilter_name)
if self._dynamic_folderfilter:
- self.ui.debug('', "Running dynamic folder filtering on '%s'[%s]"%
- (self.ffilter_name, repository))
+ self.ui.debug('',
+ u"Running dynamic folder filtering on '%s'[%s]"%
+ (self.ffilter_name.uni, repository.getname().uni))
elif not self._sync_this:
- self.ui.debug('', "Filtering out '%s'[%s] due to folderfilter"%
- (self.ffilter_name, repository))
+ self.ui.debug('',
+ u"Filtering out '%s'[%s] due to folderfilter"%
+ (self.ffilter_name.uni, repository.getname().uni))
# Passes for syncmessagesto
- self.syncmessagesto_passes = [('copying messages' , self.__syncmessagesto_copy),
- ('deleting messages' , self.__syncmessagesto_delete),
- ('syncing flags' , self.__syncmessagesto_flags)]
+ self.syncmessagesto_passes = [
+ ('copying messages' , self.__syncmessagesto_copy),
+ ('deleting messages', self.__syncmessagesto_delete),
+ ('syncing flags' , self.__syncmessagesto_flags),
+ ]
def getname(self):
- """Returns name"""
+ """Returns name (unicode)."""
+
return self.name
def __str__(self):
- # FIMXE: remove calls of this. We have getname().
- return self.name
+ """Returns name (filesystem encoded)."""
+
+ # XXX: Warn we should not use this because encoding is made implicit.
+ return self.name.fs
@property
def accountname(self):
@@ -96,16 +106,19 @@ class BaseFolder(object):
@property
def utime_from_message(self):
+
return self._utime_from_message
def suggeststhreads(self):
"""Returns true if this folder suggests using threads for actions;
false otherwise. Probably only IMAP will return true."""
+
return 0
def waitforthread(self):
"""Implements method that waits for thread to be usable.
Should be implemented only for folders that suggest threads."""
+
raise NotImplementedError
# XXX: we may need someting like supports_quickstatus() to check
@@ -145,7 +158,9 @@ class BaseFolder(object):
if self.name == self.visiblename:
return self.name
else:
- return "%s [remote name %s]"% (self.visiblename, self.name)
+ name = uniString(u"%s [remote name %s]"%
+ (self.visiblename.uni, self.name.uni))
+ return name
def getrepository(self):
"""Returns the repository object that this folder is within."""
@@ -164,20 +179,22 @@ class BaseFolder(object):
def getfullname(self):
if self.getroot():
- return self.getroot() + self.getsep() + self.getname()
+ return uniString(
+ self.getroot() + self.getsep() + self.getname())
else:
return self.getname()
def getfolderbasename(self):
- """Return base file name of file to store Status/UID info in."""
+ """Return base file name (unicode) of file to store Status/UID info
+ in."""
- if not self.name:
- basename = '.'
+ if not self.name.uni:
+ basename = uniString(u'.')
else: # Avoid directory hierarchies and file names such as '/'.
- basename = self.name.replace('/', '.')
+ basename = uniString(self.name.replace('/', '.'))
# Replace with literal 'dot' if final path name is '.' as '.' is
# an invalid file name.
- basename = re.sub('(^|\/)\.$','\\1dot', basename)
+ basename = uniString(re.sub('(^|\/)\.$','\\1dot', basename.uni))
return basename
def check_uidvalidity(self):
@@ -199,8 +216,15 @@ class BaseFolder(object):
def _getuidfilename(self):
"""provides UIDVALIDITY cache filename for class internal purposes.
- return os.path.join(self.repository.getuiddir(),
- self.getfolderbasename())
+ It is str type encoded to filesystem."""
+
+ uiddir = self.repository.getuiddir()
+ folderbasename = self.getfolderbasename()
+ # Fix the filename to IMAP UTF-7 encoding. This prevent from playing
+ # with multiple cache files representative of the same remote folder.
+ uidfilename = fsString(os.path.join(uiddir.fs, folderbasename.imap))
+
+ return uidfilename
def get_saveduidvalidity(self):
"""Return the previously cached UIDVALIDITY value
@@ -211,12 +235,13 @@ class BaseFolder(object):
if hasattr(self, '_base_saved_uidvalidity'):
return self._base_saved_uidvalidity
uidfilename = self._getuidfilename()
- if not os.path.exists(uidfilename):
+ if not os.path.exists(uidfilename.fs):
self._base_saved_uidvalidity = None
else:
- file = open(uidfilename, "rt")
+ file = open(uidfilename.fs, "rt")
self._base_saved_uidvalidity = long(file.readline().strip())
file.close()
+
return self._base_saved_uidvalidity
def save_uidvalidity(self):
@@ -228,9 +253,9 @@ class BaseFolder(object):
newval = self.get_uidvalidity()
uidfilename = self._getuidfilename()
- with open(uidfilename + ".tmp", "wt") as file:
- file.write("%d\n"% newval)
- os.rename(uidfilename + ".tmp", uidfilename)
+ with open(uidfilename.fs + ".tmp", "wt") as fd:
+ fd.write("%d\n"% newval)
+ os.rename(uidfilename.fs + ".tmp", uidfilename.fs)
self._base_saved_uidvalidity = newval
def get_uidvalidity(self):
@@ -249,7 +274,8 @@ class BaseFolder(object):
raise NotImplementedError
def dropmessagelistcache(self):
- raise NotImplementedException
+
+ raise NotImplementedError
def getmessagelist(self):
"""Gets the current message list.
@@ -433,9 +459,14 @@ class BaseFolder(object):
for uid in uidlist:
self.deletemessagelabels(uid, labels)
+ # XXX: logic should move outside... emailutil?
def addmessageheader(self, content, linebreak, headername, headervalue):
"""Adds new header to the provided message.
+ UNICODE: This method is working on email headers. Unicode support in
+ headers is supported in a full ASCII fashion. Do not work with uni
+ objects here.
+
WARNING: This function is a bit tricky, and modifying it in the wrong way,
may easily lead to data-loss.
@@ -493,20 +524,25 @@ class BaseFolder(object):
next line\n
"""
- self.ui.debug('', 'addmessageheader: called to add %s: %s'%
+ self.ui.debug('', u'addmessageheader: called to add %s: %s'%
(headername, headervalue))
insertionpoint = content.find(linebreak * 2)
if insertionpoint == -1:
- self.ui.debug('', 'addmessageheader: headers were missing')
+ self.ui.debug('', u'addmessageheader: headers were missing')
else:
- self.ui.debug('', 'addmessageheader: headers end at position %d' % insertionpoint)
+ self.ui.debug('', u'addmessageheader: headers end at position %d'%
+ insertionpoint)
mark = '==>EOH<=='
contextstart = max(0, insertionpoint - 100)
contextend = min(len(content), insertionpoint + 100)
- self.ui.debug('', 'addmessageheader: header/body transition context (marked by %s): %s' %
- (mark, repr(content[contextstart:insertionpoint]) + \
- mark + repr(content[insertionpoint:contextend])))
+ self.ui.debug('', u'addmessageheader: header/body transition '
+ 'context (marked by %s): %s%s%s'% (
+ mark,
+ repr(content[contextstart:insertionpoint]),
+ mark,
+ repr(content[insertionpoint:contextend]))
+ )
# Hoping for case #4
prefix = linebreak
@@ -528,14 +564,14 @@ class BaseFolder(object):
if content[0:len(linebreak)] != linebreak:
suffix = suffix + linebreak
- self.ui.debug('', 'addmessageheader: insertionpoint = %d'% insertionpoint)
+ self.ui.debug('', u'addmessageheader: insertionpoint = %d'% insertionpoint)
headers = content[0:insertionpoint]
- self.ui.debug('', 'addmessageheader: headers = %s'% repr(headers))
+ self.ui.debug('', u'addmessageheader: headers = %s'% repr(headers))
new_header = prefix + ("%s: %s" % (headername, headervalue)) + suffix
- self.ui.debug('', 'addmessageheader: new_header = ' + repr(new_header))
+ self.ui.debug('', u'addmessageheader: new_header = %s'% repr(new_header))
return headers + new_header + content[insertionpoint:]
-
+ # XXX: logic should move outside... emailutil?
def __find_eoh(self, content):
""" Searches for the point where mail headers end.
Either double '\n', or end of string.
@@ -543,7 +579,8 @@ class BaseFolder(object):
Arguments:
- content: contents of the message to search in
Returns: position of the first non-header byte.
- """
+
+ UNICODE: do not work with uni objects here."""
eoh_cr = content.find('\n\n')
if eoh_cr == -1:
@@ -552,6 +589,7 @@ class BaseFolder(object):
return eoh_cr
+ # XXX: logic should move outside... emailutil?
def getmessageheader(self, content, name):
"""Searches for the first occurence of the given header and returns
its value. Header name is case-insensitive.
@@ -561,21 +599,22 @@ class BaseFolder(object):
- name: name of the header to be searched
Returns: header value or None if no such header was found
- """
- self.ui.debug('', 'getmessageheader: called to get %s'% name)
+ UNICODE: do not work with uni objects here."""
+
+ self.ui.debug('', u'getmessageheader: called to get %s'% name)
eoh = self.__find_eoh(content)
- self.ui.debug('', 'getmessageheader: eoh = %d'% eoh)
+ self.ui.debug('', u'getmessageheader: eoh = %d'% eoh)
headers = content[0:eoh]
- self.ui.debug('', 'getmessageheader: headers = %s'% repr(headers))
+ self.ui.debug('', u'getmessageheader: headers = %s'% repr(headers))
- m = re.search('^%s:(.*)$' % name, headers, flags = re.MULTILINE | re.IGNORECASE)
+ m = re.search(u'^%s:(.*)$'% name, headers, flags = re.MULTILINE | re.IGNORECASE)
if m:
return m.group(1).strip()
else:
return None
-
+ # XXX: logic should move outside... emailutil?
def getmessageheaderlist(self, content, name):
"""Searches for the given header and returns a list of values for
that header.
@@ -585,17 +624,18 @@ class BaseFolder(object):
- name: name of the header to be searched
Returns: list of header values or emptylist if no such header was found
- """
- self.ui.debug('', 'getmessageheaderlist: called to get %s' % name)
+ UNICODE: do not work with uni objects here."""
+
+ self.ui.debug('', u'getmessageheaderlist: called to get %s'% name)
eoh = self.__find_eoh(content)
- self.ui.debug('', 'getmessageheaderlist: eoh = %d' % eoh)
+ self.ui.debug('', u'getmessageheaderlist: eoh = %d'% eoh)
headers = content[0:eoh]
- self.ui.debug('', 'getmessageheaderlist: headers = %s' % repr(headers))
-
- return re.findall('^%s:(.*)$' % name, headers, flags = re.MULTILINE | re.IGNORECASE)
+ self.ui.debug('', u'getmessageheaderlist: headers = %s'% repr(headers))
+ return re.findall(u'^%s:(.*)$'% name, headers, flags = re.MULTILINE | re.IGNORECASE)
+ # XXX: logic should move outside... emailutil?
def deletemessageheaders(self, content, header_list):
"""Deletes headers in the given list from the message content.
@@ -608,15 +648,16 @@ class BaseFolder(object):
if type(header_list) != type([]):
header_list = [header_list]
- self.ui.debug('', 'deletemessageheaders: called to delete %s'% (header_list))
+ self.ui.debug('', u'deletemessageheaders: called to delete %s'%
+ (header_list))
if not len(header_list): return content
eoh = self.__find_eoh(content)
- self.ui.debug('', 'deletemessageheaders: end of headers = %d'% eoh)
+ self.ui.debug('', u'deletemessageheaders: end of headers = %d'% eoh)
headers = content[0:eoh]
rest = content[eoh:]
- self.ui.debug('', 'deletemessageheaders: headers = %s'% repr(headers))
+ self.ui.debug('', u'deletemessageheaders: headers = %s'% repr(headers))
new_headers = []
for h in headers.split('\n'):
keep_it = True
@@ -628,9 +669,6 @@ class BaseFolder(object):
return ('\n'.join(new_headers) + rest)
-
-
-
def change_message_uid(self, uid, new_uid):
"""Change the message from existing uid to new_uid
@@ -657,7 +695,7 @@ class BaseFolder(object):
for uid in uidlist:
self.deletemessage(uid)
- def copymessageto(self, uid, dstfolder, statusfolder, register = 1):
+ def copymessageto(self, uid, dstfolder, statusfolder, register=1):
"""Copies a message from self to dst if needed, updating the status
Note that this function does not check against dryrun settings,
@@ -718,8 +756,9 @@ class BaseFolder(object):
self.deletemessage(uid)
else:
raise OfflineImapError("Trying to save msg (uid %d) on folder "
- "%s returned invalid uid %d"% (uid, dstfolder.getvisiblename(),
- new_uid), OfflineImapError.ERROR.MESSAGE)
+ "%s returned invalid uid %d"%
+ (uid, dstfolder.getvisiblename().fs, new_uid),
+ OfflineImapError.ERROR.MESSAGE)
except (KeyboardInterrupt): # bubble up CTRL-C
raise
except OfflineImapError as e:
@@ -727,8 +766,8 @@ class BaseFolder(object):
raise # bubble severe errors up
self.ui.error(e, exc_info()[2])
except Exception as e:
- self.ui.error(e, exc_info()[2],
- msg = "Copying message %s [acc: %s]"% (uid, self.accountname))
+ self.ui.error(e, exc_info()[2], msg=
+ u"Copying message %s [acc: %s]"% (uid, self.accountname.uni))
raise #raise on unknown errors, so we can fix those
def __syncmessagesto_copy(self, dstfolder, statusfolder):
@@ -750,8 +789,11 @@ class BaseFolder(object):
self.getmessageuidlist())
num_to_copy = len(copylist)
if num_to_copy and self.repository.account.dryrun:
- self.ui.info("[DRYRUN] Copy {0} messages from {1}[{2}] to {3}".format(
- num_to_copy, self, self.repository, dstfolder.repository))
+ self.ui.info(
+ u"[DRYRUN] Copy {0} messages from {1}[{2}] to {3}".format(
+ num_to_copy, self.getname().uni,
+ self.repository.getname().uni,
+ dstfolder.repository.getname().uni))
return
for num, uid in enumerate(copylist):
# bail out on CTRL-C or SIGTERM
@@ -761,16 +803,17 @@ class BaseFolder(object):
# exceptions are caught in copymessageto()
if self.suggeststhreads() and not globals.options.singlethreading:
self.waitforthread()
+ fs_name = "Copy message from %s:%s"% (
+ self.repository.getname().fs, self.getname().fs)
thread = threadutil.InstanceLimitedThread(\
self.getcopyinstancelimit(),
- target = self.copymessageto,
- name = "Copy message from %s:%s" % (self.repository, self),
- args = (uid, dstfolder, statusfolder))
+ target=self.copymessageto,
+ name=fs_name,
+ args=(uid, dstfolder, statusfolder))
thread.start()
threads.append(thread)
else:
- self.copymessageto(uid, dstfolder, statusfolder,
- register = 0)
+ self.copymessageto(uid, dstfolder, statusfolder, register=0)
for thread in threads:
thread.join()
@@ -840,14 +883,14 @@ class BaseFolder(object):
for flag, uids in addflaglist.items():
self.ui.addingflags(uids, flag, dstfolder)
if self.repository.account.dryrun:
- continue #don't actually add in a dryrun
+ continue # Don't actually add in a dryrun.
dstfolder.addmessagesflags(uids, set(flag))
statusfolder.addmessagesflags(uids, set(flag))
for flag,uids in delflaglist.items():
self.ui.deletingflags(uids, flag, dstfolder)
if self.repository.account.dryrun:
- continue #don't actually remove in a dryrun
+ continue # Don't actually remove in a dryrun.
dstfolder.deletemessagesflags(uids, set(flag))
statusfolder.deletemessagesflags(uids, set(flag))
@@ -899,8 +942,9 @@ class BaseFolder(object):
raise
self.ui.error(e, exc_info()[2])
except Exception as e:
- self.ui.error(e, exc_info()[2], "Syncing folder %s [acc: %s]" %\
- (self, self.accountname))
+ self.ui.error(e, exc_info()[2],
+ u"Syncing folder %s [acc: %s]"%
+ (self.name.fs, self.accountname.fs))
raise # raise unknown Exceptions so we can fix them
def __eq__(self, other):
diff --git a/offlineimap/folder/Gmail.py b/offlineimap/folder/Gmail.py
index 1afbe47..9d33cc4 100644
--- a/offlineimap/folder/Gmail.py
+++ b/offlineimap/folder/Gmail.py
@@ -21,11 +21,14 @@ from sys import exc_info
from offlineimap import imaputil, OfflineImapError
from offlineimap import imaplibutil
+from offlineimap.utils.uni import uniString, isASCII
+from offlineimap.utils import uni
import offlineimap.accounts
from .IMAP import IMAPFolder
"""Folder implementation to support features of the Gmail IMAP server."""
+
class GmailFolder(IMAPFolder):
"""Folder implementation to support features of the Gmail IMAP server.
@@ -45,23 +48,35 @@ class GmailFolder(IMAPFolder):
def __init__(self, imapserver, name, repository):
super(GmailFolder, self).__init__(imapserver, name, repository)
self.trash_folder = repository.gettrashfolder(name)
- # Gmail will really delete messages upon EXPUNGE in these folders
- self.real_delete_folders = [ self.trash_folder, repository.getspamfolder() ]
+ # Gmail will really delete messages upon EXPUNGE in these folders.
+ self.real_delete_folders = [
+ self.trash_folder, repository.getspamfolder() ]
- # The header under which labels are stored
- self.labelsheader = self.repository.account.getconf('labelsheader', 'X-Keywords')
+ # The header under which labels are stored.
+ self.labelsheader = uniString(
+ self.repository.account.getconf('labelsheader', 'X-Keywords'))
+ # labelsheader is expected plain ASCII.
+ isASCII(self.labelsheader.uni, exception_msg=
+ "labelsheader must be plain ASCII")
# enables / disables label sync
- self.synclabels = self.repository.account.getconfboolean('synclabels', False)
+ self.synclabels = \
+ self.repository.account.getconfboolean('synclabels', False)
- # if synclabels is enabled, add a 4th pass to sync labels
+ # If synclabels is enabled, add a 4th pass to sync labels.
if self.synclabels:
self.imap_query.insert(0, 'X-GM-LABELS')
- self.syncmessagesto_passes.append(('syncing labels', self.syncmessagesto_labels))
+ self.syncmessagesto_passes.append(
+ ('syncing labels', self.syncmessagesto_labels))
- # Labels to be left alone
- ignorelabels = self.repository.account.getconf('ignorelabels', '')
- self.ignorelabels = set([l for l in re.split(r'\s*,\s*', ignorelabels) if len(l)])
+ # Labels to be left alone.
+ ignorelabels = uniString(
+ self.repository.account.getconf('ignorelabels', ''))
+ # ignorelabels is expected plain ASCII.
+ isASCII(ignorelabels, exception_msg=
+ "ignorelabels must be plain ASCII")
+ self.ignorelabels = set(
+ [l for l in re.split(r'\s*,\s*', ignorelabels.dbytes) if len(l)])
def getmessage(self, uid):
@@ -71,13 +86,16 @@ class GmailFolder(IMAPFolder):
:returns: the message body or throws and OfflineImapError
(probably severity MESSAGE) if e.g. no message with
this UID could be found.
- """
+
+ UNICODE: this expects raw data. Don't introduce uni objects."""
+
imapobj = self.imapserver.acquireconnection()
try:
data = self._fetch_from_imap(imapobj, str(uid), 2)
finally:
self.imapserver.releaseconnection(imapobj)
+ # XXX: logic on labels should go to emailutil.
# data looks now e.g.
#[('320 (X-GM-LABELS (...) UID 17061 BODY[] {2565}','msgbody....')]
# we only asked for one message, and that msg is in data[0].
@@ -88,11 +106,13 @@ class GmailFolder(IMAPFolder):
if self.synclabels:
m = re.search('X-GM-LABELS\s*\(([^\)]*)\)', data[0][0])
if m:
- labels = set([imaputil.dequote(lb) for lb in imaputil.imapsplit(m.group(1))])
+ labels = set(
+ [imaputil.dequote(lb) for lb in imaputil.imapsplit(m.group(1))])
else:
labels = set()
labels = labels - self.ignorelabels
- labels_str = imaputil.format_labels_string(self.labelsheader, sorted(labels))
+ labels_str = imaputil.format_labels_string(
+ self.labelsheader, sorted(labels))
# First remove old label headers that may be in the message content retrieved
# from gmail Then add a labels header with current gmail labels.
@@ -104,7 +124,7 @@ class GmailFolder(IMAPFolder):
else:
dbg_output = body
- self.ui.debug('imap', "Returned object from fetching %d: '%s'"%
+ self.ui.debug('imap', u"Returned object from fetching %d: '%s'"%
(uid, dbg_output))
return body
@@ -141,40 +161,44 @@ class GmailFolder(IMAPFolder):
res_type, response = imapobj.fetch("'%s'"% msgsToFetch,
'(FLAGS X-GM-LABELS UID)')
if res_type != 'OK':
- raise OfflineImapError("FETCHING UIDs in folder [%s]%s failed. " % \
- (self.getrepository(), self) + \
- "Server responded '[%s] %s'" % \
+ raise OfflineImapError("FETCHING UIDs in folder [%s]%s failed. "%
+ (self.getrepository().getname().fs, self.name.fs) +
+ "Server responded '[%s] %s'"%
(res_type, response), OfflineImapError.ERROR.FOLDER), \
None, exc_info()[2]
finally:
self.imapserver.releaseconnection(imapobj)
for messagestr in response:
- # looks like: '1 (FLAGS (\\Seen Old) X-GM-LABELS (\\Inbox \\Favorites) UID 4807)' or None if no msg
+ # looks like:
+ # '1 (FLAGS (\\Seen Old) X-GM-LABELS (\\Inbox \\Favorites) UID 4807)'
+ # or
+ # None if no msg
# Discard initial message number.
if messagestr == None:
continue
messagestr = messagestr.split(' ', 1)[1]
options = imaputil.flags2hash(messagestr)
if not 'UID' in options:
- self.ui.warn('No UID in message with options %s' %\
- str(options),
- minor = 1)
+ self.ui.warn(u'No UID in message with options %s'%
+ str(options), minor=1)
else:
uid = long(options['UID'])
self.messagelist[uid] = self.msglist_item_initializer(uid)
flags = imaputil.flagsimap2maildir(options['FLAGS'])
m = re.search('\(([^\)]*)\)', options['X-GM-LABELS'])
if m:
- labels = set([imaputil.dequote(lb) for lb in imaputil.imapsplit(m.group(1))])
+ labels = set(
+ [imaputil.dequote(lb) for lb in imaputil.imapsplit(m.group(1))])
else:
labels = set()
labels = labels - self.ignorelabels
rtime = imaplibutil.Internaldate2epoch(messagestr)
- self.messagelist[uid] = {'uid': uid, 'flags': flags, 'labels': labels, 'time': rtime}
+ self.messagelist[uid] = \
+ {'uid': uid, 'flags': flags, 'labels': labels, 'time': rtime}
def savemessage(self, uid, content, flags, rtime):
- """Save the message on the Server
+ """Save the message on the Server.
This backend always assigns a new uid, so the uid arg is ignored.
@@ -203,13 +227,15 @@ class GmailFolder(IMAPFolder):
return ret
def _messagelabels_aux(self, arg, uidlist, labels):
- """Common code to savemessagelabels and addmessagelabels"""
+ """Common code to savemessagelabels and addmessagelabels."""
+
labels = labels - self.ignorelabels
uidlist = [uid for uid in uidlist if uid > 0]
if len(uidlist) > 0:
imapobj = self.imapserver.acquireconnection()
try:
- labels_str = '(' + ' '.join([imaputil.quote(lb) for lb in labels]) + ')'
+ labels_str = '(' + ' '.join(
+ [imaputil.quote(lb) for lb in labels]) + ')'
# Coalesce uid's into ranges
uid_str = imaputil.uid_sequence(uidlist)
result = self._store_to_imap(imapobj, uid_str, arg, labels_str)
@@ -222,8 +248,10 @@ class GmailFolder(IMAPFolder):
self.imapserver.releaseconnection(imapobj)
if result:
- retlabels = imaputil.flags2hash(imaputil.imapsplit(result)[1])['X-GM-LABELS']
- retlabels = set([imaputil.dequote(lb) for lb in imaputil.imapsplit(retlabels)])
+ retlabels = imaputil.flags2hash(
+ imaputil.imapsplit(result)[1])['X-GM-LABELS']
+ retlabels = set(
+ [imaputil.dequote(lb) for lb in imaputil.imapsplit(retlabels)])
return retlabels
return None
@@ -232,6 +260,7 @@ class GmailFolder(IMAPFolder):
Note that this function does not check against dryrun settings,
so you need to ensure that it is never called in a dryrun mode."""
+
if uid in self.messagelist and 'labels' in self.messagelist[uid]:
oldlabels = self.messagelist[uid]['labels']
else:
@@ -310,6 +339,7 @@ class GmailFolder(IMAPFolder):
This function checks and protects us from action in dryrun mode.
"""
+
# This applies the labels message by message, as this makes more sense for a
# Maildir target. If applied with an other Gmail IMAP target it would not be
# the fastest thing in the world though...
@@ -353,10 +383,12 @@ class GmailFolder(IMAPFolder):
statuslabels = set()
if selflabels != statuslabels:
- self.ui.settinglabels(uid, i+1, len(uidlist), sorted(selflabels), dstfolder)
+ self.ui.settinglabels(
+ uid, i+1, len(uidlist), sorted(selflabels), dstfolder)
if self.repository.account.dryrun:
continue #don't actually add in a dryrun
- dstfolder.savemessagelabels(uid, selflabels, ignorelabels = self.ignorelabels)
+ dstfolder.savemessagelabels(
+ uid, selflabels, ignorelabels=self.ignorelabels)
mtime = dstfolder.getmessagemtime(uid)
mtimes[uid] = mtime
labels[uid] = selflabels
@@ -367,4 +399,5 @@ class GmailFolder(IMAPFolder):
statusfolder.savemessagesmtimebulk(mtimes)
except NotImplementedError:
- self.ui.warn("Can't sync labels. You need to configure a local repository of type GmailMaildir")
+ self.ui.warn(u"Can't sync labels. You need to "
+ "configure a local repository of type GmailMaildir")
diff --git a/offlineimap/folder/GmailMaildir.py b/offlineimap/folder/GmailMaildir.py
index 5ca0e1f..e21152a 100644
--- a/offlineimap/folder/GmailMaildir.py
+++ b/offlineimap/folder/GmailMaildir.py
@@ -15,22 +15,28 @@
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
-
import os
from sys import exc_info
+
from .Maildir import MaildirFolder
from offlineimap import OfflineImapError
import offlineimap.accounts
from offlineimap import imaputil
+from offlineimap.utils.uni import fsString, uniString, isASCII
+
class GmailMaildirFolder(MaildirFolder):
- """Folder implementation to support adding labels to messages in a Maildir.
- """
+ """Folder implementation to support adding labels to messages in a Maildir."""
+
def __init__(self, root, name, sep, repository):
super(GmailMaildirFolder, self).__init__(root, name, sep, repository)
- # The header under which labels are stored
- self.labelsheader = self.repository.account.getconf('labelsheader', 'X-Keywords')
+ # The header under which labels are stored.
+ self.labelsheader = uniString(
+ self.repository.account.getconf('labelsheader', 'X-Keywords'))
+ # ...are expected plain ASCII.
+ isASCII(self.labelsheader, exception_msg=
+ "labelsheader must be plain ASCII")
# enables / disables label sync
self.synclabels = self.repository.account.getconfboolean('synclabels', 0)
@@ -40,22 +46,25 @@ class GmailMaildirFolder(MaildirFolder):
self.syncmessagesto_passes.append(('syncing labels', self.syncmessagesto_labels))
def quickchanged(self, statusfolder):
- """Returns True if the Maildir has changed. Checks uids, flags and mtimes"""
+ """Returns True if the Maildir has changed. Checks uids, flags and mtimes."""
self.cachemessagelist()
# Folder has different uids than statusfolder => TRUE
if sorted(self.getmessageuidlist()) != \
sorted(statusfolder.getmessageuidlist()):
return True
+
# check for flag changes, it's quick on a Maildir
for (uid, message) in self.getmessagelist().iteritems():
if message['flags'] != statusfolder.getmessageflags(uid):
return True
+
# check for newer mtimes. it is also fast
for (uid, message) in self.getmessagelist().iteritems():
if message['mtime'] > statusfolder.getmessagemtime(uid):
return True
- return False #Nope, nothing changed
+
+ return False # Nope, nothing changed.
# Interface from BaseFolder
@@ -68,25 +77,27 @@ class GmailMaildirFolder(MaildirFolder):
if self.messagelist is None:
self.messagelist = self._scanfolder()
- # Get mtimes
+ # Get mtimes.
if self.synclabels:
for uid, msg in self.messagelist.items():
- filepath = os.path.join(self.getfullname(), msg['filename'])
- msg['mtime'] = long(os.stat(filepath).st_mtime)
+ fs_filepath = os.path.join(
+ self.getfullname().fs, msg['filename'].fs)
+ msg['mtime'] = long(os.stat(fs_filepath).st_mtime)
def getmessagelabels(self, uid):
# Labels are not cached in cachemessagelist because it is too slow.
if not self.messagelist[uid]['labels_cached']:
filename = self.messagelist[uid]['filename']
- filepath = os.path.join(self.getfullname(), filename)
+ filepath = fsString(
+ os.path.join(self.getfullname().fs, filename.fs))
- if not os.path.exists(filepath):
+ if not os.path.exists(filepath.fs):
return set()
- file = open(filepath, 'rt')
- content = file.read()
- file.close()
+ f = open(filepath.fs, 'rt')
+ content = f.read()
+ f.close()
self.messagelist[uid]['labels'] = set()
for hstr in self.getmessageheaderlist(content, self.labelsheader):
@@ -121,9 +132,10 @@ class GmailMaildirFolder(MaildirFolder):
# Update the mtime and labels
filename = self.messagelist[uid]['filename']
- filepath = os.path.join(self.getfullname(), filename)
- self.messagelist[uid]['mtime'] = long(os.stat(filepath).st_mtime)
+ fs_filepath = os.path.join(self.getfullname().fs, filename.fs)
+ self.messagelist[uid]['mtime'] = long(os.stat(fs_filepath).st_mtime)
self.messagelist[uid]['labels'] = labels
+
return ret
def savemessagelabels(self, uid, labels, ignorelabels=set()):
@@ -133,11 +145,11 @@ class GmailMaildirFolder(MaildirFolder):
so you need to ensure that it is never called in a dryrun mode."""
filename = self.messagelist[uid]['filename']
- filepath = os.path.join(self.getfullname(), filename)
+ filepath = fsString(os.path.join(self.getfullname().fs, filename.fs))
- file = open(filepath, 'rt')
- content = file.read()
- file.close()
+ f = open(filepath.fs, 'rt')
+ content = f.read()
+ f.close()
oldlabels = set()
for hstr in self.getmessageheaderlist(content, self.labelsheader):
@@ -164,21 +176,22 @@ class GmailMaildirFolder(MaildirFolder):
# write file with new labels to a unique file in tmp
messagename = self.new_message_filename(uid, set())
tmpname = self.save_to_tmp_file(messagename, content)
- tmppath = os.path.join(self.getfullname(), tmpname)
+ tmppath = fsString(os.path.join(self.getfullname().fs, tmpname.fs))
# move to actual location
try:
- os.rename(tmppath, filepath)
+ os.rename(tmppath.fs, filepath.fs)
except OSError as e:
- raise OfflineImapError("Can't rename file '%s' to '%s': %s" % \
- (tmppath, filepath, e[1]), OfflineImapError.ERROR.FOLDER), \
+ raise OfflineImapError("Can't rename file '%s' to '%s': %s"%
+ (tmppath.fs, filepath.fs, e[1]),
+ OfflineImapError.ERROR.FOLDER), \
None, exc_info()[2]
if rtime != None:
- os.utime(filepath, (rtime, rtime))
+ os.utime(filepath.fs, (rtime, rtime))
# save the new mtime and labels
- self.messagelist[uid]['mtime'] = long(os.stat(filepath).st_mtime)
+ self.messagelist[uid]['mtime'] = long(os.stat(filepath.fs).st_mtime)
self.messagelist[uid]['labels'] = labels
def copymessageto(self, uid, dstfolder, statusfolder, register = 1):
@@ -198,7 +211,8 @@ class GmailMaildirFolder(MaildirFolder):
realcopy = uid > 0 and not dstfolder.uidexists(uid)
# first copy the message
- super(GmailMaildirFolder, self).copymessageto(uid, dstfolder, statusfolder, register)
+ super(GmailMaildirFolder, self).copymessageto(
+ uid, dstfolder, statusfolder, register)
# sync labels and mtime now when the message is new (the embedded labels are up to date,
# and have already propagated to the remote server.
@@ -207,7 +221,8 @@ class GmailMaildirFolder(MaildirFolder):
if realcopy and self.synclabels:
try:
labels = dstfolder.getmessagelabels(uid)
- statusfolder.savemessagelabels(uid, labels, mtime=self.getmessagemtime(uid))
+ statusfolder.savemessagelabels(
+ uid, labels, mtime=self.getmessagemtime(uid))
# dstfolder is not GmailMaildir.
except NotImplementedError:
@@ -226,6 +241,7 @@ class GmailMaildirFolder(MaildirFolder):
This function checks and protects us from action in ryrun mode.
"""
+
# For each label, we store a list of uids to which it should be
# added. Then, we can call addmessageslabels() to apply them in
# bulk, rather than one call per message.
@@ -256,7 +272,7 @@ class GmailMaildirFolder(MaildirFolder):
uidlist.append(uid)
- self.ui.collectingdata(uidlist, self)
+ self.ui.collectingdata(uidlist, self.getname())
# This can be slow if there is a lot of modified files
for uid in uidlist:
# bail out on CTRL-C or SIGTERM
@@ -290,7 +306,7 @@ class GmailMaildirFolder(MaildirFolder):
self.ui.addinglabels(uids, lb, dstfolder)
if self.repository.account.dryrun:
- continue #don't actually add in a dryrun
+ continue # don't actually add in a dryrun
dstfolder.addmessageslabels(uids, set([lb]))
statusfolder.addmessageslabels(uids, set([lb]))
@@ -317,11 +333,12 @@ class GmailMaildirFolder(MaildirFolder):
continue #don't actually update statusfolder
filename = self.messagelist[uid]['filename']
- filepath = os.path.join(self.getfullname(), filename)
- mtimes[uid] = long(os.stat(filepath).st_mtime)
+ fs_filepath = os.path.join(self.getfullname().fs, filename.fs)
+ mtimes[uid] = long(os.stat(fs_filepath).st_mtime)
# finally update statusfolder in a single DB transaction
statusfolder.savemessagesmtimebulk(mtimes)
except NotImplementedError:
- self.ui.warn("Can't sync labels. You need to configure a remote repository of type Gmail.")
+ self.ui.warn(u"Can't sync labels. You need to configure a remote "
+ "repository of type Gmail.")
diff --git a/offlineimap/folder/IMAP.py b/offlineimap/folder/IMAP.py
index c7e6516..1f93e11 100644
--- a/offlineimap/folder/IMAP.py
+++ b/offlineimap/folder/IMAP.py
@@ -22,8 +22,8 @@ import time
from sys import exc_info
from .Base import BaseFolder
-from offlineimap import imaputil, imaplibutil, emailutil, OfflineImapError
-from offlineimap import globals
+from offlineimap import imaputil, imaplibutil, emailutil, OfflineImapError, globals
+from offlineimap.utils.uni import noneString, uniString, imapString
from offlineimap.imaplib2 import MonthNames
@@ -42,19 +42,22 @@ class IMAPFolder(BaseFolder):
def __init__(self, imapserver, name, repository):
# FIXME: decide if unquoted name is from the responsability of the
# caller or not, but not both.
- name = imaputil.dequote(name)
- self.sep = imapserver.delim
+ # TODO: dequoting has definetly to be done as soon as possible: who
+ # wants to work with quoted strings?
+ name = imapString(imaputil.dequote(name.imap))
+ self.sep = imapserver.getdelim()
super(IMAPFolder, self).__init__(name, repository)
self.expunge = repository.getexpunge()
- self.root = None # imapserver.root
+ self.root = noneString() # imapserver.root
self.imapserver = imapserver
self.messagelist = None
self.randomgenerator = random.Random()
- #self.ui is set in BaseFolder
+ # UNICODE: this is IMAP query string in a list, don't use uni objects.
self.imap_query = ['BODY.PEEK[]']
+ # self.ui is set in BaseFolder
- fh_conf = self.repository.account.getconf('filterheaders', '')
- self.filterheaders = [h for h in re.split(r'\s*,\s*', fh_conf) if h]
+ uni_fh_conf = self.repository.account.getconf('filterheaders', '')
+ self.filterheaders = [h for h in re.split(r'\s*,\s*', uni_fh_conf) if h]
def __selectro(self, imapobj, force=False):
@@ -66,10 +69,12 @@ class IMAPFolder(BaseFolder):
.. todo: Still valid? Needs verification
:param: Enforce new SELECT even if we are on that folder already.
:returns: raises :exc:`OfflineImapError` severity FOLDER on error"""
+
try:
- imapobj.select(self.getfullname(), force = force)
+ fullname = self.getfullname()
+ imapobj.select(fullname.imap, force=force)
except imapobj.readonly:
- imapobj.select(self.getfullname(), readonly = True, force = force)
+ imapobj.select(fullname.imap, readonly=True, force=force)
# Interface from BaseFolder
def suggeststhreads(self):
@@ -81,7 +86,9 @@ class IMAPFolder(BaseFolder):
# Interface from BaseFolder
def getcopyinstancelimit(self):
- return 'MSGCOPY_' + self.repository.getname()
+ # XXX: has to be documented.
+ # I think to remember about that in init.py. Should check.
+ return uniString(u'MSGCOPY_' + self.repository.getname().uni)
# Interface from BaseFolder
def get_uidvalidity(self):
@@ -116,8 +123,8 @@ class IMAPFolder(BaseFolder):
imapobj = self.imapserver.acquireconnection()
try:
# Select folder and get number of messages
- restype, imapdata = imapobj.select(self.getfullname(), True,
- True)
+ restype, imapdata = imapobj.select(
+ self.getfullname().imap, True, True)
self.imapserver.releaseconnection(imapobj)
except OfflineImapError as e:
# retry on dropped connections, raise otherwise
@@ -156,25 +163,26 @@ class IMAPFolder(BaseFolder):
Returns: range(s) for messages or None if no messages
are to be fetched."""
- res_type, imapdata = imapobj.select(self.getfullname(), True, True)
+ res_type, imapdata = imapobj.select(
+ self.getfullname().imap, True, True)
if imapdata == [None] or imapdata[0] == '0':
# Empty folder, no need to populate message list
return None
- # By default examine all messages in this folder
+ # By default examine all messages in this folder.
msgsToFetch = '1:*'
maxage = self.config.getdefaultint(
- "Account %s"% self.accountname, "maxage", -1)
+ uniString(u"Account %s").uni % self.accountname.uni, "maxage", -1)
maxsize = self.config.getdefaultint(
- "Account %s"% self.accountname, "maxsize", -1)
+ uniString(u"Account %s").uni % self.accountname.uni, "maxsize", -1)
- # Build search condition
+ # Build search condition.
if (maxage != -1) | (maxsize != -1):
search_cond = "(";
if(maxage != -1):
- #find out what the oldest message is that we should look at
+ # Find out what the oldest message is that we should look at.
oldest_struct = time.gmtime(time.time() - (60*60*24*maxage))
if oldest_struct[0] < 1900:
raise OfflineImapError("maxage setting led to year %d. "
@@ -196,7 +204,8 @@ class IMAPFolder(BaseFolder):
if res_type != 'OK':
raise OfflineImapError("SEARCH in folder [%s]%s failed. "
"Search string was '%s'. Server responded '[%s] %s'"% (
- self.getrepository(), self, search_cond, res_type, res_data),
+ self.getrepository().fs, self.getname().fs,
+ search_cond, res_type, res_data),
OfflineImapError.ERROR.FOLDER)
# Resulting MSN are separated by space, coalesce into ranges
@@ -223,9 +232,11 @@ class IMAPFolder(BaseFolder):
# imaplib2 from quoting the sequence.
res_type, response = imapobj.fetch("'%s'"%
msgsToFetch, '(FLAGS UID)')
+ response = imapString(response)
if res_type != 'OK':
raise OfflineImapError("FETCHING UIDs in folder [%s]%s failed. "
- "Server responded '[%s] %s'"% (self.getrepository(), self,
+ "Server responded '[%s] %s'"% (
+ self.getrepository().getname().fs, self.name.fs,
res_type, response), OfflineImapError.ERROR.FOLDER)
finally:
self.imapserver.releaseconnection(imapobj)
@@ -238,9 +249,8 @@ class IMAPFolder(BaseFolder):
messagestr = messagestr.split(' ', 1)[1]
options = imaputil.flags2hash(messagestr)
if not 'UID' in options:
- self.ui.warn('No UID in message with options %s'% \
- str(options),
- minor = 1)
+ self.ui.warn(u'No UID in message with options %s'%
+ str(options), minor=1)
else:
uid = long(options['UID'])
self.messagelist[uid] = self.msglist_item_initializer(uid)
@@ -282,8 +292,8 @@ class IMAPFolder(BaseFolder):
else:
dbg_output = data
- self.ui.debug('imap', "Returned object from fetching %d: '%s'"%
- (uid, dbg_output))
+ self.ui.debug('imap', u"Returned object from fetching %d: '%s'"%
+ (uid, dbg_output))
return data
@@ -324,7 +334,8 @@ class IMAPFolder(BaseFolder):
def __savemessage_searchforheader(self, imapobj, headername, headervalue):
- self.ui.debug('imap', '__savemessage_searchforheader called for %s: %s'% \
+ self.ui.debug('imap',
+ u'__savemessage_searchforheader called for %s: %s'%
(headername, headervalue))
# Now find the UID it got.
headervalue = imapobj._quote(headervalue)
@@ -333,21 +344,27 @@ class IMAPFolder(BaseFolder):
headername, headervalue)[1][0]
except imapobj.error as err:
# IMAP server doesn't implement search or had a problem.
- self.ui.debug('imap', "__savemessage_searchforheader: got IMAP error '%s' while attempting to UID SEARCH for message with header %s"% (err, headername))
+ self.ui.debug('imap', u"__savemessage_searchforheader: "
+ "got IMAP error '%s' while attempting to UID SEARCH "
+ "for message with header %s"% (err, headername))
return 0
- self.ui.debug('imap', '__savemessage_searchforheader got initial matchinguids: ' + repr(matchinguids))
+ self.ui.debug('imap', u'__savemessage_searchforheader got '
+ 'initial matchinguids: %s'% repr(matchinguids))
if matchinguids == '':
- self.ui.debug('imap', "__savemessage_searchforheader: UID SEARCH for message with header %s yielded no results"% headername)
+ self.ui.debug('imap', u"__savemessage_searchforheader: "
+ "UID SEARCH for message with header %s yielded no results"%
+ headername)
return 0
matchinguids = matchinguids.split(' ')
- self.ui.debug('imap', '__savemessage_searchforheader: matchinguids now ' + \
- repr(matchinguids))
+ self.ui.debug('imap', u'__savemessage_searchforheader: '
+ 'matchinguids now %s'% repr(matchinguids))
if len(matchinguids) != 1 or matchinguids[0] == None:
raise ValueError("While attempting to find UID for message with "
- "header %s, got wrong-sized matchinguids of %s"%\
- (headername, str(matchinguids)))
+ "header %s, got wrong-sized matchinguids of %s"%
+ (headername, str(matchinguids)))
+
return long(matchinguids[0])
def __savemessage_fetchheaders(self, imapobj, headername, headervalue):
@@ -373,8 +390,8 @@ class IMAPFolder(BaseFolder):
Returns UID when found, 0 when not found."""
- self.ui.debug('imap', '__savemessage_fetchheaders called for %s: %s'% \
- (headername, headervalue))
+ self.ui.debug('imap', u'__savemessage_fetchheaders called for %s: %s'%
+ (headername, headervalue))
# run "fetch X:* rfc822.header"
# since we stored the mail we are looking for just recently, it would
@@ -395,17 +412,18 @@ class IMAPFolder(BaseFolder):
result = imapobj.uid('FETCH', bytearray('%d:*'% start), 'rfc822.header')
if result[0] != 'OK':
- raise OfflineImapError('Error fetching mail headers: %s'%
- '. '.join(result[1]), OfflineImapError.ERROR.MESSAGE)
+ joint_result = imapString('. '.join(result[1]))
+ raise OfflineImapError("Error fetching mail headers: %s"%
+ joint_result.fs, OfflineImapError.ERROR.MESSAGE)
+ # UNICODE: this block works on raw IMAP data.
result = result[1]
-
found = 0
for item in result:
if found == 0 and type(item) == type( () ):
# Walk just tuples
- if re.search("(?:^|\\r|\\n)%s:\s*%s(?:\\r|\\n)"% (headername, headervalue),
- item[1], flags=re.IGNORECASE):
+ if re.search("(?:^|\\r|\\n)%s:\s*%s(?:\\r|\\n)"%
+ (headername, headervalue), item[1], flags=re.IGNORECASE):
found = 1
elif found == 1:
if type(item) == type (""):
@@ -413,14 +431,18 @@ class IMAPFolder(BaseFolder):
if uid:
return int(uid.group(1))
else:
- self.ui.warn("Can't parse FETCH response, can't find UID: %s", result.__repr__())
+ self.ui.warn(
+ u"Can't parse FETCH response, can't find UID: %s",
+ result.__repr__())
else:
- self.ui.warn("Can't parse FETCH response, we awaited string: %s", result.__repr__())
+ self.ui.warn(
+ u"Can't parse FETCH response, we awaited string: %s",
+ result.__repr__())
return 0
def __getmessageinternaldate(self, content, rtime=None):
- """Parses mail and returns an INTERNALDATE string
+ """Parses mail and returns an INTERNALDATE string.
It will use information in the following order, falling back as an
attempt fails:
@@ -471,7 +493,7 @@ class IMAPFolder(BaseFolder):
# or something. Argh. It seems that Time2Internaldate
# will rause a ValueError if the year is 0102 but not 1902,
# but some IMAP servers nonetheless choke on 1902.
- self.ui.debug('imap', "Message with invalid date %s. "
+ self.ui.debug('imap', u"Message with invalid date %s. "
"Server will use local time."% datetuple)
return None
@@ -550,20 +572,22 @@ class IMAPFolder(BaseFolder):
# insert a random unique header that we can fetch later
(headername, headervalue) = self.__generate_randomheader(
content)
- self.ui.debug('imap', 'savemessage: header is: %s: %s'%
+ self.ui.debug('imap', u'savemessage: header is: %s: %s'%
(headername, headervalue))
- content = self.addmessageheader(content, CRLF, headername, headervalue)
+ content = self.addmessageheader(
+ content, CRLF, headername, headervalue)
if len(content)>200:
dbg_output = "%s...%s"% (content[:150], content[-50:])
else:
dbg_output = content
- self.ui.debug('imap', "savemessage: date: %s, content: '%s'"%
+ self.ui.debug('imap', u"savemessage: date: %s, content: '%s'"%
(date, dbg_output))
+ fullname = self.getfullname()
try:
# Select folder for append and make the box READ-WRITE
- imapobj.select(self.getfullname())
+ imapobj.select(fullname.imap)
except imapobj.readonly:
# readonly exception. Return original uid to notify that
# we did not save the message. (see savemessage in Base.py)
@@ -572,7 +596,7 @@ class IMAPFolder(BaseFolder):
#Do the APPEND
try:
- (typ, dat) = imapobj.append(self.getfullname(),
+ (typ, dat) = imapobj.append(fullname.imap,
imaputil.flagsmaildir2imap(flags), date, content)
# This should only catch 'NO' responses since append()
# will raise an exception for 'BAD' responses:
@@ -584,9 +608,11 @@ class IMAPFolder(BaseFolder):
# In this case, we should immediately abort the repository sync
# and continue with the next account.
msg = \
- "Saving msg (%s) in folder '%s', repository '%s' failed (abort). " \
+ "Saving msg (%s) in folder '%s', " \
+ "repository '%s' failed (abort). " \
"Server responded: %s %s\n"% \
- (msg_id, self, self.getrepository(), typ, dat)
+ (msg_id, self.name.fs,
+ self.getrepository().getname().fs, typ, dat)
raise OfflineImapError(msg, OfflineImapError.ERROR.REPO)
retry_left = 0 # Mark as success
except imapobj.abort as e:
@@ -596,11 +622,13 @@ class IMAPFolder(BaseFolder):
imapobj = self.imapserver.acquireconnection()
if not retry_left:
raise OfflineImapError("Saving msg (%s) in folder '%s', "
- "repository '%s' failed (abort). Server responded: %s\n"
- "Message content was: %s"%
- (msg_id, self, self.getrepository(), str(e), dbg_output),
- OfflineImapError.ERROR.MESSAGE), \
- None, exc_info()[2]
+ "repository '%s' failed (abort). Server responded: %s\n"
+ "Message content was: %s"% (msg_id,
+ self.name.fs,
+ self.getrepository().getname().fs,
+ str(e), dbg_output),
+ OfflineImapError.ERROR.MESSAGE), \
+ None, exc_info()[2]
# XXX: is this still needed?
self.ui.error(e, exc_info()[2])
except imapobj.error as e: # APPEND failed
@@ -611,12 +639,13 @@ class IMAPFolder(BaseFolder):
imapobj = None
raise OfflineImapError("Saving msg (%s) folder '%s', repo '%s'"
"failed (error). Server responded: %s\nMessage content was: "
- "%s" % (msg_id, self, self.getrepository(), str(e), dbg_output),
- OfflineImapError.ERROR.MESSAGE), None, exc_info()[2]
+ "%s"% (msg_id, self.name.fs,
+ self.getrepository().getname().fs, str(e), dbg_output),
+ OfflineImapError.ERROR.MESSAGE), None, exc_info()[2]
# Checkpoint. Let it write out stuff, etc. Eg searches for
# just uploaded messages won't work if we don't do this.
- (typ,dat) = imapobj.check()
- assert(typ == 'OK')
+ (typ, dat) = imapobj.check()
+ assert (typ == 'OK')
# get the new UID, do we use UIDPLUS?
if use_uidplus:
@@ -628,12 +657,12 @@ class IMAPFolder(BaseFolder):
# data. TODO
resp = imapobj._get_untagged_response('APPENDUID')
if resp == [None] or resp is None:
- self.ui.warn("Server supports UIDPLUS but got no APPENDUID "
+ self.ui.warn(u"Server supports UIDPLUS but got no APPENDUID "
"appending a message.")
return 0
uid = long(resp[-1].split(' ')[1])
if uid == 0:
- self.ui.warn("savemessage: Server supports UIDPLUS, but"
+ self.ui.warn(u"savemessage: Server supports UIDPLUS, but"
" we got no usable uid back. APPENDUID reponse was "
"'%s'"% str(resp))
else:
@@ -643,11 +672,11 @@ class IMAPFolder(BaseFolder):
# See docs for savemessage in Base.py for explanation
# of this and other return values
if uid == 0:
- self.ui.debug('imap', 'savemessage: attempt to get new UID '
+ self.ui.debug('imap', u'savemessage: attempt to get new UID '
'UID failed. Search headers manually.')
- uid = self.__savemessage_fetchheaders(imapobj, headername,
- headervalue)
- self.ui.warn('imap', "savemessage: Searching mails for new "
+ uid = self.__savemessage_fetchheaders(
+ imapobj, headername, headervalue)
+ self.ui.warn('imap', u"savemessage: Searching mails for new "
"Message-ID failed. Could not determine new UID.")
finally:
if imapobj: self.imapserver.releaseconnection(imapobj)
@@ -656,7 +685,7 @@ class IMAPFolder(BaseFolder):
self.messagelist[uid] = self.msglist_item_initializer(uid)
self.messagelist[uid]['flags'] = flags
- self.ui.debug('imap', 'savemessage: returning new UID %d'% uid)
+ self.ui.debug('imap', u'savemessage: returning new UID %d'% uid)
return uid
@@ -674,7 +703,7 @@ class IMAPFolder(BaseFolder):
fails_left = retry_num # retry on dropped connection
while fails_left:
try:
- imapobj.select(self.getfullname(), readonly = True)
+ imapobj.select(self.getfullname().imap, readonly=True)
res_type, data = imapobj.uid('fetch', uids, query)
fails_left = 0
except imapobj.abort as e:
@@ -690,19 +719,20 @@ class IMAPFolder(BaseFolder):
#IMAP server says bad request or UID does not exist
severity = OfflineImapError.ERROR.MESSAGE
reason = "IMAP server '%s' failed to fetch messages UID '%s'."\
- "Server responded: %s %s"% (self.getrepository(), uids,
- res_type, data)
+ "Server responded: %s %s"% (
+ self.getrepository().getname().fs, uids, res_type, data)
if data == [None]:
#IMAP server did not find a message with this UID
reason = "IMAP server '%s' does not have a message "\
- "with UID '%s'" % (self.getrepository(), uids)
+ "with UID '%s'"% (
+ self.getrepository().getname().fs, uids)
raise OfflineImapError(reason, severity)
return data
def _store_to_imap(self, imapobj, uid, field, data):
- """Stores data to IMAP server
+ """Stores data to IMAP server.
Arguments:
- imapobj: instance of IMAPlib to use
@@ -710,14 +740,16 @@ class IMAPFolder(BaseFolder):
- field: field name to be stored/updated
- data: field contents
"""
- imapobj.select(self.getfullname())
+
+ imapobj.select(self.getfullname().imap)
res_type, retdata = imapobj.uid('store', uid, field, data)
if res_type != 'OK':
severity = OfflineImapError.ERROR.MESSAGE
reason = "IMAP server '%s' failed to store %s for message UID '%d'."\
- "Server responded: %s %s"% (
- self.getrepository(), field, uid, res_type, retdata)
+ "Server responded: %s %s"% (self.getrepository().getname().fs,
+ field, uid, res_type, retdata)
raise OfflineImapError(reason, severity)
+
return retdata[0]
# Interface from BaseFolder
@@ -771,13 +803,13 @@ class IMAPFolder(BaseFolder):
imapobj = self.imapserver.acquireconnection()
try:
try:
- imapobj.select(self.getfullname())
+ imapobj.select(self.getfullname().imap)
except imapobj.readonly:
self.ui.flagstoreadonly(self, uidlist, flags)
return
r = imapobj.uid('store',
imaputil.uid_sequence(uidlist), operation + 'FLAGS',
- imaputil.flagsmaildir2imap(flags))
+ imaputil.flagsmaildir2imap(flags))
assert r[0] == 'OK', 'Error with store: ' + '. '.join(r[1])
r = r[1]
finally:
@@ -845,7 +877,7 @@ class IMAPFolder(BaseFolder):
imapobj = self.imapserver.acquireconnection()
try:
try:
- imapobj.select(self.getfullname())
+ imapobj.select(self.getfullname().imap)
except imapobj.readonly:
self.ui.deletereadonly(self, uidlist)
return
diff --git a/offlineimap/folder/LocalStatus.py b/offlineimap/folder/LocalStatus.py
index c753f63..e6d47ac 100644
--- a/offlineimap/folder/LocalStatus.py
+++ b/offlineimap/folder/LocalStatus.py
@@ -19,6 +19,7 @@ from sys import exc_info
import os
import threading
+from offlineimap.utils.uni import uniString, fsString, isASCII
from .Base import BaseFolder
@@ -29,10 +30,14 @@ class LocalStatusFolder(BaseFolder):
magicline = "OFFLINEIMAP LocalStatus CACHE DATA - DO NOT MODIFY - FORMAT %d"
def __init__(self, name, repository):
- self.sep = '.' #needs to be set before super.__init__()
+ self.sep = uniString(u'.') # needs to be set before super.__init__()
super(LocalStatusFolder, self).__init__(name, repository)
- self.root = repository.root
- self.filename = os.path.join(self.getroot(), self.getfolderbasename())
+ self.root = repository.getlocalroot() # XXX: what root looks like?
+ # Fix the filename to the IMAP UTF-7 encoding version. This prevents
+ # from playing with multiple cache files representative of the same
+ # remote folder.
+ self.filename = fsString(os.path.join(
+ self.root.fs, self.getfolderbasename().imap))
self.messagelist = {}
self.savelock = threading.Lock()
# Should we perform fsyncs as often as possible?
@@ -44,15 +49,16 @@ class LocalStatusFolder(BaseFolder):
return 0
def isnewfolder(self):
- return not os.path.exists(self.filename)
+ return not os.path.exists(self.filename.fs)
# Interface from BaseFolder
def getfullname(self):
return self.filename
def deletemessagelist(self):
+
if not self.isnewfolder():
- os.unlink(self.filename)
+ os.unlink(self.filename.fs)
# Interface from BaseFolder
def msglist_item_initializer(self, uid):
@@ -72,10 +78,16 @@ class LocalStatusFolder(BaseFolder):
uid = long(uid)
flags = set(flags)
except ValueError as e:
- errstr = "Corrupt line '%s' in cache file '%s'" % \
- (line, self.filename)
+ # Mixing encoding:
+ # - line: should be ASCII but unexpected bug could make it
+ # string of bytes with unkown encoding.
+ # - self.filename: filesystem encoded.
+ # Converting from unkown encoding is worse than keeping things
+ # as-is.
+ errstr = uniString(u"Corrupt line '%s' in cache file '%s'"%
+ (line, self.filename.uni))
self.ui.warn(errstr)
- raise ValueError(errstr), None, exc_info()[2]
+ raise ValueError(errstr.fs), None, exc_info()[2]
self.messagelist[uid] = self.msglist_item_initializer(uid)
self.messagelist[uid]['flags'] = flags
@@ -93,12 +105,19 @@ class LocalStatusFolder(BaseFolder):
uid = long(uid)
flags = set(flags)
mtime = long(mtime)
- labels = set([lb.strip() for lb in labels.split(',') if len(lb.strip()) > 0])
+ labels = set([
+ lb.strip() for lb in labels.split(',') if len(lb.strip()) > 0])
except ValueError as e:
- errstr = "Corrupt line '%s' in cache file '%s'"% \
- (line, self.filename)
+ # Mixing encoding:
+ # - line: should be ASCII but unexpected bug could make it
+ # string of bytes with unkown encoding.
+ # - self.filename: filesystem encoded.
+ # Converting from unkown encoding is worse than keeping things
+ # as-is.
+ errstr = uniString(u"Corrupt line '%s' in cache file '%s'"%
+ (line, self.filename.uni))
self.ui.warn(errstr)
- raise ValueError(errstr), None, exc_info()[2]
+ raise ValueError(errstr.fs), None, exc_info()[2]
self.messagelist[uid] = self.msglist_item_initializer(uid)
self.messagelist[uid]['flags'] = flags
self.messagelist[uid]['mtime'] = mtime
@@ -123,8 +142,9 @@ class LocalStatusFolder(BaseFolder):
# Convert from format v1.
elif line == (self.magicline % 1):
- self.ui._msg('Upgrading LocalStatus cache from version 1'
- 'to version 2 for %s:%s'% (self.repository, self))
+ self.ui._msg(u'Upgrading LocalStatus cache from version 1'
+ 'to version 2 for %s:%s'%
+ (self.repository.getname().uni, self.name.uni))
self.readstatus_v1(cachefd)
cachefd.close()
self.save()
@@ -139,14 +159,16 @@ class LocalStatusFolder(BaseFolder):
# Something is wrong.
else:
- errstr = "Unrecognized cache magicline in '%s'" % self.filename
+ # Keep string filesystem encoded.
+ errstr = uniString(
+ u"Unrecognized cache magicline in '%s'"% self.filename.uni)
self.ui.warn(errstr)
- raise ValueError(errstr)
+ raise ValueError(errstr.fs)
if not line:
# The status file is empty - should not have happened,
# but somehow did.
- errstr = "Cache file '%s' is empty."% self.filename
+ errstr = uniString(u"Cache file '%s' is empty."% self.filename.uni)
self.ui.warn(errstr)
cachefd.close()
return
@@ -172,15 +194,23 @@ class LocalStatusFolder(BaseFolder):
for msg in self.messagelist.values():
flags = ''.join(sorted(msg['flags']))
labels = ', '.join(sorted(msg['labels']))
- cachefd.write("%s|%s|%d|%s\n" % (msg['uid'], flags, msg['mtime'], labels))
+ data = u"%s|%s|%d|%s\n"% (msg['uid'], flags, msg['mtime'], labels)
+ # Ensure all data is full ASCII.
+ isASCII(data, exception_msg=
+ "unsupported character was about to go to the cache file %s"%
+ self.filename.fs)
+ cachefd.write(data)
cachefd.flush()
if self.doautosave:
os.fsync(cachefd.fileno())
cachefd.close()
- os.rename(self.filename + ".tmp", self.filename)
+ os.rename(self.filename.fs + ".tmp", self.filename.fs)
if self.doautosave:
- fd = os.open(os.path.dirname(self.filename), os.O_RDONLY)
+ # fsync on directory ensure that a newly created file will exist
+ # in the directory. The filesystem must support this feature.
+ p = os.path.dirname(self.filename.fs)
+ fd = os.open(p, os.O_RDONLY)
os.fsync(fd)
os.close(fd)
diff --git a/offlineimap/folder/LocalStatusSQLite.py b/offlineimap/folder/LocalStatusSQLite.py
index 8a3b9df..f0800f8 100644
--- a/offlineimap/folder/LocalStatusSQLite.py
+++ b/offlineimap/folder/LocalStatusSQLite.py
@@ -20,68 +20,77 @@ from threading import Lock
try:
import sqlite3 as sqlite
except:
- pass #fail only if needed later on, not on import
+ pass # Fail only if needed later on, not on import.
from .Base import BaseFolder
+from offlineimap.utils.uni import uniString, fsString
class LocalStatusSQLiteFolder(BaseFolder):
- """LocalStatus backend implemented with an SQLite database
+ """LocalStatus backend implemented with an SQLite database.
As python-sqlite currently does not allow to access the same sqlite
objects from various threads, we need to open get and close a db
connection and cursor for all operations. This is a big disadvantage
and we might want to investigate if we cannot hold an object open
for a thread somehow."""
- #though. According to sqlite docs, you need to commit() before
- #the connection is closed or your changes will be lost!"""
- #get db connection which autocommits
- #connection = sqlite.connect(self.filename, isolation_level=None)
- #cursor = connection.cursor()
- #return connection, cursor
-
- #current version of our db format
+
+ # Though. According to sqlite docs, you need to commit() before
+ # the connection is closed or your changes will be lost!
+ # Get db connection which autocommits
+ # connection = sqlite.connect(self.filename.fs, isolation_level=None)
+ # cursor = connection.cursor()
+ # return connection, cursor
+
+ # Current version of our db format.
cur_version = 2
def __init__(self, name, repository):
- self.sep = '.' #needs to be set before super.__init__()
+ self.sep = uniString(u'.') # needs to be set before super.__init__()
super(LocalStatusSQLiteFolder, self).__init__(name, repository)
- self.root = repository.root
- self.filename = os.path.join(self.getroot(), self.getfolderbasename())
+ self.root = repository.getlocalroot()
+ folderbasename = self.getfolderbasename()
+ # Fix the filename to the IMAP UTF-7 encoding version. This prevents
+ # from playing with multiple cache files representative of the same
+ # remote folder.
+ self.filename = fsString(os.path.join(
+ self.getroot().fs, self.getfolderbasename().imap))
self.messagelist = {}
-
self._newfolder = False # flag if the folder is new
- dirname = os.path.dirname(self.filename)
- if not os.path.exists(dirname):
- os.makedirs(dirname)
- if not os.path.isdir(dirname):
+ dirname = fsString(os.path.dirname(self.filename.fs))
+ if not os.path.exists(dirname.fs):
+ os.makedirs(dirname.fs)
+ if not os.path.isdir(dirname.fs):
+ # dirname is expected filesystem encoded.
raise UserWarning("SQLite database path '%s' is not a directory."%
- dirname)
+ dirname.fs)
# dblock protects against concurrent writes in same connection
self._dblock = Lock()
- #Try to establish connection, no need for threadsafety in __init__
+ # Try to establish connection, no need for threadsafety in __init__.
try:
- self.connection = sqlite.connect(self.filename, check_same_thread=False)
+ self.connection = sqlite.connect(
+ self.filename.fs, check_same_thread=False)
except NameError:
# sqlite import had failed
raise UserWarning('SQLite backend chosen, but no sqlite python '
'bindings available. Please install.'), None, exc_info()[2]
- #Make sure sqlite is in multithreading SERIALIZE mode
+ # Make sure sqlite is in multithreading SERIALIZE mode.
assert sqlite.threadsafety == 1, 'Your sqlite is not multithreading safe.'
- #Test if db version is current enough and if db is readable.
+ # Test if db version is current enough and if db is readable.
try:
cursor = self.connection.execute(
"SELECT value from metadata WHERE key='db_version'")
except sqlite.DatabaseError:
- #db file missing or corrupt, recreate it.
+ # db file missing or corrupt, recreate it.
+ # XXX: warn the user about that.
self.__create_db()
else:
- # fetch db version and upgrade if needed
+ # fetch db version and upgrade if needed.
version = int(cursor.fetchone()[0])
if version < LocalStatusSQLiteFolder.cur_version:
self.__upgrade_db(version)
@@ -144,27 +153,31 @@ class LocalStatusSQLiteFolder(BaseFolder):
return cursor
def __upgrade_db(self, from_ver):
- """Upgrade the sqlite format from version 'from_ver' to current"""
+ """Upgrade the sqlite format from version 'from_ver' to current."""
if hasattr(self, 'connection'):
- self.connection.close() #close old connections first
+ self.connection.close() # Close old connections first.
self.connection = sqlite.connect(self.filename,
- check_same_thread = False)
+ check_same_thread=False)
# Upgrade from database version 1 to version 2
- # This change adds labels and mtime columns, to be used by Gmail IMAP and Maildir folders.
+ # This change adds labels and mtime columns, to be used by Gmail IMAP
+ # and Maildir folders.
+
if from_ver <= 1:
- self.ui._msg('Upgrading LocalStatus cache from version 1 to version 2 for %s:%s'%
- (self.repository, self))
- self.connection.executescript("""ALTER TABLE status ADD mtime INTEGER DEFAULT 0;
- ALTER TABLE status ADD labels VARCHAR(256) DEFAULT '';
- UPDATE metadata SET value='2' WHERE key='db_version';
- """)
+ self.ui._msg(u'Upgrading LocalStatus cache from version 1 '
+ 'to version 2 for %s:%s'%
+ (self.repository.getname().uni, self.name.uni))
+ self.connection.executescript("""
+ALTER TABLE status ADD mtime INTEGER DEFAULT 0;
+ALTER TABLE status ADD labels VARCHAR(256) DEFAULT '';
+UPDATE metadata SET value='2' WHERE key='db_version';
+ """)
self.connection.commit()
# Future version upgrades come here...
- # if from_ver <= 2: ... #upgrade from 2 to 3
- # if from_ver <= 3: ... #upgrade from 3 to 4
+ # if from_ver <= 2: ... # upgrade from 2 to 3
+ # if from_ver <= 3: ... # upgrade from 3 to 4
def __create_db(self):
@@ -172,12 +185,13 @@ class LocalStatusSQLiteFolder(BaseFolder):
self.connection must point to the opened and valid SQlite
database connection."""
- self.ui._msg('Creating new Local Status db for %s:%s' \
- % (self.repository, self))
+
+ self.ui._msg(u"Creating new Local Status db for %s:%s to '%s'"%
+ (self.repository.getname().uni, self.name.uni, self.filename.uni))
self.connection.executescript("""
- CREATE TABLE metadata (key VARCHAR(50) PRIMARY KEY, value VARCHAR(128));
- INSERT INTO metadata VALUES('db_version', '2');
- CREATE TABLE status (id INTEGER PRIMARY KEY, flags VARCHAR(50), mtime INTEGER, labels VARCHAR(256));
+CREATE TABLE metadata (key VARCHAR(50) PRIMARY KEY, value VARCHAR(128));
+INSERT INTO metadata VALUES('db_version', '2');
+CREATE TABLE status (id INTEGER PRIMARY KEY, flags VARCHAR(50), mtime INTEGER, labels VARCHAR(256));
""")
self.connection.commit()
self._newfolder = True
@@ -223,7 +237,6 @@ class LocalStatusSQLiteFolder(BaseFolder):
'(id,flags,mtime,labels) VALUES (?,?,?,?)',
data, executemany=True)
-
# Following some pure SQLite functions, where we chose to use
# BaseFolder() methods instead. Doing those on the in-memory list is
# quicker anyway. If our db becomes so big that we don't want to
@@ -235,8 +248,10 @@ class LocalStatusSQLiteFolder(BaseFolder):
# with conn:
# cursor.execute('SELECT id FROM status WHERE id=:id',{'id': uid})
# return cursor.fetchone()
+ #
# This would be the pure SQLite solution, use BaseFolder() method,
# to avoid threading with sqlite...
+ #
#def getmessageuidlist(self):
# conn, cursor = self.get_cursor()
# with conn:
@@ -245,16 +260,18 @@ class LocalStatusSQLiteFolder(BaseFolder):
# for row in cursor:
# r.append(row[0])
# return r
+ #
#def getmessagecount(self):
# conn, cursor = self.get_cursor()
# with conn:
# cursor.execute('SELECT count(id) from status');
# return cursor.fetchone()[0]
+ #
#def getmessageflags(self, uid):
# conn, cursor = self.get_cursor()
# with conn:
# cursor.execute('SELECT flags FROM status WHERE id=:id',
- # {'id': uid})
+ # {'id': uid})
# for row in cursor:
# flags = [x for x in row[0]]
# return flags
@@ -286,8 +303,10 @@ class LocalStatusSQLiteFolder(BaseFolder):
self.messagelist[uid] = {'uid': uid, 'flags': flags, 'time': rtime, 'mtime': mtime, 'labels': labels}
flags = ''.join(sorted(flags))
labels = ', '.join(sorted(labels))
- self.__sql_write('INSERT INTO status (id,flags,mtime,labels) VALUES (?,?,?,?)',
- (uid,flags,mtime,labels))
+ self.__sql_write(
+ 'INSERT INTO status (id,flags,mtime,labels) VALUES (?,?,?,?)',
+ (uid,flags,mtime,labels))
+
return uid
@@ -296,7 +315,7 @@ class LocalStatusSQLiteFolder(BaseFolder):
assert self.uidexists(uid)
self.messagelist[uid]['flags'] = flags
flags = ''.join(sorted(flags))
- self.__sql_write('UPDATE status SET flags=? WHERE id=?',(flags,uid))
+ self.__sql_write('UPDATE status SET flags=? WHERE id=?', (flags,uid))
def getmessageflags(self, uid):
@@ -309,18 +328,20 @@ class LocalStatusSQLiteFolder(BaseFolder):
labels = ', '.join(sorted(labels))
if mtime:
- self.__sql_write('UPDATE status SET labels=?, mtime=? WHERE id=?',(labels,mtime,uid))
+ self.__sql_write(
+ 'UPDATE status SET labels=?, mtime=? WHERE id=?',
+ (labels,mtime,uid))
else:
- self.__sql_write('UPDATE status SET labels=? WHERE id=?',(labels,uid))
+ self.__sql_write('UPDATE status SET labels=? WHERE id=?',
+ (labels,uid))
def savemessageslabelsbulk(self, labels):
- """
- Saves labels from a dictionary in a single database operation.
-
- """
+ """Saves labels from a dictionary in a single database operation."""
+
data = [(', '.join(sorted(l)), uid) for uid, l in labels.items()]
- self.__sql_write('UPDATE status SET labels=? WHERE id=?', data, executemany=True)
+ self.__sql_write(
+ 'UPDATE status SET labels=? WHERE id=?', data, executemany=True)
for uid, l in labels.items():
self.messagelist[uid]['labels'] = l
@@ -330,7 +351,8 @@ class LocalStatusSQLiteFolder(BaseFolder):
for uid in uids:
newlabels = self.messagelist[uid]['labels'] | labels
data.append((', '.join(sorted(newlabels)), uid))
- self.__sql_write('UPDATE status SET labels=? WHERE id=?', data, executemany=True)
+ self.__sql_write(
+ 'UPDATE status SET labels=? WHERE id=?', data, executemany=True)
for uid in uids:
self.messagelist[uid]['labels'] = self.messagelist[uid]['labels'] | labels
@@ -340,7 +362,8 @@ class LocalStatusSQLiteFolder(BaseFolder):
for uid in uids:
newlabels = self.messagelist[uid]['labels'] - labels
data.append((', '.join(sorted(newlabels)), uid))
- self.__sql_write('UPDATE status SET labels=? WHERE id=?', data, executemany=True)
+ self.__sql_write(
+ 'UPDATE status SET labels=? WHERE id=?', data, executemany=True)
for uid in uids:
self.messagelist[uid]['labels'] = self.messagelist[uid]['labels'] - labels
@@ -353,7 +376,8 @@ class LocalStatusSQLiteFolder(BaseFolder):
"""Saves mtimes from the mtimes dictionary in a single database operation."""
data = [(mt, uid) for uid, mt in mtimes.items()]
- self.__sql_write('UPDATE status SET mtime=? WHERE id=?', data, executemany=True)
+ self.__sql_write(
+ 'UPDATE status SET mtime=? WHERE id=?', data, executemany=True)
for uid, mt in mtimes.items():
self.messagelist[uid]['mtime'] = mt
@@ -382,6 +406,7 @@ class LocalStatusSQLiteFolder(BaseFolder):
if not len(uidlist):
return
# arg2 needs to be an iterable of 1-tuples [(1,),(2,),...]
- self.__sql_write('DELETE FROM status WHERE id=?', zip(uidlist, ), True)
+ self.__sql_write(
+ 'DELETE FROM status WHERE id=?', zip(uidlist, ), True)
for uid in uidlist:
del(self.messagelist[uid])
diff --git a/offlineimap/folder/Maildir.py b/offlineimap/folder/Maildir.py
index b35bfc2..136209c 100644
--- a/offlineimap/folder/Maildir.py
+++ b/offlineimap/folder/Maildir.py
@@ -32,6 +32,8 @@ except NameError:
from sets import Set as set
from offlineimap import OfflineImapError
+from offlineimap.utils.uni import uniString, fsString
+
# Find the UID in a message filename
re_uidmatch = re.compile(',U=(\d+)')
@@ -57,8 +59,22 @@ def _gettimeseq():
finally:
timelock.release()
+#
+# XXX: some methods do a lot of os.path.join()/os.path.split(). Check if it can
+# be factorized in methods with names explaining WHAT are the returned values.
+# I mean, not a generic "splitted_blah()" thing but rather something like
+# "dirname_tmp_filename()".
+#
+
class MaildirFolder(BaseFolder):
def __init__(self, root, name, sep, repository):
+ """:params:
+ - root: path
+ - name: folder name
+ - sep: sep character.
+ - repository: repository instance.
+ """
+
self.sep = sep # needs to be set before super().__init__
super(MaildirFolder, self).__init__(name, repository)
self.dofsync = self.config.getdefaultboolean("general", "fsync", True)
@@ -66,21 +82,24 @@ class MaildirFolder(BaseFolder):
self.messagelist = None
# check if we should use a different infosep to support Win file systems
self.wincompatible = self.config.getdefaultboolean(
- "Account "+self.accountname, "maildir-windows-compatible", False)
- self.infosep = '!' if self.wincompatible else ':'
+ "Account " + self.accountname.dbytes,
+ "maildir-windows-compatible", False)
+ self.infosep = uniString(u'!') if self.wincompatible else uniString(u':')
"""infosep is the separator between maildir name and flag appendix"""
- self.re_flagmatch = re.compile('%s2,(\w*)'% self.infosep)
+ self.re_flagmatch = re.compile('%s2,(\w*)'% self.infosep.dbytes)
#self.ui is set in BaseFolder.init()
# Everything up to the first comma or colon (or ! if Windows):
- self.re_prefixmatch = re.compile('([^'+ self.infosep + ',]*)')
- #folder's md, so we can match with recorded file md5 for validity
- self._foldermd5 = md5(self.getvisiblename()).hexdigest()
+ self.re_prefixmatch = re.compile('([^'+ self.infosep.dbytes + ',]*)')
+ # folder's md, so we can match with recorded file md5 for validity
+ self._foldermd5 = md5(self.getvisiblename().imap).hexdigest()
# Cache the full folder path, as we use getfullname() very often
- self._fullname = os.path.join(self.getroot(), self.getname())
+ self._fullname = fsString(os.path.join(
+ self.root.fs, self.name.fs))
# Interface from BaseFolder
def getfullname(self):
"""Return the absolute file path to the Maildir folder (sans cur|new)"""
+
return self._fullname
# Interface from BaseFolder
@@ -89,14 +108,15 @@ class MaildirFolder(BaseFolder):
Maildirs have no notion of uidvalidity, so we just return a magic
token."""
+
return 42
- #Checks to see if the given message is within the maximum age according
- #to the maildir name which should begin with a timestamp
+ # Checks to see if the given message is within the maximum age according
+ # to the maildir name which should begin with a timestamp.
def _iswithinmaxage(self, messagename, maxage):
- #In order to have the same behaviour as SINCE in an IMAP search
- #we must convert this to the oldest time and then strip off hrs/mins
- #from that day
+ # In order to have the same behaviour as SINCE in an IMAP search
+ # we must convert this to the oldest time and then strip off hrs/mins
+ # from that day
oldest_time_utc = time.time() - (60*60*24*maxage)
oldest_time_struct = time.gmtime(oldest_time_utc)
oldest_time_today_seconds = ((oldest_time_struct[3] * 3600) \
@@ -132,18 +152,18 @@ class MaildirFolder(BaseFolder):
"""
prefix, uid, fmd5, flags = None, None, None, set()
- prefixmatch = self.re_prefixmatch.match(filename)
+ prefixmatch = self.re_prefixmatch.match(filename.fs)
if prefixmatch:
prefix = prefixmatch.group(1)
folderstr = ',FMD5=%s'% self._foldermd5
- foldermatch = folderstr in filename
+ foldermatch = folderstr in filename.fs
# If there was no folder MD5 specified, or if it mismatches,
# assume it is a foreign (new) message and ret: uid, fmd5 = None, None
if foldermatch:
- uidmatch = re_uidmatch.search(filename)
+ uidmatch = re_uidmatch.search(filename.fs)
if uidmatch:
uid = long(uidmatch.group(1))
- flagmatch = self.re_flagmatch.search(filename)
+ flagmatch = self.re_flagmatch.search(filename.fs)
if flagmatch:
# Filter out all lowercase (custom maildir) flags. We don't
# handle them yet.
@@ -158,44 +178,45 @@ class MaildirFolder(BaseFolder):
:returns: dict that can be used as self.messagelist.
"""
- maxage = self.config.getdefaultint("Account " + self.accountname,
- "maxage", None)
- maxsize = self.config.getdefaultint("Account " + self.accountname,
- "maxsize", None)
+ maxage = self.config.getdefaultint(
+ "Account " + self.accountname.dbytes, "maxage", None)
+ maxsize = self.config.getdefaultint(
+ "Account " + self.accountname.dbytes, "maxsize", None)
retval = {}
files = []
nouidcounter = -1 # Messages without UIDs get negative UIDs.
for dirannex in ['new', 'cur']:
- fulldirname = os.path.join(self.getfullname(), dirannex)
- files.extend((dirannex, filename) for
- filename in os.listdir(fulldirname))
+ fs_fulldirname = os.path.join(self.getfullname().fs, dirannex)
+ files.extend((dirannex, fs_filename) for
+ fs_filename in os.listdir(fs_fulldirname))
- for dirannex, filename in files:
- # We store just dirannex and filename, ie 'cur/123...'
- filepath = os.path.join(dirannex, filename)
+ for dirannex, fs_filename in files:
+ # We store just dirannex and fs_filename, ie 'cur/123...'
+ fs_filepath = os.path.join(dirannex, fs_filename)
# check maxage/maxsize if this message should be considered
- if maxage and not self._iswithinmaxage(filename, maxage):
+ if maxage and not self._iswithinmaxage(fs_filename, maxage):
continue
- if maxsize and (os.path.getsize(os.path.join(
- self.getfullname(), filepath)) > maxsize):
+ if maxsize and (os.path.getsize(
+ os.path.join(self.getfullname().fs, fs_filepath)) > maxsize):
continue
- (prefix, uid, fmd5, flags) = self._parse_filename(filename)
+ (prefix, uid, fmd5, flags) = self._parse_filename(
+ fsString(fs_filename))
if uid is None: # assign negative uid to upload it.
uid = nouidcounter
nouidcounter -= 1
else: # It comes from our folder.
- uidmatch = re_uidmatch.search(filename)
+ uidmatch = re_uidmatch.search(fs_filename)
uid = None
if not uidmatch:
uid = nouidcounter
nouidcounter -= 1
else:
uid = long(uidmatch.group(1))
- # 'filename' is 'dirannex/filename', e.g. cur/123,U=1,FMD5=1:2,S
+ # 'fs_filename' is 'dirannex/fs_filename', e.g. cur/123,U=1,FMD5=1:2,S
retval[uid] = self.msglist_item_initializer(uid)
retval[uid]['flags'] = flags
- retval[uid]['filename'] = filepath
+ retval[uid]['filename'] = fsString(fs_filepath)
return retval
# Interface from BaseFolder
@@ -235,10 +256,10 @@ class MaildirFolder(BaseFolder):
"""Return the content of the message."""
filename = self.messagelist[uid]['filename']
- filepath = os.path.join(self.getfullname(), filename)
- file = open(filepath, 'rt')
- retval = file.read()
- file.close()
+ fs_filepath = os.path.join(self.getfullname().fs, filename.fs)
+ f = open(fs_filepath, 'rt')
+ retval = f.read()
+ f.close()
#TODO: WHY are we replacing \r\n with \n here? And why do we
# read it as text?
return retval.replace("\r\n", "\n")
@@ -246,8 +267,8 @@ class MaildirFolder(BaseFolder):
# Interface from BaseFolder
def getmessagetime(self, uid):
filename = self.messagelist[uid]['filename']
- filepath = os.path.join(self.getfullname(), filename)
- return os.path.getmtime(filepath)
+ fs_filepath = os.path.join(self.getfullname().fs, filename.fs)
+ return os.path.getmtime(fs_filepath)
def new_message_filename(self, uid, flags=set()):
"""Creates a new unique Maildir filename
@@ -273,14 +294,14 @@ class MaildirFolder(BaseFolder):
Returns: relative path to the temporary file
that was created."""
- tmpname = os.path.join('tmp', filename)
+ tmpname = fsString(os.path.join('tmp', filename.fs))
# open file and write it out
tries = 7
while tries:
tries = tries - 1
try:
- fd = os.open(os.path.join(self.getfullname(), tmpname),
- os.O_EXCL|os.O_CREAT|os.O_WRONLY, 0o666)
+ fs_path = os.path.join(self.getfullname().fs, tmpname.fs)
+ fd = os.open(fs_path, os.O_EXCL|os.O_CREAT|os.O_WRONLY, 0o666)
break
except OSError as e:
if e.errno == e.EEXIST:
@@ -288,8 +309,9 @@ class MaildirFolder(BaseFolder):
time.sleep(0.23)
continue
severity = OfflineImapError.ERROR.MESSAGE
- raise OfflineImapError("Unique filename %s already exists." % \
- filename, severity), None, exc_info()[2]
+ # filename is expected filesystem encoded.
+ raise OfflineImapError("Unique filename %s already exists."%
+ filename.fs, severity), None, exc_info()[2]
else:
raise
@@ -303,7 +325,6 @@ class MaildirFolder(BaseFolder):
return tmpname
-
# Interface from BaseFolder
def savemessage(self, uid, content, flags, rtime):
"""Writes a new message, with the specified uid.
@@ -311,9 +332,10 @@ class MaildirFolder(BaseFolder):
See folder/Base for detail. Note that savemessage() does not
check against dryrun settings, so you need to ensure that
savemessage is never called in a dryrun mode."""
+
# This function only ever saves to tmp/,
# but it calls savemessageflags() to actually save to cur/ or new/.
- self.ui.savemessage('maildir', uid, flags, self)
+ self.ui.savemessage('maildir', uid, flags, self.name)
if uid < 0:
# We cannot assign a new uid.
return uid
@@ -325,18 +347,20 @@ class MaildirFolder(BaseFolder):
# Otherwise, save the message in tmp/ and then call savemessageflags()
# to give it a permanent home.
- tmpdir = os.path.join(self.getfullname(), 'tmp')
+ fs_tmpdir = os.path.join(self.getfullname().fs, 'tmp') # FIXME: never used!
messagename = self.new_message_filename(uid, flags)
tmpname = self.save_to_tmp_file(messagename, content)
if rtime != None:
- os.utime(os.path.join(self.getfullname(), tmpname), (rtime, rtime))
+ os.utime(os.path.join(self.getfullname().fs, tmpname.fs),
+ (rtime, rtime))
self.messagelist[uid] = self.msglist_item_initializer(uid)
self.messagelist[uid]['flags'] = flags
self.messagelist[uid]['filename'] = tmpname
# savemessageflags moves msg to 'cur' or 'new' as appropriate
self.savemessageflags(uid, flags)
- self.ui.debug('maildir', 'savemessage: returning uid %d' % uid)
+ self.ui.debug('maildir', u'savemessage: returning uid %d'% uid)
+
return uid
# Interface from BaseFolder
@@ -357,30 +381,32 @@ class MaildirFolder(BaseFolder):
assert uid in self.messagelist
oldfilename = self.messagelist[uid]['filename']
- dir_prefix, filename = os.path.split(oldfilename)
+ # UNICODE: Keep those as Python types.
+ fs_dir_prefix, fs_filename = os.path.split(oldfilename.fs)
# If a message has been seen, it goes into 'cur'
- dir_prefix = 'cur' if 'S' in flags else 'new'
+ fs_dir_prefix = 'cur' if 'S' in flags else 'new'
if flags != self.messagelist[uid]['flags']:
- # Flags have actually changed, construct new filename Strip
+ # Flags have actually changed, construct new filename. Strip
# off existing infostring (possibly discarding small letter
- # flags that dovecot uses TODO)
- infomatch = self.re_flagmatch.search(filename)
+ # flags that dovecot uses TODO).
+ infomatch = self.re_flagmatch.search(fs_filename)
if infomatch:
- filename = filename[:-len(infomatch.group())] #strip off
- infostr = '%s2,%s'% (self.infosep, ''.join(sorted(flags)))
- filename += infostr
+ fs_filename = fs_filename[:-len(infomatch.group())] # strip off
+ infostr = '%s2,%s'% (self.infosep.fs, ''.join(sorted(flags)))
+ fs_filename += infostr
- newfilename = os.path.join(dir_prefix, filename)
+ newfilename = fsString(os.path.join(fs_dir_prefix, fs_filename))
if (newfilename != oldfilename):
try:
- os.rename(os.path.join(self.getfullname(), oldfilename),
- os.path.join(self.getfullname(), newfilename))
+ fs_old = os.path.join(self.getfullname().fs, oldfilename.fs)
+ fs_new = os.path.join(self.getfullname().fs, newfilename.fs)
+ os.rename(fs_old, fs_new)
except OSError as e:
- raise OfflineImapError("Can't rename file '%s' to '%s': %s" % (
- oldfilename, newfilename, e[1]),
- OfflineImapError.ERROR.FOLDER), \
- None, exc_info()[2]
+ raise OfflineImapError("Can't rename file '%s' to '%s': %s"% (
+ oldfilename.fs, newfilename.fs, e[1]),
+ OfflineImapError.ERROR.FOLDER), \
+ None, exc_info()[2]
self.messagelist[uid]['flags'] = flags
self.messagelist[uid]['filename'] = newfilename
@@ -400,12 +426,13 @@ class MaildirFolder(BaseFolder):
if uid == new_uid: return
oldfilename = self.messagelist[uid]['filename']
- dir_prefix, filename = os.path.split(oldfilename)
+ fs_dir_prefix = os.path.split(oldfilename.fs)[0]
flags = self.getmessageflags(uid)
- newfilename = os.path.join(dir_prefix,
- self.new_message_filename(new_uid, flags))
- os.rename(os.path.join(self.getfullname(), oldfilename),
- os.path.join(self.getfullname(), newfilename))
+ newfilename = fsString(os.path.join(
+ fs_dir_prefix, self.new_message_filename(new_uid, flags).fs))
+ fs_old = os.path.join(self.getfullname().fs, oldfilename.fs)
+ fs_new = os.path.join(self.getfullname().fs, newfilename.fs)
+ os.rename(fs_old, fs_new)
self.messagelist[new_uid] = self.messagelist[uid]
self.messagelist[new_uid]['filename'] = newfilename
del self.messagelist[uid]
@@ -419,19 +446,20 @@ class MaildirFolder(BaseFolder):
:return: Nothing, or an Exception if UID but no corresponding file
found.
"""
+
if not self.uidexists(uid):
return
filename = self.messagelist[uid]['filename']
- filepath = os.path.join(self.getfullname(), filename)
+ fs_filepath = os.path.join(self.getfullname().fs, filename.fs)
try:
- os.unlink(filepath)
+ os.unlink(fs_filepath)
except OSError:
# Can't find the file -- maybe already deleted?
newmsglist = self._scanfolder()
if uid in newmsglist: # Nope, try new filename.
filename = newmsglist[uid]['filename']
- filepath = os.path.join(self.getfullname(), filename)
- os.unlink(filepath)
+ fs_filepath = os.path.join(self.getfullname().fs, filename.fs)
+ os.unlink(fs_filepath)
# Yep -- return.
del(self.messagelist[uid])
diff --git a/offlineimap/folder/UIDMaps.py b/offlineimap/folder/UIDMaps.py
index e8ca9a7..c1069f3 100644
--- a/offlineimap/folder/UIDMaps.py
+++ b/offlineimap/folder/UIDMaps.py
@@ -16,10 +16,15 @@
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
from sys import exc_info
+import os.path
+import codecs
from threading import Lock
+
from offlineimap import OfflineImapError
from .IMAP import IMAPFolder
-import os.path
+from offlineimap.utils import uni
+from offlineimap.utils.uni import fsString, uniString
+
class MappedIMAPFolder(IMAPFolder):
"""IMAP class to map between Folder() instances where both side assign a uid
@@ -42,27 +47,27 @@ class MappedIMAPFolder(IMAPFolder):
"""Representing the local IMAP Folder using local UIDs"""
def _getmapfilename(self):
- return os.path.join(self.repository.getmapdir(),
- self.getfolderbasename())
+ return fsString(os.path.join(
+ self.repository.getmapdir().fs, self.getfolderbasename().fs))
def _loadmaps(self):
self.maplock.acquire()
try:
mapfilename = self._getmapfilename()
- if not os.path.exists(mapfilename):
+ if not os.path.exists(mapfilename.fs):
return ({}, {})
- file = open(mapfilename, 'rt')
+ mapfile = open(mapfilename.fs, 'rt')
r2l = {}
l2r = {}
while 1:
- line = file.readline()
+ line = mapfile.readline()
if not len(line):
break
try:
line = line.strip()
except ValueError:
raise Exception("Corrupt line '%s' in UID mapping file '%s'"%
- (line, mapfilename)), None, exc_info()[2]
+ (line, mapfilename.fs)), None, exc_info()[2]
(str1, str2) = line.split(':')
loc = long(str1)
rem = long(str2)
@@ -76,11 +81,16 @@ class MappedIMAPFolder(IMAPFolder):
mapfilename = self._getmapfilename()
if dolock: self.maplock.acquire()
try:
- file = open(mapfilename + ".tmp", 'wt')
+ tmpname = fsString(mapfilename.fs + ".tmp")
+ if uni.use_unicode():
+ mapfile = codecs.open(tmpname.fs, 'wt', uni.ENCODING)
+ else:
+ mapfile = open(tmpname.fs, 'wt')
for (key, value) in self.diskl2r.iteritems():
- file.write("%d:%d\n"% (key, value))
- file.close()
- os.rename(mapfilename + '.tmp', mapfilename)
+ data = uniString("%d:%d\n"% (key, value))
+ mapfile.write(data.dbytes)
+ mapfile.close()
+ os.rename(tmpname.fs, mapfilename.fs)
finally:
if dolock: self.maplock.release()
@@ -90,7 +100,7 @@ class MappedIMAPFolder(IMAPFolder):
except KeyError as e:
raise OfflineImapError("Could not find UID for msg '{0}' (f:'{1}'."
" This is usually a bad thing and should be reported on the ma"
- "iling list.".format(e.args[0], self),
+ "iling list.".format(e.args[0], self.name.fs),
OfflineImapError.ERROR.MESSAGE), None, exc_info()[2]
# Interface from BaseFolder
@@ -131,6 +141,7 @@ class MappedIMAPFolder(IMAPFolder):
# Interface from BaseFolder
def uidexists(self, ruid):
"""Checks if the (remote) UID exists in this Folder"""
+
# This implementation overrides the one in BaseFolder, as it is
# much more efficient for the mapped case.
return ruid in self.r2l
@@ -139,6 +150,7 @@ class MappedIMAPFolder(IMAPFolder):
def getmessageuidlist(self):
"""Gets a list of (remote) UIDs.
You may have to call cachemessagelist() before calling this function!"""
+
# This implementation overrides the one in BaseFolder, as it is
# much more efficient for the mapped case.
return self.r2l.keys()
@@ -147,6 +159,7 @@ class MappedIMAPFolder(IMAPFolder):
def getmessagecount(self):
"""Gets the number of messages in this folder.
You may have to call cachemessagelist() before calling this function!"""
+
# This implementation overrides the one in BaseFolder, as it is
# much more efficient for the mapped case.
return len(self.r2l)
@@ -180,6 +193,7 @@ class MappedIMAPFolder(IMAPFolder):
# Interface from BaseFolder
def getmessage(self, uid):
"""Returns the content of the specified message."""
+
return self._mb.getmessage(self.r2l[uid])
# Interface from BaseFolder
@@ -200,8 +214,8 @@ class MappedIMAPFolder(IMAPFolder):
See folder/Base for details. Note that savemessage() does not
check against dryrun settings, so you need to ensure that
- savemessage is never called in a dryrun mode.
- """
+ savemessage is never called in a dryrun mode."""
+
self.ui.savemessage('imap', uid, flags, self)
# Mapped UID instances require the source to already have a
# positive UID, so simply return here.
@@ -238,11 +252,10 @@ class MappedIMAPFolder(IMAPFolder):
# Interface from BaseFolder
def savemessageflags(self, uid, flags):
- """
-
- Note that this function does not check against dryrun settings,
+ """Note that this function does not check against dryrun settings,
so you need to ensure that it is never called in a
dryrun mode."""
+
self._mb.savemessageflags(self.r2l[uid], flags)
# Interface from BaseFolder
@@ -251,8 +264,8 @@ class MappedIMAPFolder(IMAPFolder):
# Interface from BaseFolder
def addmessagesflags(self, uidlist, flags):
- self._mb.addmessagesflags(self._uidlist(self.r2l, uidlist),
- flags)
+ self._mb.addmessagesflags(
+ self._uidlist(self.r2l, uidlist), flags)
# Interface from BaseFolder
def change_message_uid(self, ruid, new_ruid):
@@ -261,6 +274,7 @@ class MappedIMAPFolder(IMAPFolder):
:param new_uid: The old remote UID will be changed to a new
UID. The UIDMaps case handles this efficiently by simply
changing the mappings file."""
+
if ruid not in self.r2l:
raise OfflineImapError("Cannot change unknown Maildir UID %s"%
ruid, OfflineImapError.ERROR.MESSAGE)
@@ -303,8 +317,8 @@ class MappedIMAPFolder(IMAPFolder):
# Interface from BaseFolder
def deletemessagesflags(self, uidlist, flags):
- self._mb.deletemessagesflags(self._uidlist(self.r2l, uidlist),
- flags)
+ self._mb.deletemessagesflags(
+ self._uidlist(self.r2l, uidlist), flags)
# Interface from BaseFolder
def deletemessage(self, uid):
diff --git a/offlineimap/imaplibutil.py b/offlineimap/imaplibutil.py
index 83ffe9a..dd3c96c 100644
--- a/offlineimap/imaplibutil.py
+++ b/offlineimap/imaplibutil.py
@@ -27,6 +27,11 @@ from offlineimap import OfflineImapError
from offlineimap.imaplib2 import IMAP4, IMAP4_SSL, zlib, InternalDate, Mon2num
+#
+# UNICODE: consider this module to work with IMAP encoded data. Features here
+# are low-level drivers. Do not import uni module.
+#
+
class UsefulIMAPMixIn(object):
def __getselectedfolder(self):
if self.state == 'SELECTED':
@@ -54,12 +59,12 @@ class UsefulIMAPMixIn(object):
except self.abort as e:
# self.abort is raised when we are supposed to retry
errstr = "Server '%s' closed connection, error on SELECT '%s'. Ser"\
- "ver said: %s" % (self.host, mailbox, e.args[0])
+ "ver said: %s"% (self.host, mailbox, e.args[0])
severity = OfflineImapError.ERROR.FOLDER_RETRY
raise OfflineImapError(errstr, severity), None, exc_info()[2]
if result[0] != 'OK':
#in case of error, bail out with OfflineImapError
- errstr = "Error SELECTing mailbox '%s', server reply:\n%s" %\
+ errstr = "Error SELECTing mailbox '%s', server reply:\n%s"%\
(mailbox, result)
severity = OfflineImapError.ERROR.FOLDER
raise OfflineImapError(errstr, severity)
@@ -134,7 +139,8 @@ def new_mesg(self, s, tn=None, secs=None):
if tn is None:
tn = threading.currentThread().getName()
tm = time.strftime('%M:%S', time.localtime(secs))
- getglobalui().debug('imap', ' %s.%02d %s %s' % (tm, (secs*100)%100, tn, s))
+ getglobalui().debug(u'imap', u' %s.%02d %s %s'%
+ (tm, (secs*100)%100, tn, s))
class WrappedIMAP4_SSL(UsefulIMAPMixIn, IMAP4_SSL):
@@ -151,21 +157,23 @@ class WrappedIMAP4_SSL(UsefulIMAPMixIn, IMAP4_SSL):
def open(self, host=None, port=None):
if not self.ca_certs and not self._fingerprint:
raise OfflineImapError("No CA certificates "
- "and no server fingerprints configured. "
- "You must configure at least something, otherwise "
- "having SSL helps nothing.", OfflineImapError.ERROR.REPO)
+ "and no server fingerprints configured. "
+ "You must configure at least something, otherwise "
+ "having SSL helps nothing.",
+ OfflineImapError.ERROR.REPO)
super(WrappedIMAP4_SSL, self).open(host, port)
if self._fingerprint:
# compare fingerprints
fingerprint = sha1(self.sock.getpeercert(True)).hexdigest()
if fingerprint not in self._fingerprint:
raise OfflineImapError("Server SSL fingerprint '%s' "
- "for hostname '%s' "
- "does not match configured fingerprint(s) %s. "
- "Please verify and set 'cert_fingerprint' accordingly "
- "if not set yet."%
- (fingerprint, host, self._fingerprint),
- OfflineImapError.ERROR.REPO)
+ "for hostname '%s' "
+ "does not match configured fingerprint(s) %s. "
+ "Please verify and set 'cert_fingerprint' accordingly "
+ "if not set yet."%
+ (fingerprint, host,
+ self._fingerprint),
+ OfflineImapError.ERROR.REPO)
class WrappedIMAP4(UsefulIMAPMixIn, IMAP4):
diff --git a/offlineimap/imapserver.py b/offlineimap/imapserver.py
index 3d69426..5b55173 100644
--- a/offlineimap/imapserver.py
+++ b/offlineimap/imapserver.py
@@ -15,10 +15,6 @@
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
-from offlineimap import imaplibutil, imaputil, threadutil, OfflineImapError
-from offlineimap.ui import getglobalui
-from threading import Lock, BoundedSemaphore, Thread, Event, currentThread
-import offlineimap.accounts
import hmac
import socket
import base64
@@ -28,6 +24,12 @@ from sys import exc_info
from socket import gaierror
from ssl import SSLError, cert_time_to_seconds
+from offlineimap import imaplibutil, imaputil, threadutil, OfflineImapError
+from offlineimap.ui import getglobalui
+from threading import Lock, BoundedSemaphore, Thread, Event, currentThread
+import offlineimap.accounts
+from offlineimap.utils.uni import noneString, uniString, dbytesString, fsString, imapString
+
try:
# do we have a recent pykerberos?
have_gss = False
@@ -37,8 +39,16 @@ try:
except ImportError:
pass
+
+#
+# XXX: 'repos' is a variable name currently used as alias to 'repository'.
+# This is bad because it lies about what could be understood as explicit plural
+# (a list of repositories). Either use 'repo' or 'repository' but NOT 'repos'.
+#
+# XXX: if it's actually just about initialization, call it InitIMAPServer.
+#
class IMAPServer:
- """Initializes all variables from an IMAPRepository() instance
+ """Initializes all variables from an IMAPRepository() instance.
Various functions, such as acquireconnection() return an IMAP4
object on which we can operate.
@@ -56,39 +66,40 @@ class IMAPServer:
self.preauth_tunnel = repos.getpreauthtunnel()
self.transport_tunnel = repos.gettransporttunnel()
- if self.preauth_tunnel and self.transport_tunnel:
- raise OfflineImapError('%s: '% repos +
+ if self.preauth_tunnel.uni and self.transport_tunnel:
+ raise OfflineImapError('%s: '% repos.getname().fs +
'you must enable precisely one '
'type of tunnel (preauth or transport), '
'not both', OfflineImapError.ERROR.REPO)
self.tunnel = \
- self.preauth_tunnel if self.preauth_tunnel \
+ self.preauth_tunnel if self.preauth_tunnel.uni \
else self.transport_tunnel
self.username = \
- None if self.preauth_tunnel else repos.getuser()
+ noneString() if self.preauth_tunnel.uni else repos.getuser()
self.user_identity = repos.get_remote_identity()
self.authmechs = repos.get_auth_mechanisms()
- self.password = None
- self.passworderror = None
- self.goodpassword = None
+ self.password = noneString()
+ self.passworderror = noneString()
+ self.goodpassword = noneString()
self.usessl = repos.getssl()
self.hostname = \
- None if self.preauth_tunnel else repos.gethost()
+ noneString() if self.preauth_tunnel.uni else repos.gethost()
self.port = repos.getport()
if self.port == None:
self.port = 993 if self.usessl else 143
self.sslclientcert = repos.getsslclientcert()
self.sslclientkey = repos.getsslclientkey()
self.sslcacertfile = repos.getsslcacertfile()
- if self.sslcacertfile is None:
+ if self.sslcacertfile.uni is None:
self.__verifycert = None # disable cert verification
- self.fingerprint = repos.get_ssl_fingerprint()
+ # List of str values.
+ self.fingerprints = repos.get_ssl_fingerprints()
self.sslversion = repos.getsslversion()
- self.delim = None
- self.root = None
+ self.delim = noneString()
+ self.root = noneString()
self.maxconnections = repos.getmaxconnections()
self.availableconnections = []
self.assignedconnections = []
@@ -103,26 +114,30 @@ class IMAPServer:
def __getpassword(self):
"""Returns the server password or None"""
- if self.goodpassword != None: # use cached good one first
+
+ if self.goodpassword.value != None: # use cached good one first
return self.goodpassword
- if self.password != None and self.passworderror == None:
+ if self.password.uni != None and self.passworderror.uni == None:
return self.password # non-failed preconfigured one
# get 1) configured password first 2) fall back to asking via UI
- self.password = self.repos.getpassword() or \
- self.ui.getpass(self.repos.getname(), self.config,
- self.passworderror)
- self.passworderror = None
+ self.password = self.repos.getpassword()
+ if not self.password.uni:
+ self.ui.getpass(self.repos.getname().uni, self.config,
+ self.passworderror.uni)
+ self.passworderror = noneString()
return self.password
- # XXX: is this function used anywhere?
+
def getroot(self):
"""Returns this server's folder root. Can only be called after one
or more calls to acquireconnection."""
return self.root
+ def getdelim(self):
+ return self.delim
def releaseconnection(self, connection, drop_conn=False):
"""Releases a connection, returning it to the pool.
@@ -130,7 +145,7 @@ class IMAPServer:
:param drop_conn: If True, the connection will be released and
not be reused. This can be used to indicate broken connections."""
- if connection is None: return #noop on bad connection
+ if connection is None: return # noop on bad connection
self.connectionlock.acquire()
self.assignedconnections.remove(connection)
# Don't reuse broken connections
@@ -142,44 +157,51 @@ class IMAPServer:
self.semaphore.release()
def __md5handler(self, response):
+ """This method is a hook. input/ouput are basic str python type."""
+
challenge = response.strip()
- self.ui.debug('imap', '__md5handler: got challenge %s'% challenge)
+ self.ui.debug('imap', u'__md5handler: got challenge %s'% challenge)
- passwd = self.__getpassword()
- retval = self.username + ' ' + hmac.new(passwd, challenge).hexdigest()
- self.ui.debug('imap', '__md5handler: returning %s'% retval)
+ passwd = self.__getpassword().value
+ retval = self.username.dbytes + ' ' + \
+ hmac.new(passwd, challenge).hexdigest()
+ self.ui.debug('imap', u'__md5handler: returning %s'% retval)
return retval
def __loginauth(self, imapobj):
""" Basic authentication via LOGIN command."""
- self.ui.debug('imap', 'Attempting IMAP LOGIN authentication')
- imapobj.login(self.username, self.__getpassword())
-
+ self.ui.debug('imap', u'Attempting IMAP LOGIN authentication')
+ imapobj.login(self.username.dbytes, self.__getpassword().dbytes)
def __plainhandler(self, response):
- """Implements SASL PLAIN authentication, RFC 4616,
- http://tools.ietf.org/html/rfc4616"""
+ """This method is a hook. input/ouput are basic str python type.
+
+ Implements SASL PLAIN authentication, RFC 4616,
+ http://tools.ietf.org/html/rfc4616
+ """
- authc = self.username
- passwd = self.__getpassword()
+ authc = self.username.dbytes
+ passwd = self.__getpassword().value
authz = ''
- if self.user_identity != None:
- authz = self.user_identity
- NULL = u'\x00'
- retval = NULL.join((authz, authc, passwd)).encode('utf-8')
- self.ui.debug('imap', '__plainhandler: returning %s' % retval)
+ if self.user_identity.uni != None:
+ authz = self.user_identity.imap
+ NULL = '\x00'
+ retval = NULL.join((authz, authc, passwd))
+ self.ui.debug('imap', u'__plainhandler: returning %s'%
+ dbytesString(retval).uni)
return retval
-
# XXX: describe function
def __gssauth(self, response):
+ """This method is a hook. input/ouput are basic str python type."""
+
data = base64.b64encode(response)
try:
if self.gss_step == self.GSS_STATE_STEP:
if not self.gss_vc:
rc, self.gss_vc = kerberos.authGSSClientInit(
- 'imap@' + self.hostname)
+ 'imap@' + self.hostname.dbytes)
response = kerberos.authGSSClientResponse(self.gss_vc)
rc = kerberos.authGSSClientStep(self.gss_vc, data)
if rc != kerberos.AUTH_GSS_CONTINUE:
@@ -188,12 +210,12 @@ class IMAPServer:
rc = kerberos.authGSSClientUnwrap(self.gss_vc, data)
response = kerberos.authGSSClientResponse(self.gss_vc)
rc = kerberos.authGSSClientWrap(
- self.gss_vc, response, self.username)
+ self.gss_vc, response, self.username.dbytes)
response = kerberos.authGSSClientResponse(self.gss_vc)
except kerberos.GSSError as err:
# Kerberos errored out on us, respond with None to cancel the
# authentication
- self.ui.debug('imap', '%s: %s'% (err[0][0], err[1][0]))
+ self.ui.debug('imap', u'%s: %s'% err[0][0], err[1][0])
return None
if not response:
@@ -203,7 +225,7 @@ class IMAPServer:
def __start_tls(self, imapobj):
if 'STARTTLS' in imapobj.capabilities and not self.usessl:
- self.ui.debug('imap', 'Using STARTTLS connection')
+ self.ui.debug('imap', u'Using STARTTLS connection')
try:
imapobj.starttls()
except imapobj.error as e:
@@ -305,7 +327,7 @@ class IMAPServer:
for m in mechs:
if m not in auth_methods:
raise Exception("Bad authentication method %s, "
- "please, file OfflineIMAP bug" % m)
+ "please, file OfflineIMAP bug"% m)
func, tryTLS, check_cap = auth_methods[m]
@@ -321,13 +343,12 @@ class IMAPServer:
continue
tried_to_authn = True
- self.ui.debug('imap', u'Attempting '
- '%s authentication'% m)
+ self.ui.debug('imap', u'Attempting %s authentication'% m)
try:
if func(imapobj):
return
except (imapobj.error, OfflineImapError) as e:
- self.ui.warn('%s authentication failed: %s'% (m, e))
+ self.ui.warn(u'%s authentication failed: %s'% (m, e))
exc_stack.append((m, e))
if len(exc_stack):
@@ -343,14 +364,13 @@ class IMAPServer:
lambda x: x[5:], filter(lambda x: x[0:5] == "AUTH=",
imapobj.capabilities)
))
- raise OfflineImapError(u"Repository %s: no supported "
+ raise OfflineImapError("Repository %s: no supported "
"authentication mechanisms found; configured %s, "
- "server advertises %s"% (self.repos,
+ "server advertises %s"% (self.repos.getname().fs,
", ".join(self.authmechs), methods),
OfflineImapError.ERROR.REPO)
- # XXX: move above, closer to releaseconnection()
def acquireconnection(self):
"""Fetches a connection from the pool, making sure to create a new one
if needed, to obey the maximum connection limits, etc.
@@ -359,7 +379,7 @@ class IMAPServer:
self.semaphore.acquire()
self.connectionlock.acquire()
- curThread = currentThread()
+ curThread = currentThread() # .getNames() -> 'Account sync $accountname'
imapobj = None
if len(self.availableconnections): # One is available.
@@ -385,40 +405,48 @@ class IMAPServer:
# Must be careful here that if we fail we should bail out gracefully
# and release locks / threads so that the next attempt can try...
- success = 0
+ success = False
try:
while not success:
# Generate a new connection.
- if self.tunnel:
- self.ui.connecting('tunnel', self.tunnel)
- imapobj = imaplibutil.IMAP4_Tunnel(self.tunnel,
- timeout=socket.getdefaulttimeout())
- success = 1
+ # 0. tunnel
+ if self.tunnel.uni:
+ self.ui.connecting(u'tunnel', self.tunnel.uni)
+ imapobj = imaplibutil.IMAP4_Tunnel(self.tunnel.uni,
+ timeout=socket.getdefaulttimeout())
+ success = True
+ # 1. tunnel
elif self.usessl:
- self.ui.connecting(self.hostname, self.port)
- imapobj = imaplibutil.WrappedIMAP4_SSL(self.hostname,
- self.port,
- self.sslclientkey,
- self.sslclientcert,
- self.sslcacertfile,
- self.__verifycert,
- self.sslversion,
- timeout=socket.getdefaulttimeout(),
- fingerprint=self.fingerprint
- )
+ self.ui.connecting(self.hostname.uni, self.port)
+ imapobj = imaplibutil.WrappedIMAP4_SSL(
+ self.hostname.dbytes,
+ self.port,
+ self.sslclientkey.dbytes,
+ self.sslclientcert.dbytes,
+ self.sslcacertfile.fs,
+ self.__verifycert,
+ self.sslversion.dbytes,
+ timeout=socket.getdefaulttimeout(),
+ fingerprint=self.fingerprints
+ )
+ # 2. ?
else:
- self.ui.connecting(self.hostname, self.port)
- imapobj = imaplibutil.WrappedIMAP4(self.hostname, self.port,
- timeout=socket.getdefaulttimeout())
-
- if not self.preauth_tunnel:
+ self.ui.connecting(self.hostname.uni, self.port)
+ imapobj = imaplibutil.WrappedIMAP4(
+ self.hostname.dbytes,
+ self.port,
+ timeout=socket.getdefaulttimeout())
+
+ # 3. authn helper
+ if not self.preauth_tunnel.uni:
try:
self.__authn_helper(imapobj)
self.goodpassword = self.password
- success = 1
+ success = True
except OfflineImapError as e:
- self.passworderror = str(e)
+ self.passworderror = fsString("%s"% e)
raise
+ # Ok, we could login.
# Enable compression
if self.repos.getconfboolean('usecompression', 0):
@@ -429,29 +457,30 @@ class IMAPServer:
if dat != [None]:
imapobj.capabilities = tuple(dat[-1].upper().split())
- if self.delim == None:
- listres = imapobj.list(self.reference, '""')[1]
+ if self.delim.uni == None:
+ listres = imapobj.list(self.reference.imap, '""')[1]
if listres == [None] or listres == None:
# Some buggy IMAP servers do not respond well to LIST "" ""
# Work around them.
- listres = imapobj.list(self.reference, '"*"')[1]
+ listres = imapobj.list(self.reference.imap, '"*"')[1]
if listres == [None] or listres == None:
# No Folders were returned. This occurs, e.g. if the
# 'reference' prefix does not exist on the mail
# server. Raise exception.
- err = "Server '%s' returned no folders in '%s'"% \
- (self.repos.getname(), self.reference)
- self.ui.warn(err)
- raise Exception(err)
- self.delim, self.root = \
- imaputil.imapsplit(listres[0])[1:]
- self.delim = imaputil.dequote(self.delim)
- self.root = imaputil.dequote(self.root)
+ err = uniString(u"Server '%s' returned no folders in '%s'"%
+ (self.repos.getname().uni, self.reference.uni))
+ self.ui.warn(err.uni)
+ raise Exception(err.fs)
+ imap_delim, imap_root = \
+ imaputil.imapsplit(listres[0])[1:]
+ self.delim = imapString(imaputil.dequote(imap_delim))
+ self.root = imapString(imaputil.dequote(imap_root))
with self.connectionlock:
self.assignedconnections.append(imapobj)
self.lastowner[imapobj] = curThread.ident
return imapobj
+
except Exception as e:
"""If we are here then we did not succeed in getting a
connection - we should clean up and then re-raise the
@@ -466,7 +495,7 @@ class IMAPServer:
reason = "Could not resolve name '%s' for repository "\
"'%s'. Make sure you have configured the ser"\
"ver name correctly and that you are online."%\
- (self.hostname, self.repos)
+ (self.hostname.fs, self.repos.getname().fs)
raise OfflineImapError(reason, severity), None, exc_info()[2]
elif isinstance(e, SSLError) and e.errno == errno.EPERM:
@@ -475,11 +504,11 @@ class IMAPServer:
if self.port != 993:
reason = "Could not connect via SSL to host '%s' and non-s"\
"tandard ssl port %d configured. Make sure you connect"\
- " to the correct port."% (self.hostname, self.port)
+ " to the correct port."% (self.hostname.fs, self.port)
else:
reason = "Unknown SSL protocol connecting to host '%s' for "\
- "repository '%s'. OpenSSL responded:\n%s"\
- % (self.hostname, self.repos, e)
+ "repository '%s'. OpenSSL responded:\n%s"%\
+ (self.hostname.fs, self.repos.getname().fs, e)
raise OfflineImapError(reason, severity), None, exc_info()[2]
elif isinstance(e, socket.error) and e.args[0] == errno.ECONNREFUSED:
@@ -488,14 +517,15 @@ class IMAPServer:
reason = "Connection to host '%s:%d' for repository '%s' was "\
"refused. Make sure you have the right host and port "\
"configured and that you are actually able to access the "\
- "network."% (self.hostname, self.port, self.repos)
+ "network."% (self.hostname.fs, self.port,
+ self.repos.getname().fs)
raise OfflineImapError(reason, severity), None, exc_info()[2]
# Could not acquire connection to the remote;
# socket.error(last_error) raised
if str(e)[:24] == "can't open socket; error":
- raise OfflineImapError("Could not connect to remote server '%s' "\
- "for repository '%s'. Remote does not answer."
- % (self.hostname, self.repos),
+ raise OfflineImapError("Could not connect to remote server '%s' "
+ "for repository '%s'. Remote does not answer."%
+ (self.hostname.fs, self.repos.getname().fs),
OfflineImapError.ERROR.REPO), None, exc_info()[2]
else:
# re-raise all other errors
@@ -541,7 +571,7 @@ class IMAPServer:
is expected to be invoked in a separate thread, which should be join()'d
after the event is set."""
- self.ui.debug('imap', 'keepalive thread started')
+ self.ui.debug('imap', u'keepalive thread started')
while not event.isSet():
self.connectionlock.acquire()
numconnections = len(self.assignedconnections) + \
@@ -550,7 +580,8 @@ class IMAPServer:
threads = []
for i in range(numconnections):
- self.ui.debug('imap', 'keepalive: processing connection %d of %d'% (i, numconnections))
+ self.ui.debug('imap', u'keepalive: processing connection '
+ '%d of %d'% (i, numconnections))
if len(self.idlefolders) > i:
# IDLE thread
idler = IdleThread(self, self.idlefolders[i])
@@ -560,23 +591,26 @@ class IMAPServer:
idler.start()
threads.append(idler)
- self.ui.debug('imap', 'keepalive: waiting for timeout')
+ self.ui.debug('imap', u'keepalive: waiting for timeout')
event.wait(timeout)
- self.ui.debug('imap', 'keepalive: after wait')
+ self.ui.debug('imap', u'keepalive: after wait')
for idler in threads:
# Make sure all the commands have completed.
idler.stop()
idler.join()
- self.ui.debug('imap', 'keepalive: all threads joined')
- self.ui.debug('imap', 'keepalive: event is set; exiting')
+ self.ui.debug('imap', u'keepalive: all threads joined')
+ self.ui.debug('imap', u'keepalive: event is set; exiting')
return
def __verifycert(self, cert, hostname):
"""Verify that cert (in socket.getpeercert() format) matches hostname.
CRLs are not handled.
- Returns error message if any problems are found and None on success."""
+ Returns error message if any problems are found and None on success.
+
+ We don't call this function ourself. It is passed to low-level drivers
+ as a hook. Do NOT work with unicode nor uni String, here."""
errstr = "CA Cert verifying failed: "
if not cert:
@@ -616,15 +650,26 @@ class IdleThread(object):
def __init__(self, parent, folder=None):
"""If invoked without 'folder', perform a NOOP and wait for
self.stop() to be called. If invoked with folder, switch to IDLE
- mode and synchronize once we have a new message"""
+ mode and synchronize once we have a new message.
+
+ XXX: requires better class comments:
+ - why is it here?
+ - what is threaded?
+ IOW, explain WHAT it does and HOW it works.
+ The name is lying around. It is composed with Thread, it doesn't inherit from
+ a Thread class/subclass. Call it IdleMode, IdleSync or whatever but NOT
+ IdleTread."""
self.parent = parent
self.folder = folder
self.stop_sig = Event()
self.ui = getglobalui()
- if folder is None:
+ if folder.uni is None:
self.thread = Thread(target=self.noop)
else:
+ # Oh no... Passing a 'hidden' function to something outside is BAD.
+ # It's like accessing a private method/attribute of an encapsulated
+ # object...
self.thread = Thread(target=self.__idle)
self.thread.setDaemon(1)
@@ -648,7 +693,7 @@ class IdleThread(object):
try:
imapobj.noop()
except imapobj.abort:
- self.ui.warn('Attempting NOOP on dropped connection %s'%
+ self.ui.warn(u'Attempting NOOP on dropped connection %s'%
imapobj.identifier)
self.parent.releaseconnection(imapobj, True)
imapobj = None
@@ -665,17 +710,20 @@ class IdleThread(object):
statusrepos = account.statusrepos
remotefolder = remoterepos.getfolder(self.folder)
- hook = account.getconf('presynchook', '')
+ hook = uniString(account.getconf('presynchook', ''))
account.callhook(hook)
+
offlineimap.accounts.syncfolder(account, remotefolder, quick=False)
- hook = account.getconf('postsynchook', '')
+
+ hook = uniString(account.getconf('postsynchook', ''))
account.callhook(hook)
ui = getglobalui()
- ui.unregisterthread(currentThread()) #syncfolder registered the thread
+ ui.unregisterthread(currentThread()) # syncfolder registered the thread
def __idle(self):
- """Invoke IDLE mode until timeout or self.stop() is invoked"""
+ """Invoke IDLE mode until timeout or self.stop() is invoked."""
+
def callback(args):
"""IDLE callback function invoked by imaplib2
@@ -683,6 +731,7 @@ class IdleThread(object):
while in IDLE mode, b) we get an Exception (e.g. on dropped
connections, or c) the standard imaplib IDLE timeout of 29
minutes kicks in."""
+
result, cb_arg, exc_data = args
if exc_data is None and not self.stop_sig.isSet():
# No Exception, and we are not supposed to stop:
@@ -696,7 +745,7 @@ class IdleThread(object):
while not success:
imapobj = self.parent.acquireconnection()
try:
- imapobj.select(self.folder)
+ imapobj.select(self.folder.imap)
except OfflineImapError as e:
if e.severity == OfflineImapError.ERROR.FOLDER_RETRY:
# Connection closed, release connection and retry
@@ -709,7 +758,7 @@ class IdleThread(object):
if "IDLE" in imapobj.capabilities:
imapobj.idle(callback=callback)
else:
- self.ui.warn("IMAP IDLE not supported on server '%s'."
+ self.ui.warn(u"IMAP IDLE not supported on server '%s'."
"Sleep until next refresh cycle."% imapobj.identifier)
imapobj.noop()
self.stop_sig.wait() # self.stop() or IDLE callback are invoked
@@ -717,7 +766,7 @@ class IdleThread(object):
# End IDLE mode with noop, imapobj can point to a dropped conn.
imapobj.noop()
except imapobj.abort:
- self.ui.warn('Attempting NOOP on dropped connection %s'%
+ self.ui.warn(u'Attempting NOOP on dropped connection %s'%
imapobj.identifier)
self.parent.releaseconnection(imapobj, True)
else:
diff --git a/offlineimap/imaputil.py b/offlineimap/imaputil.py
index f1f287b..e77affb 100644
--- a/offlineimap/imaputil.py
+++ b/offlineimap/imaputil.py
@@ -17,8 +17,13 @@
import re
import string
+
from offlineimap.ui import getglobalui
+#
+# UNICODE: This module makes low-level jobs for IMAP objects. Do NOT import uni
+# module. Everything is expected IMAP encoded.
+#
## Globals
@@ -30,7 +35,7 @@ def __debug(*args):
msg = []
for arg in args:
msg.append(str(arg))
- getglobalui().debug('imap', " ".join(msg))
+ getglobalui().debug('imap', u" ".join(msg))
def dequote(s):
"""Takes string which may or may not be quoted and unquotes it.
@@ -77,7 +82,7 @@ def __options2hash(list):
while (counter < len(list)):
retval[list[counter]] = list[counter + 1]
counter += 2
- __debug("__options2hash returning:", retval)
+ __debug(u"__options2hash returning:", retval)
return retval
def flags2hash(flags):
@@ -99,7 +104,7 @@ def imapsplit(imapstring):
['(\\HasNoChildren)', '"."', '"INBOX.Sent"']"""
if not isinstance(imapstring, basestring):
- __debug("imapsplit() got a non-string input; working around.")
+ __debug(u"imapsplit() got a non-string input; working around.")
# Sometimes, imaplib will throw us a tuple if the input
# contains a literal. See Python bug
# #619732 at https://sourceforge.net/tracker/index.php?func=detail&aid=619732&group_id=5470&atid=105470
@@ -121,7 +126,7 @@ def imapsplit(imapstring):
arg = arg.replace('\\', '\\\\')
arg = arg.replace('"', '\\"')
arg = '"%s"' % arg
- __debug("imapsplit() non-string [%d]: Appending %s"% (i, arg))
+ __debug(u"imapsplit() non-string [%d]: Appending %s"% (i, arg))
retval.append(arg)
else:
# Even -- we have a string that ends with a literal
@@ -130,10 +135,10 @@ def imapsplit(imapstring):
# Recursion to the rescue.
arg = imapstring[i]
arg = re.sub('\{\d+\}$', '', arg)
- __debug("imapsplit() non-string [%d]: Feeding %s to recursion"%\
+ __debug(u"imapsplit() non-string [%d]: Feeding %s to recursion"%
(i, arg))
retval.extend(imapsplit(arg))
- __debug("imapsplit() non-string: returning %s" % str(retval))
+ __debug(u"imapsplit() non-string: returning %s"% str(retval))
return retval
workstr = imapstring.strip()
@@ -254,7 +259,8 @@ def __split_quoted(s):
while True:
next_q = rest.find(q)
if next_q == -1:
- raise ValueError("can't find ending quote '%s' in '%s'"% (q, s))
+ raise ValueError("can't find ending quote '%s' in '%s'"%
+ (q, s))
# If quote is preceeded by even number of backslashes,
# then it is the ending quote, otherwise the quote
# character is escaped by backslash, so we should
diff --git a/offlineimap/init.py b/offlineimap/init.py
index 7f6a679..25b1bcd 100644
--- a/offlineimap/init.py
+++ b/offlineimap/init.py
@@ -22,14 +22,17 @@ import offlineimap.imaplib2 as imaplib
import signal
import socket
import logging
-from optparse import OptionParser
+import codecs
+from optparse import OptionParser, SUPPRESS_HELP
import offlineimap
-from offlineimap import accounts, threadutil, syncmaster
from offlineimap import globals
+from offlineimap import accounts, threadutil, syncmaster
from offlineimap.ui import UI_LIST, setglobalui, getglobalui
from offlineimap.CustomConfig import CustomConfigParser
-from offlineimap.utils import stacktrace
+from offlineimap.utils import stacktrace, uni
+from offlineimap.utils.uni import fsString, uniString, isASCII
+from offlineimap.utils import hack
class OfflineImap:
@@ -52,9 +55,8 @@ class OfflineImap:
def __parse_cmd_options(self):
parser = OptionParser(version=offlineimap.__bigversion__,
- description="%s.\n\n%s" %
- (offlineimap.__copyright__,
- offlineimap.__license__))
+ description="%s.\n\n%s" %
+ (offlineimap.__copyright__, offlineimap.__license__))
parser.add_option("--dry-run",
action="store_true", dest="dryrun",
default=False,
@@ -82,6 +84,15 @@ class OfflineImap:
"maxsyncaccounts and all maxconnections configuration file "
"variables to 1.")
+ parser.add_option("--unicode", dest="unicode_help",
+ action='store_true',
+ help="Enable Unicode support (EXPERIMENTAL).")
+ parser.add_option("--enable-unicode",
+ action='store_true', dest='use_unicode', help=SUPPRESS_HELP)
+ parser.add_option("--no-unicode",
+ action='store_false', dest='use_unicode',
+ help="Disable Unicode support (default).")
+
parser.add_option("-P", dest="profiledir", metavar="DIR",
help="Sets OfflineIMAP into profile mode. The program "
"will create DIR (it must not already exist). "
@@ -92,7 +103,8 @@ class OfflineImap:
"specific reason to do so. It will significantly "
"decrease program performance, may reduce reliability, "
"and can generate huge amounts of data. This option "
- "implies the -1 option.")
+ "implies the -1 option. "
+ "Support only ASCII encoded path.")
parser.add_option("-a", dest="accounts", metavar="ACCOUNTS",
help="Overrides the accounts section in the config file. "
@@ -123,6 +135,7 @@ class OfflineImap:
help="Log to FILE")
parser.add_option("-f", dest="folders", metavar="folder1,[folder2...]",
+ type=str,
help="Only sync the specified folders. The folder names "
"are the *untranslated* foldernames of the remote repository. "
"This command-line option overrides any 'folderfilter' "
@@ -130,6 +143,7 @@ class OfflineImap:
parser.add_option("-k", dest="configoverride",
action="append",
+ type=str,
metavar="[section:]option=value",
help=
"""Override configuration file option. If"section" is
@@ -161,71 +175,96 @@ class OfflineImap:
"not usable. Possible interface choices are: %s " %
", ".join(UI_LIST.keys()))
+ parser.set_defaults(use_unicode=False)
(options, args) = parser.parse_args()
- globals.set_options (options)
+ # UNICODE: REMEMBER that globals.options keeps options filesystem encoded.
+ globals.set_options(options)
+ # Set unicode context as early as possible! This impacts a lot of
+ # things.
+ uni.set_unicode_context(options.use_unicode)
- #read in configuration file
+ if options.unicode_help:
+ uni.help_message()
+ sys.exit(0)
+
+ # Read in configuration file.
if not options.configfile:
+ # Keep options.configfile is str filesystem encoded.
# Try XDG location, then fall back to ~/.offlineimaprc
- xdg_var = 'XDG_CONFIG_HOME'
- if not xdg_var in os.environ or not os.environ[xdg_var]:
- xdg_home = os.path.expanduser('~/.config')
+ xdg_var_fs = 'XDG_CONFIG_HOME'
+ # Expansion on non-ASCII HOME path might be hurting.
+ xdg_home_default = uniString(u'~/.config')
+ configfilename_default = uniString(u'~/.offlineimaprc')
+ # Elements of os.environ are filesystem encoded.
+ if not xdg_var_fs in os.environ or not os.environ[xdg_var_fs]:
+ # os.path.expanduser keeps given encoding.
+ xdg_home = fsString(os.path.expanduser(xdg_home_default.fs))
else:
- xdg_home = os.environ[xdg_var]
- options.configfile = os.path.join(xdg_home, "offlineimap", "config")
+ xdg_home = fsString(os.environ[xdg_var_fs])
+ options.configfile = os.path.join(xdg_home.fs, "offlineimap", "config")
if not os.path.exists(options.configfile):
- options.configfile = os.path.expanduser('~/.offlineimaprc')
- configfilename = options.configfile
+ options.configfile = os.path.expanduser(configfilename_default.fs)
+ configfilename = fsString(options.configfile)
else:
- configfilename = os.path.expanduser(options.configfile)
+ configfilename = fsString(os.path.expanduser(options.configfile))
config = CustomConfigParser()
- 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!"%
- configfilename)
+
+ if not os.path.exists(configfilename.fs):
+ # TODO, initialize and make use of chosen ui for logging.
+ logging.error(u" *** Config file '%s' does not exist; aborting!"%
+ configfilename.uni)
sys.exit(1)
- config.read(configfilename)
+ if uni.use_unicode():
+ config.readfp(codecs.open(configfilename.fs, 'rt', uni.ENCODING))
+ else:
+ config.read(configfilename.fs)
- #profile mode chosen?
+ # Profile mode chosen?
if options.profiledir:
+ profiledir = fsString(options.profiledir)
if not options.singlethreading:
# TODO, make use of chosen ui for logging
- logging.warn("Profile mode: Forcing to singlethreaded.")
+ logging.warn(u"Profile mode: Forcing to singlethreaded.")
options.singlethreading = True
- if os.path.exists(options.profiledir):
+ if os.path.exists(profiledir.fs):
# TODO, make use of chosen ui for logging
- logging.warn("Profile mode: Directory '%s' already exists!"%
- options.profiledir)
+ logging.warn(u"Profile mode: Directory '%s' already exists!"%
+ profiledir.uni)
else:
- os.mkdir(options.profiledir)
- threadutil.ExitNotifyThread.set_profiledir(options.profiledir)
+ os.mkdir(profiledir.fs)
+ # profiledir is still str filesystem encoded, change that.
+ threadutil.ExitNotifyThread.set_profiledir(profiledir)
# TODO, make use of chosen ui for logging
- logging.warn("Profile mode: Potentially large data will be "
- "created in '%s'"% options.profiledir)
+ logging.warn(u"Profile mode: Potentially large data will be "
+ "created in '%s'"% profiledir.fs)
- #override a config value
+ # Override a config value.
if options.configoverride:
- for option in options.configoverride:
+ configoverride = fsString(options.configoverride)
+ for option in configoverride.uni:
(key, value) = option.split('=', 1)
if ':' in key:
(secname, key) = key.split(':', 1)
section = secname.replace("_", " ")
else:
section = "general"
- config.set(section, key, value)
+ # Configuration file is Unicode.
+ config.set(uniString(section).uni, uniString(key).uni,
+ uniString(value).uni)
- #which ui to use? cmd line option overrides config file
- ui_type = config.getdefault('general', 'ui', 'ttyui')
+ # Which ui to use? cmd line option overrides config file.
+ ui_type = uniString(config.getdefault('general', 'ui', 'ttyui'))
if options.interface != None:
- ui_type = options.interface
- if '.' in ui_type:
- #transform Curses.Blinkenlights -> Blinkenlights
- ui_type = ui_type.split('.')[-1]
+ ui_type.fs = options.interface
+ if '.' in ui_type.uni:
+ # Transform Curses.Blinkenlights -> Blinkenlights
+ ui_type.uni = ui_type.split('.')[-1]
# TODO, make use of chosen ui for logging
- logging.warning('Using old interface name, consider using one '
- 'of %s'% ', '.join(UI_LIST.keys()))
- if options.diagnostics: ui_type = 'basic' # enforce basic UI for --info
+ logging.warn(u'Using old interface name, consider using one '
+ 'of %s'% ', '.join(UI_LIST.keys()))
+ if options.diagnostics:
+ ui_type.uni = u'basic' # enforce basic UI for --info
# dry-run? Set [general]dry-run=True
if options.dryrun:
@@ -233,79 +272,96 @@ class OfflineImap:
config.set_if_not_exists('general', 'dry-run', 'False')
try:
- # create the ui class
- self.ui = UI_LIST[ui_type.lower()](config)
+ # Create the ui class.
+ self.ui = UI_LIST[ui_type.dbytes.lower()](config)
except KeyError:
- logging.error("UI '%s' does not exist, choose one of: %s"% \
- (ui_type, ', '.join(UI_LIST.keys())))
+ logging.error(u"UI '%s' does not exist, choose one of: %s"%
+ (ui_type.fs, ', '.join(UI_LIST.keys())))
sys.exit(1)
setglobalui(self.ui)
- #set up additional log files
+ # Set up additional log files.
if options.logfile:
- self.ui.setlogfile(options.logfile)
+ self.ui.setlogfile(fsString(options.logfile))
- #welcome blurb
+ # Welcome blurb.
self.ui.init_banner()
+ if options.use_unicode:
+ self.ui.info(u"*** Unicode support is enabled ***")
if options.debugtype:
self.ui.logger.setLevel(logging.DEBUG)
if options.debugtype.lower() == 'all':
options.debugtype = 'imap,maildir,thread'
- #force single threading?
+ # Force single threading?
if not ('thread' in options.debugtype.split(',') \
and not options.singlethreading):
- self.ui._msg("Debug mode: Forcing to singlethreaded.")
+ self.ui._msg(u"Debug mode: Forcing to singlethreaded.")
options.singlethreading = True
debugtypes = options.debugtype.split(',') + ['']
for dtype in debugtypes:
dtype = dtype.strip()
self.ui.add_debug(dtype)
- if dtype.lower() == u'imap':
+ if dtype.lower() == 'imap':
imaplib.Debug = 5
if options.runonce:
- # FIXME: spaghetti code alert!
+ # It's not possible to get that from config, instead?
+ # XXX: warn about what we do.
for section in accounts.getaccountlist(config):
config.remove_option('Account ' + section, "autorefresh")
if options.quick:
+ # It's not possible to get that from config, instead?
+ # XXX: warn about what we do.
for section in accounts.getaccountlist(config):
config.set('Account ' + section, "quick", '-1')
- #custom folder list specified?
+ # Custom folder list specified?
if options.folders:
- foldernames = options.folders.split(",")
- folderfilter = "lambda f: f in %s"% foldernames
+ # Each folder is filesystem encoded, change that.
+ foldernames = []
+ for fs_foldername in options.folders.split(","):
+ foldernames.append(fsString(fs_foldername).uni)
+
+ folderfilter = uniString(u"lambda f: f in %s"% foldernames)
folderincludes = "[]"
+ # accountname is full ASCII in unicode.
+ # It's not possible to get that from config, instead?
for accountname in accounts.getaccountlist(config):
- account_section = 'Account ' + accountname
- remote_repo_section = 'Repository ' + \
- config.get(account_section, 'remoterepository')
- config.set(remote_repo_section, "folderfilter", folderfilter)
+ uni_account_section = u'Account ' + accountname.uni
+ remoterepository = uniString(
+ config.get(uni_account_section, 'remoterepository'))
+ remote_repo_section = u'Repository ' + remoterepository.uni
+ config.set(remote_repo_section, u"folderfilter", folderfilter)
config.set(remote_repo_section, "folderincludes",
- folderincludes)
+ folderincludes)
if options.logfile:
- sys.stderr = self.ui.logfile
+ # sys.stderr expects filesystem encoding. The erasing should honor
+ # this encoding.
+ sys.stderr = codecs.open(self.ui.logfile, 'wb', uni.FS_ENCODING)
socktimeout = config.getdefaultint("general", "socktimeout", 0)
if socktimeout > 0:
socket.setdefaulttimeout(socktimeout)
- threadutil.initInstanceLimit('ACCOUNTLIMIT',
+ threadutil.initInstanceLimit(uniString(u'ACCOUNTLIMIT'),
config.getdefaultint('general', 'maxsyncaccounts', 1))
for reposname in config.getsectionlist('Repository'):
- for instancename in ["FOLDER_" + reposname,
- "MSGCOPY_" + reposname]:
+ # FIXME: What's that (FOLDER_, MSGCOPY_)?
+ # Boing! concatenation of str on list?
+ # ...Oh, yeah... forgot we have magic python for OfflineImap! :-D
+ for instancename in [u"FOLDER_" + reposname, u"MSGCOPY_" + reposname]:
if options.singlethreading:
- threadutil.initInstanceLimit(instancename, 1)
+ threadutil.initInstanceLimit(uniString(instancename), 1)
else:
- threadutil.initInstanceLimit(instancename,
+ threadutil.initInstanceLimit(uniString(instancename),
config.getdefaultint('Repository ' + reposname,
- 'maxconnections', 2))
+ 'maxconnections', 2))
+
self.config = config
return (options, args)
@@ -314,36 +370,47 @@ class OfflineImap:
self.config is supposed to have been correctly initialized
already."""
+
try:
- pidfd = open(self.config.getmetadatadir() + "/pid", "w")
+ pidfd = open(self.config.getmetadatadir().fs + "/pid", "w")
pidfd.write(str(os.getpid()) + "\n")
pidfd.close()
except:
pass
try:
- # Honor CLI --account option, only.
- # Accounts to sync are put into syncaccounts variable.
- activeaccounts = self.config.get("general", "accounts")
+ # Honor CLI --account option.
+ activeaccounts = uniString(self.config.get("general", "accounts"))
+ # Check all declared accounts are full ASCII.
+ # FIXME: put this into CustomConfigParser.
+ isASCII(activeaccounts.uni, exception_msg=
+ "configuration: non ASCII character in accounts")
if options.accounts:
- activeaccounts = options.accounts
+ activeaccounts = fsString(options.accounts)
+ # Remove whitespaces.
activeaccounts = activeaccounts.replace(" ", "")
+ # Make it a list with unicode values.
activeaccounts = activeaccounts.split(",")
+ # Dict of instanciated accounts with (unicode) account name as key.
+ # FIXME: why would we need to get instanciated accounts here? Hmm...
+ # ...Oh, yeah... forgot we have magic logic too! :-o
allaccounts = accounts.AccountHashGenerator(self.config)
+ # Accounts to sync are put into syncaccounts, a list of (unicode)
+ # values.
syncaccounts = []
- for account in activeaccounts:
- if account not in allaccounts:
+ for accountname in activeaccounts:
+ if accountname.uni not in allaccounts:
if len(allaccounts) == 0:
- errormsg = "The account '%s' does not exist because no" \
- " accounts are defined!"% account
+ uni_errormsg = (u"The account '%s' does not exist because no"
+ " accounts are defined!"% accountname.uni)
else:
- errormsg = "The account '%s' does not exist. Valid ac" \
- "counts are: %s"% \
- (account, ", ".join(allaccounts.keys()))
- self.ui.terminate(1, errormsg=errormsg)
- if account not in syncaccounts:
- syncaccounts.append(account)
+ uni_errormsg = (u"The account '%s' does not exist. Valid ac"
+ "counts are: %s"% (accountname.uni,
+ u", ".join([a.uni for a in allaccounts])))
+ self.ui.terminate(1, errormsg=uni_errormsg)
+ if accountname not in syncaccounts:
+ syncaccounts.append(accountname)
def sig_handler(sig, frame):
if sig == signal.SIGUSR1:
@@ -355,8 +422,8 @@ class OfflineImap:
accounts.Account.set_abort_event(self.config, 2)
elif sig in (signal.SIGTERM, signal.SIGINT, signal.SIGHUP):
# tell each account to ABORT ASAP (ctrl-c)
- getglobalui().warn("Terminating NOW (this may "\
- "take a few seconds)...")
+ getglobalui().warn("Terminating NOW (this may "
+ "take a few seconds)...")
accounts.Account.set_abort_event(self.config, 3)
elif sig == signal.SIGQUIT:
stacktrace.dump(sys.stderr)
@@ -369,44 +436,53 @@ class OfflineImap:
signal.signal(signal.SIGINT, sig_handler)
signal.signal(signal.SIGQUIT, sig_handler)
- #various initializations that need to be performed:
+ # Various initializations that need to be performed:
+ # XXX: is there any reason to no import mbnames in imports?
offlineimap.mbnames.init(self.config, syncaccounts)
if options.singlethreading:
- #singlethreaded
+ # singlethreaded
self.__sync_singlethreaded(syncaccounts)
else:
# multithreaded
+ # ExitNotifyThread is inherited from threading.Thread.
t = threadutil.ExitNotifyThread(target=syncmaster.syncitall,
- name='Sync Runner',
- kwargs = {'accounts': syncaccounts,
- 'config': self.config})
+ name='Sync Runner',
+ kwargs={'accounts': syncaccounts, 'config': self.config})
t.start()
threadutil.exitnotifymonitorloop(threadutil.threadexited)
self.ui.terminate()
except (SystemExit):
raise
except Exception as e:
+ # FIXME: UNICODE: This helps having good traces. There are some
+ # Exception with missing of full traces or other informations when
+ # not set. This should be improved.
+ if uni.use_unicode():
+ hack.inspect_crash()
+ raise
self.ui.error(e)
self.ui.terminate()
def __sync_singlethreaded(self, accs):
"""Executed if we do not want a separate syncmaster thread
- :param accs: A list of accounts that should be synced
- """
+ :param accs: A list of accounts that should be synced."""
+
for accountname in accs:
account = offlineimap.accounts.SyncableAccount(self.config,
- accountname)
- threading.currentThread().name = "Account sync %s"% accountname
+ accountname)
+ threading.currentThread().name = "Account sync %s"% accountname.dbytes
account.syncrunner()
def __serverdiagnostics(self, options):
- activeaccounts = self.config.get("general", "accounts")
+ """Start server diagnostic for active accounts."""
+
+ activeaccounts = uniString(self.config.get("general", "accounts"))
if options.accounts:
- activeaccounts = options.accounts
+ activeaccounts = fsString(options.accounts)
activeaccounts = activeaccounts.split(",")
allaccounts = accounts.AccountListGenerator(self.config)
for account in allaccounts:
- if account.name not in activeaccounts: continue
+ if account.getname() not in activeaccounts: continue
account.serverdiagnostics()
diff --git a/offlineimap/localeval.py b/offlineimap/localeval.py
index a9494fb..2188fdd 100644
--- a/offlineimap/localeval.py
+++ b/offlineimap/localeval.py
@@ -17,6 +17,10 @@
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
import imp
+import codecs
+
+from offlineimap.utils import uni
+from offlineimap.utils.uni import noneString
try:
import errno
except:
@@ -25,24 +29,31 @@ except:
class LocalEval:
"""Here is a powerfull but very dangerous option, of course."""
- def __init__(self, path=None):
+ def __init__(self, path=noneString):
self.namespace = {}
- if path is not None:
+ if path.uni is not None:
# FIXME: limit opening files owned by current user with rights set
# to fixed mode 644.
- foo = open(path, 'r')
+ if uni.use_unicode():
+ foo = codecs.open(path.fs, 'r', uni.ENCODING)
+ else:
+ foo = open(path.fs, 'r')
module = imp.load_module(
'<none>',
foo,
- path,
+ path.fs,
('', 'r', imp.PY_SOURCE))
for attr in dir(module):
self.namespace[attr] = getattr(module, attr)
def eval(self, text, namespace=None):
+ """eval() builtin use Latin-1 or UTF-8 arguments, also does this one.
+
+ :param: text is a uni object."""
+
names = {}
names.update(self.namespace)
if namespace is not None:
names.update(namespace)
- return eval(text, names)
+ return eval(text.uni, names)
diff --git a/offlineimap/mbnames.py b/offlineimap/mbnames.py
index 936a110..bf095d2 100644
--- a/offlineimap/mbnames.py
+++ b/offlineimap/mbnames.py
@@ -19,67 +19,113 @@
import os.path
import re # for folderfilter
from threading import Lock
+import codecs
+from offlineimap.utils import uni
+from offlineimap.utils.uni import uniString
+
+
+# Format of boxes is:
+# - keys: account names (uni objects)
+# - values: list of folder names (uni objects)
boxes = {}
+# Format of localroots is:
+# - keys: account names (uni objects)
+# - values: list of local repository roots (uni objects)
localroots = {}
-config = None
+# List of (unicode) (sync)-account names.
accounts = None
+
+config = None
mblock = Lock()
def init(conf, accts):
+ """Initialize mbnames.
+
+ :param accts: list of (unicode) (syncable) accounts.
+ """
+
global config, accounts
config = conf
accounts = accts
def add(accountname, foldername, localfolders):
+ """Add the infos to the boxes and localroots variables."""
+
if not accountname in boxes:
- boxes[accountname] = []
+ boxes[accountname] = [] # Add account name key if missing.
+ # XXX: Erase (?) local repository root.
localroots[accountname] = localfolders
if not foldername in boxes[accountname]:
+ # Add folder name to the list.
boxes[accountname].append(foldername)
def write():
# See if we're ready to write it out.
- for account in accounts:
- if account not in boxes:
+ for uni_accountname in accounts:
+ if uni_accountname not in boxes:
return
__genmbnames()
def __genmbnames():
- """Takes a configparser object and a boxlist, which is a list of hashes
- containing 'accountname' and 'foldername' keys."""
+ """Takes a configparser object and a boxlist, which is a list of dicts
+ containing 'accountname.uni' and 'foldername.uni' keys."""
xforms = [os.path.expanduser, os.path.expandvars]
mblock.acquire()
try:
- localeval = config.getlocaleval()
if not config.getdefaultboolean("mbnames", "enabled", 0):
return
- path = config.apply_xforms(config.get("mbnames", "filename"), xforms)
- file = open(path, "wt")
- file.write(localeval.eval(config.get("mbnames", "header")))
+
+ localeval = config.getlocaleval()
+ path = uniString(config.get("mbnames", "filename"))
+ path = uniString(config.apply_xforms(path, xforms))
+ if uni.use_unicode():
+ fd_mbnames = codecs.open(path.fs, "wt", uni.ENCODING)
+ else:
+ fd_mbnames = open(path.fs, "wt")
+
+ mbnames_header = uniString(config.get("mbnames", "header"))
+ # Write to file with default encoding.
+ fd_mbnames.write(localeval.eval(mbnames_header).dbytes)
+
+ # Default folderfilter.
folderfilter = lambda accountname, foldername: 1
+ # User folderfilter.
if config.has_option("mbnames", "folderfilter"):
- folderfilter = localeval.eval(config.get("mbnames", "folderfilter"),
- {'re': re})
+ mbnames_folderfilter = uniString(
+ config.get("mbnames", "folderfilter"))
+ folderfilter = localeval.eval(mbnames_folderfilter, {'re': re})
+
+ # Default sort_keyfunc.
mb_sort_keyfunc = lambda d: (d['accountname'], d['foldername'])
+ # User sort_keyfunc.
if config.has_option("mbnames", "sort_keyfunc"):
- mb_sort_keyfunc = localeval.eval(config.get("mbnames", "sort_keyfunc"),
- {'re': re})
+ mbnames_sort_keyfunc = uniString(
+ config.get("mbnames", "sort_keyfunc"))
+ mb_sort_keyfunc = localeval.eval(mbnames_sort_keyfunc, {'re': re})
+
itemlist = []
for accountname in boxes.keys():
- localroot = localroots[accountname]
+ localfolders = localroots[accountname]
for foldername in boxes[accountname]:
- if folderfilter(accountname, foldername):
- itemlist.append({'accountname': accountname,
- 'foldername': foldername,
- 'localfolders': localroot})
- itemlist.sort(key = mb_sort_keyfunc)
- format_string = config.get("mbnames", "peritem", raw=1)
- itemlist = [format_string % d for d in itemlist]
- file.write(localeval.eval(config.get("mbnames", "sep")).join(itemlist))
- file.write(localeval.eval(config.get("mbnames", "footer")))
- file.close()
+ if folderfilter(accountname.uni, foldername.uni):
+ itemlist.append({'accountname': accountname.uni,
+ 'foldername': foldername.uni,
+ 'localfolders': localfolders.uni})
+ itemlist.sort(key=mb_sort_keyfunc)
+ uni_format_string = config.get("mbnames", "peritem", raw=1)
+ itemlist = [uni_format_string % d for d in itemlist]
+
+ mbnames_sep = uniString(config.get("mbnames", "sep"))
+ mbnames_footer = uniString(config.get("mbnames", "footer"))
+
+ uni_eval_mbnames_sep = localeval.eval(mbnames_sep).join(itemlist)
+ uni_eval_mbnames_footer = localeval.eval(mbnames_footer)
+
+ fd_mbnames.write(uni_eval_mbnames_sep)
+ fd_mbnames.write(uni_eval_mbnames_footer)
+ fd_mbnames.close()
finally:
mblock.release()
diff --git a/offlineimap/repository/Base.py b/offlineimap/repository/Base.py
index 0cf44f8..76fc0e8 100644
--- a/offlineimap/repository/Base.py
+++ b/offlineimap/repository/Base.py
@@ -21,7 +21,10 @@ from sys import exc_info
from offlineimap import CustomConfig
from offlineimap.ui import getglobalui
+from offlineimap.utils.uni import fsString, uniString, noneString, use_unicode
from offlineimap.error import OfflineImapError
+from offlineimap.utils import hack
+
class BaseRepository(CustomConfig.ConfigHelperMixin, object):
@@ -33,33 +36,54 @@ class BaseRepository(CustomConfig.ConfigHelperMixin, object):
self.localeval = account.getlocaleval()
self._accountname = self.account.getname()
self._readonly = self.getconfboolean('readonly', False)
- self.uiddir = os.path.join(self.config.getmetadatadir(), 'Repository-' + self.name)
- if not os.path.exists(self.uiddir):
- os.mkdir(self.uiddir, 0o700)
- self.mapdir = os.path.join(self.uiddir, 'UIDMapping')
- if not os.path.exists(self.mapdir):
- os.mkdir(self.mapdir, 0o700)
+ metadatapath = uniString(self.config.getmetadatadir())
+ # FIXME: self.uiddir variable name is lying about itself.
+ self.uiddir = fsString(os.path.join(
+ metadatapath.fs, 'Repository-' + self.name.fs))
+ if not os.path.exists(self.uiddir.fs):
+ os.mkdir(self.uiddir.fs, 0o700)
+ self.mapdir = fsString(os.path.join(self.uiddir.fs, 'UIDMapping'))
+ if not os.path.exists(self.mapdir.fs):
+ os.mkdir(self.mapdir.fs, 0o700)
# FIXME: self.uiddir variable name is lying about itself.
- self.uiddir = os.path.join(self.uiddir, 'FolderValidity')
- if not os.path.exists(self.uiddir):
- os.mkdir(self.uiddir, 0o700)
+ self.uiddir = fsString(os.path.join(self.uiddir.fs, 'FolderValidity'))
+ if not os.path.exists(self.uiddir.fs):
+ os.mkdir(self.uiddir.fs, 0o700)
+ # Expects Unicode syntaxt u''.
self.nametrans = lambda foldername: foldername
+ # Expects Unicode syntaxt u''.
self.folderfilter = lambda foldername: 1
+ # Expects Unicode syntaxt u''.
self.folderincludes = []
+ # Expects Unicode syntaxt u''.
self.foldersort = None
if self.config.has_option(self.getsection(), 'nametrans'):
self.nametrans = self.localeval.eval(
- self.getconf('nametrans'), {'re': re})
+ uniString(self.getconf('nametrans')), {'re': re})
if self.config.has_option(self.getsection(), 'folderfilter'):
self.folderfilter = self.localeval.eval(
- self.getconf('folderfilter'), {'re': re})
+ uniString(self.getconf('folderfilter')), {'re': re})
if self.config.has_option(self.getsection(), 'folderincludes'):
- self.folderincludes = self.localeval.eval(
- self.getconf('folderincludes'), {'re': re})
+ folderincludes = self.localeval.eval(
+ uniString(self.getconf('folderincludes')), {'re': re})
+ self.folderincludes = [uniString(f) for f in folderincludes]
if self.config.has_option(self.getsection(), 'foldersort'):
self.foldersort = self.localeval.eval(
- self.getconf('foldersort'), {'re': re})
+ uniString(self.getconf('foldersort')), {'re': re})
+ # Check if user defined stuff don't even run.
+ if not use_unicode():
+ try:
+ for funcname in ['folderfilter', 'foldersort', 'nametrans']:
+ func = self.__dict__[funcname]
+ if func:
+ func('ascii')
+ for funcname in ['folderincludes']:
+ 'ascii' in self.__dict__[funcname]
+ except Exception as e:
+ raise Exception("function %s failed to run. Is there any "
+ "Unicode string in it?"% funcname)
+
def restore_atime(self):
"""Sets folders' atime back to their values after a sync
@@ -91,7 +115,8 @@ class BaseRepository(CustomConfig.ConfigHelperMixin, object):
return self.name
def __str__(self):
- return self.name
+ # Warn to not use this because encoding is made implicit.
+ return self.name.fs
@property
def accountname(self):
@@ -106,7 +131,7 @@ class BaseRepository(CustomConfig.ConfigHelperMixin, object):
# Interface from CustomConfig.ConfigHelperMixin
def getsection(self):
- return 'Repository ' + self.name
+ return uniString(u'Repository ' + self.name.uni).uni
# Interface from CustomConfig.ConfigHelperMixin
def getconfig(self):
@@ -135,7 +160,7 @@ class BaseRepository(CustomConfig.ConfigHelperMixin, object):
def should_sync_folder(self, fname):
"""Should this folder be synced?"""
- return fname in self.folderincludes or self.folderfilter(fname)
+ return fname.uni in self.folderincludes or self.folderfilter(fname)
def get_create_folders(self):
"""Is folder creation enabled on this repository?
@@ -148,12 +173,15 @@ class BaseRepository(CustomConfig.ConfigHelperMixin, object):
def makefolder(self, foldername):
"""Create a new folder."""
+
raise NotImplementedError
def deletefolder(self, foldername):
+
raise NotImplementedError
def getfolder(self, foldername):
+
raise NotImplementedError
def sync_folder_structure(self, dst_repo, status_repo):
@@ -179,43 +207,48 @@ class BaseRepository(CustomConfig.ConfigHelperMixin, object):
src_hash = {}
for folder in src_folders:
src_hash[folder.getvisiblename().replace(
- src_repo.getsep(), dst_repo.getsep())] = folder
+ src_repo.getsep().uni, dst_repo.getsep().uni)] = folder
dst_hash = {}
for folder in dst_folders:
dst_hash[folder.getvisiblename().replace(
- dst_repo.getsep(), src_repo.getsep())] = folder
+ dst_repo.getsep().uni, src_repo.getsep().uni)] = folder
# Find new folders on src_repo.
- for src_name_t, src_folder in src_hash.iteritems():
+ for uni_src_name_t, src_folder in src_hash.iteritems():
+ src_name_t = uniString(uni_src_name_t) # Fix type.
+
# Don't create on dst_repo, if it is readonly
if not dst_repo.get_create_folders():
break
- if src_folder.sync_this and not src_name_t in dst_folders:
+ if src_folder.sync_this and not src_name_t.uni in dst_hash:
try:
dst_repo.makefolder(src_name_t)
dst_haschanged = True # Need to refresh list
except OfflineImapError as e:
- self.ui.error(e, exc_info()[2],
- "Creating folder %s on repository %s"%
- (src_name_t, dst_repo))
+ self.ui.error(e, exc_info()[2],
+ u"Creating folder %s on repository %s"%
+ (src_name_t.uni, dst_repo.getname().uni))
raise
- status_repo.makefolder(src_name_t.replace(dst_repo.getsep(),
- status_repo.getsep()))
+ status_repo.makefolder(uniString(src_name_t.replace(
+ dst_repo.getsep(), status_repo.getsep())))
+
# Find new folders on dst_repo.
for dst_name_t, dst_folder in dst_hash.iteritems():
+
if not src_repo.get_create_folders():
# Don't create missing folder on readonly repo.
break
- if dst_folder.sync_this and not dst_name_t in src_folders:
+ if dst_folder.sync_this and not dst_name_t in src_hash:
# nametrans sanity check!
# Does nametrans back&forth lead to identical names?
# 1) would src repo filter out the new folder name? In this
# case don't create it on it:
if not self.should_sync_folder(dst_name_t):
- self.ui.debug('', "Not creating folder '%s' (repository '%s"
- "') as it would be filtered out on that repository."%
- (dst_name_t, self))
+ self.ui.debug('',
+ u"Not creating folder '%s' (repository '%s') as it "
+ "would be filtered out on that repository."%
+ (dst_name_t.uni, self.name.uni))
continue
# get IMAPFolder and see if the reverse nametrans
# works fine TODO: getfolder() works only because we
@@ -223,9 +256,10 @@ class BaseRepository(CustomConfig.ConfigHelperMixin, object):
# like to change. Take care!
folder = self.getfolder(dst_name_t)
# apply reverse nametrans to see if we end up with the same name
- newdst_name = folder.getvisiblename().replace(
- src_repo.getsep(), dst_repo.getsep())
- if dst_folder.name != newdst_name:
+ newdst_name = uniString(folder.getvisiblename().uni.replace(
+ src_repo.getsep().uni, dst_repo.getsep().uni))
+ #hack.debugger()
+ if dst_folder.getname().imap != newdst_name.imap:
raise OfflineImapError("INFINITE FOLDER CREATION DETECTED! "
"Folder '%s' (repository '%s') would be created as fold"
"er '%s' (repository '%s'). The latter becomes '%s' in "
@@ -234,23 +268,25 @@ class BaseRepository(CustomConfig.ConfigHelperMixin, object):
"itories so they lead to identical names if applied bac"
"k and forth. 2) Use folderfilter settings on a reposit"
"ory to prevent some folders from being created on the "
- "other side." % (dst_folder.name, dst_repo, dst_name_t,
- src_repo, newdst_name),
- OfflineImapError.ERROR.REPO)
+ "other side."% (dst_folder.getname().fs,
+ dst_repo.getname().fs, dst_name_t.fs,
+ src_repo.getname().fs, newdst_name.fs),
+ OfflineImapError.ERROR.REPO)
# end sanity check, actually create the folder
try:
src_repo.makefolder(dst_name_t)
src_haschanged = True # Need to refresh list
except OfflineImapError as e:
- self.ui.error(e, exc_info()[2], "Creating folder %s on "
- "repository %s" % (dst_name_t, src_repo))
+ self.ui.error(e, exc_info()[2],
+ u"Creating folder %s on repository %s"%
+ (dst_name_t.fs, src_repo.getname().fs))
raise
- status_repo.makefolder(dst_name_t.replace(
- src_repo.getsep(), status_repo.getsep()))
+ status_repo.makefolder(uniString(dst_name_t.replace(
+ src_repo.getsep(), status_repo.getsep())))
# Find deleted folders.
# TODO: We don't delete folders right now.
- #Forget old list of cached folders so we get new ones if needed
+ # Forget old list of cached folders so we get new ones if needed.
if src_haschanged:
self.forgetfolders()
if dst_haschanged:
@@ -268,5 +304,6 @@ class BaseRepository(CustomConfig.ConfigHelperMixin, object):
def getlocalroot(self):
""" Local root folder for storing messages.
Will not be set for remote repositories."""
- return None
+
+ return noneString()
diff --git a/offlineimap/repository/Gmail.py b/offlineimap/repository/Gmail.py
index 2e23e62..2ff67fd 100644
--- a/offlineimap/repository/Gmail.py
+++ b/offlineimap/repository/Gmail.py
@@ -17,6 +17,8 @@
from offlineimap.repository.IMAP import IMAPRepository
from offlineimap import folder, OfflineImapError
+from offlineimap.utils.uni import uniString
+
class GmailRepository(IMAPRepository):
"""Gmail IMAP repository.
@@ -24,6 +26,7 @@ class GmailRepository(IMAPRepository):
Falls back to hard-coded gmail host name and port, if none were specified:
http://mail.google.com/support/bin/answer.py?answer=78799&topic=12814
"""
+
# Gmail IMAP server hostname
HOSTNAME = "imap.gmail.com"
# Gmail IMAP server port
@@ -31,44 +34,49 @@ class GmailRepository(IMAPRepository):
def __init__(self, reposname, account):
"""Initialize a GmailRepository object."""
+
# Enforce SSL usage
- account.getconfig().set('Repository ' + reposname,
- 'ssl', 'yes')
+ account.getconfig().set(uniString(
+ 'Repository ' + reposname.dbytes, 'ssl', 'yes')).dbytes
IMAPRepository.__init__(self, reposname, account)
-
def gethost(self):
"""Return the server name to connect to.
Gmail implementation first checks for the usual IMAP settings
and falls back to imap.gmail.com if not specified."""
+
try:
return super(GmailRepository, self).gethost()
except OfflineImapError:
# nothing was configured, cache and return hardcoded one
- self._host = GmailRepository.HOSTNAME
+ self._host = uniString(GmailRepository.HOSTNAME)
return self._host
def getport(self):
+
return GmailRepository.PORT
def getssl(self):
+
return 1
def getpreauthtunnel(self):
+
return None
def getfolder(self, foldername):
- return self.getfoldertype()(self.imapserver, foldername,
- self)
+
+ return self.getfoldertype()(
+ self.imapserver, foldername, self)
def getfoldertype(self):
return folder.Gmail.GmailFolder
def gettrashfolder(self, foldername):
#: Where deleted mail should be moved
- return self.getconf('trashfolder','[Gmail]/Trash')
+ return uniString(self.getconf('trashfolder','[Gmail]/Trash'))
def getspamfolder(self):
#: Gmail also deletes messages upon EXPUNGE in the Spam folder
- return self.getconf('spamfolder','[Gmail]/Spam')
+ return uniString(self.getconf('spamfolder','[Gmail]/Spam'))
diff --git a/offlineimap/repository/IMAP.py b/offlineimap/repository/IMAP.py
index b109546..3ad8bb6 100644
--- a/offlineimap/repository/IMAP.py
+++ b/offlineimap/repository/IMAP.py
@@ -26,27 +26,33 @@ from offlineimap import folder, imaputil, imapserver, OfflineImapError
from offlineimap.folder.UIDMaps import MappedIMAPFolder
from offlineimap.threadutil import ExitNotifyThread
from offlineimap.utils.distro import get_os_sslcertfile, get_os_sslcertfile_searchpath
+from offlineimap.utils.uni import noneString, uniString, dbytesString, \
+ imapString, valueString, isASCII
+from offlineimap.utils import hack
class IMAPRepository(BaseRepository):
def __init__(self, reposname, account):
"""Initialize an IMAPRepository object."""
+
BaseRepository.__init__(self, reposname, account)
# self.ui is being set by the BaseRepository
- self._host = None
+ self._host = noneString()
self.imapserver = imapserver.IMAPServer(self)
self.folders = None
if self.getconf('sep', None):
- self.ui.info("The 'sep' setting is being ignored for IMAP "
- "repository '%s' (it's autodetected)"% self)
+ # FIXME: should warn, instead.
+ self.ui.info(u"The 'sep' setting is being ignored for IMAP "
+ "repository '%s' (it's autodetected)"% self.name.uni)
def startkeepalive(self):
keepalivetime = self.getkeepalive()
if not keepalivetime: return
self.kaevent = Event()
- self.kathread = ExitNotifyThread(target = self.imapserver.keepalive,
- name = "Keep alive " + self.getname(),
- args = (keepalivetime, self.kaevent))
+ self.kathread = ExitNotifyThread(
+ target=self.imapserver.keepalive,
+ name="Keep alive " + self.name.fs,
+ args=(keepalivetime, self.kaevent))
self.kathread.setDaemon(1)
self.kathread.start()
@@ -83,46 +89,50 @@ class IMAPRepository(BaseRepository):
This requires that self.imapserver has been initialized with an
acquireconnection() or it will still be `None`"""
- assert self.imapserver.delim != None, "'%s' " \
- "repository called getsep() before the folder separator was " \
- "queried from the server"% self
- return self.imapserver.delim
+
+ delim = self.imapserver.getdelim()
+ assert delim.uni != None, ("'%s' "
+ "repository called getsep() before the folder separator was "
+ "queried from the server"% self.name.fs)
+ return delim
def gethost(self):
"""Return the configured hostname to connect to
:returns: hostname as string or throws Exception"""
- if self._host: # use cached value if possible
+
+ if self._host.uni: # Use cached value if possible.
return self._host
# 1) check for remotehosteval setting
if self.config.has_option(self.getsection(), 'remotehosteval'):
- host = self.getconf('remotehosteval')
+ host = noneString()
+ hosteval = uniString(self.getconf('remotehosteval'))
try:
- host = self.localeval.eval(host)
+ host = uniString(self.localeval.eval(hosteval))
except Exception as e:
raise OfflineImapError("remotehosteval option for repository "
- "'%s' failed:\n%s"% (self, e), OfflineImapError.ERROR.REPO), \
- None, exc_info()[2]
- if host:
+ "'%s' failed:\n%s"% (self.name.fs, e),
+ OfflineImapError.ERROR.REPO), None, exc_info()[2]
+ if host.uni:
self._host = host
return self._host
# 2) check for plain remotehost setting
- host = self.getconf('remotehost', None)
- if host != None:
+ host = uniString(self.getconf('remotehost', None))
+ if host.uni != None:
self._host = host
return self._host
# no success
- raise OfflineImapError("No remote host for repository "
- "'%s' specified."% self, OfflineImapError.ERROR.REPO)
+ raise OfflineImapError("No remote host for repository '%s' "
+ "specified."% self.name.fs, OfflineImapError.ERROR.REPO)
def get_remote_identity(self):
"""Remote identity is used for certain SASL mechanisms
(currently -- PLAIN) to inform server about the ID
we want to authorize as instead of our login name."""
- return self.getconf('remote_identity', default=None)
+ return uniString(self.getconf('remote_identity', default=None))
def get_auth_mechanisms(self):
supported = ["GSSAPI", "CRAM-MD5", "PLAIN", "LOGIN"]
@@ -132,58 +142,66 @@ class IMAPRepository(BaseRepository):
# TODO: due to the chosen-plaintext resistance.
default = ["GSSAPI", "CRAM-MD5", "PLAIN", "LOGIN"]
- mechs = self.getconflist('auth_mechanisms', r',\s*',
- default)
+ mechs = self.getconflist('auth_mechanisms', r',\s*', default)
for m in mechs:
+ isASCII(m, exception_msg=
+ "auth_mechanisms must be plain ASCII")
if m not in supported:
- raise OfflineImapError("Repository %s: "% self + \
- "unknown authentication mechanism '%s'"% m,
- OfflineImapError.ERROR.REPO)
+ raise OfflineImapError("Repository %s: unknown "
+ "authentication mechanism '%s'"%
+ self.name.fs, m, OfflineImapError.ERROR.REPO)
+
+ self.ui.debug('imap', u"Using authentication mechanisms %s"% mechs)
- self.ui.debug('imap', "Using authentication mechanisms %s" % mechs)
return mechs
def getuser(self):
- user = None
+ def getnetrcuser(path=None):
+ try:
+ if path:
+ netrcentry = netrc.netrc('/etc/netrc').authenticators(self.gethost())
+ else:
+ netrcentry = netrc.netrc().authenticators(self.gethost())
+ except IOError as inst:
+ if inst.errno != errno.ENOENT:
+ raise
+ else:
+ if netrcentry:
+ # Couldn't find the expected encoding of netrc. Assume it to
+ # be uni.ENCODING (UTF-8) because it's the less offending.
+ return dbytesString(netrcentry[0])
+ return noneString()
+
+ user = noneString()
localeval = self.localeval
if self.config.has_option(self.getsection(), 'remoteusereval'):
- user = self.getconf('remoteusereval')
- if user != None:
- return localeval.eval(user)
+ user = uniString(self.getconf('remoteusereval'))
+ if user.uni != None:
+ return uniString(localeval.eval(user))
- user = self.getconf('remoteuser')
- if user != None:
+ user = uniString(self.getconf('remoteuser'))
+ if user.uni != None:
return user
- try:
- netrcentry = netrc.netrc().authenticators(self.gethost())
- except IOError as inst:
- if inst.errno != errno.ENOENT:
- raise
- else:
- if netrcentry:
- return netrcentry[0]
+ user = getnetrcuser('/etc/netrc')
+ if user.dbytes != None:
+ return user
- try:
- netrcentry = netrc.netrc('/etc/netrc').authenticators(self.gethost())
- except IOError as inst:
- if inst.errno not in (errno.ENOENT, errno.EACCES):
- raise
- else:
- if netrcentry:
- return netrcentry[0]
+ user = getnetrcuser()
+ if user.dbytes != None:
+ return user
+ return user
def getport(self):
- port = None
-
if self.config.has_option(self.getsection(), 'remoteporteval'):
- port = self.getconf('remoteporteval')
- if port != None:
- return self.localeval.eval(port)
+ porteval = uniString(self.getconf('remoteporteval'))
+ if porteval.uni != None:
+ # XXX: we should be type checking of what eval() returns...
+ return self.localeval.eval(porteval)
return self.getconfint('remoteport', None)
@@ -192,11 +210,11 @@ class IMAPRepository(BaseRepository):
def getsslclientcert(self):
xforms = [os.path.expanduser, os.path.expandvars, os.path.abspath]
- return self.getconf_xform('sslclientcert', xforms, None)
+ return uniString(self.getconf_xform('sslclientcert', xforms, None))
def getsslclientkey(self):
xforms = [os.path.expanduser, os.path.expandvars, os.path.abspath]
- return self.getconf_xform('sslclientkey', xforms, None)
+ return uniString(self.getconf_xform('sslclientkey', xforms, None))
def getsslcacertfile(self):
"""Determines CA bundle.
@@ -217,52 +235,61 @@ class IMAPRepository(BaseRepository):
"""
xforms = [os.path.expanduser, os.path.expandvars, os.path.abspath]
- cacertfile = self.getconf_xform('sslcacertfile', xforms, None)
- if self.getconf('sslcacertfile', None) == "OS-DEFAULT":
- cacertfile = get_os_sslcertfile()
- if cacertfile == None:
+
+ cacertfile = uniString(self.getconf_xform(
+ 'sslcacertfile', xforms, None))
+ if uniString(self.getconf('sslcacertfile', None)).dbytes == "OS-DEFAULT":
+ cacertfile = dbytesString(get_os_sslcertfile())
+ if cacertfile.uni == None:
searchpath = get_os_sslcertfile_searchpath()
+ # searchpath is iterable of plain ASCII paths.
+ isASCII(', '.join(searchpath), exception_msg=
+ "OS-DEFAULT paths must be plain ASCII")
if searchpath:
reason = "Default CA bundle was requested, "\
"but no existing locations available. "\
- "Tried %s." % (", ".join(searchpath))
+ "Tried %s."% (", ".join(searchpath))
else:
reason = "Default CA bundle was requested, "\
"but OfflineIMAP doesn't know any for your "\
"current operating system."
raise OfflineImapError(reason, OfflineImapError.ERROR.REPO)
- if cacertfile is None:
- return None
- if not os.path.isfile(cacertfile):
+ if cacertfile.uni is None:
+ return noneString()
+ if not os.path.isfile(cacertfile.fs):
reason = "CA certfile for repository '%s' couldn't be found. "\
- "No such file: '%s'" % (self.name, cacertfile)
+ "No such file: '%s'"% (self.name.fs, cacertfile.fs)
raise OfflineImapError(reason, OfflineImapError.ERROR.REPO)
return cacertfile
def getsslversion(self):
- return self.getconf('ssl_version', None)
+ return uniString(self.getconf('ssl_version', None))
- def get_ssl_fingerprint(self):
- """Return array of possible certificate fingerprints.
+ def get_ssl_fingerprints(self):
+ """Return array of possible certificate fingerprints (type str).
Configuration item cert_fingerprint can contain multiple
comma-separated fingerprints in hex form."""
- value = self.getconf('cert_fingerprint', "")
+ # Encode back to what user actually wrote.
+ value = uniString(self.getconf('cert_fingerprint', "")).dbytes
return [f.strip().lower() for f in value.split(',') if f]
def getpreauthtunnel(self):
- return self.getconf('preauthtunnel', None)
+ return uniString(self.getconf('preauthtunnel', None))
def gettransporttunnel(self):
- return self.getconf('transporttunnel', None)
+ return uniString(self.getconf('transporttunnel', None))
def getreference(self):
- return self.getconf('reference', '')
+ return uniString(self.getconf('reference', '""'))
def getidlefolders(self):
+ """Return a list of idle folders."""
+
localeval = self.localeval
- return localeval.eval(self.getconf('idlefolders', '[]'))
+ # XXX: we should be type checking of what eval() returns...
+ return localeval.eval(uniString(self.getconf('idlefolders', '[]')))
def getmaxconnections(self):
num1 = len(self.getidlefolders())
@@ -286,45 +313,50 @@ class IMAPRepository(BaseRepository):
On success we return the password.
If all strategies fail we return None."""
+ def getnetrcpass(path):
+ try:
+ if path:
+ netrcentry = netrc.netrc('/etc/netrc').authenticators(
+ self.gethost())
+ else:
+ netrcentry = netrc.netrc().authenticators(self.gethost())
+ except IOError as inst:
+ if inst.errno != errno.ENOENT:
+ raise
+ else:
+ if netrcentry:
+ # Assume netrc use UTF-8 encoding. This has to be
+ # checked.
+ user = uniString(self.getconf('remoteuser'))
+ if user.uni == None or user.dbytes == netrcentry[0]:
+ return valueString(netrcentry[2])
+ return noneString()
+
# 1. evaluate Repository 'remotepasseval'
- passwd = self.getconf('remotepasseval', None)
- if passwd != None:
- return self.localeval.eval(passwd)
+ passwdeval = uniString(self.getconf('remotepasseval', None))
+ if passwdeval.value != None:
+ return valueString(self.localeval.eval(passwdeval))
# 2. read password from Repository 'remotepass'
- password = self.getconf('remotepass', None)
- if password != None:
- return password
+ password = uniString(self.getconf('remotepass', None))
+ if password.uni != None:
+ return valueString(password.dbytes)
# 3. read password from file specified in Repository 'remotepassfile'
- passfile = self.getconf('remotepassfile', None)
- if passfile != None:
- fd = open(os.path.expanduser(passfile))
- password = fd.readline().strip()
+ passfile = uniString(self.getconf('remotepassfile', None))
+ if passfile.uni != None:
+ fs_file = os.path.expanduser(passfile.fs)
+ fd = open(fs_file, 'rb')
+ password = dbytesString(fd.readline().strip())
fd.close()
- return password
+ return valueString(password.dbytes)
# 4. read password from ~/.netrc
- try:
- netrcentry = netrc.netrc().authenticators(self.gethost())
- except IOError as inst:
- if inst.errno != errno.ENOENT:
- raise
- else:
- if netrcentry:
- user = self.getconf('remoteuser')
- if user == None or user == netrcentry[0]:
- return netrcentry[2]
+ password = getnetrcpass()
+ if password.value is not None:
+ return password
# 5. read password from /etc/netrc
- try:
- netrcentry = netrc.netrc('/etc/netrc').authenticators(self.gethost())
- except IOError as inst:
- if inst.errno not in (errno.ENOENT, errno.EACCES):
- raise
- else:
- if netrcentry:
- user = self.getconf('remoteuser')
- if user == None or user == netrcentry[0]:
- return netrcentry[2]
- # no strategy yielded a password!
- return None
+ password = getnetrcpass('/etc/netrc')
+ if password.value is not None:
+ return password
+ return noneString()
def getfolder(self, foldername):
"""Return instance of OfflineIMAP representative folder."""
@@ -341,6 +373,7 @@ class IMAPRepository(BaseRepository):
def forgetfolders(self):
self.folders = None
+ # XXX: make it clear it returns instances and not names.
def getfolders(self):
"""Return a list of instances of OfflineIMAP representative folder."""
@@ -348,17 +381,17 @@ class IMAPRepository(BaseRepository):
return self.folders
retval = []
imapobj = self.imapserver.acquireconnection()
- # check whether to list all folders, or subscribed only
+ # Check whether to list all folders, or subscribed only.
listfunction = imapobj.list
if self.getconfboolean('subscribedonly', False):
listfunction = imapobj.lsub
try:
- listresult = listfunction(directory = self.imapserver.reference)[1]
+ ref = self.imapserver.reference
+ listresult = listfunction(directory=ref)[1]
finally:
self.imapserver.releaseconnection(imapobj)
for s in listresult:
- if s == None or \
- (isinstance(s, basestring) and s == ''):
+ if s == None or (isinstance(s, basestring) and s == ''):
# Bug in imaplib: empty strings in results from
# literals. TODO: still relevant?
continue
@@ -366,22 +399,22 @@ class IMAPRepository(BaseRepository):
flaglist = [x.lower() for x in imaputil.flagsplit(flags)]
if '\\noselect' in flaglist:
continue
- foldername = imaputil.dequote(name)
- retval.append(self.getfoldertype()(self.imapserver, foldername,
- self))
- # Add all folderincludes
+ foldername = imapString(imaputil.dequote(name))
+ retval.append(
+ self.getfoldertype()(self.imapserver, foldername, self))
+ # Add all folderincludes.
if len(self.folderincludes):
imapobj = self.imapserver.acquireconnection()
try:
for foldername in self.folderincludes:
try:
- imapobj.select(foldername, readonly = True)
+ imapobj.select(foldername.imap, readonly=True)
except OfflineImapError as e:
- # couldn't select this folderinclude, so ignore folder.
+ # Couldn't select this folderinclude, so ignore folder.
if e.severity > OfflineImapError.ERROR.FOLDER:
raise
self.ui.error(e, exc_info()[2],
- 'Invalid folderinclude:')
+ 'Invalid folderinclude: %s'% foldername.fs)
continue
retval.append(self.getfoldertype()(
self.imapserver, foldername, self))
@@ -389,10 +422,10 @@ class IMAPRepository(BaseRepository):
self.imapserver.releaseconnection(imapobj)
if self.foldersort is None:
- # default sorting by case insensitive transposed name
- retval.sort(key=lambda x: str.lower(x.getvisiblename()))
+ # Default sorting by case insensitive transposed name.
+ retval.sort(key=lambda x: x.getvisiblename().lower())
else:
- # do foldersort in a python3-compatible way
+ # Do foldersort in a python3-compatible way.
# http://bytes.com/topic/python/answers/844614-python-3-sorting-comparison-function
def cmp2key(mycmp):
"""Converts a cmp= function into a key= function
@@ -417,20 +450,20 @@ class IMAPRepository(BaseRepository):
:param foldername: Full path of the folder to be created."""
- if self.getreference():
+ if self.getreference().uni:
foldername = self.getreference() + self.getsep() + foldername
- if not foldername: # Create top level folder as folder separator
+ if not foldername.uni: # Create top level folder as folder separator.
foldername = self.getsep()
- self.ui.makefolder(self, foldername)
+ self.ui.makefolder(self, foldername.uni)
if self.account.dryrun:
return
imapobj = self.imapserver.acquireconnection()
try:
- result = imapobj.create(foldername)
+ result = imapobj.create(foldername.imap)
if result[0] != 'OK':
raise OfflineImapError("Folder '%s'[%s] could not be created. "
- "Server responded: %s"% (foldername, self, str(result)),
- OfflineImapError.ERROR.FOLDER)
+ "Server responded: %s"% (foldername.imap, self.name.fs,
+ str(result)), OfflineImapError.ERROR.FOLDER)
finally:
self.imapserver.releaseconnection(imapobj)
diff --git a/offlineimap/repository/LocalStatus.py b/offlineimap/repository/LocalStatus.py
index fc34a55..6a89a6f 100644
--- a/offlineimap/repository/LocalStatus.py
+++ b/offlineimap/repository/LocalStatus.py
@@ -20,6 +20,8 @@ import os
from offlineimap.folder.LocalStatus import LocalStatusFolder
from offlineimap.folder.LocalStatusSQLite import LocalStatusSQLiteFolder
from offlineimap.repository.Base import BaseRepository
+from offlineimap.utils.uni import uniString, fsString
+
class LocalStatusRepository(BaseRepository):
def __init__(self, reposname, account):
@@ -29,32 +31,35 @@ class LocalStatusRepository(BaseRepository):
self.backends = {}
self.backends['sqlite'] = {
'class': LocalStatusSQLiteFolder,
- 'root': os.path.join(account.getaccountmeta(), 'LocalStatus-sqlite')
+ 'root': fsString(os.path.join(
+ account.getaccountmeta().fs, 'LocalStatus-sqlite'))
}
self.backends['plain'] = {
'class': LocalStatusFolder,
- 'root': os.path.join(account.getaccountmeta(), 'LocalStatus')
+ 'root': fsString(os.path.join(
+ account.getaccountmeta().fs, 'LocalStatus'))
}
- # Set class and root for the configured backend
- self.setup_backend(self.account.getconf('status_backend', 'plain'))
+ # Set class and root for the configured backend.
+ self.setup_backend(uniString(
+ self.account.getconf('status_backend', 'plain')))
- if not os.path.exists(self.root):
- os.mkdir(self.root, 0o700)
+ if not os.path.exists(self.root.fs):
+ os.mkdir(self.root.fs, 0o700)
# self._folders is a dict of name:LocalStatusFolders()
self._folders = {}
def setup_backend(self, backend):
- if backend in self.backends.keys():
+ if backend.dbytes in self.backends.keys():
self._backend = backend
- self.root = self.backends[backend]['root']
- self.LocalStatusFolderClass = self.backends[backend]['class']
+ self.root = self.backends[backend.dbytes]['root']
+ self.LocalStatusFolderClass = self.backends[backend.dbytes]['class']
else:
raise SyntaxWarning("Unknown status_backend '%s' for account '%s'"%
- (backend, self.account.name))
+ (backend.fs, self.account.getname().fs))
def import_other_backend(self, folder):
for bk, dic in self.backends.items():
@@ -62,15 +67,16 @@ class LocalStatusRepository(BaseRepository):
if dic['class'] == type(folder):
continue
- repobk = LocalStatusRepository(self.name, self.account)
+ repobk = LocalStatusRepository(self.getname(), self.account)
repobk.setup_backend(bk) # fake the backend
- folderbk = dic['class'](folder.name, repobk)
+ folderbk = dic['class'](folder.getname(), repobk)
# if backend contains data, import it to folder.
if not folderbk.isnewfolder():
- self.ui._msg('Migrating LocalStatus cache from %s to %s " \
- "status folder for %s:%s'%
- (bk, self._backend, self.name, folder.name))
+ self.ui._msg(u"Migrating LocalStatus cache from %s to %s "
+ "status folder for %s:%s"%
+ (bk.getname().uni, self._backend.uni,
+ self.name.uni, folder.getname().uni))
folderbk.cachemessagelist()
folder.messagelist = folderbk.messagelist
@@ -78,7 +84,7 @@ class LocalStatusRepository(BaseRepository):
break
def getsep(self):
- return '.'
+ return uniString(u'.')
def makefolder(self, foldername):
"""Create a LocalStatus Folder."""
@@ -88,7 +94,22 @@ class LocalStatusRepository(BaseRepository):
# Create an empty StatusFolder
folder = self.LocalStatusFolderClass(foldername, self)
- folder.save()
+ # With Unicode, makefolder() might be raised while cache file already
+ # exists. Calling makefolder() let us update the folder name on disk in
+ # a Maildir if the folder name is not full ASCII.
+ #
+ # Avoid clearing the folder cache file if it already exists. We don't
+ # want to re-download emails from that folder if we already have a cache
+ # file.
+ #
+ # Make the check here to not annoy callers with this issue and because
+ # we can't insert it in the save() method simply (missing of context).
+ #
+ # FIXME: why this call to save() in the first place? We have NOTHING to
+ # save at all. This will only create the cache file which case should be
+ # handled from within the class...
+ if folder.isnewfolder():
+ folder.save()
# Invalidate the cache.
self.forgetfolders()
@@ -96,8 +117,8 @@ class LocalStatusRepository(BaseRepository):
def getfolder(self, foldername):
"""Return the Folder() object for a foldername."""
- if foldername in self._folders:
- return self._folders[foldername]
+ if foldername.uni in self._folders:
+ return self._folders[foldername.uni]
folder = self.LocalStatusFolderClass(foldername, self)
@@ -105,7 +126,7 @@ class LocalStatusRepository(BaseRepository):
if folder.isnewfolder():
self.import_other_backend(folder)
- self._folders[foldername] = folder
+ self._folders[foldername.uni] = folder
return folder
def getfolders(self):
diff --git a/offlineimap/repository/Maildir.py b/offlineimap/repository/Maildir.py
index 0262ba2..d07f0be 100644
--- a/offlineimap/repository/Maildir.py
+++ b/offlineimap/repository/Maildir.py
@@ -15,12 +15,17 @@
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+import os
+from stat import *
+
from offlineimap import folder
from offlineimap.ui import getglobalui
from offlineimap.error import OfflineImapError
from offlineimap.repository.Base import BaseRepository
-import os
-from stat import *
+from offlineimap.utils import uni
+from offlineimap.utils.uni import isASCII, fsString, uniString, noneString
+from offlineimap.utils import hack
+
class MaildirRepository(BaseRepository):
def __init__(self, reposname, account):
@@ -32,20 +37,25 @@ class MaildirRepository(BaseRepository):
self.root = self.getlocalroot()
self.folders = None
self.ui = getglobalui()
- self.debug("MaildirRepository initialized, sep is %s"% repr(self.getsep()))
+ self.debug(u"MaildirRepository initialized, sep is %s"% repr(self.getsep()))
self.folder_atimes = []
# Create the top-level folder if it doesn't exist
- if not os.path.isdir(self.root):
- os.mkdir(self.root, 0o700)
+ if not os.path.isdir(self.root.fs):
+ os.mkdir(self.root.fs, 0o700)
def _append_folder_atimes(self, foldername):
- """Store the atimes of a folder's new|cur in self.folder_atimes"""
+ """Store the atimes of a folder's new|cur in self.folder_atimes.
+
+ :params foldername: filsystem encoded."""
- p = os.path.join(self.root, foldername)
- new = os.path.join(p, 'new')
- cur = os.path.join(p, 'cur')
- atimes = (p, os.path.getatime(new), os.path.getatime(cur))
+ # self.root is already encoded... It's a path.
+ # We assume foldername is filesystem encoded.
+ p = fsString(os.path.join(self.root.fs, foldername.fs))
+ fs_new = os.path.join(p.fs, 'new')
+ fs_cur = os.path.join(p.fs, 'cur')
+ # Later use of the path expects filesystem encoding.
+ atimes = (p, os.path.getatime(fs_new), os.path.getatime(fs_cur))
self.folder_atimes.append(atimes)
def restore_atime(self):
@@ -57,20 +67,24 @@ class MaildirRepository(BaseRepository):
return # not configured to restore
for (dirpath, new_atime, cur_atime) in self.folder_atimes:
- new_dir = os.path.join(dirpath, 'new')
- cur_dir = os.path.join(dirpath, 'cur')
- os.utime(new_dir, (new_atime, os.path.getmtime(new_dir)))
- os.utime(cur_dir, (cur_atime, os.path.getmtime(cur_dir)))
+ # dirpath is already filesystem encoded, see
+ # _append_folder_atimes()
+ fs_new_dir = os.path.join(dirpath.fs, 'new')
+ fs_cur_dir = os.path.join(dirpath.fs, 'cur')
+ os.utime(fs_new_dir, (new_atime, os.path.getmtime(fs_new_dir)))
+ os.utime(fs_cur_dir, (cur_atime, os.path.getmtime(fs_cur_dir)))
def getlocalroot(self):
xforms = [os.path.expanduser]
- return self.getconf_xform('localfolders', xforms)
+ localroot = uniString(self.getconf_xform('localfolders', xforms))
+ # encode local root path as soon as possible.
+ return localroot
def debug(self, msg):
self.ui.debug('maildir', msg)
def getsep(self):
- return self.getconf('sep', '.').strip()
+ return uniString(self.getconf('sep', '.').strip())
def makefolder(self, foldername):
"""Create new Maildir folder if necessary
@@ -79,48 +93,58 @@ class MaildirRepository(BaseRepository):
need to invoke :meth:`forgetfolders` to force new caching when
you are done creating folders yourself.
- :param foldername: A relative mailbox name. The maildir will be
- created in self.root+'/'+foldername. All intermediate folder
- levels will be created if they do not exist yet. 'cur',
- 'tmp', and 'new' subfolders will be created in the maildir.
+ :param foldername: A relative mailbox name (unicode).
+ The maildir will be created in self.root+'/'+foldername.
+ All intermediate folder levels will be created if they do
+ not exist yet. 'cur', 'tmp', and 'new' subfolders will be
+ created in the maildir.
"""
- self.ui.makefolder(self, foldername)
+ self.ui.makefolder(self, foldername.uni)
if self.account.dryrun:
return
- full_path = os.path.abspath(os.path.join(self.root, foldername))
# sanity tests
- if self.getsep() == '/':
+ if self.getsep().uni == '/':
for component in foldername.split('/'):
- assert not component in ['new', 'cur', 'tmp'],\
+ assert not component.uni in ['new', 'cur', 'tmp'],\
"When using nested folders (/ as a Maildir separator), "\
"folder names may not contain 'new', 'cur', 'tmp'."
- assert foldername.find('../') == -1, "Folder names may not contain ../"
- assert not foldername.startswith('/'), "Folder names may not begin with /"
+ assert foldername.find(u'../') == -1, "Folder names may not contain ../"
+ assert not foldername.startswith(u'/'), "Folder names may not begin with /"
+
+ diverged, fs_unexpected, fs_expected = uni.diverged_foldernames(
+ foldername)
+ if diverged:
+ uni.rename_diverged(self.root, fs_unexpected, fs_expected)
+ self.debug(u" makefolder : renamed '%s' to '%s'"%
+ (fs_unexpected.uni, fsString(fs_expected).uni))
+
+ full_path = fsString(os.path.abspath(os.path.join(
+ self.root.fs, fs_expected)))
# If we're using hierarchical folders, it's possible that
# sub-folders may be created before higher-up ones.
- self.debug("makefolder: calling makedirs '%s'"% full_path)
+ self.debug(u"makefolder: calling makedirs '%s'"% full_path.uni)
try:
- os.makedirs(full_path, 0o700)
+ os.makedirs(full_path.fs, 0o700)
except OSError as e:
- if e.errno == 17 and os.path.isdir(full_path):
- self.debug("makefolder: '%s' already a directory"% foldername)
+ if e.errno == 17 and os.path.isdir(full_path.fs):
+ self.debug(u"makefolder: '%s' already a directory"% foldername.fs)
else:
raise
- for subdir in ['cur', 'new', 'tmp']:
+ for fs_subdir in ['cur', 'new', 'tmp']:
try:
- os.mkdir(os.path.join(full_path, subdir), 0o700)
+ os.mkdir(os.path.join(full_path.fs, fs_subdir), 0o700)
except OSError as e:
if e.errno == 17 and os.path.isdir(full_path):
- self.debug("makefolder: '%s' already has subdir %s"%
- (foldername, subdir))
+ self.debug(u"makefolder: '%s' already has subdir %s"%
+ (foldername.uni, fs_subdir))
else:
raise
def deletefolder(self, foldername):
- self.ui.warn("NOT YET IMPLEMENTED: DELETE FOLDER %s"% foldername)
+ self.ui.warn(u"NOT YET IMPLEMENTED: DELETE FOLDER %s"% foldername.uni)
def getfolder(self, foldername):
"""Return a Folder instance of this Maildir
@@ -129,69 +153,92 @@ class MaildirRepository(BaseRepository):
we only return existing folders and that 2 calls with the same
name will return the same object."""
- # getfolders() will scan and cache the values *if* necessary
+ # getfolders() will scan and cache the values *if* necessary.
folders = self.getfolders()
for f in folders:
- if foldername == f.name:
+ if foldername.uni == f.name:
return f
raise OfflineImapError("getfolder() asked for a nonexisting "
- "folder '%s'."% foldername,
- OfflineImapError.ERROR.FOLDER)
+ "folder '%s'."% foldername.fs, OfflineImapError.ERROR.FOLDER)
def _getfolders_scandir(self, root, extension=None):
"""Recursively scan folder 'root'; return a list of MailDirFolder
- :param root: (absolute) path to Maildir root
- :param extension: (relative) subfolder to examine within root"""
+ :param root: (absolute) path to Maildir root, uni object.
+ :param extension: (relative) subfolder to examine within root, uni
+ object.
+ """
- self.debug("_GETFOLDERS_SCANDIR STARTING. root = %s, extension = %s"%
- (root, extension))
+ if type(extension) != type(noneString()):
+ extension = noneString()
+ self.debug(u"_GETFOLDERS_SCANDIR STARTING. root = %s, extension = %s"%
+ (root.uni, extension.uni))
retval = []
# Configure the full path to this repository -- "toppath"
- if extension:
- toppath = os.path.join(root, extension)
+ if extension.uni:
+ toppath = fsString(os.path.join(root.fs, extension.fs))
else:
toppath = root
- self.debug(" toppath = %s"% toppath)
+ self.debug(u" toppath = %s"% (toppath.uni))
# Iterate over directories in top & top itself.
- for dirname in os.listdir(toppath) + ['']:
- self.debug(" dirname = %s"% dirname)
- if dirname == '' and extension is not None:
- self.debug(' skip this entry (already scanned)')
+ # os.listdir() returns str when the path is str and unicode if the path
+ # is unicode. Here, we assume filsystem encoding.
+ for fs_dirname in os.listdir(toppath.fs) + ['']:
+ # Sanity check for legacy mode.
+ if not uni.use_unicode() and not isASCII(fs_dirname):
+ self.debug(u" skip dirname (unexpected character) = %s"%
+ dirname.std)
continue
- if dirname in ['cur', 'new', 'tmp']:
- self.debug(" skip this entry (Maildir special)")
+
+ dirname = fsString(fs_dirname)
+ if dirname.fs == '' and extension.uni is not None:
+ self.debug(u' skip this entry (already scanned)')
+ continue
+
+ # If we run without Unicode support, folders are IMAP UTF-7 encoded
+ # (full ASCII).
+ if dirname.fs != '':
+ diverged, fs_unexpected, fs_expected = uni.diverged_foldernames(dirname)
+ if diverged:
+ uni.rename_diverged(toppath, fs_unexpected, fs_expected)
+ self.debug(u" scandir folders: renamed '%s' to '%s'"%
+ (fsString(fs_unexpected).uni, fsString(fs_expected).uni))
+
+ self.debug(u" dirname = %s"% dirname.uni)
+ if dirname.fs in ['cur', 'new', 'tmp']:
+ self.debug(u" skip this entry (Maildir special)")
# Bypass special files.
continue
- fullname = os.path.join(toppath, dirname)
- if not os.path.isdir(fullname):
- self.debug(" skip this entry (not a directory)")
+
+ fullname = fsString(os.path.join(toppath.fs, dirname.fs))
+ if not os.path.isdir(fullname.fs):
+ self.debug(u" skip this entry (not a directory)")
# Not a directory -- not a folder.
continue
# extension can be None.
- if extension:
- foldername = os.path.join(extension, dirname)
+ if extension.uni:
+ foldername = fsString(os.path.join(extension.fs, dirname.fs))
else:
foldername = dirname
- if (os.path.isdir(os.path.join(fullname, 'cur')) and
- os.path.isdir(os.path.join(fullname, 'new')) and
- os.path.isdir(os.path.join(fullname, 'tmp'))):
+ if (os.path.isdir(os.path.join(fullname.fs, 'cur')) and
+ os.path.isdir(os.path.join(fullname.fs, 'new')) and
+ os.path.isdir(os.path.join(fullname.fs, 'tmp'))):
# This directory has maildir stuff -- process
- self.debug(" This is maildir folder '%s'."% foldername)
+ self.debug(u" This is maildir folder '%s'."% foldername.uni)
if self.getconfboolean('restoreatime', False):
self._append_folder_atimes(foldername)
fd = self.getfoldertype()(self.root, foldername,
- self.getsep(), self)
+ self.getsep(), self)
retval.append(fd)
if self.getsep() == '/' and dirname != '':
# Recursively check sub-directories for folders too.
retval.extend(self._getfolders_scandir(root, foldername))
- self.debug("_GETFOLDERS_SCANDIR RETURNING %s"% \
- repr([x.getname() for x in retval]))
+ self.debug(u"_GETFOLDERS_SCANDIR RETURNING %s"%
+ repr([x.getname().uni for x in retval]))
return retval
def getfolders(self):
diff --git a/offlineimap/repository/__init__.py b/offlineimap/repository/__init__.py
index 0fbbc13..e726e2f 100644
--- a/offlineimap/repository/__init__.py
+++ b/offlineimap/repository/__init__.py
@@ -28,6 +28,8 @@ from offlineimap.repository.Maildir import MaildirRepository
from offlineimap.repository.GmailMaildir import GmailMaildirRepository
from offlineimap.repository.LocalStatus import LocalStatusRepository
from offlineimap.error import OfflineImapError
+from offlineimap.utils.uni import uniString, isASCII
+from offlineimap.utils import hack
class Repository(object):
@@ -41,43 +43,46 @@ class Repository(object):
:param regtype: 'remote', 'local', or 'status'"""
if reqtype == 'remote':
- name = account.getconf('remoterepository')
+ name = uniString(account.getconf('remoterepository'))
# We don't support Maildirs on the remote side.
typemap = {'IMAP': IMAPRepository,
'Gmail': GmailRepository}
elif reqtype == 'local':
- name = account.getconf('localrepository')
+ name = uniString(account.getconf('localrepository'))
typemap = {'IMAP': MappedIMAPRepository,
'Maildir': MaildirRepository,
'GmailMaildir': GmailMaildirRepository}
elif reqtype == 'status':
# create and return a LocalStatusRepository.
- name = account.getconf('localrepository')
+ name = uniString(account.getconf('localrepository'))
return LocalStatusRepository(name, account)
else:
- errstr = "Repository type %s not supported" % reqtype
+ errstr = "Repository type %s not supported"% reqtype
raise OfflineImapError(errstr, OfflineImapError.ERROR.REPO)
# Get repository type.
config = account.getconfig()
try:
- repostype = config.get('Repository ' + name, 'type').strip()
+ repostype = uniString(config.get(
+ 'Repository ' + name.uni, 'type').strip())
+ isASCII(repostype.uni, exception_msg=
+ "repository type must be plain ASCII")
except NoSectionError as e:
- errstr = ("Could not find section '%s' in configuration. Required "
- "for account '%s'." % ('Repository %s' % name, account))
- raise OfflineImapError(errstr, OfflineImapError.ERROR.REPO), \
- None, exc_info()[2]
+ errstr = ("Could not find section Repository '%s' in configuration."
+ " Required for account '%s'."% (name.fs, account.getname().fs))
+ raise OfflineImapError(
+ errstr, OfflineImapError.ERROR.REPO), None, exc_info()[2]
try:
- repo = typemap[repostype]
+ repo = typemap[repostype.dbytes]
except KeyError:
- errstr = "'%s' repository not supported for '%s' repositories."% \
- (repostype, reqtype)
- raise OfflineImapError(errstr, OfflineImapError.ERROR.REPO), \
- None, exc_info()[2]
+ errstr = ("'%s' repository not supported for '%s' repositories."%
+ (repostype.fs, reqtype))
+ raise OfflineImapError(
+ errstr, OfflineImapError.ERROR.REPO), None, exc_info()[2]
return repo(name, account)
@@ -87,6 +92,6 @@ class Repository(object):
executed instead of this stub
:param account: :class:`Account`
- :param regtype: 'remote', 'local', or 'status'
+ :param regtype: uni object of 'remote', 'local', or 'status'
"""
pass
diff --git a/offlineimap/syncmaster.py b/offlineimap/syncmaster.py
index 5fd0dee..e6a4648 100644
--- a/offlineimap/syncmaster.py
+++ b/offlineimap/syncmaster.py
@@ -16,24 +16,34 @@
# 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 currentThread
+
from offlineimap.threadutil import threadlist, InstanceLimitedThread
from offlineimap.accounts import SyncableAccount
-from threading import currentThread
+from offlineimap.utils.uni import uniString
+
def syncaccount(threads, config, accountname):
account = SyncableAccount(config, accountname)
- thread = InstanceLimitedThread(instancename = 'ACCOUNTLIMIT',
- target = account.syncrunner,
- name = "Account sync %s" % accountname)
+ thread = InstanceLimitedThread(
+ instancename=uniString(u'ACCOUNTLIMIT'), # Not redirected to Thread.
+ target=account.syncrunner,
+ name="Account sync %s"% accountname.std)
thread.setDaemon(True)
+ # Actually start thread.
thread.start()
+ # Add started thread to the list.
threads.add(thread)
def syncitall(accounts, config):
- # Special exit message for SyncRunner thread, so main thread can exit
+ # Special exit message for SyncRunner thread, so main thread can exit.
currentThread().exit_message = 'SYNCRUNNER_EXITED_NORMALLY'
+ # Retrieve all prepared threads.
threads = threadlist()
- for accountname in accounts:
- syncaccount(threads, config, accountname)
+ # accounts is a list of (unicode) names.
+ for uni_accountname in accounts:
+ syncaccount(threads, config, uniString(uni_accountname))
# Wait for the threads to finish.
+ # FIXME: should actually be called 'join' (much more undersantable), instead
+ # of 'reset'.
threads.reset()
diff --git a/offlineimap/threadutil.py b/offlineimap/threadutil.py
index f69f8a6..294a45b 100644
--- a/offlineimap/threadutil.py
+++ b/offlineimap/threadutil.py
@@ -15,7 +15,7 @@
# 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 Lock, Thread, BoundedSemaphore, currentThread
+from threading import Lock, Thread, BoundedSemaphore
try:
from Queue import Queue, Empty
except ImportError: # python3
@@ -23,8 +23,14 @@ except ImportError: # python3
import traceback
import os.path
import sys
+
from offlineimap.ui import getglobalui
+#
+# UNICODE: Thread library has ASCII expectations.
+#
+
+
######################################################################
# General utilities
######################################################################
@@ -70,6 +76,7 @@ class threadlist:
finally:
self.lock.release()
+ # Fix name.
def reset(self):
while 1:
thread = self.pop()
@@ -109,11 +116,11 @@ def exitnotifymonitorloop(callback):
# we need a timeout in the get() call, so that ctrl-c can throw
# a SIGINT (http://bugs.python.org/issue1360). A timeout with empty
# Queue will raise `Empty`.
- thrd = exitthreads.get(True, 60)
+ thrd = exitthreads.get(True, 10)
# request to abort when callback returns true
do_loop = (callback(thrd) != True)
except Empty:
- pass
+ pass # ???
def threadexited(thread):
"""Called when a thread exits.
@@ -133,12 +140,12 @@ def threadexited(thread):
return True
else:
ui.threadExited(thread)
- return False
+ return False
class ExitNotifyThread(Thread):
"""This class is designed to alert a "monitor" to the fact that a
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
+ why. All instances are made daemon threads (setDaemon(True), so we
bail out when the mainloop dies.
The thread can set instance variables self.exit_message for a human
@@ -171,8 +178,8 @@ class ExitNotifyThread(Thread):
prof = prof.runctx("Thread.run(self)", globals(), locals())
except SystemExit:
pass
- prof.dump_stats(os.path.join(ExitNotifyThread.profiledir,
- "%s_%s.prof"% (self.ident, self.getName())))
+ prof.dump_stats(os.path.join(ExitNotifyThread.profiledir.fs,
+ "%s_%s.prof"% (self.ident.fs, self.getName().fs)))
except Exception as e:
# Thread exited with Exception, store it
tb = traceback.format_exc()
@@ -218,7 +225,9 @@ instancelimitedlock = Lock()
def initInstanceLimit(instancename, instancemax):
"""Initialize the instance-limited thread implementation to permit
- up to intancemax threads with the given instancename."""
+ up to intancemax threads with the given instancename.
+
+ :param instancename: instance name (uni object)."""
instancelimitedlock.acquire()
if not instancename in instancelimitedsems:
diff --git a/offlineimap/ui/Curses.py b/offlineimap/ui/Curses.py
index ddc05ea..e4214ab 100644
--- a/offlineimap/ui/Curses.py
+++ b/offlineimap/ui/Curses.py
@@ -25,6 +25,8 @@ import logging
from offlineimap.ui.UIBase import UIBase
from offlineimap.threadutil import ExitNotifyThread
+from offlineimap.utils import uni
+from offlineimap.utils.uni import fsString
import offlineimap
@@ -180,7 +182,8 @@ class CursesAccountFrame:
# if this belongs to an Account (and not *Control), set the
# skipsleep pref
if isinstance(self.account, offlineimap.accounts.Account):
- self.ui.info("Requested synchronization for acc: %s"% self.account)
+ self.ui.info(u"Requested synchronization for acc: %s"%
+ self.account)
self.account.config.set('Account %s'% self.account.name,
'skipsleep', '1')
@@ -348,7 +351,12 @@ class Blinkenlights(UIBase, CursesUtil):
ch = CursesLogHandler()
#ch.setLevel(logging.DEBUG)
# create formatter and add it to the handlers
- self.formatter = logging.Formatter("%(message)s")
+ if uni.use_unicode():
+ encode_function = uni.uni2fs
+ else:
+ encode_function = None
+ self.formatter = uni.UnicodeFormatter("%(message)s",
+ encode_function=encode_function)
ch.setFormatter(self.formatter)
# add the handlers to the logger
self.logger.addHandler(ch)
@@ -511,7 +519,7 @@ class Blinkenlights(UIBase, CursesUtil):
return
if chr(key) == 'q':
# Request to quit completely.
- self.warn("Requested shutdown via 'q'")
+ self.warn(u"Requested shutdown via 'q'")
offlineimap.accounts.Account.set_abort_event(self.config, 3)
try:
index = int(chr(key))
@@ -525,7 +533,7 @@ class Blinkenlights(UIBase, CursesUtil):
def sleep(self, sleepsecs, account):
self.gettf().setcolor('red')
- self.info("Next sync in %d:%02d"% (sleepsecs / 60, sleepsecs % 60))
+ self.info(u"Next sync in %d:%02d"% (sleepsecs / 60, sleepsecs % 60))
return super(Blinkenlights, self).sleep(sleepsecs, account)
def sleeping(self, sleepsecs, remainingsecs):
@@ -551,15 +559,15 @@ class Blinkenlights(UIBase, CursesUtil):
self.lock()
try:
#s.gettf().setcolor('white')
- self.warn(" *** Input Required")
- self.warn(" *** Please enter password for account %s: " % \
- accountname)
+ self.warn(u" *** Input Required")
+ self.warn(u" *** Please enter password for account %s: "%
+ accountname)
self.logwin.refresh()
password = self.logwin.getstr()
finally:
self.unlock()
self.inputhandler.input_release()
- return password
+ return fsString(password)
def setupwindows(self, resize=False):
"""Setup and draw bannerwin and logwin.
diff --git a/offlineimap/ui/Machine.py b/offlineimap/ui/Machine.py
index dc650c3..cda1f1b 100644
--- a/offlineimap/ui/Machine.py
+++ b/offlineimap/ui/Machine.py
@@ -20,14 +20,31 @@ except ImportError: # python3
import sys
import time
import logging
+
from threading import currentThread
from offlineimap.ui.UIBase import UIBase
+from offlineimap.utils import uni
+from offlineimap.utils.uni import dbytesString
import offlineimap
protocol = '7.0.0'
-class MachineLogFormatter(logging.Formatter):
+#
+# UNICODE: This module is a low-level UI driver. Work with Unicode strings.
+#
+
+
+def getThreadname(thread):
+ return dbytesString(thread.getName()).uni
+
+
+class MachineLogFormatter(uni.UnicodeFormatter):
"""urlencodes any outputted line, to avoid multi-line output"""
+
+ def __init__(self, fmt, datefmt=None):
+ uni.UnicodeFormatter.__init__(self, fmt, datefmt,
+ encode_function=uni.uni2bytes)
+
def format(s, record):
# Mapping of log levels to historic tag names
severity_map = {
@@ -43,10 +60,10 @@ class MachineLogFormatter(logging.Formatter):
whoami = record.machineui["id"]
else:
command = ""
- whoami = currentThread().getName()
+ whoami = getThreadname(currentThread())
- prefix = "%s:%s"% (command, urlencode([('', whoami)])[1:])
- return "%s:%s:%s"% (severity, prefix, urlencode([('', line)])[1:])
+ prefix = u"%s:%s"% (command, urlencode([(u'', whoami)])[1:])
+ return u"%s:%s:%s"% (severity, prefix, urlencode([(u'', line)])[1:])
class MachineUI(UIBase):
@@ -67,7 +84,7 @@ class MachineUI(UIBase):
extra = {
'machineui': {
'command': command,
- 'id': currentThread().getName(),
+ 'id': getThreadname(currentThread())
}
})
@@ -84,7 +101,7 @@ class MachineUI(UIBase):
def unregisterthread(s, thread):
UIBase.unregisterthread(s, thread)
- s._printData(s.logger.info, 'unregisterthread', thread.getName())
+ s._printData(s.logger.info, 'unregisterthread', getThreadname(thread))
def debugging(s, debugtype):
s._printData(s.logger.debug, 'debugging', debugtype)
@@ -96,79 +113,80 @@ class MachineUI(UIBase):
s._printData(s.logger.info, 'acctdone', accountname)
def validityproblem(s, folder):
- s._printData(s.logger.warning, 'validityproblem', "%s\n%s\n%s\n%s"%
- (folder.getname(), folder.getrepository().getname(),
+ s._printData(s.logger.warning, 'validityproblem', u"%s\n%s\n%s\n%s"%
+ (folder.getname().uni, folder.getrepository().getname().uni,
folder.get_saveduidvalidity(), folder.get_uidvalidity()))
- def connecting(s, hostname, port):
- s._printData(s.logger.info, 'connecting', "%s\n%s"% (hostname, str(port)))
+ def connecting(s, uni_hostname, port):
+ s._printData(s.logger.info, 'connecting', u"%s\n%s"%
+ (uni_hostname, str(port)))
def syncfolders(s, srcrepos, destrepos):
- s._printData(s.logger.info, 'syncfolders', "%s\n%s"% (s.getnicename(srcrepos),
- s.getnicename(destrepos)))
+ s._printData(s.logger.info, 'syncfolders', u"%s\n%s"%
+ (s.getnicename(srcrepos), s.getnicename(destrepos)))
def syncingfolder(s, srcrepos, srcfolder, destrepos, destfolder):
- s._printData(s.logger.info, 'syncingfolder', "%s\n%s\n%s\n%s\n"%
+ s._printData(s.logger.info, 'syncingfolder', u"%s\n%s\n%s\n%s\n"%
(s.getnicename(srcrepos), srcfolder.getname(),
s.getnicename(destrepos), destfolder.getname()))
def loadmessagelist(s, repos, folder):
- s._printData(s.logger.info, 'loadmessagelist', "%s\n%s"% (s.getnicename(repos),
- folder.getvisiblename()))
+ s._printData(s.logger.info, 'loadmessagelist', u"%s\n%s"%
+ (s.getnicename(repos), folder.getvisiblename().uni))
def messagelistloaded(s, repos, folder, count):
- s._printData(s.logger.info, 'messagelistloaded', "%s\n%s\n%d"%
- (s.getnicename(repos), folder.getname(), count))
+ s._printData(s.logger.info, 'messagelistloaded', u"%s\n%s\n%d"%
+ (s.getnicename(repos), folder.getname().uni, count))
def syncingmessages(s, sr, sf, dr, df):
- s._printData(s.logger.info, 'syncingmessages', "%s\n%s\n%s\n%s\n"%
- (s.getnicename(sr), sf.getname(), s.getnicename(dr),
- df.getname()))
+ s._printData(s.logger.info, 'syncingmessages', u"%s\n%s\n%s\n%s\n"%
+ (s.getnicename(sr), sf.getname().uni, s.getnicename(dr),
+ df.getname().uni))
def copyingmessage(s, uid, num, num_to_copy, srcfolder, destfolder):
- s._printData(s.logger.info, 'copyingmessage', "%d\n%s\n%s\n%s[%s]"%
- (uid, s.getnicename(srcfolder), srcfolder.getname(),
+ s._printData(s.logger.info, 'copyingmessage', u"%d\n%s\n%s\n%s[%s]"%
+ (uid, s.getnicename(srcfolder), srcfolder.getname().uni,
s.getnicename(destfolder), destfolder))
def folderlist(s, list):
- return ("\f".join(["%s\t%s"% (s.getnicename(x), x.getname()) for x in list]))
+ return (u"\f".join([u"%s\t%s"% (s.getnicename(x), x.getname().uni) for x in list]))
def uidlist(s, list):
- return ("\f".join([str(u) for u in list]))
+ return (u"\f".join([str(u) for u in list]))
def deletingmessages(s, uidlist, destlist):
ds = s.folderlist(destlist)
- s._printData(s.logger.info, 'deletingmessages', "%s\n%s"% (s.uidlist(uidlist), ds))
+ s._printData(s.logger.info, 'deletingmessages', u"%s\n%s"%
+ (s.uidlist(uidlist), ds))
def addingflags(s, uidlist, flags, dest):
- s._printData(s.logger.info, "addingflags", "%s\n%s\n%s"% (s.uidlist(uidlist),
- "\f".join(flags),
- dest))
+ s._printData(s.logger.info, "addingflags", u"%s\n%s\n%s"%
+ (s.uidlist(uidlist), u"\f".join(flags), dest))
def deletingflags(s, uidlist, flags, dest):
- s._printData(s.logger.info, 'deletingflags', "%s\n%s\n%s"% (s.uidlist(uidlist),
- "\f".join(flags),
- dest))
+ s._printData(s.logger.info, 'deletingflags', u"%s\n%s\n%s"%
+ (s.uidlist(uidlist), u"\f".join(flags), dest))
def threadException(s, thread):
- s._printData(s.logger.warning, 'threadException', "%s\n%s"%
- (thread.getName(), s.getThreadExceptionString(thread)))
+ s._printData(s.logger.warning, 'threadException', u"%s\n%s"%
+ (getThreadname(thread), s.getThreadExceptionString(thread)))
s.delThreadDebugLog(thread)
s.terminate(100)
def terminate(s, exitstatus=0, errortitle='', errormsg=''):
- s._printData(s.logger.info, 'terminate', "%d\n%s\n%s"% (exitstatus, errortitle, errormsg))
+ s._printData(s.logger.info, 'terminate', u"%d\n%s\n%s"%
+ (exitstatus, errortitle, errormsg))
sys.exit(exitstatus)
def mainException(s):
s._printData(s.logger.warning, 'mainException', s.getMainExceptionString())
def threadExited(s, thread):
- s._printData(s.logger.info, 'threadExited', thread.getName())
+ s._printData(s.logger.info, 'threadExited', getThreadname(thread))
UIBase.threadExited(s, thread)
def sleeping(s, sleepsecs, remainingsecs):
- s._printData(s.logger.info, 'sleeping', "%d\n%d"% (sleepsecs, remainingsecs))
+ s._printData(s.logger.info, 'sleeping', u"%d\n%d"% (sleepsecs, remainingsecs))
if sleepsecs > 0:
time.sleep(sleepsecs)
return 0
@@ -176,9 +194,8 @@ class MachineUI(UIBase):
def getpass(s, accountname, config, errmsg=None):
if errmsg:
- s._printData(s.logger.warning,
- 'getpasserror', "%s\n%s"% (accountname, errmsg),
- False)
+ s._printData(s.logger.warning, 'getpasserror', u"%s\n%s"%
+ (accountname, errmsg), False)
s._log_con_handler.acquire() # lock the console output
try:
diff --git a/offlineimap/ui/TTY.py b/offlineimap/ui/TTY.py
index 0b5aa6a..ae2459a 100644
--- a/offlineimap/ui/TTY.py
+++ b/offlineimap/ui/TTY.py
@@ -19,31 +19,45 @@ import logging
import sys
import time
from getpass import getpass
+
from offlineimap import banner
from offlineimap.ui.UIBase import UIBase
+from offlineimap.utils import uni
+from offlineimap.utils.uni import fsString
+
-class TTYFormatter(logging.Formatter):
+class TTYFormatter(uni.UnicodeFormatter):
"""Specific Formatter that adds thread information to the log output."""
- def __init__(self, *args, **kwargs):
+ def __init__(self, fmt, datefmt=None):
#super() doesn't work in py2.6 as 'logging' uses old-style class
- logging.Formatter.__init__(self, *args, **kwargs)
+ if uni.use_unicode():
+ encode_function = uni.uni2fs
+ else:
+ encode_function = None
+ uni.UnicodeFormatter.__init__(self, fmt, datefmt,
+ encode_function=encode_function)
self._last_log_thread = None
def format(self, record):
- """Override format to add thread information."""
+ """Override format to add thread information.
- #super() doesn't work in py2.6 as 'logging' uses old-style class
- log_str = logging.Formatter.format(self, record)
+ We are near to output. It's convenient to encode everything here."""
+
+ # super() doesn't work in py2.6 as 'logging' uses old-style class.
+ log_str = uni.UnicodeFormatter.format(self, 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
+ #
+ # Because the Thread module does not support Unicode, threadName is
+ # encoded with uni.ENCODING. Re-encode to filesystem.
+ t_name = uni.uni2fs(uni.bytes2uni(record.threadName))
if t_name == 'MainThread':
- return log_str # main thread doesn't get things prepended
+ 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)
+ log_str = "%s:\n %s"% (t_name, log_str)
else:
log_str = " %s"% log_str
return log_str
@@ -60,7 +74,7 @@ class TTYUI(UIBase):
ch = logging.StreamHandler()
#ch.setLevel(logging.DEBUG)
# create formatter and add it to the handlers
- self.formatter = TTYFormatter("%(message)s")
+ self.formatter = TTYFormatter(u"%(message)s")
ch.setFormatter(self.formatter)
# add the handlers to the logger
self.logger.addHandler(ch)
@@ -78,17 +92,18 @@ class TTYUI(UIBase):
"""TTYUI backend is capable of querying the password."""
if errmsg:
- self.warn("%s: %s"% (accountname, errmsg))
+ self.warn(u"%s: %s"% (accountname, errmsg))
self._log_con_handler.acquire() # lock the console output
try:
- return getpass("Enter password for account '%s': " % accountname)
+ return fsString(getpass(
+ u"Enter password for account '%s': "% accountname))
finally:
self._log_con_handler.release()
def mainException(self):
if isinstance(sys.exc_info()[1], KeyboardInterrupt):
- self.logger.warn("Timer interrupted at user request; program "
- "terminating.\n")
+ self.logger.warn(u"Timer interrupted at user request; program "
+ u"terminating.\n")
self.terminate()
else:
UIBase.mainException(self)
@@ -105,7 +120,7 @@ class TTYUI(UIBase):
if sleepsecs > 0:
if remainingsecs//60 != (remainingsecs-sleepsecs)//60:
- self.logger.info("Next refresh in %.1f minutes" % (
- remainingsecs/60.0))
+ self.logger.info(u"Next refresh in %.1f minutes"%
+ (remainingsecs/60.0))
time.sleep(sleepsecs)
return 0
diff --git a/offlineimap/ui/UIBase.py b/offlineimap/ui/UIBase.py
index 9285b51..75ee3fd 100644
--- a/offlineimap/ui/UIBase.py
+++ b/offlineimap/ui/UIBase.py
@@ -26,8 +26,14 @@ try:
except ImportError: #python3
from queue import Queue
from collections import deque
+
+from offlineimap import globals
from offlineimap.error import OfflineImapError
import offlineimap
+from offlineimap.utils import uni
+from offlineimap.utils.uni import fsString
+from offlineimap.utils import hack
+
debugtypes = {'':'Other offlineimap related sync messages',
'imap': 'IMAP protocol debugging',
@@ -82,7 +88,12 @@ class UIBase(object):
ch = logging.StreamHandler(sys.stdout)
#ch.setLevel(logging.DEBUG)
# create formatter and add it to the handlers
- self.formatter = logging.Formatter("%(message)s")
+ if globals.options.use_unicode:
+ encode_function = uni.uni2fs
+ else:
+ encode_function = None
+ self.formatter = uni.UnicodeFormatter("%(message)s",
+ encode_function=encode_function)
ch.setFormatter(self.formatter)
# add the handlers to the logger
self.logger.addHandler(ch)
@@ -92,16 +103,22 @@ class UIBase(object):
def setlogfile(self, logfile):
"""Create file handler which logs to file."""
- fh = logging.FileHandler(logfile, 'at')
- file_formatter = logging.Formatter("%(asctime)s %(levelname)s: "
- "%(message)s", '%Y-%m-%d %H:%M:%S')
+ if globals.options.use_unicode:
+ encode_function = uni.uni2bytes
+ # logfile was kept encoded.
+ else:
+ encoding = uni.uni2std
+ fh = logging.FileHandler(logfile, 'at', encoding=encoding)
+ file_formatter = uni.UnicodeFormatter(u"%(asctime)s %(levelname)s: "
+ u"%(message)s", '%Y-%m-%d %H:%M:%S',
+ encode_function=None)
fh.setFormatter(file_formatter)
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.__bigversion__, p_ver, sys.platform,
- " ".join(sys.argv))
+ msg = u"OfflineImap %s starting...\n Python: %s Platform: %s\n "\
+ u"Args: %s"% (offlineimap.__bigversion__, p_ver, sys.platform,
+ u" ".join(sys.argv))
self.logger.info(msg)
def _msg(self, msg):
@@ -142,10 +159,12 @@ class UIBase(object):
ui.error(exc, sys.exc_info()[2], msg="While syncing Folder %s in "
"repo %s")
"""
+
if msg:
- self.logger.error("ERROR: %s\n %s" % (msg, exc))
+ self.logger.error(u"ERROR: %s\n %s"%
+ (msg, fsString(str(exc)).uni))
else:
- self.logger.error("ERROR: %s" % (exc))
+ self.logger.error(u"ERROR: %s"% (fsString(str(exc)).uni))
instant_traceback = exc_traceback
if not self.debuglist:
@@ -160,14 +179,15 @@ class UIBase(object):
"""Register current thread as being associated with an account name."""
cur_thread = threading.currentThread()
+ thr_name = cur_thread.getName()
if cur_thread in self.threadaccounts:
# was already associated with an old account, update info
- self.debug('thread', "Register thread '%s' (previously '%s', now "
- "'%s')" % (cur_thread.getName(),
- self.getthreadaccount(cur_thread), account))
+ self.debug('thread', u"Register thread '%s' "
+ u"(previously '%s', now '%s')"% (thr_name,
+ self.getthreadaccount(cur_thread), account))
else:
- self.debug('thread', "Register new thread '%s' (account '%s')"%
- (cur_thread.getName(), account))
+ self.debug('thread', u"Register new thread '%s' (account '%s')"%
+ (thr_name, account))
self.threadaccounts[cur_thread] = account
def unregisterthread(self, thr):
@@ -175,7 +195,8 @@ class UIBase(object):
if thr in self.threadaccounts:
del self.threadaccounts[thr]
- self.debug('thread', "Unregister thread '%s'" % thr.getName())
+ thr_name = thr.getName()
+ self.debug('thread', u"Unregister thread '%s'"% thr_name)
def getthreadaccount(self, thr=None):
"""Get Account() for a thread (current if None)
@@ -195,14 +216,14 @@ class UIBase(object):
# introduced in p2.6 only, so we'll need to work around and
# shorten our debugmsg list manually :-(
self.debugmessages[cur_thread] = deque()
- self.debugmessages[cur_thread].append("%s: %s" % (debugtype, msg))
+ self.debugmessages[cur_thread].append(u"%s: %s"% (debugtype, msg))
# Shorten queue if needed
if len(self.debugmessages[cur_thread]) > self.debugmsglen:
self.debugmessages[cur_thread].popleft()
if debugtype in self.debuglist: # log if we are supposed to do so
- self.logger.debug("[%s]: %s" % (debugtype, msg))
+ self.logger.debug("u[%s]: %s"% (debugtype, msg))
def add_debug(self, debugtype):
global debugtypes
@@ -215,18 +236,18 @@ class UIBase(object):
def debugging(self, debugtype):
global debugtypes
- self.logger.debug("Now debugging for %s: %s" % (debugtype,
- debugtypes[debugtype]))
+ msg = u"Now debugging for %s: %s"% (debugtype, debugtypes[debugtype])
+ self.logger.debug(msg)
def invaliddebug(self, debugtype):
- self.warn("Invalid debug type: %s" % debugtype)
+ self.warn(u"Invalid debug type: %s"% debugtype)
- def getnicename(self, object):
+ def getnicename(self, obj):
"""Return the type of a repository or Folder as string.
(IMAP, Gmail, Maildir, etc...)"""
- prelimname = object.__class__.__name__.split('.')[-1]
+ prelimname = obj.__class__.__name__.split('.')[-1]
# Strip off extra stuff.
return re.sub('(Folder|Repository)', '', prelimname)
@@ -239,20 +260,20 @@ class UIBase(object):
################################################## INPUT
- def getpass(self, accountname, config, errmsg = None):
+ def getpass(self, accountname, config, errmsg=None):
raise NotImplementedError("Prompting for a password is not supported"
" in this UI backend.")
def folderlist(self, folder_list):
- return ', '.join(["%s[%s]"% \
- (self.getnicename(x), x.getname()) for x in folder_list])
+ return u', '.join([u"%s[%s]"% \
+ (self.getnicename(x), x.getname().uni) for x in folder_list])
################################################## WARNINGS
def msgtoreadonly(self, destfolder, uid, content, flags):
if self.config.has_option('general', 'ignore-readonly') and \
self.config.getboolean('general', 'ignore-readonly'):
return
- self.warn("Attempted to synchronize message %d to folder %s[%s], "
+ self.warn(u"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))
@@ -261,7 +282,7 @@ class UIBase(object):
if self.config.has_option('general', 'ignore-readonly') and \
self.config.getboolean('general', 'ignore-readonly'):
return
- self.warn("Attempted to modify flags for messages %s in folder %s[%s], "
+ self.warn(u"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))
@@ -270,7 +291,7 @@ class UIBase(object):
if self.config.has_option('general', 'ignore-readonly') and \
self.config.getboolean('general', 'ignore-readonly'):
return
- self.warn("Attempted to modify labels for messages %s in folder %s[%s], "
+ self.warn(u"Attempted to modify labels for messages %s in folder %s[%s], "
"but that folder is read-only. No labels have been modified "
"for that message."% (
str(uidlist), self.getnicename(destfolder), destfolder))
@@ -279,7 +300,7 @@ class UIBase(object):
if self.config.has_option('general', 'ignore-readonly') and \
self.config.getboolean('general', 'ignore-readonly'):
return
- self.warn("Attempted to delete messages %s in folder %s[%s], but that "
+ self.warn(u"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))
@@ -298,162 +319,173 @@ class UIBase(object):
if not self.logger.isEnabledFor(logging.INFO): return
displaystr = ''
- hostname = hostname if hostname else ''
- port = "%s"% port if port else ''
+ hostname = hostname if hostname else u''
+ port = u"%s"% port if port else u''
if hostname:
- displaystr = ' to %s:%s' % (hostname, port)
- self.logger.info("Establishing connection%s" % displaystr)
+ displaystr = u' to %s:%s'% (hostname, port)
+ self.logger.info(u"Establishing connection%s"% displaystr)
def acct(self, account):
"""Output that we start syncing an account (and start counting)."""
self.acct_startimes[account] = time.time()
- self.logger.info("*** Processing account %s" % account)
+ self.logger.info(u"*** Processing account %s"% account)
def acctdone(self, account):
"""Output that we finished syncing an account (in which time)."""
sec = time.time() - self.acct_startimes[account]
del self.acct_startimes[account]
- self.logger.info("*** Finished account '%s' in %d:%02d"%
+ self.logger.info(u"*** Finished account '%s' in %d:%02d"%
(account, sec // 60, sec % 60))
def syncfolders(self, src_repo, dst_repo):
"""Log 'Copying folder structure...'."""
if self.logger.isEnabledFor(logging.DEBUG):
- self.debug('', "Copying folder structure from %s to %s" %\
- (src_repo, dst_repo))
+ self.debug('', u"Copying folder structure from %s to %s"%
+ (src_repo, dst_repo))
############################## Folder syncing
def makefolder(self, repo, foldername):
"""Called when a folder is created."""
- prefix = "[DRYRUN] " if self.dryrun else ""
- self.info(("{0}Creating folder {1}[{2}]".format(
+ prefix = u"[DRYRUN] " if self.dryrun else u""
+ self.info((u"{0}Creating folder {1}[{2}]".format(
prefix, foldername, repo)))
def syncingfolder(self, srcrepos, srcfolder, destrepos, destfolder):
"""Called when a folder sync operation is started."""
- self.logger.info("Syncing %s: %s -> %s"% (srcfolder,
+ self.logger.info(u"Syncing %s: %s -> %s"% (srcfolder,
self.getnicename(srcrepos),
self.getnicename(destrepos)))
def skippingfolder(self, folder):
"""Called when a folder sync operation is started."""
- self.logger.info("Skipping %s (not changed)" % folder)
+
+ self.logger.info(u"Skipping %s (not changed)"% folder)
def validityproblem(self, folder):
- self.logger.warning("UID validity problem for folder %s (repo %s) "
- "(saved %d; got %d); skipping it. Please see FAQ "
- "and manual on how to handle this."% \
- (folder, folder.getrepository(),
- folder.get_saveduidvalidity(), folder.get_uidvalidity()))
+ msg = u"UID validity problem for folder %s (repo %s) " \
+ "(saved %d; got %d); skipping it. Please see FAQ " \
+ "and manual on how to handle this."% \
+ (folder, folder.getrepository(),
+ folder.get_saveduidvalidity(),
+ folder.get_uidvalidity())
+ self.logger.warning(msg)
def loadmessagelist(self, repos, folder):
- self.logger.debug("Loading message list for %s[%s]"% (
- self.getnicename(repos),
- folder))
+ msg = u"Loading message list for %s[%s]"% (
+ self.getnicename(repos), folder)
+ self.logger.debug(msg)
def messagelistloaded(self, repos, folder, count):
- self.logger.debug("Message list for %s[%s] loaded: %d messages" % (
- self.getnicename(repos), folder, count))
+ self.logger.debug(u"Message list for %s[%s] loaded: %d messages"%
+ (self.getnicename(repos), folder, count))
############################## Message syncing
def syncingmessages(self, sr, srcfolder, dr, dstfolder):
- self.logger.debug("Syncing messages %s[%s] -> %s[%s]" % (
- self.getnicename(sr), srcfolder,
- self.getnicename(dr), dstfolder))
+ msg = u"Syncing messages %s[%s] -> %s[%s]"% (
+ self.getnicename(sr), srcfolder,
+ self.getnicename(dr), dstfolder)
+ self.logger.debug(msg)
def copyingmessage(self, uid, num, num_to_copy, src, destfolder):
- """Output a log line stating which message we copy"""
- self.logger.info("Copy message %s (%d of %d) %s:%s -> %s" % (
+ """Output a log line stating which message we copy. """
+
+ self.logger.info(u"Copy message %s (%d of %d) %s:%s -> %s"% (
uid, num, num_to_copy, src.repository, src,
destfolder.repository))
def deletingmessages(self, uidlist, destlist):
ds = self.folderlist(destlist)
- prefix = "[DRYRUN] " if self.dryrun else ""
- self.info("{0}Deleting {1} messages ({2}) in {3}".format(
+ prefix = u"[DRYRUN] " if self.dryrun else u""
+ self.info(u"{0}Deleting {1} messages ({2}) in {3}".format(
prefix, len(uidlist),
offlineimap.imaputil.uid_sequence(uidlist), ds))
def addingflags(self, uidlist, flags, dest):
- self.logger.info("Adding flag %s to %d messages on %s" % (
- ", ".join(flags), len(uidlist), dest))
+ msg = u"Adding flag %s to %d messages on %s"% (
+ u", ".join(flags), len(uidlist), dest)
+ self.logger.info(msg)
def deletingflags(self, uidlist, flags, dest):
- self.logger.info("Deleting flag %s from %d messages on %s" % (
- ", ".join(flags), len(uidlist), dest))
+ msg = u"Deleting flag %s from %d messages on %s"% (
+ u", ".join(flags), len(uidlist), dest)
+ self.logger.info(msg)
def addinglabels(self, uidlist, label, dest):
- self.logger.info("Adding label %s to %d messages on %s" % (
- label, len(uidlist), dest))
+ msg = u"Adding label %s to %d messages on %s"% (
+ label, len(uidlist), dest)
+ self.logger.info(msg)
def deletinglabels(self, uidlist, label, dest):
- self.logger.info("Deleting label %s from %d messages on %s" % (
- label, len(uidlist), dest))
+ msg = u"Deleting label %s from %d messages on %s"% (
+ label, len(uidlist), dest)
+ self.logger.info(msg)
def settinglabels(self, uid, num, num_to_set, labels, dest):
- self.logger.info("Setting labels to message %d on %s (%d of %d): %s" % (
- uid, dest, num, num_to_set, ", ".join(labels)))
+ msg = u"Setting labels to message %d on %s (%d of %d): %s"% (
+ uid, dest, num, num_to_set, ", ".join(labels))
+ self.logger.info()
def collectingdata(self, uidlist, source):
if uidlist:
- self.logger.info("Collecting data from %d messages on %s"% (
- len(uidlist), source))
+ msg = u"Collecting data from %d messages on %s"% (
+ len(uidlist), source)
else:
- self.logger.info("Collecting data from messages on %s"% source)
+ msg = u"Collecting data from messages on %s"% source
+ self.logger.info(msg)
def serverdiagnostics(self, repository, type):
"""Connect to repository and output useful information for debugging."""
conn = None
- self._msg("%s repository '%s': type '%s'" % (type, repository.name,
- self.getnicename(repository)))
+ self._msg(u"%s repository '%s': type '%s'"% (
+ type, repository.getname().uni, self.getnicename(repository)))
try:
if hasattr(repository, 'gethost'): # IMAP
- self._msg("Host: %s Port: %s SSL: %s"% (repository.gethost(),
+ self._msg(u"Host: %s Port: %s SSL: %s"% (repository.gethost().uni,
repository.getport(), repository.getssl()))
try:
conn = repository.imapserver.acquireconnection()
except OfflineImapError as e:
- self._msg("Failed to connect. Reason %s" % e)
+ self._msg(u"Failed to connect. Reason %s"% e)
else:
if 'ID' in conn.capabilities:
- self._msg("Server supports ID extension.")
+ self._msg(u"Server supports ID extension.")
#TODO: Debug and make below working, it hangs Gmail
#res_type, response = conn.id((
# 'name', offlineimap.__productname__,
# 'version', offlineimap.__bigversion__))
- #self._msg("Server ID: %s %s" % (res_type, response[0]))
- self._msg("Server welcome string: %s" % str(conn.welcome))
- self._msg("Server capabilities: %s\n" % str(conn.capabilities))
+ #self._msg(u"Server ID: %s %s" % (res_type, response[0]))
+ self._msg(u"Server welcome string: %s"% str(conn.welcome))
+ self._msg(u"Server capabilities: %s\n"% str(conn.capabilities))
repository.imapserver.releaseconnection(conn)
if type != 'Status':
folderfilter = repository.getconf('folderfilter', None)
if folderfilter:
- self._msg("folderfilter= %s\n" % folderfilter)
+ self._msg(u"folderfilter= %s\n"% folderfilter)
folderincludes = repository.getconf('folderincludes', None)
if folderincludes:
- self._msg("folderincludes= %s\n" % folderincludes)
+ self._msg(u"folderincludes= %s\n"% folderincludes)
nametrans = repository.getconf('nametrans', None)
if nametrans:
- self._msg("nametrans= %s\n" % nametrans)
+ self._msg(u"nametrans= %s\n"% nametrans)
folders = repository.getfolders()
- foldernames = [(f.name, f.getvisiblename(), f.sync_this)
+ foldernames = [(f.getname().uni, f.getvisiblename().uni, f.sync_this)
for f in folders]
folders = []
for name, visiblename, sync_this in foldernames:
- syncstr = "" if sync_this else " (disabled)"
- if name == visiblename: folders.append("%s%s" % (name,
- syncstr))
- else: folders.append("%s -> %s%s" % (name,
- visiblename, syncstr))
- self._msg("Folderlist:\n %s\n" % "\n ".join(folders))
+ syncstr = u"" if sync_this else u" (disabled)"
+ if name == visiblename: folders.append(u"%s%s"%
+ (name, syncstr))
+ else: folders.append(u"%s -> %s%s"%
+ (name, visiblename, syncstr))
+ self._msg(u"Folderlist:\n %s\n"% u"\n ".join(folders))
finally:
if conn: #release any existing IMAP connection
repository.imapserver.close()
@@ -462,18 +494,18 @@ class UIBase(object):
"""Output a log line stating that we save a msg."""
self.debug(debugtype, "Write mail '%s:%d' with flags %s"%
- (folder, uid, repr(flags)))
+ (folder.getname().uni, uid, repr(flags)))
################################################## Threads
def getThreadDebugLog(self, thread):
+ thr_name = thread.getName()
if thread in self.debugmessages:
- message = "\nLast %d debug messages logged for %s prior to exception:\n"\
- % (len(self.debugmessages[thread]), thread.getName())
- message += "\n".join(self.debugmessages[thread])
+ message = u"\nLast %d debug messages logged for %s prior to" \
+ " exception:\n"% (len(self.debugmessages[thread]), thr_name)
+ message += u"\n".join(self.debugmessages[thread])
else:
- message = "\nNo debug messages were logged for %s."% \
- thread.getName()
+ message = u"\nNo debug messages were logged for %s."% thr_name
return message
def delThreadDebugLog(self, thread):
@@ -481,9 +513,10 @@ class UIBase(object):
del self.debugmessages[thread]
def getThreadExceptionString(self, thread):
- message = "Thread '%s' terminated with exception:\n%s"% \
- (thread.getName(), thread.exit_stacktrace)
- message += "\n" + self.getThreadDebugLog(thread)
+ thr_name = thread.getName()
+ message = u"Thread '%s' terminated with exception:\n%s"% (
+ thr_name, thread.exit_stacktrace)
+ message += u"\n" + self.getThreadDebugLog(thread)
return message
def threadException(self, thread):
@@ -497,23 +530,23 @@ class UIBase(object):
def terminate(self, exitstatus = 0, errortitle = None, errormsg = None):
"""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():
- self.warn("ERROR: Exceptions occurred during the run!")
+ self.warn(u"ERROR: Exceptions occurred during the run!")
while not self.exc_queue.empty():
msg, exc, exc_traceback = self.exc_queue.get()
if msg:
- self.warn("ERROR: %s\n %s"% (msg, exc))
+ self.warn(u"ERROR: %s\n %s"% (msg, fsString(str(exc)).uni))
else:
- self.warn("ERROR: %s"% (exc))
+ self.warn(u"ERROR: %s"% (fsString(str(exc)).uni))
if exc_traceback:
- self.warn("\nTraceback:\n%s"% "".join(
- traceback.format_tb(exc_traceback)))
+ self.warn(u"\nTraceback:\n%s"% u"".join(
+ traceback.format_tb(exc_traceback)))
if errormsg and errortitle:
- self.warn('ERROR: %s\n\n%s\n'% (errortitle, errormsg))
+ self.warn(u'ERROR: %s\n\n%s\n'% (errortitle, errormsg))
elif errormsg:
- self.warn('%s\n'% errormsg)
+ self.warn(u'%s\n'% errormsg)
sys.exit(exitstatus)
def threadExited(self, thread):
@@ -528,7 +561,7 @@ class UIBase(object):
def callhook(self, msg):
if self.dryrun:
- self.info("[DRYRUN] {0}".format(msg))
+ self.info(u"[DRYRUN] {0}".format(msg))
else:
self.info(msg)
@@ -566,7 +599,7 @@ class UIBase(object):
if sleepsecs > 0:
if remainingsecs//60 != (remainingsecs-sleepsecs)//60:
- self.logger.debug("Next refresh in %.1f minutes" % (
- remainingsecs/60.0))
+ self.logger.debug(u"Next refresh in %.1f minutes"% (
+ remainingsecs/60.0))
time.sleep(sleepsecs)
return 0
diff --git a/offlineimap/ui/debuglock.py b/offlineimap/ui/debuglock.py
index 673efb0..96609af 100644
--- a/offlineimap/ui/debuglock.py
+++ b/offlineimap/ui/debuglock.py
@@ -17,7 +17,14 @@
from threading import Lock, currentThread
import traceback
-logfile = open("/tmp/logfile", "wt")
+import codecs
+
+from offlineimap.utils import uni
+
+if uni.use_unicode():
+ logfile = codecs.open("/tmp/logfile", "wt", uni.ENCODING)
+else:
+ logfile = open("/tmp/logfile", "wt")
loglock = Lock()
class DebuggingLock:
@@ -26,24 +33,27 @@ class DebuggingLock:
self.name = name
def acquire(self, blocking = 1):
- self.print_tb("Acquire lock")
+ self.print_tb(u"Acquire lock")
self.lock.acquire(blocking)
- self.logmsg("===== %s: Thread %s acquired lock\n"%
+ self.logmsg(u"===== %s: Thread %s acquired lock\n"%
(self.name, currentThread().getName()))
def release(self):
- self.print_tb("Release lock")
+ self.print_tb(u"Release lock")
self.lock.release()
def logmsg(self, msg):
loglock.acquire()
- logfile.write(msg + "\n")
+ msg = msg + u"\n"
+ if uni.use_unicode():
+ msg = uni.uni2bytes(msg)
+ logfile.write(msg)
logfile.flush()
loglock.release()
def print_tb(self, msg):
- self.logmsg(".... %s: Thread %s attempting to %s\n"% \
- (self.name, currentThread().getName(), msg) + \
- "\n".join(traceback.format_list(traceback.extract_stack())))
+ self.logmsg(u".... %s: Thread %s attempting to %s\n"% \
+ (self.name, currentThread().getName(), msg) + \
+ u"\n".join(traceback.format_list(traceback.extract_stack())))
diff --git a/offlineimap/utils/const.py b/offlineimap/utils/const.py
index f4584bc..80fdd47 100644
--- a/offlineimap/utils/const.py
+++ b/offlineimap/utils/const.py
@@ -5,6 +5,11 @@
import copy
+#
+# UNICODE: assume variables to be full ASCII. Should be fine while
+# metaprogramming.
+#
+
class ConstProxy(object):
"""Implements read-only access to a given object
that can be attached to each instance only once."""
@@ -21,12 +26,12 @@ class ConstProxy(object):
def __setattr__(self, name, value):
- raise AttributeError("tried to set '%s' to '%s' for constant object"% \
+ raise AttributeError("tried to set '%s' to '%s' for constant object"%
(name, value))
def __delattr__(self, name):
- raise RuntimeError("tried to delete field '%s' from constant object"% \
+ raise RuntimeError("tried to delete field '%s' from constant object"%
(name))
diff --git a/offlineimap/utils/distro.py b/offlineimap/utils/distro.py
index 8cd2b79..3d35223 100644
--- a/offlineimap/utils/distro.py
+++ b/offlineimap/utils/distro.py
@@ -11,6 +11,8 @@ import os
# For the former we will just return the value, for an iterable
# we will walk through the values and will return the first
# one that corresponds to the existing file.
+#
+# UNICODE: all paths must be full ASCII.
__DEF_OS_LOCATIONS = {
'freebsd': '/usr/local/share/certs/ca-root-nss.crt',
'openbsd': '/etc/ssl/cert.pem',
@@ -35,9 +37,8 @@ def get_os_name():
the first component of platform.linux_distribution.
Return value will be all-lowercase to avoid confusion about
- proper name capitalisation.
+ proper name capitalisation."""
- """
OS = platform.system().lower()
if OS.startswith('linux'):
@@ -55,8 +56,7 @@ def get_os_sslcertfile_searchpath():
that they can iterate over result.
Returned value of None means that there is no search path
- at all.
- """
+ at all."""
OS = get_os_name()
@@ -83,9 +83,9 @@ def get_os_sslcertfile():
return None
for f in l:
- assert (type(f) == type(""))
- if os.path.exists(f) and \
- (os.path.isfile(f) or os.path.islink(f)):
- return f
+ assert (type(f) == type(""))
+ if os.path.exists(f) and (
+ os.path.isfile(f) or os.path.islink(f)):
+ return f
return None
--
2.2.2
More information about the OfflineIMAP-project
mailing list