Fix so timing out connections to actually work.

synapse/federation/replication.py

@@ -72,5 +72,7 @@ class ReplicationLayer(FederationClient, FederationServer):
 
         self._order = 0
 
+        self.hs = hs
+
     def __str__(self):
         return "<ReplicationLayer(%s)>" % self.server_name

synapse/util/__init__.py

@@ -18,6 +18,9 @@ from synapse.util.logcontext import LoggingContext
 from twisted.internet import defer, reactor, task
 
 import time
+import logging
+
+logger = logging.getLogger(__name__)
 
 
 class Clock(object):
@@ -55,20 +58,51 @@ class Clock(object):
         timer.cancel()
 
     def time_bound_deferred(self, given_deferred, time_out):
+        if given_deferred.called:
+            return given_deferred
+
         ret_deferred = defer.Deferred()
 
-        def timed_out():
-            if not given_deferred.called:
-                given_deferred.cancel()
+        def timed_out_fn():
+            try:
                 ret_deferred.errback(RuntimeError("Timed out"))
+            except:
+                pass
+
+            try:
+                given_deferred.cancel()
+            except:
+                pass
+
+        timer = None
+
+        def cancel(res):
+            try:
+                self.cancel_call_later(timer)
+            except:
+                pass
+            return res
+
+        ret_deferred.addBoth(cancel)
+
+        def sucess(res):
+            try:
+                ret_deferred.callback(res)
+            except:
+                pass
+
+            return res
+
+        def err(res):
+            try:
+                ret_deferred.errback(res)
+            except:
+                pass
 
-        timer = self.call_later(time_out, timed_out)
+            return res
 
-        def succeed(result):
-            self.cancel_call_later(timer)
-            ret_deferred.callback(result)
+        given_deferred.addCallbacks(callback=sucess, errback=err)
 
-        given_deferred.addCallback(succeed)
-        given_deferred.addErrback(ret_deferred.errback)
+        timer = self.call_later(time_out, timed_out_fn)
 
         return ret_deferred