Add create_config helper

Rather than implicitly updating the config in `serialize_event`, let's
add a helper for creating the config that does the necessary
checks/updates itself.

Author: erikjohnston

rust/src/events/serialize.rs

@@ -130,16 +130,6 @@ pub struct SerializeEventConfig {
 impl SerializeEventConfig {
     #[new]
     #[allow(clippy::too_many_arguments)]
-    #[pyo3(signature = (
-        *,
-        as_client_event = true,
-        event_format = EventFormat::ClientV1,
-        requester = None,
-        event_field_allowlist = None,
-        include_stripped_room_state = false,
-        include_admin_metadata = false,
-        msc4354_enabled = false,
-    ))]
     fn new(
         as_client_event: bool,
         event_format: EventFormat,
@@ -199,23 +189,6 @@ impl SerializeEventConfig {
     fn msc4354_enabled(&self) -> bool {
         self.msc4354_enabled
     }
-
-    /// Returns a copy of this config with `include_admin_metadata` enabled.
-    fn for_admin(&self) -> Self {
-        Self {
-            include_admin_metadata: true,
-            ..self.clone()
-        }
-    }
-
-    /// Returns a copy of this config with `msc4354_enabled` set as given.
-    #[pyo3(signature = (enabled = true))]
-    fn with_msc4354(&self, enabled: bool) -> Self {
-        Self {
-            msc4354_enabled: enabled,
-            ..self.clone()
-        }
-    }
 }
 
 /// Synchronously serialize a batch of events for clients.

synapse/appservice/api.py

@@ -40,7 +40,7 @@
     TransactionUnusedFallbackKeys,
 )
 from synapse.events import EventBase
-from synapse.events.utils import FilteredEvent, SerializeEventConfig
+from synapse.events.utils import FilteredEvent
 from synapse.http.client import SimpleHttpClient, is_unknown_endpoint
 from synapse.logging import opentracing
 from synapse.metrics import SERVER_NAME_LABEL
@@ -547,7 +547,7 @@ async def _serialize(
         return await self._event_serializer.serialize_events(
             [FilteredEvent(event=e, membership=None) for e in events],
             time_now,
-            config=SerializeEventConfig(
+            config=await self._event_serializer.create_config(
                 as_client_event=True,
                 # If this is an invite or a knock membership event, then include
                 # any stripped state alongside the event. We could narrow this

synapse/events/utils.py

@@ -48,6 +48,7 @@
     redact_event,
     serialize_events,
 )
+from synapse.synapse_rust.types import Requester
 from synapse.types import JsonDict
 
 from . import EventBase, StrippedStateEvent
@@ -135,15 +136,6 @@ def admin_override(cls, event: "EventBase") -> "FilteredEvent":
         return cls(event=event, membership=None)
 
 
-_DEFAULT_SERIALIZE_EVENT_CONFIG = SerializeEventConfig()
-
-
-def make_config_for_admin(existing: SerializeEventConfig) -> SerializeEventConfig:
-    # Thin wrapper kept for callers; see SerializeEventConfig.for_admin for the
-    # admin-only options it sets.
-    return existing.for_admin()
-
-
 class EventClientSerializer:
     """Serializes events that are to be sent to clients.
 
@@ -160,12 +152,65 @@ def __init__(self, hs: "HomeServer") -> None:
             ADD_EXTRA_FIELDS_TO_UNSIGNED_CLIENT_EVENT_CALLBACK
         ] = []
 
+    async def create_config(
+        self,
+        *,
+        as_client_event: bool = True,
+        event_format: EventFormat = EventFormat.ClientV1,
+        requester: Requester | None = None,
+        event_field_allowlist: list[str] | None = None,
+        include_stripped_room_state: bool = False,
+        include_admin_metadata: bool | None = None,
+    ) -> SerializeEventConfig:
+        """
+        Create a new SerializeEventConfig for the given parameters.
+
+        Helper method that sets the `include_admin_metadata` field based on
+        whether the requester is a server admin if it is not explicitly
+        provided. Also sets the `msc4354_enabled` field based on the homeserver
+        config.
+
+        Args:
+            as_client_event: Whether to serialize the events as client events.
+            event_format: The format to serialize events in. requester: The user
+            requesting the events, if any. Used to determine
+                whether to include admin-only metadata in the serialized events.
+            event_field_allowlist: A list of event fields to include in the
+                serialized events.
+            include_stripped_room_state: Whether to include stripped room state
+                in the serialized events.
+            include_admin_metadata: Whether to include admin-only metadata in
+                the serialized events. If None, this will be determined based on
+                whether the requester is a server admin.
+        Returns:
+            A SerializeEventConfig instance.
+        """
+
+        # If include_admin_metadata is None, determine whether to include
+        # admin-only metadata based on the requester.
+        if include_admin_metadata is None:
+            # Check if the requester is a server admin.
+            if requester is not None and await self._auth.is_server_admin(requester):
+                include_admin_metadata = True
+            else:
+                include_admin_metadata = False
+
+        return SerializeEventConfig(
+            as_client_event=as_client_event,
+            event_format=event_format,
+            requester=requester,
+            event_field_allowlist=event_field_allowlist,
+            include_stripped_room_state=include_stripped_room_state,
+            include_admin_metadata=include_admin_metadata,
+            msc4354_enabled=self._config.experimental.msc4354_enabled,
+        )
+
     async def serialize_event(
         self,
         event: JsonDict | FilteredEvent,
         time_now: int,
         *,
-        config: SerializeEventConfig = _DEFAULT_SERIALIZE_EVENT_CONFIG,
+        config: SerializeEventConfig | None = None,
         bundle_aggregations: dict[str, "BundledAggregations"] | None = None,
         redaction_map: Mapping[str, "EventBase"] | None = None,
     ) -> JsonDict:
@@ -187,7 +232,9 @@ async def serialize_event(
         if not isinstance(event, FilteredEvent):
             return event
 
-        config = await self._update_config(config)
+        if config is None:
+            # Generate default config if none was provided.
+            config = await self.create_config()
 
         # Perform all the async DB/IO work up front, then run the synchronous
         # serialization core.
@@ -204,28 +251,6 @@ async def serialize_event(
             unsigned_additions=unsigned_additions,
         )[0]
 
-    async def _update_config(
-        self, config: SerializeEventConfig
-    ) -> SerializeEventConfig:
-        """Update the config based on the requester and server config."""
-
-        # Force-enable server admin metadata because the only time an event with
-        # relevant metadata will be when the admin requested it via their admin
-        # client config account data. Also, it's "just" some `unsigned` fields, so
-        # shouldn't cause much in terms of problems to downstream consumers.
-        #
-        # The requester is constant across the whole (recursive) serialization,
-        # so we only need to resolve this once.
-        if config.requester is not None and await self._auth.is_server_admin(
-            config.requester
-        ):
-            config = make_config_for_admin(config)
-
-        if self._config.experimental.msc4354_enabled:
-            config = config.with_msc4354(True)
-
-        return config
-
     async def _prepare_serialization(
         self,
         events: Collection[FilteredEvent],
@@ -313,7 +338,7 @@ async def serialize_events(
         events: Collection[JsonDict | FilteredEvent],
         time_now: int,
         *,
-        config: SerializeEventConfig = _DEFAULT_SERIALIZE_EVENT_CONFIG,
+        config: SerializeEventConfig | None = None,
         bundle_aggregations: dict[str, "BundledAggregations"] | None = None,
     ) -> list[JsonDict]:
         """Serializes multiple events.
@@ -334,7 +359,9 @@ async def serialize_events(
             str(len(events)),
         )
 
-        config = await self._update_config(config)
+        if config is None:
+            # Generate default config if none was provided.
+            config = await self.create_config()
 
         filtered_events = [e for e in events if isinstance(e, FilteredEvent)]
 

synapse/handlers/events.py

@@ -25,7 +25,7 @@
 
 from synapse.api.constants import EduTypes, EventTypes, Membership, PresenceState
 from synapse.api.errors import AuthError, SynapseError
-from synapse.events.utils import FilteredEvent, SerializeEventConfig
+from synapse.events.utils import FilteredEvent
 from synapse.handlers.presence import format_user_presence_state
 from synapse.storage.databases.main.events_worker import EventRedactBehaviour
 from synapse.streams.config import PaginationConfig
@@ -129,7 +129,7 @@ async def get_stream(
             chunks = await self._event_serializer.serialize_events(
                 events,
                 time_now,
-                config=SerializeEventConfig(
+                config=await self._event_serializer.create_config(
                     as_client_event=as_client_event, requester=requester
                 ),
             )

synapse/handlers/initial_sync.py

@@ -30,7 +30,7 @@
     Membership,
 )
 from synapse.api.errors import SynapseError
-from synapse.events.utils import FilteredEvent, SerializeEventConfig
+from synapse.events.utils import FilteredEvent
 from synapse.events.validator import EventValidator
 from synapse.handlers.presence import format_user_presence_state
 from synapse.handlers.receipts import ReceiptEventSource
@@ -169,7 +169,9 @@ async def _snapshot_all_rooms(
 
         public_room_ids = await self.store.get_public_room_ids()
 
-        serializer_options = SerializeEventConfig(as_client_event=as_client_event)
+        serializer_options = await self._event_serializer.create_config(
+            as_client_event=as_client_event
+        )
 
         async def handle_room(event: RoomsForUser) -> None:
             d: JsonDict = {
@@ -395,7 +397,9 @@ async def _room_initial_sync_parted(
         end_token = StreamToken.START.copy_and_replace(StreamKeyType.ROOM, stream_token)
 
         time_now = self.clock.time_msec()
-        serialize_options = SerializeEventConfig(requester=requester)
+        serialize_options = await self._event_serializer.create_config(
+            requester=requester
+        )
 
         return {
             "membership": membership,
@@ -436,7 +440,9 @@ async def _room_initial_sync_joined(
 
         # TODO: These concurrently
         time_now = self.clock.time_msec()
-        serialize_options = SerializeEventConfig(requester=requester)
+        serialize_options = await self._event_serializer.create_config(
+            requester=requester
+        )
         # Don't bundle aggregations as this is a deprecated API.
         state = await self._event_serializer.serialize_events(
             [FilteredEvent.state(e) for e in current_state.values()],

synapse/handlers/message.py

@@ -64,7 +64,6 @@
 )
 from synapse.events.utils import (
     FilteredEvent,
-    SerializeEventConfig,
     maybe_upsert_event_field,
 )
 from synapse.events.validator import EventValidator
@@ -269,7 +268,7 @@ async def get_state_events(
         events = await self._event_serializer.serialize_events(
             [FilteredEvent.state(e) for e in room_state.values()],
             self.clock.time_msec(),
-            config=SerializeEventConfig(requester=requester),
+            config=await self._event_serializer.create_config(requester=requester),
         )
         return events
 

synapse/handlers/relations.py

@@ -31,7 +31,7 @@
 from synapse.api.constants import Direction, EventTypes, RelationTypes
 from synapse.api.errors import SynapseError
 from synapse.events import EventBase, relation_from_event
-from synapse.events.utils import FilteredEvent, SerializeEventConfig
+from synapse.events.utils import FilteredEvent
 from synapse.logging.context import make_deferred_yieldable, run_in_background
 from synapse.logging.opentracing import trace
 from synapse.storage.databases.main.relations import ThreadsNextBatch, _RelatedEvent
@@ -150,7 +150,9 @@ async def get_relations(
         )
 
         now = self._clock.time_msec()
-        serialize_options = SerializeEventConfig(requester=requester)
+        serialize_options = await self._event_serializer.create_config(
+            requester=requester
+        )
         return_value: JsonDict = {
             "chunk": await self._event_serializer.serialize_events(
                 filtered_events,

synapse/handlers/search.py

@@ -29,7 +29,7 @@
 from synapse.api.constants import EventTypes, Membership
 from synapse.api.errors import NotFoundError, SynapseError
 from synapse.api.filtering import Filter
-from synapse.events.utils import FilteredEvent, SerializeEventConfig
+from synapse.events.utils import FilteredEvent
 from synapse.types import JsonDict, Requester, StrCollection, StreamKeyType, UserID
 from synapse.types.state import StateFilter
 from synapse.visibility import filter_and_transform_events_for_client
@@ -377,7 +377,9 @@ async def _search(
         # blocking calls after this. Otherwise, the 'age' will be wrong.
 
         time_now = self.clock.time_msec()
-        serialize_options = SerializeEventConfig(requester=requester)
+        serialize_options = await self._event_serializer.create_config(
+            requester=requester
+        )
 
         for context in contexts.values():
             context["events_before"] = await self._event_serializer.serialize_events(

synapse/rest/admin/events.py

@@ -5,7 +5,6 @@
 from synapse.events.utils import (
     EventFormat,
     FilteredEvent,
-    SerializeEventConfig,
 )
 from synapse.http.servlet import RestServlet
 from synapse.http.site import SynapseRequest
@@ -57,7 +56,7 @@ async def on_GET(
         if event is None:
             raise NotFoundError("Event not found")
 
-        config = SerializeEventConfig(
+        config = await self._event_serializer.create_config(
             as_client_event=False,
             event_format=EventFormat.Raw,
             requester=requester,

synapse/rest/admin/rooms.py

@@ -1028,7 +1028,7 @@ async def on_GET(
         ):
             as_client_event = False
 
-        serialize_options = SerializeEventConfig(
+        serialize_options = await self._event_serializer.create_config(
             as_client_event=as_client_event, requester=requester
         )