Stop sending receipts to large rooms

Author: incognitobeeper

synapse/api/constants.py

@@ -277,6 +277,9 @@ class ReceiptTypes:
     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 RECEIPTS_MAX_ROOM_SIZE, EduTypes, ReceiptTypes
 from synapse.appservice import ApplicationService
 from synapse.streams import EventSource
 from synapse.types import (
@@ -116,6 +116,14 @@ 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.make_private_copy()
+
         for receipt in receipts:
             res = await self.store.insert_receipt(
                 receipt.room_id,

synapse/types/__init__.py

@@ -12,6 +12,8 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
+
 import abc
 import re
 import string
@@ -52,6 +54,7 @@
     IReactorTime,
 )
 
+from synapse.api.constants import ReceiptTypes
 from synapse.api.errors import Codes, SynapseError
 from synapse.util.cancellation import cancellable
 from synapse.util.stringutils import parse_and_validate_server_name
@@ -853,6 +856,19 @@ 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 make_private_copy(self) -> ReadReceipt:
+        return ReadReceipt(
+            room_id=self.room_id,
+            user_id=self.user_id,
+            event_ids=self.event_ids,
+            thread_id=self.thread_id,
+            data=self.data,
+            receipt_type=ReceiptTypes.READ_PRIVATE,
+        )
+
 
 @attr.s(slots=True, frozen=True, auto_attribs=True)
 class DeviceListUpdates:

tests/rest/client/test_sync.py

@@ -22,6 +22,7 @@
 
 import synapse.rest.admin
 from synapse.api.constants import (
+    RECEIPTS_MAX_ROOM_SIZE,
     EduTypes,
     EventContentFields,
     EventTypes,
@@ -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(
         [