mirror of
https://github.com/element-hq/synapse.git
synced 2026-08-18 15:10:35 +00:00
27c3b5394b
### Summary
This moves the synchronous core of client event serialization out of
`synapse/events/utils.py` and into Rust
(`rust/src/events/serialize.rs`).
Event serialization is on the hot path for `/sync`, `/messages`, and
most client-facing endpoints. Previously it was a recursive pure-Python
routine (`_serialize_event` / `_inject_bundled_aggregations` /
`only_fields`) that interleaved
CPU-bound formatting with `async` DB/IO. This PR separates those two
concerns and moves the CPU-bound half to Rust:
- **Async prep stays in Python.**
`EventClientSerializer._prepare_serialization` does all DB/IO up front:
batch-fetching redaction events and running the registered module
`unsigned`-callback hooks, for the top-level events *and* every bundled
sub-event (edits and thread latest events, which are themselves
serialized). The admin/MSC4354 config is resolved once via
`_update_config`, rather than re-checked on every recursive call as the
old code did.
- **The synchronous core moves to Rust.** Given an event plus the
pre-fetched `redaction_map`, `unsigned_additions`, and
`bundle_aggregations`, the Rust code produces the client JSON entirely
in Rust — including the v1/v2 format transforms, `only_event_fields`
filtering, redaction handling, and recursive bundled aggregations.
### Details
- The Rust entry point is a single batch function, `serialize_events`,
taking a list of `(event, membership)` pairs. The three lookup maps are
shared across the whole batch, so they're read out of Python and
converted to Rust
structures **once** per batch rather than once per event.
`EventClientSerializer.serialize_event` (singular) is a thin wrapper
that calls it with a one-element list.
- `SerializeEventConfig` is now a Rust `pyclass`, and the old
`event_format` callable is replaced by the `EventFormat` enum (`Raw` /
`ClientV1` / `ClientV2` / `ClientV2WithoutRoomId`). Call sites in
`rest/admin/events.py` and
`rest/client/{notifications,room,sync}.py` are updated to pass the enum.
`make_config_for_admin` and MSC4354 enablement now go through
`SerializeEventConfig.for_admin()` / `with_msc4354()`.
- New accessors on `EventInternalMetadata` (`redacted_by`, `txn_id`,
`device_id`, `token_id`, `delay_id`, `soft_failed`,
`policy_server_spammy`) expose to Rust the fields the serializer reads.
- The `_split_field` unit tests move from `tests/events/test_utils.py`
to a Rust test in `serialize.rs`, since the implementation moved.
### Behaviour
This is intended to be a behaviour-preserving refactor — the Rust core
mirrors the previous Python output (field ordering, v1 key promotion,
redaction placement per room version, null-`redacts` handling,
transaction-ID gating).
Existing serialization, relations, and sync tests pass unchanged.
---------
Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>
Co-authored-by: Eric Eastwood <madlittlemods@gmail.com>
Co-authored-by: Eric Eastwood <erice@element.io>
84 lines
2.9 KiB
Rust
84 lines
2.9 KiB
Rust
/*
|
|
* This file is licensed under the Affero General Public License (AGPL) version 3.
|
|
*
|
|
* Copyright (C) 2025 Element Creations, Ltd
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU Affero General Public License as
|
|
* published by the Free Software Foundation, either version 3 of the
|
|
* License, or (at your option) any later version.
|
|
*
|
|
* See the GNU Affero General Public License for more details:
|
|
* <https://www.gnu.org/licenses/agpl-3.0.html>.
|
|
*/
|
|
|
|
use once_cell::sync::OnceCell;
|
|
use pyo3::{
|
|
types::{IntoPyDict, PyAnyMethods},
|
|
Bound, BoundObject, IntoPyObject, Py, PyAny, PyErr, PyResult, Python,
|
|
};
|
|
|
|
/// A reference to the `synapse.util.duration` module.
|
|
static DURATION: OnceCell<Py<PyAny>> = OnceCell::new();
|
|
|
|
/// Access to the `synapse.util.duration` module.
|
|
fn duration_module(py: Python<'_>) -> PyResult<&Bound<'_, PyAny>> {
|
|
Ok(DURATION
|
|
.get_or_try_init(|| py.import("synapse.util.duration").map(Into::into))?
|
|
.bind(py))
|
|
}
|
|
|
|
/// Mirrors the `synapse.util.duration.Duration` Python class.
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
|
|
pub struct SynapseDuration {
|
|
milliseconds: u64,
|
|
}
|
|
|
|
impl SynapseDuration {
|
|
/// Creates a `SynapseDuration` from a number of milliseconds.
|
|
pub const fn from_milliseconds(milliseconds: u64) -> Self {
|
|
Self { milliseconds }
|
|
}
|
|
|
|
/// Returns the duration as a number of milliseconds.
|
|
pub const fn as_millis(&self) -> u64 {
|
|
self.milliseconds
|
|
}
|
|
|
|
/// Creates a `SynapseDuration` from a number of hours.
|
|
pub const fn from_hours(hours: u32) -> Self {
|
|
// We take a u32 here so that we know the multiplication won't overflow.
|
|
// We could instead panic, but that is unstable in a const context (for
|
|
// the current MSRV 1.82).
|
|
Self {
|
|
milliseconds: (hours as u64) * 3_600_000,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<'py> IntoPyObject<'py> for SynapseDuration {
|
|
type Target = PyAny;
|
|
type Output = Bound<'py, Self::Target>;
|
|
type Error = PyErr;
|
|
|
|
fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
|
|
let duration_module = duration_module(py)?;
|
|
let kwargs = [("milliseconds", self.milliseconds)].into_py_dict(py)?;
|
|
let duration_instance = duration_module.call_method("Duration", (), Some(&kwargs))?;
|
|
Ok(duration_instance.into_bound())
|
|
}
|
|
}
|
|
|
|
impl<'py> IntoPyObject<'py> for &SynapseDuration {
|
|
type Target = PyAny;
|
|
type Output = Bound<'py, Self::Target>;
|
|
type Error = PyErr;
|
|
|
|
fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
|
|
let duration_module = duration_module(py)?;
|
|
let kwargs = [("milliseconds", self.milliseconds)].into_py_dict(py)?;
|
|
let duration_instance = duration_module.call_method("Duration", (), Some(&kwargs))?;
|
|
Ok(duration_instance.into_bound())
|
|
}
|
|
}
|