Add a cache on get_rooms_for_local_user_where_membership_is

synapse/api/constants.py

@@ -50,7 +50,7 @@ class Membership:
     KNOCK: Final = "knock"
     LEAVE: Final = "leave"
     BAN: Final = "ban"
-    LIST: Final = {INVITE, JOIN, KNOCK, LEAVE, BAN}
+    LIST: Final = (INVITE, JOIN, KNOCK, LEAVE, BAN)
 
 
 class PresenceState:

synapse/handlers/initial_sync.py

@@ -135,7 +135,7 @@ async def _snapshot_all_rooms(
             memberships.append(Membership.LEAVE)
 
         room_list = await self.store.get_rooms_for_local_user_where_membership_is(
-            user_id=user_id, membership_list=memberships
+            user_id=user_id, membership_list=tuple(memberships)
         )
 
         user = UserID.from_string(user_id)

synapse/handlers/search.py

@@ -278,7 +278,7 @@ async def _search(
         # TODO: Search through left rooms too
         rooms = await self.store.get_rooms_for_local_user_where_membership_is(
             requester.user.to_string(),
-            membership_list=[Membership.JOIN],
+            membership_list=(Membership.JOIN,),
             # membership_list=[Membership.JOIN, Membership.LEAVE, Membership.Ban],
         )
         room_ids = {r.room_id for r in rooms}

synapse/server_notices/server_notices_manager.py

@@ -114,7 +114,7 @@ async def maybe_get_notice_room_for_user(self, user_id: str) -> Optional[str]:
             return None
 
         rooms = await self._store.get_rooms_for_local_user_where_membership_is(
-            user_id, [Membership.INVITE, Membership.JOIN]
+            user_id, (Membership.INVITE, Membership.JOIN)
         )
         for room in rooms:
             # it's worth noting that there is an asymmetry here in that we
@@ -262,7 +262,7 @@ async def maybe_invite_user_to_room(self, user_id: str, room_id: str) -> None:
         # Check whether the user has already joined or been invited to this room. If
         # that's the case, there is no need to re-invite them.
         joined_rooms = await self._store.get_rooms_for_local_user_where_membership_is(
-            user_id, [Membership.INVITE, Membership.JOIN]
+            user_id, (Membership.INVITE, Membership.JOIN)
         )
         for room in joined_rooms:
             if room.room_id == room_id:

synapse/storage/_base.py

@@ -120,6 +120,9 @@ def _invalidate_state_caches(
                 "get_user_in_room_with_profile", (room_id, user_id)
             )
             self._attempt_to_invalidate_cache("get_rooms_for_user", (user_id,))
+            self._attempt_to_invalidate_cache(
+                "_get_rooms_for_local_user_where_membership_is_inner", (user_id,)
+            )
 
         # Purge other caches based on room state.
         self._attempt_to_invalidate_cache("get_room_summary", (room_id,))
@@ -146,6 +149,9 @@ def _invalidate_state_caches_all(self, room_id: str) -> None:
         self._attempt_to_invalidate_cache("does_pair_of_users_share_a_room", None)
         self._attempt_to_invalidate_cache("get_user_in_room_with_profile", None)
         self._attempt_to_invalidate_cache("get_rooms_for_user", None)
+        self._attempt_to_invalidate_cache(
+            "_get_rooms_for_local_user_where_membership_is_inner", None
+        )
         self._attempt_to_invalidate_cache("get_room_summary", (room_id,))
 
     def _attempt_to_invalidate_cache(

synapse/storage/databases/main/cache.py

@@ -331,6 +331,9 @@ def _invalidate_caches_for_event(
                 "get_invited_rooms_for_local_user", (state_key,)
             )
             self._attempt_to_invalidate_cache("get_rooms_for_user", (state_key,))
+            self._attempt_to_invalidate_cache(
+                "_get_rooms_for_local_user_where_membership_is_inner", (state_key,)
+            )
 
             self._attempt_to_invalidate_cache(
                 "did_forget",
@@ -393,6 +396,9 @@ def _invalidate_caches_for_room_events(self, room_id: str) -> None:
         self._attempt_to_invalidate_cache("get_thread_id_for_receipts", None)
         self._attempt_to_invalidate_cache("get_invited_rooms_for_local_user", None)
         self._attempt_to_invalidate_cache("get_rooms_for_user", None)
+        self._attempt_to_invalidate_cache(
+            "_get_rooms_for_local_user_where_membership_is_inner", None
+        )
         self._attempt_to_invalidate_cache("did_forget", None)
         self._attempt_to_invalidate_cache("get_forgotten_rooms_for_user", None)
         self._attempt_to_invalidate_cache("get_references_for_event", None)

synapse/storage/databases/main/roommember.py

@@ -385,7 +385,7 @@ async def get_invited_rooms_for_local_user(
         """
 
         return await self.get_rooms_for_local_user_where_membership_is(
-            user_id, [Membership.INVITE]
+            user_id, (Membership.INVITE,)
         )
 
     async def get_knocked_at_rooms_for_local_user(
@@ -401,7 +401,7 @@ async def get_knocked_at_rooms_for_local_user(
         """
 
         return await self.get_rooms_for_local_user_where_membership_is(
-            user_id, [Membership.KNOCK]
+            user_id, (Membership.KNOCK,)
         )
 
     async def get_invite_for_local_user_in_room(
@@ -445,9 +445,7 @@ async def get_rooms_for_local_user_where_membership_is(
         if not membership_list:
             return []
 
-        rooms = await self.db_pool.runInteraction(
-            "get_rooms_for_local_user_where_membership_is",
-            self._get_rooms_for_local_user_where_membership_is_txn,
+        rooms = await self._get_rooms_for_local_user_where_membership_is_inner(
             user_id,
             membership_list,
         )
@@ -466,6 +464,24 @@ async def get_rooms_for_local_user_where_membership_is(
 
         return [room for room in rooms if room.room_id not in rooms_to_exclude]
 
+    @cached(max_entries=1000, tree=True)
+    async def _get_rooms_for_local_user_where_membership_is_inner(
+        self,
+        user_id: str,
+        membership_list: Collection[str],
+    ) -> Sequence[RoomsForUser]:
+        if not membership_list:
+            return []
+
+        rooms = await self.db_pool.runInteraction(
+            "get_rooms_for_local_user_where_membership_is",
+            self._get_rooms_for_local_user_where_membership_is_txn,
+            user_id,
+            membership_list,
+        )
+
+        return rooms
+
     def _get_rooms_for_local_user_where_membership_is_txn(
         self,
         txn: LoggingTransaction,

tests/handlers/test_sync.py

@@ -211,6 +211,7 @@ def test_unknown_room_version(self) -> None:
 
         # Blow away caches (supported room versions can only change due to a restart).
         self.store.get_rooms_for_user.invalidate_all()
+        self.store._get_rooms_for_local_user_where_membership_is_inner.invalidate_all()
         self.store._get_event_cache.clear()
         self.store._event_ref.clear()
 

tests/rest/client/test_account.py

@@ -535,7 +535,7 @@ def test_pending_invites(self) -> None:
         # Check that the membership of @invitee:test in the room is now "leave".
         memberships = self.get_success(
             store.get_rooms_for_local_user_where_membership_is(
-                invitee_id, [Membership.LEAVE]
+                invitee_id, (Membership.LEAVE,)
             )
         )
         self.assertEqual(len(memberships), 1, memberships)

tests/storage/test_roommember.py

@@ -68,7 +68,7 @@ def test_one_member(self) -> None:
 
         rooms_for_user = self.get_success(
             self.store.get_rooms_for_local_user_where_membership_is(
-                self.u_alice, [Membership.JOIN]
+                self.u_alice, (Membership.JOIN,)
             )
         )