Raise default room version to "12"

changelog.d/20130.misc

@@ -0,0 +1 @@
+Raise default room version to "12". Contributed by @jason-famedly @famedly.

synapse/config/server.py

@@ -176,7 +176,7 @@ def generate_ip_set(
     "fec0::/10",
 ]
 
-DEFAULT_ROOM_VERSION = "11"
+DEFAULT_ROOM_VERSION = "12"
 
 # Defaults for the presence state machine timers, in milliseconds. Overridden
 # by the corresponding options in the `presence` config section.

synapse/handlers/message.py

@@ -2404,7 +2404,15 @@ async def _rebuild_event_after_third_party_rules(
                 original_event.room_version, third_party_result
             )
             self.validator.validate_builder(builder)
-            assert builder.room_id is not None
+
+            # The room_id should only be None for creation events using msc4291
+            # rooms(version "12" and newer)
+            if not (
+                builder.room_version.msc4291_room_ids_as_hashes
+                and builder.type == EventTypes.Create
+            ):
+                assert builder.room_id is not None
+
         except SynapseError as e:
             raise Exception(
                 "Third party rules module created an invalid event: " + e.msg,
@@ -2439,12 +2447,21 @@ async def _rebuild_event_after_third_party_rules(
         for k, v in original_event.internal_metadata.get_dict().items():
             setattr(builder.internal_metadata, k, v)
 
-        # modules can send new state events, so we re-calculate the auth events just in
-        # case.
-        prev_event_ids = await self.store.get_prev_events_for_room(builder.room_id)
+        # Creation events using msc4291 rooms will not have a room_id, and will
+        # also not have prev_events nor prev_state_events.
+        # This was asserted above, so makes an acceptable sign that room_id can not be
+        # None here(which makes mypy happy) but if it is then the lists should be empty.
+        prev_event_ids = []
+        if builder.room_id is not None:
+            # modules can send new state events, so we re-calculate the auth events just
+            # in case.
+            prev_event_ids = await self.store.get_prev_events_for_room(builder.room_id)
 
         prev_state_events = None
-        if original_event.room_version.msc4242_state_dags:
+        if (
+            original_event.room_version.msc4242_state_dags
+            and builder.room_id is not None
+        ):
             prev_state_events = list(
                 await self.store.get_state_dag_extremities(builder.room_id)
             )

synapse/handlers/relations.py

@@ -44,6 +44,7 @@
     BundledAggregations,
     ThreadAggregation,
 )
+from synapse.synapse_rust.room_versions import RoomVersion
 from synapse.types import JsonDict, Requester, UserID
 from synapse.util.async_helpers import gather_results
 from synapse.visibility import filter_and_transform_events_for_client
@@ -193,6 +194,7 @@ async def redact_events_related_to(
         event_id: str,
         initial_redaction_event: EventBase,
         relation_types: list[str],
+        room_version: RoomVersion,
     ) -> None:
         """Redacts all events related to the given event ID with one of the given
         relation types.
@@ -210,6 +212,8 @@ async def redact_events_related_to(
                 event_id.
             relation_types: The types of relations to look for. If "*" is in the list,
                 all related events will be redacted regardless of the type.
+            room_version: The RoomVersion of the room, for deciding where the 'redacts'
+                key should go in the event dict
 
         Raises:
             ShadowBanError if the requester is shadow-banned
@@ -226,16 +230,24 @@ async def redact_events_related_to(
             )
 
         for related_event_id in related_event_ids:
+            # Depending on the room version involved, the "redacts" key can go in one of
+            # two places. If we only use what was provided in the initial event, it will
+            # only target an event that was already redacted and nothing will happen.
+            new_redaction_content = dict(initial_redaction_event.content)
+            event_dict: JsonDict = {
+                "type": EventTypes.Redaction,
+                "content": new_redaction_content,
+                "room_id": initial_redaction_event.room_id,
+                "sender": requester.user.to_string(),
+            }
+            if room_version.updated_redaction_rules:
+                event_dict["content"].update({"redacts": related_event_id})
+            else:
+                event_dict["redacts"] = related_event_id
             try:
                 await self._event_creation_handler.create_and_send_nonmember_event(
                     requester,
-                    {
-                        "type": EventTypes.Redaction,
-                        "content": initial_redaction_event.content,
-                        "room_id": initial_redaction_event.room_id,
-                        "sender": requester.user.to_string(),
-                        "redacts": related_event_id,
-                    },
+                    event_dict,
                     ratelimit=False,
                 )
             except SynapseError as e:

synapse/rest/client/room.py

@@ -1412,6 +1412,7 @@ async def _do(
                         event_id=event_id,
                         initial_redaction_event=event,
                         relation_types=with_relations,
+                        room_version=room_version,
                     )
 
             event_id = event.event_id

synapse/storage/databases/main/events_worker.py

@@ -1468,7 +1468,7 @@ async def _fetch_event_ids_and_get_outstanding_redactions(
                 #
                 if d["type"] != EventTypes.Member:
                     raise InvalidEventError(
-                        "Room %s for event %s is unknown" % (d["room_id"], event_id)
+                        "Room %s for event %s is unknown" % (d.get("room_id"), event_id)
                     )
 
                 # so, assuming this is an out-of-band-invite that arrived before
@@ -1499,7 +1499,7 @@ async def _fetch_event_ids_and_get_outstanding_redactions(
                     logger.warning(
                         "Event %s in room %s has unknown room version %s",
                         event_id,
-                        d["room_id"],
+                        d.get("room_id"),
                         room_version_id,
                     )
                     continue
@@ -1509,7 +1509,7 @@ async def _fetch_event_ids_and_get_outstanding_redactions(
                         "Event %s in room %s with version %s has wrong format: "
                         "expected %s, was %s",
                         event_id,
-                        d["room_id"],
+                        d.get("room_id"),
                         room_version_id,
                         room_version.event_format,
                         format_version,
@@ -1538,7 +1538,7 @@ async def _fetch_event_ids_and_get_outstanding_redactions(
                 # it's difficult to see what to do here. Pretty much all bets are off
                 # if Synapse cannot rely on the consistency of its database.
                 raise DatabaseCorruptionError(
-                    d["room_id"], event_id, original_ev.event_id
+                    d.get("room_id"), event_id, original_ev.event_id
                 )
 
             event_map[event_id] = original_ev

tests/federation/test_federation_client.py

@@ -25,14 +25,14 @@
 from twisted.internet import defer
 from twisted.internet.testing import MemoryReactor
 
-from synapse.api.room_versions import RoomVersions
 from synapse.events import EventBase
 from synapse.rest import admin
 from synapse.rest.client import login, room
 from synapse.server import HomeServer
 from synapse.util.clock import Clock
 
 from tests.test_utils import FakeResponse, event_injection
+from tests.test_utils.event_builders import make_test_pdu_event
 from tests.unittest import FederatingHomeserverTestCase
 
 
@@ -58,28 +58,42 @@ def prepare(
         self.reactor.advance(1000000000)
 
         self.creator = f"@creator:{self.OTHER_SERVER_NAME}"
-        self.test_room_id = "!room_id"
+        self.room_version = self.hs.config.server.default_room_version
 
     def test_get_room_state(self) -> None:
         # mock up some events to use in the response.
-        # In real life, these would have things in `prev_events` and `auth_events`, but that's
-        # a bit annoying to mock up, and the code under test doesn't care, so we don't bother.
+        # In real life, these would have things in `prev_events` and `auth_events`, but
+        # that's a bit annoying to mock up, and the code under test doesn't care, so we
+        # don't bother. We do bother with the room_id though, since it has to be
+        # generated by the hash of the creation event.
+        create_event_source = {
+            "type": "m.room.create",
+            "state_key": "",
+            "sender": self.creator,
+            "content": {"room_version": self.room_version.identifier},
+            "prev_events": [],
+            "auth_events": [],
+            "depth": 1,
+            "origin_server_ts": 500,
+        }
+        if not self.room_version.msc4291_room_ids_as_hashes:
+            # Do not bother saving this now, we will pull it out of the calculated event
+            # later.
+            create_event_source["room_id"] = f"!room:{self.OTHER_SERVER_NAME}"
+
         create_event_dict = self.add_hashes_and_signatures_from_other_server(
-            {
-                "room_id": self.test_room_id,
-                "type": "m.room.create",
-                "state_key": "",
-                "sender": self.creator,
-                "content": {"creator": self.creator},
-                "prev_events": [],
-                "auth_events": [],
-                "depth": 1,
-                "origin_server_ts": 500,
-            }
+            create_event_source,
+            self.room_version,
+        )
+        create_event = make_test_pdu_event(
+            create_event_source,
+            self.room_version,
         )
+        room_id = create_event.room_id
+
         member_event_dict = self.add_hashes_and_signatures_from_other_server(
             {
-                "room_id": self.test_room_id,
+                "room_id": room_id,
                 "type": "m.room.member",
                 "sender": self.creator,
                 "state_key": self.creator,
@@ -88,11 +102,12 @@ def test_get_room_state(self) -> None:
                 "auth_events": [],
                 "depth": 2,
                 "origin_server_ts": 600,
-            }
+            },
+            self.room_version,
         )
         pl_event_dict = self.add_hashes_and_signatures_from_other_server(
             {
-                "room_id": self.test_room_id,
+                "room_id": room_id,
                 "type": "m.room.power_levels",
                 "sender": self.creator,
                 "state_key": "",
@@ -101,7 +116,8 @@ def test_get_room_state(self) -> None:
                 "auth_events": [],
                 "depth": 3,
                 "origin_server_ts": 700,
-            }
+            },
+            self.room_version,
         )
 
         # mock up the response, and have the agent return it
@@ -125,16 +141,19 @@ def test_get_room_state(self) -> None:
         state_resp, auth_resp = self.get_success(
             self.hs.get_federation_client().get_room_state(
                 "yet.another.server",
-                self.test_room_id,
+                room_id,
                 "event_id",
-                RoomVersions.V9,
+                self.room_version,
             )
         )
 
         # check the right call got made to the agent
         self._mock_agent.request.assert_called_once_with(
             b"GET",
-            b"matrix-federation://yet.another.server/_matrix/federation/v1/state/%21room_id?event_id=event_id",
+            # Please double-check me that ascii encoding is correct thing to do here
+            f"matrix-federation://yet.another.server/_matrix/federation/v1/state/%21{room_id[1:]}?event_id=event_id".encode(
+                "ascii"
+            ),
             headers=mock.ANY,
             bodyProducer=None,
         )
@@ -158,7 +177,7 @@ def test_get_pdu_returns_nothing_when_event_does_not_exist(self) -> None:
             self.hs.get_federation_client().get_pdu(
                 ["yet.another.server"],
                 "event_should_not_exist",
-                RoomVersions.V9,
+                self.room_version,
             )
         )
         self.assertEqual(pulled_pdu_info, None)
@@ -185,7 +204,7 @@ def test_get_pdu_event_from_cache_is_pristine(self) -> None:
             self.hs.get_federation_client().get_pdu(
                 ["yet.another.server"],
                 remote_pdu.event_id,
-                RoomVersions.V9,
+                self.room_version,
             )
         )
         assert pulled_pdu_info2 is not None
@@ -204,7 +223,7 @@ def _get_pdu_once(self) -> EventBase:
         """
         message_event_dict = self.add_hashes_and_signatures_from_other_server(
             {
-                "room_id": self.test_room_id,
+                "room_id": f"!bogus_made_up_room_id:{self.OTHER_SERVER_NAME}",
                 "type": "m.room.message",
                 "sender": self.creator,
                 "state_key": "",
@@ -213,7 +232,8 @@ def _get_pdu_once(self) -> EventBase:
                 "auth_events": [],
                 "origin_server_ts": 700,
                 "depth": 10,
-            }
+            },
+            self.room_version,
         )
 
         # mock up the response, and have the agent return it
@@ -233,7 +253,7 @@ def _get_pdu_once(self) -> EventBase:
             self.hs.get_federation_client().get_pdu(
                 ["yet.another.server"],
                 "event_id",
-                RoomVersions.V9,
+                self.room_version,
             )
         )
         assert pulled_pdu_info is not None

tests/federation/test_federation_out_of_band_membership.py

@@ -32,7 +32,7 @@
 from twisted.internet.testing import MemoryReactor
 
 from synapse.api.constants import EventContentFields, EventTypes, Membership
-from synapse.api.room_versions import RoomVersion, RoomVersions
+from synapse.api.room_versions import RoomVersion
 from synapse.events import EventBase
 from synapse.events.utils import strip_event
 from synapse.federation.transport.client import SendJoinResponse
@@ -188,13 +188,11 @@ def _invite_local_user_to_remote_room_and_join(self) -> RemoteRoomJoinResult:
 
         # Create a remote room
         room_creator_user_id = f"@remote-user:{self.OTHER_SERVER_NAME}"
-        remote_room_id = f"!remote-room:{self.OTHER_SERVER_NAME}"
-        room_version = RoomVersions.V11
+        room_version = self.hs.config.server.default_room_version
 
         room_create_event = make_test_event(
             self.add_hashes_and_signatures_from_other_server(
                 {
-                    "room_id": remote_room_id,
                     "sender": room_creator_user_id,
                     "depth": 1,
                     "origin_server_ts": 1,
@@ -210,6 +208,8 @@ def _invite_local_user_to_remote_room_and_join(self) -> RemoteRoomJoinResult:
             room_version=room_version,
         )
 
+        remote_room_id = room_create_event.room_id
+
         creator_membership_event = make_test_event(
             self.add_hashes_and_signatures_from_other_server(
                 {
@@ -220,7 +220,7 @@ def _invite_local_user_to_remote_room_and_join(self) -> RemoteRoomJoinResult:
                     "type": EventTypes.Member,
                     "state_key": room_creator_user_id,
                     "content": {"membership": Membership.JOIN},
-                    "auth_events": [room_create_event.event_id],
+                    "auth_events": [],
                     "prev_events": [room_create_event.event_id],
                 }
             ),
@@ -239,7 +239,6 @@ def _invite_local_user_to_remote_room_and_join(self) -> RemoteRoomJoinResult:
                     "state_key": local_user1_id,
                     "content": {"membership": Membership.INVITE},
                     "auth_events": [
-                        room_create_event.event_id,
                         creator_membership_event.event_id,
                     ],
                     "prev_events": [creator_membership_event.event_id],
@@ -300,7 +299,6 @@ def _invite_local_user_to_remote_room_and_join(self) -> RemoteRoomJoinResult:
                 "state_key": local_user1_id,
                 "content": {"membership": Membership.JOIN},
                 "auth_events": [
-                    room_create_event.event_id,
                     user1_invite_membership_event.event_id,
                 ],
                 "prev_events": [user1_invite_membership_event.event_id],
@@ -542,9 +540,6 @@ async def put_json(
                     "state_key": local_user2_id,
                     "content": {"membership": Membership.INVITE},
                     "auth_events": [
-                        remote_room_join_result.state_map[
-                            (EventTypes.Create, "")
-                        ].event_id,
                         remote_room_join_result.state_map[
                             (
                                 EventTypes.Member,