Merge pull request #879 from matrix-org/erikj/linearize_fed_server

Linearize some federation endpoints based on (origin, room_id)

synapse/federation/federation_server.py

@@ -49,6 +49,7 @@ class FederationServer(FederationBase):
         super(FederationServer, self).__init__(hs)
 
         self._room_pdu_linearizer = Linearizer()
+        self._server_linearizer = Linearizer()
 
     def set_handler(self, handler):
         """Sets the handler that the replication layer will use to communicate
@@ -89,11 +90,14 @@ class FederationServer(FederationBase):
     @defer.inlineCallbacks
     @log_function
     def on_backfill_request(self, origin, room_id, versions, limit):
+        with (yield self._server_linearizer.queue((origin, room_id))):
             pdus = yield self.handler.on_backfill_request(
                 origin, room_id, versions, limit
             )
 
-        defer.returnValue((200, self._transaction_from_pdus(pdus).get_dict()))
+            res = self._transaction_from_pdus(pdus).get_dict()
+
+        defer.returnValue((200, res))
 
     @defer.inlineCallbacks
     @log_function
@@ -184,6 +188,7 @@ class FederationServer(FederationBase):
     @defer.inlineCallbacks
     @log_function
     def on_context_state_request(self, origin, room_id, event_id):
+        with (yield self._server_linearizer.queue((origin, room_id))):
             if event_id:
                 pdus = yield self.handler.get_state_for_pdu(
                     origin, room_id, event_id,
@@ -283,14 +288,16 @@ class FederationServer(FederationBase):
 
     @defer.inlineCallbacks
     def on_event_auth(self, origin, room_id, event_id):
+        with (yield self._server_linearizer.queue((origin, room_id))):
             time_now = self._clock.time_msec()
             auth_pdus = yield self.handler.on_event_auth(event_id)
-        defer.returnValue((200, {
+            res = {
                 "auth_chain": [a.get_pdu_json(time_now) for a in auth_pdus],
-        }))
+            }
+        defer.returnValue((200, res))
 
     @defer.inlineCallbacks
-    def on_query_auth_request(self, origin, content, event_id):
+    def on_query_auth_request(self, origin, content, room_id, event_id):
         """
         Content is a dict with keys::
             auth_chain (list): A list of events that give the auth chain.
@@ -309,6 +316,7 @@ class FederationServer(FederationBase):
         Returns:
             Deferred: Results in `dict` with the same format as `content`
         """
+        with (yield self._server_linearizer.queue((origin, room_id))):
             auth_chain = [
                 self.event_from_pdu_json(e)
                 for e in content["auth_chain"]
@@ -386,6 +394,7 @@ class FederationServer(FederationBase):
     @log_function
     def on_get_missing_events(self, origin, room_id, earliest_events,
                               latest_events, limit, min_depth):
+        with (yield self._server_linearizer.queue((origin, room_id))):
             logger.info(
                 "on_get_missing_events: earliest_events: %r, latest_events: %r,"
                 " limit: %d, min_depth: %d",
@@ -396,7 +405,9 @@ class FederationServer(FederationBase):
             )
 
             if len(missing_events) < 5:
-            logger.info("Returning %d events: %r", len(missing_events), missing_events)
+                logger.info(
+                    "Returning %d events: %r", len(missing_events), missing_events
+                )
             else:
                 logger.info("Returning %d events", len(missing_events))
 

synapse/federation/transport/server.py

@@ -388,7 +388,7 @@ class FederationQueryAuthServlet(BaseFederationServlet):
     @defer.inlineCallbacks
     def on_POST(self, origin, content, query, context, event_id):
         new_content = yield self.handler.on_query_auth_request(
-            origin, content, event_id
+            origin, content, context, event_id
         )
 
         defer.returnValue((200, new_content))