[feat] use async events api
authorKali Kaneko <kali@leap.se>
Tue, 15 Sep 2015 03:08:41 +0000 (23:08 -0400)
committerKali Kaneko <kali@leap.se>
Tue, 15 Sep 2015 03:12:33 +0000 (23:12 -0400)
this avoids using a separate thread with tornado ioloop for events
client, since we can use twisted reactor.

- Resolves: #7274

src/leap/keymanager/__init__.py

index 999b53c..34bc964 100644 (file)
@@ -55,7 +55,7 @@ from twisted.internet import defer
 from urlparse import urlparse
 
 from leap.common.check import leap_assert
-from leap.common.events import emit, catalog
+from leap.common.events import emit_async, catalog
 from leap.common.decorators import memoized_method
 
 from leap.keymanager.errors import (
@@ -287,7 +287,7 @@ class KeyManager(object):
                 self._api_version,
                 self._uid)
             self._put(uri, data)
-            emit(catalog.KEYMANAGER_DONE_UPLOADING_KEYS, self._address)
+            emit_async(catalog.KEYMANAGER_DONE_UPLOADING_KEYS, self._address)
 
         d = self.get_key(
             self._address, ktype, private=False, fetch_remote=False)
@@ -323,24 +323,24 @@ class KeyManager(object):
         leap_assert(
             ktype in self._wrapper_map,
             'Unkown key type: %s.' % str(ktype))
-        emit(catalog.KEYMANAGER_LOOKING_FOR_KEY, address)
+        emit_async(catalog.KEYMANAGER_LOOKING_FOR_KEY, address)
 
         def key_found(key):
-            emit(catalog.KEYMANAGER_KEY_FOUND, address)
+            emit_async(catalog.KEYMANAGER_KEY_FOUND, address)
             return key
 
         def key_not_found(failure):
             if not failure.check(KeyNotFound):
                 return failure
 
-            emit(catalog.KEYMANAGER_KEY_NOT_FOUND, address)
+            emit_async(catalog.KEYMANAGER_KEY_NOT_FOUND, address)
 
             # we will only try to fetch a key from nickserver if fetch_remote
             # is True and the key is not private.
             if fetch_remote is False or private is True:
                 return failure
 
-            emit(catalog.KEYMANAGER_LOOKING_FOR_KEY, address)
+            emit_async(catalog.KEYMANAGER_LOOKING_FOR_KEY, address)
             d = self._fetch_keys_from_server(address)
             d.addCallback(
                 lambda _:
@@ -397,10 +397,10 @@ class KeyManager(object):
         self._assert_supported_key_type(ktype)
 
         def signal_finished(key):
-            emit(catalog.KEYMANAGER_FINISHED_KEY_GENERATION, self._address)
+            emit_async(catalog.KEYMANAGER_FINISHED_KEY_GENERATION, self._address)
             return key
 
-        emit(catalog.KEYMANAGER_STARTED_KEY_GENERATION, self._address)
+        emit_async(catalog.KEYMANAGER_STARTED_KEY_GENERATION, self._address)
         d = self._wrapper_map[ktype].gen_key(self._address)
         d.addCallback(signal_finished)
         return d