From 49686ede02ca85567c057d92fdf0e6b6fa5d8011 Mon Sep 17 00:00:00 2001 From: "H. Shay" Date: Wed, 24 Aug 2022 14:08:04 -0700 Subject: create events and contexts seperately --- synapse/handlers/room.py | 118 +++++++++++++++++++++++++++++++++-------------- 1 file changed, 84 insertions(+), 34 deletions(-) diff --git a/synapse/handlers/room.py b/synapse/handlers/room.py index 9d15f8929c..c5f7e1b286 100644 --- a/synapse/handlers/room.py +++ b/synapse/handlers/room.py @@ -108,6 +108,7 @@ class EventContext: class RoomCreationHandler: def __init__(self, hs: "HomeServer"): self.store = hs.get_datastores().main + self.state = hs.get_state_handler() self._storage_controllers = hs.get_storage_controllers() self.auth = hs.get_auth() self.auth_blocking = hs.get_auth_blocking() @@ -1043,6 +1044,9 @@ class RoomCreationHandler: event_keys = {"room_id": room_id, "sender": creator_id, "state_key": ""} depth = 1 last_sent_event_id: Optional[str] = None + prev_event: List[str] = [] + state_map = {} + auth_events = [] def create_event_dict(etype: str, content: JsonDict, **kwargs: Any) -> JsonDict: e = {"type": etype, "content": content} @@ -1053,21 +1057,28 @@ class RoomCreationHandler: return e async def create_event( - etype: str, content: JsonDict, **kwargs: Any - ) -> Tuple[EventBase, synapse.events.snapshot.EventContext]: - nonlocal last_sent_event_id + etype: str, + content: JsonDict, + auth_event_ids: Optional[List[str]] = None, + **kwargs: Any, + ) -> EventBase: nonlocal depth + nonlocal prev_event event_dict = create_event_dict(etype, content, **kwargs) - event, context = await self.event_creation_handler.create_event( + event = await self.event_creation_handler.create_event_for_batch( creator, event_dict, - prev_event_ids=[last_sent_event_id] if last_sent_event_id else [], + prev_event, depth=depth, + auth_event_ids=auth_event_ids, ) depth += 1 - return event, context + prev_event = [event.event_id] + state_map[(event.type, event.state_key)] = event.event_id + + return event async def send( event: EventBase, @@ -1075,9 +1086,6 @@ class RoomCreationHandler: creator: Requester, ) -> int: nonlocal last_sent_event_id - assert self.hs.is_mine_id(event.sender), "User must be our own: %s" % ( - event.sender, - ) ev = await self.event_creation_handler.handle_new_client_event( requester=creator, @@ -1101,12 +1109,15 @@ class RoomCreationHandler: ) creation_content.update({"creator": creator_id}) - creation_event, creation_context = await create_event( - etype=EventTypes.Create, content=creation_content + creation_event = await create_event( + EventTypes.Create, + creation_content, ) + creation_context = await self.state.compute_event_context(creation_event) logger.debug("Sending %s in new room", EventTypes.Member) await send(creation_event, creation_context, creator) + auth_events.append(creation_event.event_id) # Room create event must exist at this point assert last_sent_event_id is not None @@ -1122,16 +1133,19 @@ class RoomCreationHandler: depth=depth, ) last_sent_event_id = member_event_id + prev_event = [member_event_id] depth += 1 + auth_events.append(member_event_id) # We treat the power levels override specially as this needs to be one # of the first events that get sent into a room. pl_content = initial_state.pop((EventTypes.PowerLevels, ""), None) if pl_content is not None: - power_event, power_context = await create_event( - etype=EventTypes.PowerLevels, content=pl_content - ) + power_event = await create_event(EventTypes.PowerLevels, pl_content) + power_context = await self.state.compute_event_context(power_event) + current_state_group = power_context._state_group last_sent_stream_id = await send(power_event, power_context, creator) + auth_events.append(power_event.event_id) else: power_level_content: JsonDict = { "users": {creator_id: 100}, @@ -1174,53 +1188,89 @@ class RoomCreationHandler: # apply those. if power_level_content_override: power_level_content.update(power_level_content_override) - - pl_event, pl_context = await create_event( - etype=EventTypes.PowerLevels, content=power_level_content + pl_event = await create_event( + EventTypes.PowerLevels, + power_level_content, ) + pl_context = await self.state.compute_event_context(pl_event) + current_state_group = pl_context._state_group last_sent_stream_id = await send(pl_event, pl_context, creator) + auth_events.append(pl_event.event_id) events_to_send = [] if room_alias and (EventTypes.CanonicalAlias, "") not in initial_state: - room_alias_event, room_alias_context = await create_event( - etype=EventTypes.CanonicalAlias, - content={"alias": room_alias.to_string()}, + room_alias_event = await create_event( + EventTypes.CanonicalAlias, + {"alias": room_alias.to_string()}, + ) + assert current_state_group is not None + room_alias_context = await self.state.compute_event_context_for_batched( + room_alias_event, state_map, current_state_group ) + current_state_group = room_alias_context._state_group events_to_send.append((room_alias_event, room_alias_context)) if (EventTypes.JoinRules, "") not in initial_state: - join_rules_event, join_rules_context = await create_event( - etype=EventTypes.JoinRules, content={"join_rule": config["join_rules"]} + join_rules_event = await create_event( + EventTypes.JoinRules, + {"join_rule": config["join_rules"]}, + auth_events, ) - + assert current_state_group is not None + join_rules_context = await self.state.compute_event_context_for_batched( + join_rules_event, state_map, current_state_group + ) + current_state_group = join_rules_context._state_group events_to_send.append((join_rules_event, join_rules_context)) if (EventTypes.RoomHistoryVisibility, "") not in initial_state: - visibility_event, visibility_context = await create_event( - etype=EventTypes.RoomHistoryVisibility, - content={"history_visibility": config["history_visibility"]}, + visibility_event = await create_event( + EventTypes.RoomHistoryVisibility, + {"history_visibility": config["history_visibility"]}, + auth_events, + ) + assert current_state_group is not None + visibility_context = await self.state.compute_event_context_for_batched( + visibility_event, state_map, current_state_group ) + current_state_group = visibility_context._state_group events_to_send.append((visibility_event, visibility_context)) if config["guest_can_join"]: if (EventTypes.GuestAccess, "") not in initial_state: - guest_access_event, guest_access_context = await create_event( - etype=EventTypes.GuestAccess, - content={EventContentFields.GUEST_ACCESS: GuestAccess.CAN_JOIN}, + guest_access_event = await create_event( + EventTypes.GuestAccess, + {EventContentFields.GUEST_ACCESS: GuestAccess.CAN_JOIN}, + auth_events, ) + assert current_state_group is not None + guest_access_context = ( + await self.state.compute_event_context_for_batched( + guest_access_event, state_map, current_state_group + ) + ) + current_state_group = guest_access_context._state_group events_to_send.append((guest_access_event, guest_access_context)) for (etype, state_key), content in initial_state.items(): - event, context = await create_event( - etype=etype, state_key=state_key, content=content + event = await create_event(etype, content, auth_events, state_key=state_key) + assert current_state_group is not None + context = await self.state.compute_event_context_for_batched( + event, state_map, current_state_group ) + current_state_group = context._state_group events_to_send.append((event, context)) if config["encrypted"]: - encryption_event, encryption_context = await create_event( - etype=EventTypes.RoomEncryption, + encryption_event = await create_event( + EventTypes.RoomEncryption, + {"algorithm": RoomEncryptionAlgorithms.DEFAULT}, + auth_events, state_key="", - content={"algorithm": RoomEncryptionAlgorithms.DEFAULT}, + ) + assert current_state_group is not None + encryption_context = await self.state.compute_event_context_for_batched( + encryption_event, state_map, current_state_group ) events_to_send.append((encryption_event, encryption_context)) -- cgit 1.4.1