[feat] make events multi-user aware

- Resolves: #7656
- Releases: 0.4.1

5 files changed, 54 insertions, 16 deletions

diff --git a/changes/next-changelog.rst b/changes/next-changelog.rst
new file mode 100644
index 0000000..e218bb9
--- /dev/null
+++ b/changes/next-changelog.rst
@@ -0,0 +1,29 @@
+0.4.1 - xxx
++++++++++++++++++++++++++++++++
+
+Please add lines to this file, they will be moved to the CHANGELOG.rst during
+the next release.
+
+There are two template lines for each category, use them as reference.
+
+I've added a new category `Misc` so we can track doc/style/packaging stuff.
+
+Features
+~~~~~~~~
+- `#7656 <https://leap.se/code/issues/7656>`_: Emit multi-user aware events.
+- `#1234 <https://leap.se/code/issues/1234>`_: Description of the new feature corresponding with issue #1234.
+- New feature without related issue number.
+
+Bugfixes
+~~~~~~~~
+- `#1235 <https://leap.se/code/issues/1235>`_: Description for the fixed stuff corresponding with issue #1235.
+- Bugfix without related issue number.
+
+Misc
+~~~~
+- `#1236 <https://leap.se/code/issues/1236>`_: Description of the new feature corresponding with issue #1236.
+- Some change without issue number.
+
+Known Issues
+~~~~~~~~~~~~
+- `#1236 <https://leap.se/code/issues/1236>`_: Description of the known issue corresponding with issue #1236.
diff --git a/src/leap/mail/imap/server.py b/src/leap/mail/imap/server.py
index 99e7174..0e5d011 100644
--- a/src/leap/mail/imap/server.py
+++ b/src/leap/mail/imap/server.py
@@ -224,7 +224,7 @@ class LEAPIMAPServer(imap4.IMAP4Server):
             # bad username, reject.
             raise cred.error.UnauthorizedLogin()
         # any dummy password is allowed so far. use realm instead!
-        emit_async(catalog.IMAP_CLIENT_LOGIN, "1")
+        emit_async(catalog.IMAP_CLIENT_LOGIN, username, "1")
         return imap4.IAccount, self.theAccount, lambda: None
 
     def do_FETCH(self, tag, messages, query, uid=0):
diff --git a/src/leap/mail/incoming/service.py b/src/leap/mail/incoming/service.py
index d8b91ba..3896c17 100644
--- a/src/leap/mail/incoming/service.py
+++ b/src/leap/mail/incoming/service.py
@@ -233,7 +233,7 @@ class IncomingMail(Service):
             failure.trap(InvalidAuthTokenError)
             # if the token is invalid, send an event so the GUI can
             # disable mail and show an error message.
-            emit_async(catalog.SOLEDAD_INVALID_AUTH_TOKEN)
+            emit_async(catalog.SOLEDAD_INVALID_AUTH_TOKEN, self._userid)
 
         log.msg('FETCH: syncing soledad...')
         d = self._soledad.sync()
@@ -254,7 +254,7 @@ class IncomingMail(Service):
             num_mails = len(doclist) if doclist is not None else 0
             if num_mails != 0:
                 log.msg("there are %s mails" % (num_mails,))
-            emit_async(catalog.MAIL_FETCHED_INCOMING,
+            emit_async(catalog.MAIL_FETCHED_INCOMING, self._userid,
                        str(num_mails), str(fetched_ts))
             return doclist
 
@@ -262,7 +262,7 @@ class IncomingMail(Service):
         """
         Sends unread event to ui.
         """
-        emit_async(catalog.MAIL_UNREAD_MESSAGES,
+        emit_async(catalog.MAIL_UNREAD_MESSAGES, self._userid,
                    str(self._inbox_collection.count_unseen()))
 
     # process incoming mail.
@@ -286,7 +286,7 @@ class IncomingMail(Service):
         deferreds = []
         for index, doc in enumerate(doclist):
             logger.debug("processing doc %d of %d" % (index + 1, num_mails))
-            emit_async(catalog.MAIL_MSG_PROCESSING,
+            emit_async(catalog.MAIL_MSG_PROCESSING, self._userid,
                        str(index), str(num_mails))
 
             keys = doc.content.keys()
@@ -336,7 +336,8 @@ class IncomingMail(Service):
                 decrdata = ""
                 success = False
 
-            emit_async(catalog.MAIL_MSG_DECRYPTED, "1" if success else "0")
+            emit_async(catalog.MAIL_MSG_DECRYPTED, self._userid,
+                       "1" if success else "0")
             return self._process_decrypted_doc(doc, decrdata)
 
         d = self._keymanager.decrypt(
@@ -743,10 +744,11 @@ class IncomingMail(Service):
                 listener(result)
 
             def signal_deleted(doc_id):
-                emit_async(catalog.MAIL_MSG_DELETED_INCOMING)
+                emit_async(catalog.MAIL_MSG_DELETED_INCOMING,
+                           self._userid)
                 return doc_id
 
-            emit_async(catalog.MAIL_MSG_SAVED_LOCALLY)
+            emit_async(catalog.MAIL_MSG_SAVED_LOCALLY, self._userid)
             d = self._delete_incoming_message(doc)
             d.addCallback(signal_deleted)
             return d
diff --git a/src/leap/mail/outgoing/service.py b/src/leap/mail/outgoing/service.py
index 7cc5a24..3bd0ea2 100644
--- a/src/leap/mail/outgoing/service.py
+++ b/src/leap/mail/outgoing/service.py
@@ -135,7 +135,8 @@ class OutgoingMail:
         """
         dest_addrstr = smtp_sender_result[1][0][0]
         log.msg('Message sent to %s' % dest_addrstr)
-        emit_async(catalog.SMTP_SEND_MESSAGE_SUCCESS, dest_addrstr)
+        emit_async(catalog.SMTP_SEND_MESSAGE_SUCCESS,
+                   self._from_address, dest_addrstr)
 
     def sendError(self, failure):
         """
@@ -145,7 +146,8 @@ class OutgoingMail:
         :type e: anything
         """
         # XXX: need to get the address from the exception to send signal
-        # emit_async(catalog.SMTP_SEND_MESSAGE_ERROR, self._user.dest.addrstr)
+        # emit_async(catalog.SMTP_SEND_MESSAGE_ERROR, self._from_address,
+        #   self._user.dest.addrstr)
         err = failure.value
         log.err(err)
         raise err
@@ -178,7 +180,8 @@ class OutgoingMail:
             requireAuthentication=False,
             requireTransportSecurity=True)
         factory.domain = __version__
-        emit_async(catalog.SMTP_SEND_MESSAGE_START, recipient.dest.addrstr)
+        emit_async(catalog.SMTP_SEND_MESSAGE_START,
+                   self._from_address, recipient.dest.addrstr)
         reactor.connectSSL(
             self._host, self._port, factory,
             contextFactory=SSLContextFactory(self._cert, self._key))
@@ -241,6 +244,7 @@ class OutgoingMail:
 
         def signal_encrypt_sign(newmsg):
             emit_async(catalog.SMTP_END_ENCRYPT_AND_SIGN,
+                       self._from_address,
                        "%s,%s" % (self._from_address, to_address))
             return newmsg, recipient
 
@@ -248,7 +252,7 @@ class OutgoingMail:
             failure.trap(KeyNotFound, KeyAddressMismatch)
 
             log.msg('Will send unencrypted message to %s.' % to_address)
-            emit_async(catalog.SMTP_START_SIGN, self._from_address)
+            emit_async(catalog.SMTP_START_SIGN, self._from_address, to_address)
             d = self._sign(message, from_address)
             d.addCallback(signal_sign)
             return d
@@ -260,6 +264,7 @@ class OutgoingMail:
         log.msg("Will encrypt the message with %s and sign with %s."
                 % (to_address, from_address))
         emit_async(catalog.SMTP_START_ENCRYPT_AND_SIGN,
+                   self._from_address,
                    "%s,%s" % (self._from_address, to_address))
         d = self._maybe_attach_key(origmsg, from_address, to_address)
         d.addCallback(maybe_encrypt_and_sign)
diff --git a/src/leap/mail/smtp/gateway.py b/src/leap/mail/smtp/gateway.py
index 45560bf..3657250 100644
--- a/src/leap/mail/smtp/gateway.py
+++ b/src/leap/mail/smtp/gateway.py
@@ -202,20 +202,21 @@ class SMTPDelivery(object):
         def found(_):
             log.msg("Accepting mail for %s..." % user.dest.addrstr)
             emit_async(catalog.SMTP_RECIPIENT_ACCEPTED_ENCRYPTED,
-                       user.dest.addrstr)
+                       self._userid, user.dest.addrstr)
 
         def not_found(failure):
             failure.trap(KeyNotFound)
 
             # if key was not found, check config to see if will send anyway
             if self._encrypted_only:
-                emit_async(catalog.SMTP_RECIPIENT_REJECTED, user.dest.addrstr)
+                emit_async(catalog.SMTP_RECIPIENT_REJECTED, self._userid,
+                           user.dest.addrstr)
                 raise smtp.SMTPBadRcpt(user.dest.addrstr)
             log.msg("Warning: will send an unencrypted message (because "
                     "encrypted_only' is set to False).")
             emit_async(
                 catalog.SMTP_RECIPIENT_ACCEPTED_UNENCRYPTED,
-                user.dest.addrstr)
+                self._userid, user.dest.addrstr)
 
         def encrypt_func(_):
             return lambda: EncryptedMessage(user, self._outgoing_mail)
@@ -307,7 +308,8 @@ class EncryptedMessage(object):
         """
         log.msg("Connection lost unexpectedly!")
         log.err()
-        emit_async(catalog.SMTP_CONNECTION_LOST, self._user.dest.addrstr)
+        emit_async(catalog.SMTP_CONNECTION_LOST, self._userid,
+                   self._user.dest.addrstr)
         # unexpected loss of connection; don't save
 
         self._lines = []