summaryrefslogtreecommitdiff
path: root/src/leap/mail/imap/account.py
diff options
context:
space:
mode:
authorKali Kaneko <kali@leap.se>2014-10-16 14:51:53 +0200
committerKali Kaneko <kali@leap.se>2015-02-11 14:05:42 -0400
commit80ed7b9b85686b5d10f359114ca703dba4a5820b (patch)
treef041b51fa949c3b44e9a53a6e3c51b77fa8a6986 /src/leap/mail/imap/account.py
parentaa619124b9293b12d732e275c7f57b11dcb01f60 (diff)
adapt to soledad 0.7 async API
Diffstat (limited to 'src/leap/mail/imap/account.py')
-rw-r--r--src/leap/mail/imap/account.py253
1 files changed, 191 insertions, 62 deletions
diff --git a/src/leap/mail/imap/account.py b/src/leap/mail/imap/account.py
index 70ed13b..fe466cb 100644
--- a/src/leap/mail/imap/account.py
+++ b/src/leap/mail/imap/account.py
@@ -22,6 +22,7 @@ import logging
import os
import time
+from twisted.internet import defer
from twisted.mail import imap4
from twisted.python import log
from zope.interface import implements
@@ -65,6 +66,7 @@ class SoledadBackedAccount(WithMsgFields, IndexedDB, MBoxParser):
_soledad = None
selected = None
closed = False
+ _initialized = False
def __init__(self, account_name, soledad, memstore=None):
"""
@@ -93,14 +95,39 @@ class SoledadBackedAccount(WithMsgFields, IndexedDB, MBoxParser):
self.__mailboxes = set([])
- self.initialize_db()
+ self._deferred_initialization = defer.Deferred()
+ self._initialize_storage()
- # every user should have the right to an inbox folder
- # at least, so let's make one!
- self._load_mailboxes()
+ def _initialize_storage(self):
- if not self.mailboxes:
- self.addMailbox(self.INBOX_NAME)
+ def add_mailbox_if_none(result):
+ # every user should have the right to an inbox folder
+ # at least, so let's make one!
+ if not self.mailboxes:
+ self.addMailbox(self.INBOX_NAME)
+
+ def finish_initialization(result):
+ self._initialized = True
+ self._deferred_initialization.callback(None)
+
+ def load_mbox_cache(result):
+ d = self._load_mailboxes()
+ d.addCallback(lambda _: result)
+ return d
+
+ d = self.initialize_db()
+
+ d.addCallback(load_mbox_cache)
+ d.addCallback(add_mailbox_if_none)
+ d.addCallback(finish_initialization)
+
+ def callWhenReady(self, cb):
+ if self._initialized:
+ cb(self)
+ return defer.succeed(None)
+ else:
+ self._deferred_initialization.addCallback(cb)
+ return self._deferred_initialization
def _get_empty_mailbox(self):
"""
@@ -120,10 +147,14 @@ class SoledadBackedAccount(WithMsgFields, IndexedDB, MBoxParser):
:rtype: SoledadDocument
"""
# XXX use soledadstore instead ...;
- doc = self._soledad.get_from_index(
+ def get_first_if_any(docs):
+ return docs[0] if docs else None
+
+ d = self._soledad.get_from_index(
self.TYPE_MBOX_IDX, self.MBOX_KEY,
self._parse_mailbox_name(name))
- return doc[0] if doc else None
+ d.addCallback(get_first_if_any)
+ return d
@property
def mailboxes(self):
@@ -134,19 +165,12 @@ class SoledadBackedAccount(WithMsgFields, IndexedDB, MBoxParser):
return sorted(self.__mailboxes)
def _load_mailboxes(self):
- self.__mailboxes.update(
- [doc.content[self.MBOX_KEY]
- for doc in self._soledad.get_from_index(
- self.TYPE_IDX, self.MBOX_KEY)])
-
- @property
- def subscriptions(self):
- """
- A list of the current subscriptions for this account.
- """
- return [doc.content[self.MBOX_KEY]
- for doc in self._soledad.get_from_index(
- self.TYPE_SUBS_IDX, self.MBOX_KEY, '1')]
+ def update_mailboxes(db_indexes):
+ self.__mailboxes.update(
+ [doc.content[self.MBOX_KEY] for doc in db_indexes])
+ d = self._soledad.get_from_index(self.TYPE_IDX, self.MBOX_KEY)
+ d.addCallback(update_mailboxes)
+ return d
def getMailbox(self, name):
"""
@@ -182,7 +206,7 @@ class SoledadBackedAccount(WithMsgFields, IndexedDB, MBoxParser):
one is provided.
:type creation_ts: int
- :returns: True if successful
+ :returns: a Deferred that will contain the document if successful.
:rtype: bool
"""
name = self._parse_mailbox_name(name)
@@ -203,21 +227,29 @@ class SoledadBackedAccount(WithMsgFields, IndexedDB, MBoxParser):
mbox[self.MBOX_KEY] = name
mbox[self.CREATED_KEY] = creation_ts
- doc = self._soledad.create_doc(mbox)
- self._load_mailboxes()
- return bool(doc)
+ def load_mbox_cache(result):
+ d = self._load_mailboxes()
+ d.addCallback(lambda _: result)
+ return d
+
+ d = self._soledad.create_doc(mbox)
+ d.addCallback(load_mbox_cache)
+ return d
def create(self, pathspec):
"""
Create a new mailbox from the given hierarchical name.
- :param pathspec: The full hierarchical name of a new mailbox to create.
- If any of the inferior hierarchical names to this one
- do not exist, they are created as well.
+ :param pathspec:
+ The full hierarchical name of a new mailbox to create.
+ If any of the inferior hierarchical names to this one
+ do not exist, they are created as well.
:type pathspec: str
- :return: A true value if the creation succeeds.
- :rtype: bool
+ :return:
+ A deferred that will fire with a true value if the creation
+ succeeds.
+ :rtype: Deferred
:raise MailboxException: Raised if this mailbox cannot be added.
"""
@@ -225,18 +257,43 @@ class SoledadBackedAccount(WithMsgFields, IndexedDB, MBoxParser):
paths = filter(
None,
self._parse_mailbox_name(pathspec).split('/'))
+
+ subs = []
+ sep = '/'
+
for accum in range(1, len(paths)):
try:
- self.addMailbox('/'.join(paths[:accum]))
+ partial = sep.join(paths[:accum])
+ d = self.addMailbox(partial)
+ subs.append(d)
except imap4.MailboxCollision:
pass
try:
- self.addMailbox('/'.join(paths))
+ df = self.addMailbox(sep.join(paths))
except imap4.MailboxCollision:
if not pathspec.endswith('/'):
- return False
- self._load_mailboxes()
- return True
+ df = defer.succeed(False)
+ else:
+ df = defer.succeed(True)
+ finally:
+ subs.append(df)
+
+ def all_good(result):
+ return all(result)
+
+ def load_mbox_cache(result):
+ d = self._load_mailboxes()
+ d.addCallback(lambda _: result)
+ return d
+
+ if subs:
+ d1 = defer.gatherResults(subs, consumeErrors=True)
+ d1.addCallback(load_mbox_cache)
+ d1.addCallback(all_good)
+ else:
+ d1 = defer.succeed(False)
+ d1.addCallback(load_mbox_cache)
+ return d1
def select(self, name, readwrite=1):
"""
@@ -275,17 +332,20 @@ class SoledadBackedAccount(WithMsgFields, IndexedDB, MBoxParser):
:param name: the mailbox to be deleted
:type name: str
- :param force: if True, it will not check for noselect flag or inferior
- names. use with care.
+ :param force:
+ if True, it will not check for noselect flag or inferior
+ names. use with care.
:type force: bool
+ :rtype: Deferred
"""
name = self._parse_mailbox_name(name)
if name not in self.mailboxes:
- raise imap4.MailboxException("No such mailbox: %r" % name)
+ err = imap4.MailboxException("No such mailbox: %r" % name)
+ return defer.fail(err)
mbox = self.getMailbox(name)
- if force is False:
+ if not force:
# See if this box is flagged \Noselect
# XXX use mbox.flags instead?
mbox_flags = mbox.getFlags()
@@ -294,11 +354,12 @@ class SoledadBackedAccount(WithMsgFields, IndexedDB, MBoxParser):
# as part of their root.
for others in self.mailboxes:
if others != name and others.startswith(name):
- raise imap4.MailboxException, (
+ err = imap4.MailboxException(
"Hierarchically inferior mailboxes "
"exist and \\Noselect is set")
+ return defer.fail(err)
self.__mailboxes.discard(name)
- mbox.destroy()
+ return mbox.destroy()
# XXX FIXME --- not honoring the inferior names...
@@ -331,14 +392,30 @@ class SoledadBackedAccount(WithMsgFields, IndexedDB, MBoxParser):
if new in self.mailboxes:
raise imap4.MailboxCollision(repr(new))
+ rename_deferreds = []
+
+ def load_mbox_cache(result):
+ d = self._load_mailboxes()
+ d.addCallback(lambda _: result)
+ return d
+
+ def update_mbox_doc_name(mbox, oldname, newname, update_deferred):
+ mbox.content[self.MBOX_KEY] = newname
+ d = self._soledad.put_doc(mbox)
+ d.addCallback(lambda r: update_deferred.callback(True))
+
for (old, new) in inferiors:
- self._memstore.rename_fdocs_mailbox(old, new)
- mbox = self._get_mailbox_by_name(old)
- mbox.content[self.MBOX_KEY] = new
self.__mailboxes.discard(old)
- self._soledad.put_doc(mbox)
+ self._memstore.rename_fdocs_mailbox(old, new)
+
+ d0 = defer.Deferred()
+ d = self._get_mailbox_by_name(old)
+ d.addCallback(update_mbox_doc_name, old, new, d0)
+ rename_deferreds.append(d0)
- self._load_mailboxes()
+ d1 = defer.gatherResults(rename_deferreds, consumeErrors=True)
+ d1.addCallback(load_mbox_cache)
+ return d1
def _inferiorNames(self, name):
"""
@@ -354,6 +431,8 @@ class SoledadBackedAccount(WithMsgFields, IndexedDB, MBoxParser):
inferiors.append(infname)
return inferiors
+ # TODO ------------------ can we preserve the attr?
+ # maybe add to memory store.
def isSubscribed(self, name):
"""
Returns True if user is subscribed to this mailbox.
@@ -361,10 +440,35 @@ class SoledadBackedAccount(WithMsgFields, IndexedDB, MBoxParser):
:param name: the mailbox to be checked.
:type name: str
- :rtype: bool
+ :rtype: Deferred (will fire with bool)
+ """
+ subscribed = self.SUBSCRIBED_KEY
+
+ def is_subscribed(mbox):
+ subs_bool = bool(mbox.content.get(subscribed, False))
+ return subs_bool
+
+ d = self._get_mailbox_by_name(name)
+ d.addCallback(is_subscribed)
+ return d
+
+ # TODO ------------------ can we preserve the property?
+ # maybe add to memory store.
+
+ def _get_subscriptions(self):
"""
- mbox = self._get_mailbox_by_name(name)
- return mbox.content.get('subscribed', False)
+ Return a list of the current subscriptions for this account.
+
+ :returns: A deferred that will fire with the subscriptions.
+ :rtype: Deferred
+ """
+ def get_docs_content(docs):
+ return [doc.content[self.MBOX_KEY] for doc in docs]
+
+ d = self._soledad.get_from_index(
+ self.TYPE_SUBS_IDX, self.MBOX_KEY, '1')
+ d.addCallback(get_docs_content)
+ return d
def _set_subscription(self, name, value):
"""
@@ -376,26 +480,42 @@ class SoledadBackedAccount(WithMsgFields, IndexedDB, MBoxParser):
:param value: the boolean value
:type value: bool
"""
+ # XXX Note that this kind of operation has
+ # no guarantees of atomicity. We should not be accessing mbox
+ # documents concurrently.
+
+ subscribed = self.SUBSCRIBED_KEY
+
+ def update_subscribed_value(mbox):
+ mbox.content[subscribed] = value
+ return self._soledad.put_doc(mbox)
+
# maybe we should store subscriptions in another
# document...
if name not in self.mailboxes:
- self.addMailbox(name)
- mbox = self._get_mailbox_by_name(name)
-
- if mbox:
- mbox.content[self.SUBSCRIBED_KEY] = value
- self._soledad.put_doc(mbox)
+ d = self.addMailbox(name)
+ d.addCallback(lambda v: self._get_mailbox_by_name(name))
+ else:
+ d = self._get_mailbox_by_name(name)
+ d.addCallback(update_subscribed_value)
+ return d
def subscribe(self, name):
"""
- Subscribe to this mailbox
+ Subscribe to this mailbox if not already subscribed.
:param name: name of the mailbox
:type name: str
+ :rtype: Deferred
"""
name = self._parse_mailbox_name(name)
- if name not in self.subscriptions:
- self._set_subscription(name, True)
+
+ def check_and_subscribe(subscriptions):
+ if name not in subscriptions:
+ return self._set_subscription(name, True)
+ d = self._get_subscriptions()
+ d.addCallback(check_and_subscribe)
+ return d
def unsubscribe(self, name):
"""
@@ -403,12 +523,21 @@ class SoledadBackedAccount(WithMsgFields, IndexedDB, MBoxParser):
:param name: name of the mailbox
:type name: str
+ :rtype: Deferred
"""
name = self._parse_mailbox_name(name)
- if name not in self.subscriptions:
- raise imap4.MailboxException(
- "Not currently subscribed to %r" % name)
- self._set_subscription(name, False)
+
+ def check_and_unsubscribe(subscriptions):
+ if name not in subscriptions:
+ raise imap4.MailboxException(
+ "Not currently subscribed to %r" % name)
+ return self._set_subscription(name, False)
+ d = self._get_subscriptions()
+ d.addCallback(check_and_unsubscribe)
+ return d
+
+ def getSubscriptions(self):
+ return self._get_subscriptions()
def listMailboxes(self, ref, wildcard):
"""