Stop sending receipts to large rooms

Author: incognitobeeper

synapse/api/constants.py

@@ -276,6 +276,7 @@ class ReceiptTypes:
     FULLY_READ: Final = "m.fully_read"
     BEEPER_INBOX_DONE: Final = "com.beeper.inbox.done"
 
+RECEIPTS_MAX_ROOM_SIZE = 100
 
 class PublicRoomsFilterFields:
     """Fields in the search filter for `/publicRooms` that we understand.

synapse/handlers/receipts.py

@@ -14,7 +14,7 @@
 import logging
 from typing import TYPE_CHECKING, Iterable, List, Optional, Tuple
 
-from synapse.api.constants import EduTypes, ReceiptTypes
+from synapse.api.constants import EduTypes, RECEIPTS_MAX_ROOM_SIZE, ReceiptTypes
 from synapse.appservice import ApplicationService
 from synapse.streams import EventSource
 from synapse.types import (
@@ -116,6 +116,15 @@ async def _handle_new_receipts(self, receipts: List[ReadReceipt]) -> bool:
         min_batch_id: Optional[int] = None
         max_batch_id: Optional[int] = None
 
+        # Beeper: we don't want to send read receipts to large rooms,
+        # so we convert messages to private, that are over RECEIPT_MAX_ROOM_SIZE.
+        for i, r in enumerate(receipts):
+            if r.receipt_type != ReceiptTypes.READ_PRIVATE:
+                num_users = await self.store.get_number_joined_users_in_room(r.room_id)
+                if num_users > RECEIPTS_MAX_ROOM_SIZE:
+                    receipts[i] = r.copy_with_modification(receipt_type=ReceiptTypes.READ_PRIVATE)
+
+
         for receipt in receipts:
             res = await self.store.insert_receipt(
                 receipt.room_id,
@@ -179,8 +188,17 @@ async def received_client_receipt(
         if not is_new:
             return
 
-        if self.federation_sender and receipt_type != ReceiptTypes.READ_PRIVATE:
-            await self.federation_sender.send_read_receipt(receipt)
+        if receipt_type == ReceiptTypes.READ_PRIVATE:
+            return
+
+        if not self.federation_sender:
+            return
+
+        num_users = await self.store.get_number_joined_users_in_room(room_id)
+        if num_users > RECEIPTS_MAX_ROOM_SIZE:
+            return
+
+        await self.federation_sender.send_read_receipt(receipt)
 
 
 class ReceiptEventSource(EventSource[int, JsonDict]):

synapse/types/__init__.py

@@ -853,6 +853,22 @@ class ReadReceipt:
     thread_id: Optional[str]
     data: JsonDict
 
+    # Beeper: we don't want to alter the frozen attr, but
+    # do occasionally need to make a private copy to
+    # avoid traffic to large rooms.
+    def copy_with_modification(self, **mods):
+        new_attrs = {
+            'room_id': self.room_id,
+            'receipt_type': self.receipt_type,
+            'user_id': self.user_id,
+            'event_ids': self.event_ids,
+            'thread_id': self.thread_id,
+            'data': self.data,
+            **mods
+        }
+        return ReadReceipt(**new_attrs)
+
+
 
 @attr.s(slots=True, frozen=True, auto_attribs=True)
 class DeviceListUpdates:

tests/rest/client/test_sync.py

@@ -26,6 +26,7 @@
     EventContentFields,
     EventTypes,
     ReceiptTypes,
+    RECEIPTS_MAX_ROOM_SIZE,
     RelationTypes,
 )
 from synapse.rest.client import devices, knock, login, read_marker, receipts, room, sync
@@ -382,6 +383,7 @@ class ReadReceiptsTestCase(unittest.HomeserverTestCase):
     servlets = [
         synapse.rest.admin.register_servlets,
         login.register_servlets,
+        read_marker.register_servlets,
         receipts.register_servlets,
         room.register_servlets,
         sync.register_servlets,
@@ -499,6 +501,35 @@ def test_read_receipt_with_empty_body_is_rejected(self) -> None:
         self.assertEqual(channel.code, HTTPStatus.BAD_REQUEST)
         self.assertEqual(channel.json_body["errcode"], "M_NOT_JSON", channel.json_body)
 
+    def test_read_receipt_not_sent_to_large_rooms(self) -> None:
+        # Beeper: we don't send read receipts on rooms with more
+        # users than # RECEIPTS_MAX_ROOM_SIZE
+        for i in range(RECEIPTS_MAX_ROOM_SIZE):
+            user = self.register_user(f"user_{i}", f"secure_password_{i}")
+            tok = self.login(f"user_{i}", f"secure_password_{i}")
+            self.helper.join(room=self.room_id, user=user, tok=tok)
+
+        res = self.helper.send(
+            self.room_id, body="woah, this is a big room!", tok=self.tok
+        )
+
+        for receipt_type in (
+            ReceiptTypes.FULLY_READ,
+            ReceiptTypes.READ_PRIVATE,
+            ReceiptTypes.READ,
+        ):
+            # Send a read receipt
+            channel = self.make_request(
+                "POST",
+                f"/rooms/{self.room_id}/receipt/{receipt_type}/{res['event_id']}",
+                {},
+                access_token=self.tok2,
+            )
+            self.assertEqual(channel.code, 200)
+
+            # Test that we didn't get a read receipt.
+            self.assertIsNone(self._get_read_receipt())
+
     def _get_read_receipt(self) -> Optional[JsonDict]:
         """Syncs and returns the read receipt."""
 
@@ -728,6 +759,15 @@ def test_unread_counts(self) -> None:
         self.assertEqual(channel.code, 200, channel.json_body)
         self._check_unread_count(0)
 
+    def test_large_rooms_dont_alter_unread_count_behaviour(self) -> None:
+        # Beeper: create a lot of users and join them to the room
+        for i in range(RECEIPTS_MAX_ROOM_SIZE):
+            user = self.register_user(f"user_{i}", f"secure_password_{i}")
+            tok = self.login(f"user_{i}", f"secure_password_{i}")
+            self.helper.join(self.room_id, user=user, tok=tok)
+
+        self.test_unread_counts()
+
     # We test for all three receipt types that influence notification counts
     @parameterized.expand(
         [