Replace EventContext fields prev_group and delta_ids with field state_group_deltas

changelog.d/15233.misc

@@ -0,0 +1 @@
+Replace EventContext fields prev_group and delta_ids with field state_group_deltas.

synapse/events/snapshot.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 from abc import ABC, abstractmethod
-from typing import TYPE_CHECKING, List, Optional, Tuple
+from typing import TYPE_CHECKING, Dict, List, Optional, Tuple
 
 import attr
 from frozendict import frozendict
@@ -106,21 +106,9 @@ class EventContext(UnpersistedEventContextBase):
         state_delta_due_to_event: If `state_group` and `state_group_before_event` are not None
             then this is the delta of the state between the two groups.
 
-        prev_group: If it is known, ``state_group``'s prev_group. Note that this being
-            None does not necessarily mean that ``state_group`` does not have
-            a prev_group!
-
-            If the event is a state event, this is normally the same as
-            ``state_group_before_event``.
-
-            If ``state_group`` is None (ie, the event is an outlier), ``prev_group``
-            will always also be ``None``.
-
-            Note that this *not* (necessarily) the state group associated with
-            ``_prev_state_ids``.
-
-        delta_ids: If ``prev_group`` is not None, the state delta between ``prev_group``
-            and ``state_group``.
+        state_group_deltas: a dict containing information about the state groups associated with
+            the event and the state delta between these groups, ie a map from
+            (prev state group, new state group) -> delta state dict
 
         partial_state: if True, we may be storing this event with a temporary,
             incomplete state.
@@ -131,8 +119,9 @@ class EventContext(UnpersistedEventContextBase):
     _state_group: Optional[int] = None
     state_group_before_event: Optional[int] = None
     _state_delta_due_to_event: Optional[StateMap[str]] = None
-    prev_group: Optional[int] = None
-    delta_ids: Optional[StateMap[str]] = None
+    state_group_deltas: Optional[
+        Dict[Tuple[Optional[int], Optional[int]], Optional[StateMap[str]]]
+    ] = None
     app_service: Optional[ApplicationService] = None
 
     partial_state: bool = False
@@ -144,16 +133,16 @@ def with_state(
         state_group_before_event: Optional[int],
         state_delta_due_to_event: Optional[StateMap[str]],
         partial_state: bool,
-        prev_group: Optional[int] = None,
-        delta_ids: Optional[StateMap[str]] = None,
+        state_group_deltas: Optional[
+            Dict[Tuple[Optional[int], Optional[int]], Optional[StateMap[str]]]
+        ],
     ) -> "EventContext":
         return EventContext(
             storage=storage,
             state_group=state_group,
             state_group_before_event=state_group_before_event,
             state_delta_due_to_event=state_delta_due_to_event,
-            prev_group=prev_group,
-            delta_ids=delta_ids,
+            state_group_deltas=state_group_deltas,
             partial_state=partial_state,
         )
 
@@ -177,16 +166,14 @@ async def serialize(self, event: EventBase, store: "DataStore") -> JsonDict:
         Returns:
             The serialized event.
         """
-
         return {
             "state_group": self._state_group,
             "state_group_before_event": self.state_group_before_event,
             "rejected": self.rejected,
-            "prev_group": self.prev_group,
+            "state_group_deltas": _encode_state_group_delta(self.state_group_deltas),
             "state_delta_due_to_event": _encode_state_dict(
                 self._state_delta_due_to_event
             ),
-            "delta_ids": _encode_state_dict(self.delta_ids),
             "app_service_id": self.app_service.id if self.app_service else None,
             "partial_state": self.partial_state,
         }
@@ -209,11 +196,10 @@ def deserialize(storage: "StorageControllers", input: JsonDict) -> "EventContext
             storage=storage,
             state_group=input["state_group"],
             state_group_before_event=input["state_group_before_event"],
-            prev_group=input["prev_group"],
+            state_group_deltas=_decode_state_group_delta(input["state_group_deltas"]),
             state_delta_due_to_event=_decode_state_dict(
                 input["state_delta_due_to_event"]
             ),
-            delta_ids=_decode_state_dict(input["delta_ids"]),
             rejected=input["rejected"],
             partial_state=input.get("partial_state", False),
         )
@@ -344,7 +330,7 @@ class UnpersistedEventContext(UnpersistedEventContextBase):
     _storage: "StorageControllers"
     state_group_before_event: Optional[int]
     state_group_after_event: Optional[int]
-    state_delta_due_to_event: Optional[dict]
+    state_delta_due_to_event: Optional[StateMap[str]]
     prev_group_for_state_group_before_event: Optional[int]
     delta_ids_to_state_group_before_event: Optional[StateMap[str]]
     partial_state: bool
@@ -375,26 +361,24 @@ async def batch_persist_unpersisted_contexts(
 
         events_and_persisted_context = []
         for event, unpersisted_context in amended_events_and_context:
-            if event.is_state():
-                context = EventContext(
-                    storage=unpersisted_context._storage,
-                    state_group=unpersisted_context.state_group_after_event,
-                    state_group_before_event=unpersisted_context.state_group_before_event,
-                    state_delta_due_to_event=unpersisted_context.state_delta_due_to_event,
-                    partial_state=unpersisted_context.partial_state,
-                    prev_group=unpersisted_context.state_group_before_event,
-                    delta_ids=unpersisted_context.state_delta_due_to_event,
-                )
-            else:
-                context = EventContext(
-                    storage=unpersisted_context._storage,
-                    state_group=unpersisted_context.state_group_after_event,
-                    state_group_before_event=unpersisted_context.state_group_before_event,
-                    state_delta_due_to_event=unpersisted_context.state_delta_due_to_event,
-                    partial_state=unpersisted_context.partial_state,
-                    prev_group=unpersisted_context.prev_group_for_state_group_before_event,
-                    delta_ids=unpersisted_context.delta_ids_to_state_group_before_event,
-                )
+            state_group_deltas = {
+                (
+                    unpersisted_context.state_group_before_event,
+                    unpersisted_context.state_group_after_event,
+                ): unpersisted_context.state_delta_due_to_event,
+                (
+                    unpersisted_context.prev_group_for_state_group_before_event,
+                    unpersisted_context.state_group_before_event,
+                ): unpersisted_context.delta_ids_to_state_group_before_event,
+            }
+            context = EventContext(
+                storage=unpersisted_context._storage,
+                state_group=unpersisted_context.state_group_after_event,
+                state_group_before_event=unpersisted_context.state_group_before_event,
+                state_delta_due_to_event=unpersisted_context.state_delta_due_to_event,
+                partial_state=unpersisted_context.partial_state,
+                state_group_deltas=state_group_deltas,
+            )
             events_and_persisted_context.append((event, context))
         return events_and_persisted_context
 
@@ -447,26 +431,37 @@ async def persist(self, event: EventBase) -> EventContext:
 
         # if the event isn't a state event the state group doesn't change
         if not self.state_delta_due_to_event:
-            state_group_after_event = self.state_group_before_event
+            self.state_group_after_event = self.state_group_before_event
 
         # otherwise if it is a state event we need to get a state group for it
         else:
-            state_group_after_event = await self._storage.state.store_state_group(
+            self.state_group_after_event = await self._storage.state.store_state_group(
                 event.event_id,
                 event.room_id,
                 prev_group=self.state_group_before_event,
                 delta_ids=self.state_delta_due_to_event,
                 current_state_ids=None,
             )
+        state_group_deltas: Optional[
+            Dict[Tuple[Optional[int], Optional[int]], Optional[StateMap[str]]]
+        ] = {
+            (
+                self.state_group_before_event,
+                self.state_group_after_event,
+            ): self.state_delta_due_to_event,
+            (
+                self.prev_group_for_state_group_before_event,
+                self.state_group_before_event,
+            ): self.delta_ids_to_state_group_before_event,
+        }
 
         return EventContext.with_state(
             storage=self._storage,
-            state_group=state_group_after_event,
+            state_group=self.state_group_after_event,
             state_group_before_event=self.state_group_before_event,
             state_delta_due_to_event=self.state_delta_due_to_event,
+            state_group_deltas=state_group_deltas,
             partial_state=self.partial_state,
-            prev_group=self.state_group_before_event,
-            delta_ids=self.state_delta_due_to_event,
         )
 
 
@@ -482,6 +477,38 @@ def _encode_state_dict(
     return [(etype, state_key, v) for (etype, state_key), v in state_dict.items()]
 
 
+def _encode_state_group_delta(
+    state_group_delta: Optional[
+        Dict[Tuple[Optional[int], Optional[int]], Optional[StateMap[str]]]
+    ]
+) -> Optional[
+    List[Tuple[Optional[int], Optional[int], Optional[List[Tuple[str, str, str]]]]]
+]:
+    if state_group_delta is None:
+        return None
+
+    state_group_delta_encoded = []
+    for key, value in state_group_delta.items():
+        state_group_delta_encoded.append((key[0], key[1], _encode_state_dict(value)))
+
+    return state_group_delta_encoded
+
+
+def _decode_state_group_delta(
+    input: Optional[
+        List[Tuple[Optional[int], Optional[int], Optional[List[Tuple[str, str, str]]]]]
+    ]
+) -> Optional[Dict[Tuple[Optional[int], Optional[int]], Optional[StateMap[str]]]]:
+    if input is None:
+        return None
+
+    state_group_deltas = {}
+    for element in input:
+        state_group_deltas[(element[0], element[1])] = _decode_state_dict(element[2])
+
+    return state_group_deltas
+
+
 def _decode_state_dict(
     input: Optional[List[Tuple[str, str, str]]]
 ) -> Optional[StateMap[str]]:

synapse/storage/controllers/persist_events.py

@@ -827,8 +827,6 @@ async def _get_new_state_after_events(
             the new current state is only returned if we've already calculated
             it.
         """
-        # Map from (prev state group, new state group) -> delta state dict
-        state_group_deltas = {}
 
         for ev, ctx in events_context:
             if ctx.state_group is None:
@@ -840,9 +838,6 @@ async def _get_new_state_after_events(
                     )
                 continue
 
-            if ctx.prev_group:
-                state_group_deltas[(ctx.prev_group, ctx.state_group)] = ctx.delta_ids
-
         # We need to map the event_ids to their state groups. First, let's
         # check if the event is one we're persisting, in which case we can
         # pull the state group from its context.
@@ -894,7 +889,10 @@ async def _get_new_state_after_events(
             new_state_group = next(iter(new_state_groups))
             old_state_group = next(iter(old_state_groups))
 
-            delta_ids = state_group_deltas.get((old_state_group, new_state_group), None)
+            assert ctx.state_group_deltas is not None
+            delta_ids = ctx.state_group_deltas.get(
+                (old_state_group, new_state_group), None
+            )
             if delta_ids is not None:
                 # We have a delta from the existing to new current state,
                 # so lets just return that.

tests/events/test_snapshot.py

@@ -101,8 +101,7 @@ def _check_serialize_deserialize(
         self.assertEqual(
             context.state_group_before_event, d_context.state_group_before_event
         )
-        self.assertEqual(context.prev_group, d_context.prev_group)
-        self.assertEqual(context.delta_ids, d_context.delta_ids)
+        self.assertEqual(context.state_group_deltas, d_context.state_group_deltas)
         self.assertEqual(context.app_service, d_context.app_service)
 
         self.assertEqual(

tests/test_state.py

@@ -555,9 +555,14 @@ def test_annotate_with_old_state(
         )
 
         self.assertIsNotNone(context.state_group_before_event)
+        assert context.state_group_deltas is not None
+        self.assertEqual(
+            context.state_group_deltas.get(
+                (context.state_group_before_event, context.state_group)
+            ),
+            {(event.type, event.state_key): event.event_id},
+        )
         self.assertNotEqual(context.state_group_before_event, context.state_group)
-        self.assertEqual(context.state_group_before_event, context.prev_group)
-        self.assertEqual({("state", ""): event.event_id}, context.delta_ids)
 
     @defer.inlineCallbacks
     def test_trivial_annotate_message(