Sliding Sync: Support filtering by 'tags' / 'not_tags' in SSS

changelog.d/17662.feature

@@ -0,0 +1 @@
+Add support for the `tags` and `not_tags` filters for simplified sliding sync.

synapse/handlers/sliding_sync/room_lists.py

@@ -50,6 +50,7 @@
 from synapse.storage.databases.main.stream import CurrentStateDeltaMembership
 from synapse.storage.roommember import RoomsForUser, RoomsForUserSlidingSync
 from synapse.types import (
+    JsonMapping,
     MutableStateMap,
     PersistedEventPosition,
     RoomStreamToken,
@@ -301,6 +302,9 @@ async def _compute_interested_rooms_new_tables(
         )
         dm_room_ids = await self._get_dm_rooms_for_user(user_id)
 
+        # Fetch the user tags for their rooms
+        room_tags = await self.store.get_tags_for_user(user_id)
+
         # Handle state resets in the from -> to token range.
         state_reset_rooms = (
             newly_left_room_map.keys() - room_membership_for_user_map.keys()
@@ -349,6 +353,7 @@ async def _compute_interested_rooms_new_tables(
                             list_config.filters,
                             to_token,
                             dm_room_ids,
+                            room_tags,
                         )
 
                     # Find which rooms are partially stated and may need to be filtered out
@@ -1699,6 +1704,7 @@ async def filter_rooms_using_tables(
         filters: SlidingSyncConfig.SlidingSyncList.Filters,
         to_token: StreamToken,
         dm_room_ids: AbstractSet[str],
+        room_tags: Mapping[str, Mapping[str, JsonMapping]],
     ) -> Dict[str, RoomsForUserSlidingSync]:
         """
         Filter rooms based on the sync request.
@@ -1710,6 +1716,7 @@ async def filter_rooms_using_tables(
             filters: Filters to apply
             to_token: We filter based on the state of the room at this token
             dm_room_ids: Set of room IDs which are DMs
+            room_tags: Mapping of room ID to tags
 
         Returns:
             A filtered dictionary of room IDs along with membership information in the
@@ -1795,9 +1802,21 @@ async def filter_rooms_using_tables(
                 # )
                 raise NotImplementedError()
 
-        if filters.tags is not None or filters.not_tags is not None:
+        if filters.tags is not None:
             with start_active_span("filters.tags"):
-                raise NotImplementedError()
+                filtered_room_id_set = {
+                    room_id
+                    for room_id in filtered_room_id_set
+                    if set(room_tags.get(room_id, [])) & set(filters.tags)
+                }
+
+        if filters.not_tags is not None:
+            with start_active_span("filters.not_tags"):
+                filtered_room_id_set = {
+                    room_id
+                    for room_id in filtered_room_id_set
+                    if not set(room_tags.get(room_id, [])) & set(filters.not_tags)
+                }
 
         # Assemble a new sync room map but only with the `filtered_room_id_set`
         return {room_id: sync_room_map[room_id] for room_id in filtered_room_id_set}

tests/handlers/test_sliding_sync.py

@@ -18,7 +18,7 @@
 #
 #
 import logging
-from typing import Dict, List, Optional
+from typing import Dict, List, Mapping, Optional
 from unittest.mock import patch
 
 from parameterized import parameterized
@@ -45,7 +45,7 @@
 from synapse.rest.client import knock, login, room
 from synapse.server import HomeServer
 from synapse.storage.util.id_generators import MultiWriterIdGenerator
-from synapse.types import JsonDict, StreamToken, UserID
+from synapse.types import JsonDict, JsonMapping, StreamToken, UserID
 from synapse.types.handlers.sliding_sync import SlidingSyncConfig
 from synapse.util import Clock
 
@@ -3006,6 +3006,7 @@ def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None:
         self.sliding_sync_handler = self.hs.get_sliding_sync_handler()
         self.store = self.hs.get_datastores().main
         self.event_sources = hs.get_event_sources()
+        self.account_data_handler = hs.get_account_data_handler()
 
     def _get_sync_room_ids_for_user(
         self,
@@ -3209,6 +3210,128 @@ def test_filter_dm_rooms(self) -> None:
 
         self.assertEqual(falsy_filtered_room_map.keys(), {room_id})
 
+    def test_filter_rooms_by_tags(self) -> None:
+        """
+        Test `filter.tags` for rooms with given tags
+        """
+        user1_id = self.register_user("user1", "pass")
+        user1_tok = self.login(user1_id, "pass")
+
+        # Create a room with no tags
+        self.helper.create_room_as(user1_id, tok=user1_tok)
+
+        footag_room_id = self.helper.create_room_as(user1_id, tok=user1_tok)
+        bartag_room_id = self.helper.create_room_as(user1_id, tok=user1_tok)
+
+        tag_data: Mapping[str, Mapping[str, JsonMapping]] = {
+            footag_room_id: {"foo": {}},
+            bartag_room_id: {"bar": {}},
+        }
+
+        after_rooms_token = self.event_sources.get_current_token()
+
+        # Get the rooms the user should be syncing with
+        room_membership_for_user_map = self.get_success(
+            self.store.get_sliding_sync_rooms_for_user(user1_id)
+        )
+
+        # Try with `tags=foo`
+        foo_filtered_room_map = self.get_success(
+            self.sliding_sync_handler.room_lists.filter_rooms_using_tables(
+                user1_id,
+                room_membership_for_user_map,
+                SlidingSyncConfig.SlidingSyncList.Filters(
+                    tags=["foo"],
+                ),
+                after_rooms_token,
+                set(),
+                tag_data,
+            )
+        )
+
+        self.assertEqual(foo_filtered_room_map.keys(), {footag_room_id})
+
+        # Try with a random tag we didn't add
+        foobar_filtered_room_map = self.get_success(
+            self.sliding_sync_handler.room_lists.filter_rooms_using_tables(
+                user1_id,
+                room_membership_for_user_map,
+                SlidingSyncConfig.SlidingSyncList.Filters(
+                    tags=["flomp"],
+                ),
+                after_rooms_token,
+                set(),
+                tag_data,
+            )
+        )
+
+        self.assertEqual(len(foobar_filtered_room_map), 0)
+
+    def test_filter_rooms_by_not_tags(self) -> None:
+        """
+        Test `filter.not_tags` for excluding rooms with given tags
+        """
+        user1_id = self.register_user("user1", "pass")
+        user1_tok = self.login(user1_id, "pass")
+
+        # Create a room with no tags
+        untagged_room_id = self.helper.create_room_as(user1_id, tok=user1_tok)
+
+        footag_room_id = self.helper.create_room_as(user1_id, tok=user1_tok)
+        bartag_room_id = self.helper.create_room_as(user1_id, tok=user1_tok)
+
+        tag_data: Mapping[str, Mapping[str, JsonMapping]] = {
+            footag_room_id: {"foo": {}},
+            bartag_room_id: {"bar": {}},
+        }
+
+        after_rooms_token = self.event_sources.get_current_token()
+
+        # Get the rooms the user should be syncing with
+        # sync_room_map = self._get_sync_room_ids_for_user(
+        #     UserID.from_string(user1_id),
+        #     from_token=None,
+        #     to_token=after_rooms_token,
+        # )
+
+        room_membership_for_user_map = self.get_success(
+            self.store.get_sliding_sync_rooms_for_user(user1_id)
+        )
+
+        # Try with `not_tags=foo`
+        foo_filtered_room_map = self.get_success(
+            self.sliding_sync_handler.room_lists.filter_rooms_using_tables(
+                user1_id,
+                room_membership_for_user_map,
+                SlidingSyncConfig.SlidingSyncList.Filters(
+                    not_tags=["foo"],
+                ),
+                after_rooms_token,
+                set(),
+                tag_data,
+            )
+        )
+
+        self.assertEqual(
+            foo_filtered_room_map.keys(), {untagged_room_id, bartag_room_id}
+        )
+
+        # Try with not_tags=[foo,bar]
+        foobar_filtered_room_map = self.get_success(
+            self.sliding_sync_handler.room_lists.filter_rooms_using_tables(
+                user1_id,
+                room_membership_for_user_map,
+                SlidingSyncConfig.SlidingSyncList.Filters(
+                    not_tags=["foo", "bar"],
+                ),
+                after_rooms_token,
+                set(),
+                tag_data,
+            )
+        )
+
+        self.assertEqual(foobar_filtered_room_map.keys(), {untagged_room_id})
+
     def test_filter_encrypted_rooms(self) -> None:
         """
         Test `filter.is_encrypted` for encrypted rooms