Imitiating buttfly in being explicitly typed

[theonering] / src / connection.py

diff --git a/src/connection.py b/src/connection.py
index c209370..59ffa76 100644 (file)
--- a/src/connection.py
+++ b/src/connection.py
@@ -6,7 +6,6 @@ import telepathy
 
 import constants
 import tp
-import util.go_utils as gobject_utils
 import util.misc as misc_utils
 
 import gvoice
@@ -138,10 +137,12 @@ class TheOneRingConnection(
                        autogv.NewGVConversations(weakref.ref(self)),
                        autogv.RefreshVoicemail(weakref.ref(self)),
                        autogv.AutoDisconnect(weakref.ref(self)),
+                       autogv.DelayEnableContactIntegration(constants._telepathy_implementation_name_),
                ]
-               self._delayedConnect = gobject_utils.Async(self._delayed_connect)
 
                _moduleLogger.info("Connection to the account %s created" % account)
+               self._timedDisconnect = autogv.TimedDisconnect(weakref.ref(self))
+               self._timedDisconnect.start()
 
        @property
        def manager(self):
@@ -165,15 +166,26 @@ class TheOneRingConnection(
 
        def get_handle_by_name(self, handleType, handleName):
                requestedHandleName = handleName.encode('utf-8')
+
+               # We need to return an existing or create a new handle.  Unfortunately
+               # handle init's take care of normalizing the handle name.  So we have
+               # to create a new handle regardless and burn some handle id's and burn
+               # some extra memory of creating objects we throw away if the handle
+               # already exists.
                if handleType == telepathy.HANDLE_TYPE_CONTACT:
-                       _moduleLogger.debug("get_handle_by_name Contact: %s" % requestedHandleName)
                        h = handle.create_handle(self, 'contact', requestedHandleName)
                elif handleType == telepathy.HANDLE_TYPE_LIST:
                        # Support only server side (immutable) lists
-                       _moduleLogger.debug("get_handle_by_name List: %s" % requestedHandleName)
                        h = handle.create_handle(self, 'list', requestedHandleName)
                else:
                        raise telepathy.errors.NotAvailable('Handle type unsupported %d' % handleType)
+
+               for candidate in self._handles.itervalues():
+                       if candidate.get_name() == h.get_name():
+                               h = candidate
+                               _moduleLogger.debug("Re-used handle for %s, I hoped this helped" % handleName)
+                               break
+
                return h
 
        @property
@@ -188,22 +200,27 @@ class TheOneRingConnection(
                if self._status != telepathy.CONNECTION_STATUS_DISCONNECTED:
                        _moduleLogger.info("Attempting connect when not disconnected")
                        return
-               _moduleLogger.info("Kicking off connect")
-               self._delayedConnect.start()
-
-       @misc_utils.log_exception(_moduleLogger)
-       def _delayed_connect(self):
                _moduleLogger.info("Connecting...")
                self.StatusChanged(
                        telepathy.CONNECTION_STATUS_CONNECTING,
                        telepathy.CONNECTION_STATUS_REASON_REQUESTED
                )
+               self._timedDisconnect.stop()
+               self.session.login(
+                       self.__credentials[0],
+                       self.__credentials[1],
+                       self._on_login,
+                       self._on_login_error,
+               )
+
+       @misc_utils.log_exception(_moduleLogger)
+       def _on_login(self, *args):
+               _moduleLogger.info("Connected, setting up...")
                try:
                        self.__session.load(self.__cachePath)
 
                        for plumber in self._plumbing:
                                plumber.start()
-                       self.session.login(*self.__credentials)
                        if not self.__callbackNumberParameter:
                                callback = gvoice.backend.get_sane_callback(
                                        self.session.backend
@@ -217,28 +234,34 @@ class TheOneRingConnection(
                        publishHandle = self.get_handle_by_name(telepathy.HANDLE_TYPE_LIST, "publish")
                        publishProps = self.generate_props(telepathy.CHANNEL_TYPE_CONTACT_LIST, publishHandle, False)
                        self.__channelManager.channel_for_props(publishProps, signal=True)
-               except gvoice.backend.NetworkError:
-                       _moduleLogger.exception("Connection Failed")
-                       self.disconnect(telepathy.CONNECTION_STATUS_REASON_NETWORK_ERROR)
-                       return
                except Exception:
-                       _moduleLogger.exception("Connection Failed")
+                       _moduleLogger.exception("Setup failed")
                        self.disconnect(telepathy.CONNECTION_STATUS_REASON_AUTHENTICATION_FAILED)
                        return
 
-               _moduleLogger.info("Connected")
+               _moduleLogger.info("Connected and set up")
                self.StatusChanged(
                        telepathy.CONNECTION_STATUS_CONNECTED,
                        telepathy.CONNECTION_STATUS_REASON_REQUESTED
                )
 
        @misc_utils.log_exception(_moduleLogger)
+       def _on_login_error(self, error):
+               _moduleLogger.error(error)
+               if isinstance(error, StopIteration):
+                       pass
+               elif isinstance(error, gvoice.backend.NetworkError):
+                       self.disconnect(telepathy.CONNECTION_STATUS_REASON_NETWORK_ERROR)
+               else:
+                       self.disconnect(telepathy.CONNECTION_STATUS_REASON_AUTHENTICATION_FAILED)
+
+       @misc_utils.log_exception(_moduleLogger)
        def Disconnect(self):
                """
                For org.freedesktop.telepathy.Connection
                """
                _moduleLogger.info("Kicking off disconnect")
-               self._delayed_disconnect()
+               self.disconnect(telepathy.CONNECTION_STATUS_REASON_REQUESTED)
 
        @misc_utils.log_exception(_moduleLogger)
        def RequestChannel(self, type, handleType, handleId, suppressHandler):
@@ -277,15 +300,10 @@ class TheOneRingConnection(
 
                return props
 
-       @gobject_utils.async
-       def _delayed_disconnect(self):
-               self.disconnect(telepathy.CONNECTION_STATUS_REASON_REQUESTED)
-               return False
-
        def disconnect(self, reason):
                _moduleLogger.info("Disconnecting")
 
-               self._delayedConnect.cancel()
+               self._timedDisconnect.stop()
 
                # Not having the disconnect first can cause weird behavior with clients
                # including not being able to reconnect or even crashing
@@ -298,9 +316,15 @@ class TheOneRingConnection(
                        plumber.stop()
 
                self.__channelManager.close()
+               self.manager.disconnected(self)
+
                self.session.save(self.__cachePath)
                self.session.logout()
                self.session.close()
 
-               self.manager.disconnected(self)
+               # In case one of the above items takes too long (which it should never
+               # do), we leave the starting of the shutdown-on-idle counter to the
+               # very end
+               self.manager.disconnect_completed()
+
                _moduleLogger.info("Disconnected")