Make base insertion event float off on its own

See #10250 (comment)

Conflicts:
	synapse/rest/client/v1/room.py

synapse/handlers/message.py

@@ -518,6 +518,9 @@ async def create_event(
             outlier: Indicates whether the event is an `outlier`, i.e. if
                 it's from an arbitrary point and floating in the DAG as
                 opposed to being inline with the current DAG.
+            historical: Indicates whether the message is being inserted
+                back in time around some existing events. This is used to skip
+                a few checks and mark the event as backfilled.
             depth: Override the depth used to order the event in the DAG.
                 Should normally be set to None, which will cause the depth to be calculated
                 based on the prev_events.
@@ -772,6 +775,7 @@ async def create_and_send_nonmember_event(
         txn_id: Optional[str] = None,
         ignore_shadow_ban: bool = False,
         outlier: bool = False,
+        historical: bool = False,
         depth: Optional[int] = None,
     ) -> Tuple[EventBase, int]:
         """
@@ -799,6 +803,9 @@ async def create_and_send_nonmember_event(
             outlier: Indicates whether the event is an `outlier`, i.e. if
                 it's from an arbitrary point and floating in the DAG as
                 opposed to being inline with the current DAG.
+            historical: Indicates whether the message is being inserted
+                back in time around some existing events. This is used to skip
+                a few checks and mark the event as backfilled.
             depth: Override the depth used to order the event in the DAG.
                 Should normally be set to None, which will cause the depth to be calculated
                 based on the prev_events.
@@ -847,6 +854,7 @@ async def create_and_send_nonmember_event(
                 prev_event_ids=prev_event_ids,
                 auth_event_ids=auth_event_ids,
                 outlier=outlier,
+                historical=historical,
                 depth=depth,
             )
 

synapse/rest/client/v1/room.py

@@ -350,12 +350,15 @@ async def _inherit_depth_from_prev_ids(self, prev_event_ids) -> int:
 
         return depth
 
-    def _create_insertion_event_dict(self, sender: str, origin_server_ts: int):
+    def _create_insertion_event_dict(
+        self, sender: str, room_id: str, origin_server_ts: int
+    ):
         """Creates an event dict for an "insertion" event with the proper fields
         and a random chunk ID.
 
         Args:
             sender: The event author MXID
+            room_id: The room ID that the event belongs to
             origin_server_ts: Timestamp when the event was sent
 
         Returns:
@@ -366,6 +369,7 @@ def _create_insertion_event_dict(self, sender: str, origin_server_ts: int):
         insertion_event = {
             "type": EventTypes.MSC2716_INSERTION,
             "sender": sender,
+            "room_id": room_id,
             "content": {
                 EventContentFields.MSC2716_NEXT_CHUNK_ID: next_chunk_id,
                 EventContentFields.MSC2716_HISTORICAL: True,
@@ -479,11 +483,17 @@ async def on_POST(self, request, room_id):
 
         events_to_create = body["events"]
 
+        prev_event_ids = prev_events_from_query
+        inherited_depth = await self._inherit_depth_from_prev_ids(
+            prev_events_from_query
+        )
+
         # Figure out which chunk to connect to. If they passed in
         # chunk_id_from_query let's use it. The chunk ID passed in comes
         # from the chunk_id in the "insertion" event from the previous chunk.
         last_event_in_chunk = events_to_create[-1]
         chunk_id_to_connect_to = chunk_id_from_query
+        base_insertion_event = None
         if chunk_id_from_query:
             # TODO: Verify the chunk_id_from_query corresponds to an insertion event
             pass
@@ -495,11 +505,25 @@ async def on_POST(self, request, room_id):
         # an insertion event), in which case we just create a new insertion event
         # that can then get pointed to by a "marker" event later.
         else:
-            base_insertion_event = self._create_insertion_event_dict(
+            base_insertion_event_dict = self._create_insertion_event_dict(
                 sender=requester.user.to_string(),
+                room_id=room_id,
                 origin_server_ts=last_event_in_chunk["origin_server_ts"],
             )
-            events_to_create.append(base_insertion_event)
+            base_insertion_event_dict["prev_events"] = prev_event_ids.copy()
+
+            (
+                base_insertion_event,
+                _,
+            ) = await self.event_creation_handler.create_and_send_nonmember_event(
+                requester,
+                base_insertion_event_dict,
+                prev_event_ids=base_insertion_event_dict.get("prev_events"),
+                auth_event_ids=auth_event_ids,
+                historical=True,
+                depth=inherited_depth,
+            )
+
             chunk_id_to_connect_to = base_insertion_event["content"][
                 EventContentFields.MSC2716_NEXT_CHUNK_ID
             ]
@@ -513,6 +537,7 @@ async def on_POST(self, request, room_id):
         # event in the chunk) so the next chunk can be connected to this one.
         insertion_event = self._create_insertion_event_dict(
             sender=requester.user.to_string(),
+            room_id=room_id,
             # Since the insertion event is put at the start of the chunk,
             # where the oldest-in-time event is, copy the origin_server_ts from
             # the first event we're inserting
@@ -521,12 +546,7 @@ async def on_POST(self, request, room_id):
         # Prepend the insertion event to the start of the chunk
         events_to_create = [insertion_event] + events_to_create
 
-        inherited_depth = await self._inherit_depth_from_prev_ids(
-            prev_events_from_query
-        )
-
         event_ids = []
-        prev_event_ids = prev_events_from_query
         events_to_persist = []
         for ev in events_to_create:
             assert_params_in_dict(ev, ["type", "origin_server_ts", "content", "sender"])
@@ -580,6 +600,10 @@ async def on_POST(self, request, room_id):
                 context=context,
             )
 
+        # Add the base_insertion_event to the bottom of the list we return
+        if base_insertion_event is not None:
+            event_ids.append(base_insertion_event.event_id)
+
         return 200, {
             "state_events": auth_event_ids,
             "events": event_ids,