mirror of
https://github.com/element-hq/synapse.git
synced 2026-07-18 11:47:30 +00:00
539f708f32
This is a simplification so that `unsigned` only includes "simple"
values, to make it easier to port to Rust.
Reviewable commit-by-commit
Summary:
1. **Add `recheck` column to `redactions` table**
A new boolean `recheck` column (default true) is added to the
`redactions` table. This captures whether a redaction needs its sender
domain checked at read time — required for room v3+ where redactions are
accepted speculatively and later validated. When persisting a new
redaction, `recheck` is set directly from
`event.internal_metadata.need_to_check_redaction()`.
It's fine if initially we recheck all redactions, as it only results in
a little more CPU overhead (as we always pull out the redaction event
regardless).
2. **Backfill `recheck` via background update**
A background update (`redactions_recheck`) backfills the new column for
existing rows by reading `recheck_redaction` from each event's
`internal_metadata` JSON. This avoids loading full event objects by
reading `event_json` directly via a SQL JOIN.
3. **Don't fetch confirmed redaction events from the DB**
Previously, when loading events, Synapse recursively fetched all
redaction events regardless of whether they needed domain rechecking.
Now `_fetch_event_rows` reads the `recheck` column and splits redactions
into two lists:
- `unconfirmed_redactions` — need fetching and domain validation
- `confirmed_redactions` — already validated, applied directly without
fetching the event
This avoids unnecessary DB reads for the common case of
already-confirmed redactions.
4. **Move `redacted_because` population to `EventClientSerializer`**
Previously, `redacted_because` (the full redaction event object) was
stored in `event.unsigned` at DB fetch time, coupling storage-layer code
to client serialization concerns. This is removed from
`_maybe_redact_event_row` and moved into
`EventClientSerializer.serialize_event`, which fetches the redaction
event on demand. The storage layer now only sets
`unsigned["redacted_by"]` (the redaction event ID).
5. **Always use `EventClientSerializer`**
The standalone `serialize_event` function was made private
(`_serialize_event`). All external callers — `rest/client/room.py`,
`rest/admin/events.py, appservice/api.py`, and `tests` — were updated to
use `EventClientSerializer.serialize_event` / `serialize_events`,
ensuring
`redacted_because` is always populated correctly via the serializer.
6. **Batch-fetch redaction events in `serialize_events`**
`serialize_events` now collects all `redacted_by` IDs from the event
batch upfront and fetches them in a single `get_events` call, passing
the result as a `redaction_map` to each `serialize_event` call. This
reduces N individual DB round-trips to one when serializing a batch of
events that includes redacted events.
---------
Co-authored-by: Andrew Morgan <1342360+anoadragon453@users.noreply.github.com>
Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
74 lines
2.2 KiB
Python
74 lines
2.2 KiB
Python
from http import HTTPStatus
|
|
from typing import TYPE_CHECKING
|
|
|
|
from synapse.api.errors import NotFoundError
|
|
from synapse.events.utils import (
|
|
SerializeEventConfig,
|
|
format_event_raw,
|
|
)
|
|
from synapse.http.servlet import RestServlet
|
|
from synapse.http.site import SynapseRequest
|
|
from synapse.rest.admin import admin_patterns
|
|
from synapse.rest.admin._base import assert_user_is_admin
|
|
from synapse.storage.databases.main.events_worker import EventRedactBehaviour
|
|
from synapse.types import JsonDict
|
|
|
|
if TYPE_CHECKING:
|
|
from synapse.server import HomeServer
|
|
|
|
|
|
class EventRestServlet(RestServlet):
|
|
"""
|
|
Get an event that is known to the homeserver.
|
|
The requester must have administrator access in Synapse.
|
|
|
|
GET /_synapse/admin/v1/fetch_event/<event_id>
|
|
returns:
|
|
200 OK with event json if the event is known to the homeserver. Otherwise raises
|
|
a NotFound error.
|
|
|
|
Args:
|
|
event_id: the id of the requested event.
|
|
Returns:
|
|
JSON blob of the event
|
|
"""
|
|
|
|
PATTERNS = admin_patterns("/fetch_event/(?P<event_id>[^/]*)$")
|
|
|
|
def __init__(self, hs: "HomeServer"):
|
|
self._auth = hs.get_auth()
|
|
self._store = hs.get_datastores().main
|
|
self._clock = hs.get_clock()
|
|
self._event_serializer = hs.get_event_client_serializer()
|
|
|
|
async def on_GET(
|
|
self, request: SynapseRequest, event_id: str
|
|
) -> tuple[int, JsonDict]:
|
|
requester = await self._auth.get_user_by_req(request)
|
|
await assert_user_is_admin(self._auth, requester)
|
|
|
|
event = await self._store.get_event(
|
|
event_id,
|
|
EventRedactBehaviour.as_is,
|
|
allow_none=True,
|
|
)
|
|
|
|
if event is None:
|
|
raise NotFoundError("Event not found")
|
|
|
|
config = SerializeEventConfig(
|
|
as_client_event=False,
|
|
event_format=format_event_raw,
|
|
requester=requester,
|
|
only_event_fields=None,
|
|
include_stripped_room_state=True,
|
|
include_admin_metadata=True,
|
|
)
|
|
res = {
|
|
"event": await self._event_serializer.serialize_event(
|
|
event, self._clock.time_msec(), config=config
|
|
)
|
|
}
|
|
|
|
return HTTPStatus.OK, res
|