Use the new keymanager async API

2 files changed, 95 insertions, 107 deletions

diff --git a/src/leap/bitmask/backend/components.py b/src/leap/bitmask/backend/components.py
index 4b63af84..2523faea 100644
--- a/src/leap/bitmask/backend/components.py
+++ b/src/leap/bitmask/backend/components.py
@@ -906,52 +906,6 @@ class Keymanager(object):
         # NOTE: This feature is disabled right now since is dangerous
         return
 
-        new_key = ''
-        signal = None
-        try:
-            with open(filename, 'r') as keys_file:
-                new_key = keys_file.read()
-        except IOError as e:
-            logger.error("IOError importing key. {0!r}".format(e))
-            signal = self._signaler.keymanager_import_ioerror
-            self._signaler.signal(signal)
-            return
-
-        keymanager = self._keymanager_proxy
-        try:
-            # NOTE: parse_openpgp_ascii_key is not in keymanager anymore
-            #       the API for that will need some thinking 
-            public_key, private_key = keymanager.parse_openpgp_ascii_key(
-                new_key)
-        except (KeyAddressMismatch, KeyFingerprintMismatch) as e:
-            logger.error(repr(e))
-            signal = self._signaler.keymanager_import_datamismatch
-            self._signaler.signal(signal)
-            return
-
-        if public_key is None or private_key is None:
-            signal = self._signaler.keymanager_import_missingkey
-            self._signaler.signal(signal)
-            return
-
-        current_public_key = keymanager.get_key(username, openpgp.OpenPGPKey)
-        if public_key.address != current_public_key.address:
-            logger.error("The key does not match the ID")
-            signal = self._signaler.keymanager_import_addressmismatch
-            self._signaler.signal(signal)
-            return
-
-        keymanager.delete_key(self._key)
-        keymanager.delete_key(self._key_priv)
-        keymanager.put_key(public_key)
-        keymanager.put_key(private_key)
-        keymanager.send_key(openpgp.OpenPGPKey)
-
-        logger.debug('Import ok')
-        signal = self._signaler.keymanager_import_ok
-
-        self._signaler.signal(signal)
-
     def export_keys(self, username, filename):
         """
         Export the given username's keys to a file.
@@ -963,35 +917,50 @@ class Keymanager(object):
         """
         keymanager = self._keymanager_proxy
 
-        public_key = keymanager.get_key(username, openpgp.OpenPGPKey)
-        private_key = keymanager.get_key(username, openpgp.OpenPGPKey,
-                                         private=True)
-        try:
+        def export(keys):
+            public_key, private_key = keys
+            # XXX: This is blocking. We could use writeToFD, but is POSIX only
+            #      https://twistedmatrix.com/documents/current/api/twisted.internet.fdesc.html#writeToFD
             with open(filename, 'w') as keys_file:
                 keys_file.write(public_key.key_data)
                 keys_file.write(private_key.key_data)
 
             logger.debug('Export ok')
             self._signaler.signal(self._signaler.keymanager_export_ok)
-        except IOError as e:
-            logger.error("IOError exporting key. {0!r}".format(e))
+
+        def log_error(failure):
+            logger.error(
+                "Error exporting key. {0!r}".format(failure.value))
             self._signaler.signal(self._signaler.keymanager_export_error)
 
+        dpub = keymanager.get_key(username, openpgp.OpenPGPKey)
+        dpriv = keymanager.get_key(username, openpgp.OpenPGPKey,
+                                   private=True)
+        d = defer.gatherResults([dpub, dpriv])
+        d.addCallback(export)
+        d.addErrback(log_error)
+
     def list_keys(self):
         """
         List all the keys stored in the local DB.
         """
-        keys = self._keymanager_proxy.get_all_keys()
-        self._signaler.signal(self._signaler.keymanager_keys_list, keys)
+        d = self._keymanager_proxy.get_all_keys()
+        d.addCallback(
+            lambda keys:
+            self._signaler.signal(self._signaler.keymanager_keys_list, keys))
 
     def get_key_details(self, username):
         """
         List all the keys stored in the local DB.
         """
-        public_key = self._keymanager_proxy.get_key(username,
-                                                    openpgp.OpenPGPKey)
-        details = (public_key.key_id, public_key.fingerprint)
-        self._signaler.signal(self._signaler.keymanager_key_details, details)
+        def signal_details(public_key):
+            details = (public_key.key_id, public_key.fingerprint)
+            self._signaler.signal(self._signaler.keymanager_key_details,
+                                  details)
+
+        d = self._keymanager_proxy.get_key(username,
+                                           openpgp.OpenPGPKey)
+        d.addCallback(signal_details)
 
 
 class Mail(object):
diff --git a/src/leap/bitmask/services/soledad/soledadbootstrapper.py b/src/leap/bitmask/services/soledad/soledadbootstrapper.py
index 2044a27c..ac7ca836 100644
--- a/src/leap/bitmask/services/soledad/soledadbootstrapper.py
+++ b/src/leap/bitmask/services/soledad/soledadbootstrapper.py
@@ -27,7 +27,7 @@ from ssl import SSLError
 from sqlite3 import ProgrammingError as sqlite_ProgrammingError
 
 from u1db import errors as u1db_errors
-from twisted.internet import threads
+from twisted.internet import threads, defer
 from zope.proxy import sameProxiedObjects
 from pysqlcipher.dbapi2 import ProgrammingError as sqlcipher_ProgrammingError
 
@@ -317,19 +317,26 @@ class SoledadBootstrapper(AbstractBootstrapper):
         if flags.OFFLINE:
             self._init_keymanager(self._address, token)
         else:
-            try:
-                address = make_address(
-                    self._user, self._provider_config.get_domain())
-                self._init_keymanager(address, token)
-                self._keymanager.get_key(
+            address = make_address(
+                self._user, self._provider_config.get_domain())
+
+            def key_not_found(failure):
+                if failure.check(KeyNotFound):
+                    logger.debug("Key not found. Generating key for %s" %
+                                 (address,))
+                    self._do_soledad_sync()
+                else:
+                    return failure
+
+            d = self._init_keymanager(address, token)
+            d.addCallback(
+                lambda _: self._keymanager.get_key(
                     address, openpgp.OpenPGPKey,
-                    private=True, fetch_remote=False)
-                d = threads.deferToThread(self._do_soledad_sync)
-                d.addErrback(self._soledad_sync_errback)
-            except KeyNotFound:
-                logger.debug("Key not found. Generating key for %s" %
-                             (address,))
-                self._do_soledad_sync()
+                    private=True, fetch_remote=False))
+            d.addCallbacks(
+                lambda _: threads.deferToThread(self._do_soledad_sync),
+                key_not_found)
+            d.addErrback(self._soledad_sync_errback)
 
     def _pick_server(self, uuid):
         """
@@ -537,6 +544,7 @@ class SoledadBootstrapper(AbstractBootstrapper):
         :type address: str
         :param token: the auth token for accessing webapp.
         :type token: str
+        :rtype: Deferred
         """
         srp_auth = self.srpauth
         logger.debug('initializing keymanager...')
@@ -576,20 +584,27 @@ class SoledadBootstrapper(AbstractBootstrapper):
         if flags.OFFLINE is False:
             # make sure key is in server
             logger.debug('Trying to send key to server...')
-            try:
-                self._keymanager.send_key(openpgp.OpenPGPKey)
-            except KeyNotFound:
-                logger.debug('No key found for %s, will generate soon.'
-                             % address)
-            except Exception as exc:
-                logger.error("Error sending key to server.")
-                logger.exception(exc)
-                # but we do not raise
+
+            def send_errback(failure):
+                if failure.check(KeyNotFound):
+                    logger.debug('No key found for %s, will generate soon.'
+                                 % address)
+                else:
+                    logger.error("Error sending key to server.")
+                    logger.exception(failure.value)
+                    # but we do not raise
+
+            d = self._keymanager.send_key(openpgp.OpenPGPKey)
+            d.addErrback(send_errback)
+            return d
+        else:
+            return defer.succeed(None)
 
     def _gen_key(self):
         """
         Generates the key pair if needed, uploads it to the webapp and
         nickserver
+        :rtype: Deferred
         """
         leap_assert(self._provider_config is not None,
                     "We need a provider configuration!")
@@ -600,30 +615,33 @@ class SoledadBootstrapper(AbstractBootstrapper):
             self._user, self._provider_config.get_domain())
         logger.debug("Retrieving key for %s" % (address,))
 
-        try:
-            self._keymanager.get_key(
-                address, openpgp.OpenPGPKey, private=True, fetch_remote=False)
-            return
-        except KeyNotFound:
-            logger.debug("Key not found. Generating key for %s" % (address,))
-
-        # generate key
-        try:
-            self._keymanager.gen_key(openpgp.OpenPGPKey)
-        except Exception as exc:
-            logger.error("Error while generating key!")
-            logger.exception(exc)
-            raise
-
-        # send key
-        try:
-            self._keymanager.send_key(openpgp.OpenPGPKey)
-        except Exception as exc:
-            logger.error("Error while sending key!")
-            logger.exception(exc)
-            raise
-
-        logger.debug("Key generated successfully.")
+        def if_not_found_generate(failure):
+            if failure.check(KeyNotFound):
+                logger.debug("Key not found. Generating key for %s"
+                             % (address,))
+                d = self._keymanager.gen_key(openpgp.OpenPGPKey)
+                d.addCallbacks(send_key, log_key_error("generating"))
+                return d
+            else:
+                return failure
+
+        def send_key(_):
+            d = self._keymanager.send_key(openpgp.OpenPGPKey)
+            d.addCallbacks(
+                lambda _: logger.debug("Key generated successfully."),
+                log_key_error("sending"))
+
+        def log_key_error(step):
+            def log_err(failure):
+                logger.error("Error while %s key!", (step,))
+                logger.exception(failure.value)
+                return failure
+            return log_err
+
+        d = self._keymanager.get_key(
+            address, openpgp.OpenPGPKey, private=True, fetch_remote=False)
+        d.addErrback(if_not_found_generate)
+        return d
 
     def run_soledad_setup_checks(self, provider_config, user, password,
                                  download_if_needed=False):
@@ -664,9 +682,10 @@ class SoledadBootstrapper(AbstractBootstrapper):
             self.load_and_sync_soledad(uuid)
 
             if not flags.OFFLINE:
-                self._gen_key()
-
-            self._signaler.signal(signal_finished)
+                d = self._gen_key()
+                d.addCallback(lambda _: self._signaler.signal(signal_finished))
+            else:
+                self._signaler.signal(signal_finished)
         except Exception as e:
             # TODO: we should handle more specific exceptions in here
             self._soledad = None