initial cut at a room summary API

changelog.d/3331.feature

@@ -0,0 +1 @@
+add support for the include_redundant_members filter param as per MSC1227

changelog.d/3567.feature

@@ -0,0 +1 @@
+make the /context API filter & lazy-load aware as per MSC1227

changelog.d/3568.feature

@@ -0,0 +1 @@
+speed up /members API and add `at` and `membership` params as per MSC1227

changelog.d/3574.feature

@@ -0,0 +1 @@
+implement `summary` block in /sync response as per MSC688

synapse/api/filtering.py

@@ -117,6 +117,9 @@
         "lazy_load_members": {
             "type": "boolean"
         },
+        "include_redundant_members": {
+            "type": "boolean"
+        },
     }
 }
 
@@ -267,6 +270,9 @@ def ephemeral_limit(self):
     def lazy_load_members(self):
         return self._room_state_filter.lazy_load_members()
 
+    def include_redundant_members(self):
+        return self._room_state_filter.include_redundant_members()
+
     def filter_presence(self, events):
         return self._presence_filter.filter(events)
 
@@ -426,6 +432,9 @@ def limit(self):
     def lazy_load_members(self):
         return self.filter_json.get("lazy_load_members", False)
 
+    def include_redundant_members(self):
+        return self.filter_json.get("include_redundant_members", False)
+
 
 def _matches_wildcard(actual_value, filter_value):
     if filter_value.endswith("*"):

synapse/handlers/message.py

@@ -82,14 +82,49 @@ def get_room_data(self, user_id=None, room_id=None,
         defer.returnValue(data)
 
     @defer.inlineCallbacks
-    def get_state_events(self, user_id, room_id, is_guest=False):
+    def _check_in_room_or_world_readable(self, room_id, user_id):
+        try:
+            # check_user_was_in_room will return the most recent membership
+            # event for the user if:
+            #  * The user is a non-guest user, and was ever in the room
+            #  * The user is a guest user, and has joined the room
+            # else it will throw.
+            member_event = yield self.auth.check_user_was_in_room(room_id, user_id)
+            defer.returnValue((member_event.membership, member_event.event_id))
+            return
+        except AuthError:
+            visibility = yield self.state_handler.get_current_state(
+                room_id, EventTypes.RoomHistoryVisibility, ""
+            )
+            if (
+                visibility and
+                visibility.content["history_visibility"] == "world_readable"
+            ):
+                defer.returnValue((Membership.JOIN, None))
+                return
+            raise AuthError(
+                403, "Guest access not allowed", errcode=Codes.GUEST_ACCESS_FORBIDDEN
+            )
+
+    @defer.inlineCallbacks
+    def get_state_events(
+        self, user_id, room_id, types=None, filtered_types=None,
+        at_event=None, is_guest=False
+    ):
         """Retrieve all state events for a given room. If the user is
         joined to the room then return the current state. If the user has
-        left the room return the state events from when they left.
+        left the room return the state events from when they left. If an explicit
+        'at' parameter is passed, return the state events as of that event.
 
         Args:
             user_id(str): The user requesting state events.
             room_id(str): The room ID to get all state events from.
+            types(list[(Str, (Str|None))]): the (type, state_key)s to return
+                results for.
+            filtered_types(list[Str]): the list of types to apply the types filter
+                to.
+            at_event(str): the event_id we are requesting the state as of
+            is_guest(Boolean): whether this user is a guest
         Returns:
             A list of dicts representing state events. [{}, {}, {}]
         """
@@ -98,10 +133,19 @@ def get_state_events(self, user_id, room_id, is_guest=False):
         )
 
         if membership == Membership.JOIN:
-            room_state = yield self.state.get_current_state(room_id)
+            if at_event:
+                room_state = yield self.store.get_state_for_events(
+                    [at_event], types, filtered_types=filtered_types
+                )
+                room_state = room_state[at_event]
+            else:
+                state_ids = yield self.store.get_filtered_current_state_ids(
+                    room_id, types, filtered_types=filtered_types
+                )
+                room_state = yield self.store.get_events(state_ids.values())
         elif membership == Membership.LEAVE:
             room_state = yield self.store.get_state_for_events(
-                [membership_event_id], None
+                [membership_event_id], types, filtered_types=filtered_types
             )
             room_state = room_state[membership_event_id]
 

synapse/handlers/room.py

@@ -401,7 +401,7 @@ def __init__(self, hs):
         self.store = hs.get_datastore()
 
     @defer.inlineCallbacks
-    def get_event_context(self, user, room_id, event_id, limit):
+    def get_event_context(self, user, room_id, event_id, limit, event_filter):
         """Retrieves events, pagination tokens and state around a given event
         in a room.
 
@@ -411,6 +411,8 @@ def get_event_context(self, user, room_id, event_id, limit):
             event_id (str)
             limit (int): The maximum number of events to return in total
                 (excluding state).
+            event_filter (Filter|None): the filter to apply to the events returned
+                (excluding the target event_id)
 
         Returns:
             dict, or None if the event isn't found
@@ -445,7 +447,7 @@ def filter_evts(events):
             )
 
         results = yield self.store.get_events_around(
-            room_id, event_id, before_limit, after_limit
+            room_id, event_id, before_limit, after_limit, event_filter
         )
 
         results["events_before"] = yield filter_evts(results["events_before"])
@@ -457,8 +459,24 @@ def filter_evts(events):
         else:
             last_event_id = event_id
 
+        types = None
+        filtered_types = None
+        if event_filter and event_filter.lazy_load_members():
+            members = {}
+            for ev in (
+                results["events_before"] +
+                [results["event"]] +
+                results["events_after"]
+            ):
+                members[ev.sender] = True
+            filtered_types = [EventTypes.Member]
+            types = [(EventTypes.Member, member) for member in members.keys()]
+
+        # XXX: why do we return the state as of the last event rather than the
+        # first? Shouldn't we be consistent with /sync?
+
         state = yield self.store.get_state_for_events(
-            [last_event_id], None
+            [last_event_id], types, filtered_types=filtered_types
         )
         results["state"] = list(state[last_event_id].values())
 

synapse/handlers/search.py

@@ -287,7 +287,7 @@ def search(self, user, content, batch=None):
             contexts = {}
             for event in allowed_events:
                 res = yield self.store.get_events_around(
-                    event.room_id, event.event_id, before_limit, after_limit
+                    event.room_id, event.event_id, before_limit, after_limit,
                 )
 
                 logger.info(