Avoid deep recursion in appservice recovery (#5885)

Hopefully, this will fix a stack overflow when recovering an appservice.

The recursion here leads to a huge chain of deferred callbacks, which then
overflows the stack when the chain completes. `inlineCallbacks` makes a better
job of this if we use iteration instead.

Clean up the code a bit too, while we're there.

changelog.d/5885.bugfix

@@ -0,0 +1 @@
+Fix stack overflow when recovering an appservice which had an outage.

synapse/appservice/scheduler.py

@@ -224,7 +224,9 @@ class _Recoverer(object):
                 "as-recoverer-%s" % (self.service.id,), self.retry
             )
 
-        self.clock.call_later((2 ** self.backoff_counter), _retry)
+        delay = 2 ** self.backoff_counter
+        logger.info("Scheduling retries on %s in %fs", self.service.id, delay)
+        self.clock.call_later(delay, _retry)
 
     def _backoff(self):
         # cap the backoff to be around 8.5min => (2^9) = 512 secs
@@ -234,25 +236,30 @@ class _Recoverer(object):
 
     @defer.inlineCallbacks
     def retry(self):
+        logger.info("Starting retries on %s", self.service.id)
         try:
-            txn = yield self.store.get_oldest_unsent_txn(self.service)
+            while True:
-            if txn:
+                txn = yield self.store.get_oldest_unsent_txn(self.service)
+                if not txn:
+                    # nothing left: we're done!
+                    self.callback(self)
+                    return
+
                 logger.info(
                     "Retrying transaction %s for AS ID %s", txn.id, txn.service.id
                 )
                 sent = yield txn.send(self.as_api)
-                if sent:
+                if not sent:
-                    yield txn.complete(self.store)
+                    break
-                    # reset the backoff counter and retry immediately
+
-                    self.backoff_counter = 1
+                yield txn.complete(self.store)
-                    yield self.retry()
+
-                else:
+                # reset the backoff counter and then process the next transaction
-                    self._backoff()
+                self.backoff_counter = 1
-            else:
+
-                self._set_service_recovered()
+        except Exception:
-        except Exception as e:
+            logger.exception("Unexpected error running retries")
-            logger.exception(e)
+
-            self._backoff()
+        # we didn't manage to send all of the transactions before we got an error of
-
+        # some flavour: reschedule the next retry.
-    def _set_service_recovered(self):
+        self._backoff()
-        self.callback(self)