Compare commits

..
22 changed files with 399 additions and 315 deletions

No files matched your search

+1 -1
View File
@@ -71,7 +71,7 @@ runs:
- name: Install timelord-cli and git-warp-time
if: steps.check-binaries.outputs.need-install == 'true'
uses: https://github.com/taiki-e/install-action@ab49d3c64680143e184118bed66a46419fc15519 # v2
uses: https://github.com/taiki-e/install-action@cfdb7ed4ccc7c7dce37759eae89dc5674b469b39 # v2
with:
tool: git-warp-time,timelord-cli@3.0.1
+1 -1
View File
@@ -43,7 +43,7 @@ jobs:
name: Renovate
runs-on: ubuntu-latest
container:
image: ghcr.io/renovatebot/renovate:44.241.0@sha256:22d22b4ca7d768b5b469309d34379783bf91cd94a58faecf1cd0f4528a65d21c
image: ghcr.io/renovatebot/renovate:44.227.4@sha256:e09d40686f73d43b2c1e4667cb47d3c1d24a6ac730b74ce7aced9c84f68594f1
options: --tmpfs /tmp:exec
steps:
- name: Checkout
Generated
-1
View File
@@ -949,7 +949,6 @@ dependencies = [
"sha1 0.11.0",
"tokio",
"tracing",
"wildmatch",
]
[[package]]
-3
View File
@@ -272,9 +272,6 @@ version = "0.5.2"
[workspace.dependencies.libloading]
version = "0.9.0"
[workspace.dependencies.wildmatch]
version = "2.7.0"
# Validating urls in config, was already a transitive dependency
[workspace.dependencies.url]
version = "2.5.8"
+3 -8
View File
@@ -23,15 +23,12 @@ to encourage users to stay up-to-date with the latest release, and we have no co
We appreciate the efforts of security researchers and the community in identifying and reporting vulnerabilities. To
ensure that potential vulnerabilities are addressed properly, please follow these guidelines:
1. **Contact _all_ members of the team** over E2EE private message on Matrix.
Add each contact to the same encrypted room. **Do not message maintainers individually**.
If you cannot reach us from matrix.org, please try [another server][sl] (e.g. continuwuity.rocks).
1. **Contact members of the team directly** over E2EE private message.
- [@jade:ellis.link](https://matrix.to/#/@jade:ellis.link)
- [@nex:nexy7574.co.uk](https://matrix.to/#/@nex:nexy7574.co.uk)
- [@ginger:gingershaped.computer](https://matrix.to/#/@ginger:gingershaped.computer)
2. **Email the security team** at [security@continuwuity.org](mailto:security@continuwuity.org). This is not E2EE, so
don't include sensitive details. Do not ask where to send sensitive details either; that
information is included in this security policy. We may not respond to emails that do this.
don't include sensitive details.
3. **Do not disclose the vulnerability publicly** until a fix has been pushed to the main branch.
4. **Provide detailed information** about the vulnerability, including:
- A clear description of the issue
@@ -45,8 +42,6 @@ ensure that potential vulnerabilities are addressed properly, please follow thes
If you have any doubts about a potential security vulnerability, contact us via private channels first! We'd prefer that
you bother us, instead of having a vulnerability disclosed without a fix.
[sl]: https://servers.joinmatrix.org
### Terms for credit
Before reporting a vulnerability, please remember that we are a small team maintaining a large codebase depended upon by
@@ -110,4 +105,4 @@ When security vulnerabilities are identified:
---
This security policy was last updated on November 17th, 2026.
This security policy was last updated on May 25, 2025.
-1
View File
@@ -1 +0,0 @@
Legacy `/sync` now honours the `room.rooms`, `room.not_rooms`, `account_data.types` and `account_data.not_types` filter fields instead of returning every room and all account data. Contributed by @eleboucher.
-1
View File
@@ -1 +0,0 @@
Requests waiting on `/_matrix/client/v3/sync` can now be interrupted by the server shutdown, unblocking the 30-second shutdown delay imposed on a quiet server.
-1
View File
@@ -1 +0,0 @@
`/_matrix/client/v3/sync` no longer waits 30 seconds if the `timeout` parameter is omitted or set to zero, correctly reflecting the specification's rule that such requests should return immediately, even if they are empty.
-1
View File
@@ -1 +0,0 @@
The sticky events feature flag is correctly advertised in `/_matrix/client/versions` again after it was accidentally removed in #2517.
+13 -13
View File
@@ -431,9 +431,9 @@
}
},
"node_modules/@rspress/core": {
"version": "2.1.3",
"resolved": "https://registry.npmjs.org/@rspress/core/-/core-2.1.3.tgz",
"integrity": "sha512-qKa5c7zHO8cmhxkReURd3dN/ZRfHYnEztdIQ9hMuolaNzhSYo2A36XErUvLvbMf2EUM2AxfPYRQv+4Crfeq6pw==",
"version": "2.1.2",
"resolved": "https://registry.npmjs.org/@rspress/core/-/core-2.1.2.tgz",
"integrity": "sha512-3ghPRkZFwbuO3tr2Rb5cxi6QfSFWOcxoZ5p4pv21lbN5DxAzMduITFlfgBMTArIQbehXrfXw3OUXe1l422b0RA==",
"dev": true,
"license": "MIT",
"dependencies": {
@@ -441,7 +441,7 @@
"@mdx-js/react": "^3.1.1",
"@rsbuild/core": "^2.2.14",
"@rsbuild/plugin-react": "~2.1.1",
"@rspress/shared": "2.1.3",
"@rspress/shared": "2.1.2",
"@shikijs/rehype": "^4.2.0",
"@shikijs/transformers": "^4.2.0",
"@types/mdast": "^4.0.4",
@@ -485,9 +485,9 @@
}
},
"node_modules/@rspress/plugin-client-redirects": {
"version": "2.1.3",
"resolved": "https://registry.npmjs.org/@rspress/plugin-client-redirects/-/plugin-client-redirects-2.1.3.tgz",
"integrity": "sha512-iEqJ8qEFuUxGKRVaS/WMyFi8FiJlogdcEHbGK/UjY8+8Hg8r8aSv4YihmNh3Ev/uIW21hrC8aXMEgVo0H51Q+g==",
"version": "2.1.2",
"resolved": "https://registry.npmjs.org/@rspress/plugin-client-redirects/-/plugin-client-redirects-2.1.2.tgz",
"integrity": "sha512-kNCC7fffXA277TzTDfKpP+QuCI1X218lJ5JH/2iqYR8PHnLw0Y6ZIwoFmJlE0eKaBdniYyBRGn9zgvT93mCWdg==",
"dev": true,
"license": "MIT",
"engines": {
@@ -498,9 +498,9 @@
}
},
"node_modules/@rspress/plugin-sitemap": {
"version": "2.1.3",
"resolved": "https://registry.npmjs.org/@rspress/plugin-sitemap/-/plugin-sitemap-2.1.3.tgz",
"integrity": "sha512-Fqo7/4PfQK1ecHUFoUDMrR/E+Hcu+kIohxSs8QabflMy3dqk+M3ZqzJDOHpVYB+HLLGwKiqkPLT4BK+W93clkw==",
"version": "2.1.2",
"resolved": "https://registry.npmjs.org/@rspress/plugin-sitemap/-/plugin-sitemap-2.1.2.tgz",
"integrity": "sha512-qF9NDLLJORa7MM8QY/etgMlrXM8hlArNaK5ntiFimqtKRoF1YTJQSKPsAfMq2PvYrpQJyEqsSg6wJ+r+lyjNlw==",
"dev": true,
"license": "MIT",
"engines": {
@@ -511,9 +511,9 @@
}
},
"node_modules/@rspress/shared": {
"version": "2.1.3",
"resolved": "https://registry.npmjs.org/@rspress/shared/-/shared-2.1.3.tgz",
"integrity": "sha512-VwJ7kgsTWVqHzSXQVHIUCsdMparmq9b/IDmTa3a6jMPl1zmm5Qg9M0eP4j8JXWoIS9n19XtCkQcZmMTFOPRy3A==",
"version": "2.1.2",
"resolved": "https://registry.npmjs.org/@rspress/shared/-/shared-2.1.2.tgz",
"integrity": "sha512-W34tT1fdP3PrdbXpZNKqOGZMOw+RYL70Z9vnkbT1HTTbtX4uMIDE+SU7ByihG0S0LYBsT3kPxA2cXj696253Uw==",
"dev": true,
"license": "MIT",
"dependencies": {
-1
View File
@@ -87,7 +87,6 @@ serde.workspace = true
sha1.workspace = true
tokio.workspace = true
tracing.workspace = true
wildmatch.workspace = true
[lints]
workspace = true
+52 -75
View File
@@ -64,7 +64,7 @@ pub(super) async fn load_joined_room(
services: &Services,
sync_context: SyncContext<'_>,
ref room_id: OwnedRoomId,
) -> Result<JoinedRoom> {
) -> Result<(JoinedRoom, DeviceListUpdates)> {
/*
Building a sync response involves many steps which all depend on each other.
To parallelize the process as much as possible, each step is divided into its own function,
@@ -80,6 +80,7 @@ pub(super) async fn load_joined_room(
sticky,
summary,
notification_counts,
device_list_updates,
},
) = try_join3(
build_account_data(services, sync_context, room_id),
@@ -116,7 +117,7 @@ pub(super) async fn load_joined_room(
unread_thread_notifications: BTreeMap::new(),
});
Ok(joined_room)
Ok((joined_room, device_list_updates))
}
/// Collect changes to the syncing user's account data events.
@@ -262,6 +263,7 @@ struct StateAndTimeline {
sticky: Sticky,
summary: Option<RoomSummary>,
notification_counts: Option<UnreadNotificationsCount>,
device_list_updates: DeviceListUpdates,
}
async fn build_sticky_events(
@@ -375,14 +377,24 @@ async fn build_state_and_timeline(
debug_warn!("timeline for newly joined room is empty");
}
let summary = build_room_summary(
services,
sync_context,
room_id,
shortstatehashes,
&timeline,
&state_events,
joined_since_last_sync,
let (summary, device_list_updates) = try_join(
build_room_summary(
services,
sync_context,
room_id,
shortstatehashes,
&timeline,
&state_events,
joined_since_last_sync,
),
build_device_list_updates(
services,
sync_context,
room_id,
shortstatehashes,
&state_events,
joined_since_last_sync,
),
)
.await?;
@@ -418,6 +430,7 @@ async fn build_state_and_timeline(
sticky,
summary,
notification_counts,
device_list_updates,
})
}
@@ -841,34 +854,35 @@ async fn build_heroes(
.await
}
/// Collect updates to users' device lists for E2EE in a joined room.
#[tracing::instrument(level = "debug", skip_all, fields(%room_id))]
pub(super) async fn load_device_list_updates(
/// Collect updates to users' device lists for E2EE.
#[tracing::instrument(level = "debug", skip_all)]
async fn build_device_list_updates(
services: &Services,
sync_context: SyncContext<'_>,
room_id: &RoomId,
) -> Result<DeviceListUpdates> {
let SyncContext {
SyncContext {
syncing_user,
last_sync_end_count,
current_count,
..
} = sync_context;
let mut device_list_updates = DeviceListUpdates::new();
}: SyncContext<'_>,
room_id: &RoomId,
ShortStateHashes { current_shortstatehash, .. }: ShortStateHashes,
state_events: &Vec<PduEvent>,
joined_since_last_sync: bool,
) -> Result<DeviceListUpdates> {
let is_encrypted_room = services
.rooms
.state_accessor
.state_get(current_shortstatehash, &StateEventType::RoomEncryption, "")
.is_ok();
// initial syncs don't include device updates, and rooms which aren't
// encrypted don't affect them, so return early in either of those cases
if last_sync_end_count.is_none()
|| !services
.rooms
.state_accessor
.is_encrypted_room(room_id)
.await
{
return Ok(device_list_updates);
if last_sync_end_count.is_none() || !(is_encrypted_room.await) {
return Ok(DeviceListUpdates::new());
}
let mut device_list_updates = DeviceListUpdates::new();
// add users with changed keys to the `changed` list
services
.users
@@ -879,56 +893,19 @@ pub(super) async fn load_device_list_updates(
})
.await;
let shortstatehashes = fetch_shortstatehashes(services, sync_context, room_id).await?;
let ShortStateHashes {
current_shortstatehash,
last_sync_end_shortstatehash,
} = shortstatehashes;
if check_joined_since_last_sync(services, shortstatehashes, sync_context).await? {
// the syncing user now shares an encrypted room with every member
services
.rooms
.state_cache
.room_members(room_id)
.ready_for_each(|user_id| {
device_list_updates.changed.insert(user_id);
})
.await;
} else if let Some(last_sync_end_shortstatehash) = last_sync_end_shortstatehash
&& last_sync_end_shortstatehash != current_shortstatehash
{
// add users who now share encrypted rooms to `changed` and
// users who no longer share encrypted rooms to `left`
let state_added = services
.rooms
.state_accessor
.state_added((last_sync_end_shortstatehash, current_shortstatehash))
.await?;
for (shortstatekey, _) in state_added {
let Ok((StateEventType::RoomMember, state_key)) = services
.rooms
.short
.get_statekey_from_short(shortstatekey)
.await
// add users who now share encrypted rooms to `changed` and
// users who no longer share encrypted rooms to `left`
for state_event in state_events {
if state_event.kind == RoomMember {
let Some(content): Option<RoomMemberEventContent> = state_event.get_content().ok()
else {
continue;
};
let Ok(user_id) = OwnedUserId::try_from(state_key.as_str()) else {
continue;
};
let Ok(content): Result<RoomMemberEventContent> = services
.rooms
.state_accessor
.state_get_content(
current_shortstatehash,
&StateEventType::RoomMember,
user_id.as_str(),
)
.await
let Some(user_id): Option<OwnedUserId> = state_event
.state_key
.as_ref()
.and_then(|key| key.parse().ok())
else {
continue;
};
@@ -944,7 +921,7 @@ pub(super) async fn load_device_list_updates(
| Leave if !shares_encrypted_room => {
device_list_updates.left.insert(user_id);
},
| Join if shares_encrypted_room => {
| Join if joined_since_last_sync || shares_encrypted_room => {
device_list_updates.changed.insert(user_id);
},
| _ => (),
+21 -117
View File
@@ -3,6 +3,7 @@ mod left;
mod state;
use std::{
cmp::{self},
collections::{BTreeMap, HashMap, HashSet},
time::Duration,
};
@@ -20,7 +21,7 @@ use futures::{FutureExt, StreamExt, TryFutureExt, future::OptionFuture};
use ruma::{
DeviceId, OwnedUserId, RoomId, UserId,
api::client::{
filter::{self, FilterDefinition, RoomFilter},
filter::FilterDefinition,
sync::sync_events::{
self, DeviceLists,
v3::{
@@ -38,17 +39,13 @@ use service::{
account_data::AnyRawAccountDataEvent,
rooms::lazy_loading::{self, MemberSet, Options as _},
};
use wildmatch::WildMatch;
use super::{load_timeline, share_encrypted_room};
use crate::{
Ruma,
client::{
is_ignored_invite,
sync::v3::{
joined::{load_device_list_updates, load_joined_room},
left::load_left_room,
},
sync::v3::{joined::load_joined_room, left::load_left_room},
},
client_ip::ClientIp,
};
@@ -206,12 +203,7 @@ pub(crate) async fn sync_events_route(
let mut wake_receiver = services.sync.subscribe_to_wake(sender_user);
let response = build_sync_events(&services, &body).await?;
let timeout_duration = body.body.timeout.unwrap_or_default();
// If the timeout is zero, request has full_state=true, or there's
// meaningful data to return, do so immediately.
if timeout_duration.is_zero()
|| body.body.full_state
if body.body.full_state
|| !(response.rooms.is_empty()
&& response.presence.is_empty()
&& response.account_data.is_empty()
@@ -221,15 +213,11 @@ pub(crate) async fn sync_events_route(
return Ok(response);
}
// Otherwise, wait for a wake signal to rebuild changes. Cap timeout at 30
// seconds (this isn't specced, but a reasonable cap since most clients have
// a 30-second polling interval).
let duration = timeout_duration.min(Duration::from_secs(30));
let mut shutdown_signal = services.server.signal.subscribe();
tokio::select! {
_ = tokio::time::timeout(duration, wake_receiver.changed()) => {},
_ = shutdown_signal.recv() => return Err!(Request(Unknown("Server is shutting down"), SERVICE_UNAVAILABLE)),
};
// Hang a few seconds so requests are not spammed
// Stop hanging if new info arrives
let default = Duration::from_secs(30);
let duration = cmp::min(body.body.timeout.unwrap_or(default), default);
_ = tokio::time::timeout(duration, wake_receiver.changed()).await;
// Retry returning data
build_sync_events(&services, &body).await
@@ -283,47 +271,34 @@ pub(crate) async fn build_sync_events(
.rooms
.state_cache
.rooms_joined(syncing_user)
.ready_filter(|room_id| room_selected(&filter.room, room_id))
.broad_filter_map(|room_id| async {
let joined_room = load_joined_room(services, context, room_id.clone()).await;
match joined_room {
| Ok(room) => Some((room_id, room)),
| Ok((room, updates)) => Some((room_id, room, updates)),
| Err(err) => {
error!(?err, %room_id, "error loading joined room");
None
},
}
})
.ready_fold(BTreeMap::new(), |mut joined_rooms, (room_id, joined_room)| {
if !joined_room.is_empty() {
joined_rooms.insert(room_id, joined_room);
}
.ready_fold(
(BTreeMap::new(), DeviceListUpdates::new()),
|(mut joined_rooms, mut all_updates), (room_id, joined_room, updates)| {
all_updates.merge(updates);
joined_rooms
});
if !joined_room.is_empty() {
joined_rooms.insert(room_id, joined_room);
}
// a filtered out room still contributes its device list updates
let device_list_updates = services
.rooms
.state_cache
.rooms_joined(syncing_user)
.broad_filter_map(|room_id| async move {
load_device_list_updates(services, context, &room_id)
.await
.inspect_err(|err| error!(?err, %room_id, "error loading device list updates"))
.ok()
})
.ready_fold(DeviceListUpdates::new(), |mut all_updates, updates| {
all_updates.merge(updates);
all_updates
});
(joined_rooms, all_updates)
},
);
let left_rooms = services
.rooms
.state_cache
.rooms_left(syncing_user)
.ready_filter(|(room_id, _)| room_selected(&filter.room, room_id))
.broad_filter_map(|(room_id, leave_pdu)| async {
let left_room = load_left_room(services, context, room_id.clone(), leave_pdu).await;
@@ -342,7 +317,6 @@ pub(crate) async fn build_sync_events(
.rooms
.state_cache
.rooms_invited(syncing_user)
.ready_filter(|(room_id, _)| room_selected(&filter.room, room_id))
.wide_filter_map(async |(room_id, invite_state)| {
if is_ignored_invite(services, syncing_user, &room_id).await {
None
@@ -373,7 +347,6 @@ pub(crate) async fn build_sync_events(
.rooms
.state_cache
.rooms_knocked(syncing_user)
.ready_filter(|(room_id, _)| room_selected(&filter.room, room_id))
.fold_default(|mut knocked_rooms: BTreeMap<_, _>, (room_id, knock_state)| async move {
let knock_count = services
.rooms
@@ -403,13 +376,6 @@ pub(crate) async fn build_sync_events(
.account_data
.changes_since(None, syncing_user, last_sync_end_count, Some(current_count))
.ready_filter_map(|e| extract_variant!(e, AnyRawAccountDataEvent::Global))
.ready_filter(|event| {
event
.get_field::<String>("type")
.ok()
.flatten()
.is_some_and(|event_type| type_selected(&filter.account_data, &event_type))
})
.collect();
let to_device_events = services
@@ -438,8 +404,7 @@ pub(crate) async fn build_sync_events(
.list_unused_fallback_key_types(syncing_user, syncing_device);
let (
joined_rooms,
mut device_list_updates,
(joined_rooms, mut device_list_updates),
left_rooms,
invited_rooms,
knocked_rooms,
@@ -452,7 +417,6 @@ pub(crate) async fn build_sync_events(
) = async {
futures::join!(
joined_rooms,
device_list_updates,
left_rooms,
invited_rooms,
knocked_rooms,
@@ -501,24 +465,6 @@ pub(crate) async fn build_sync_events(
Ok(response)
}
fn room_selected(filter: &RoomFilter, room_id: &RoomId) -> bool {
!filter.not_rooms.iter().any(|not_room| not_room == room_id)
&& filter
.rooms
.as_ref()
.is_none_or(|rooms| rooms.iter().any(|room| room == room_id))
}
fn type_selected(filter: &filter::Filter, event_type: &str) -> bool {
let matches = |pattern: &String| WildMatch::new(pattern).matches(event_type);
!filter.not_types.iter().any(matches)
&& filter
.types
.as_ref()
.is_none_or(|types| types.iter().any(matches))
}
#[tracing::instrument(name = "presence", level = "debug", skip_all)]
async fn process_presence_updates(
services: &Services,
@@ -582,45 +528,3 @@ async fn prepare_lazily_loaded_members(
lazily_loaded_members
}
#[cfg(test)]
mod tests {
use ruma::{owned_room_id, room_id};
use super::*;
#[test]
fn rooms_filter_selects_rooms() {
let room_id = room_id!("!a:example.com");
let mut filter = RoomFilter::default();
assert!(room_selected(&filter, room_id));
filter.rooms = Some(Vec::new());
assert!(!room_selected(&filter, room_id));
filter.rooms = Some(vec![room_id.to_owned()]);
assert!(room_selected(&filter, room_id));
filter.not_rooms = vec![owned_room_id!("!a:example.com")];
assert!(!room_selected(&filter, room_id));
}
#[test]
fn types_filter_selects_account_data() {
let mut filter = filter::Filter::default();
assert!(type_selected(&filter, "m.direct"));
filter.types = Some(Vec::new());
assert!(!type_selected(&filter, "m.direct"));
filter.types = Some(vec!["m.direct".to_owned()]);
assert!(type_selected(&filter, "m.direct"));
filter.types = Some(vec!["m.*".to_owned()]);
assert!(type_selected(&filter, "m.direct"));
assert!(!type_selected(&filter, "im.ponies.user_emotes"));
filter.not_types = vec!["m.direct".to_owned()];
assert!(!type_selected(&filter, "m.direct"));
}
}
+27 -51
View File
@@ -44,7 +44,10 @@ use ruma::{
to_device::DeviceIdOrAllDevices,
};
use service::{
rooms::event_handler::{DagBuilderTree, build_local_dag},
rooms::{
event_handler::{DagBuilderTree, build_local_dag},
queue::QueueJob,
},
transactions::{FederationTxnState, TransactionError, TxnKey, WrappedTransactionResponse},
};
use tokio::sync::watch::{Receiver, Sender};
@@ -332,13 +335,6 @@ async fn handle_room(
room_id: OwnedRoomId,
pdus: impl Iterator<Item = Pdu> + Send,
) -> std::result::Result<Vec<(OwnedEventId, Result)>, TransactionError> {
let _room_lock = services
.rooms
.event_handler
.mutex_federation
.lock(room_id.as_str())
.await;
let room_id = &room_id;
let mut pdu_map: HashMap<OwnedEventId, CanonicalJsonObject> = pdus
.into_iter()
@@ -358,50 +354,30 @@ async fn handle_room(
let value = pdu_map
.remove(&event_id)
.expect("sorted event IDs must be from the original map");
services
.server
.check_running()
.map_err(|_| TransactionError::ShuttingDown)?;
let event_type = KeyValue::new(
"type",
pdu_type_label(value.get("type").and_then(CanonicalJsonValue::as_str)),
);
let origin_server_ts = value
.get("origin_server_ts")
.and_then(CanonicalJsonValue::as_integer)
.and_then(|ts| u64::try_from(i64::from(ts)).ok());
let room_id = match value
.get("room_id")
.and_then(CanonicalJsonValue::as_str)
.map(|v| v.try_into().map_err(Into::into))
{
| Some(Ok(v)) => v,
| Some(Err(e)) => {
results.push((event_id, Err(e)));
continue;
},
| None => {
results
.push((event_id, Err!(Request(BadJson("PDU is missing a room_id field")))));
continue;
},
};
let job = QueueJob {
room_id,
event_id: event_id.clone(),
origin: origin.to_owned(),
object: value,
};
let start = Instant::now();
let result = services
.rooms
.event_handler
.handle_incoming_pdu(origin, room_id, &event_id, value, false)
.boxed()
.await
.map(|_| ());
let outcome = KeyValue::new("outcome", match &result {
| Ok(()) => "accepted",
| Err(Error::BadRequest(ErrorKind::Forbidden, ..)) => "forbidden",
| Err(Error::BadRequest(ErrorKind::InvalidParam | ErrorKind::BadJson, ..)) =>
"invalid",
| Err(_) => "error",
});
let instruments = &services.server.metrics.instruments;
instruments
.federation_incoming_pdu_duration
.record(start.elapsed().as_secs_f64(), std::slice::from_ref(&outcome));
if let (Ok(()), Some(ts)) = (&result, origin_server_ts) {
let lag = millis_since_unix_epoch().saturating_sub(ts);
instruments
.federation_incoming_pdu_lag
.record(Duration::from_millis(lag).as_secs_f64(), &[]);
}
instruments
.federation_incoming_pdus
.add(1, &[event_type, outcome]);
results.push((event_id, result));
results.push((event_id, services.rooms.queue.new_job(job).await));
}
Ok(results)
}
+2 -5
View File
@@ -35,10 +35,10 @@ pub fn versions() -> Vec<String> {
pub fn unstable_features(experiments: &Experiments) -> BTreeMap<String, bool> {
BTreeMap::from_iter([
// MatrixRTC (https://github.com/matrix-org/matrix-spec-proposals/pull/4143)
// Expected for spec v1.20/v2.0
// Expected for spec v1.20
("org.matrix.msc4143".to_owned(), true),
// Simplified Sliding sync (https://github.com/matrix-org/matrix-spec-proposals/pull/4186)
// Expected for spec v1.20/v2.0
// Expected for spec v1.20
("org.matrix.simplified_msc3575".to_owned(), true),
("org.matrix.msc4155".to_owned(), experiments.msc4155.is_enabled()),
// profile change propagation (https://github.com/matrix-org/matrix-spec-proposals/pull/4466)
@@ -48,8 +48,5 @@ pub fn unstable_features(experiments: &Experiments) -> BTreeMap<String, bool> {
("org.continuwuity.msc4484.unstable".to_owned(), experiments.msc4484.is_enabled()),
("org.continuwuity.msc4560".to_owned(), experiments.msc4560.is_enabled()),
("fi.mau.msc2815".to_owned(), experiments.msc2815.is_enabled()),
// Sticky events (https://github.com/matrix-org/matrix-spec-proposals/pull/4354)
// Proposal merged, expected for spec v1.20/v2.0
("org.matrix.msc4354".to_owned(), true),
])
}
+1 -1
View File
@@ -25,7 +25,7 @@ http.workspace = true
ruma.workspace = true
serde = { workspace = true }
serde_json = { workspace = true }
wildmatch.workspace = true
wildmatch = "2.7.0"
[dev-dependencies]
+30 -29
View File
@@ -11,8 +11,8 @@ version.workspace = true
[lib]
path = "mod.rs"
crate-type = [
"rlib",
# "dylib",
"rlib",
# "dylib",
]
[features]
@@ -23,61 +23,61 @@ bindgen-static = [
"conduwuit-database/bindgen-static"
]
brotli_compression = [
"conduwuit-core/brotli_compression",
"reqwest/brotli",
"conduwuit-core/brotli_compression",
"reqwest/brotli",
]
console = [
"dep:rustyline-async",
"dep:termimad",
"dep:rustyline-async",
"dep:termimad",
]
element_hacks = []
gzip_compression = [
"conduwuit-core/gzip_compression",
"reqwest/gzip",
"conduwuit-core/gzip_compression",
"reqwest/gzip",
]
http3 = [
"reqwest/http3"
]
io_uring = [
"conduwuit-database/io_uring",
"conduwuit-database/io_uring",
]
jemalloc = [
"conduwuit-core/jemalloc",
"conduwuit-database/jemalloc",
"conduwuit-core/jemalloc",
"conduwuit-database/jemalloc",
]
jemalloc_conf = [
"conduwuit-core/jemalloc_conf",
"conduwuit-database/jemalloc_conf",
"conduwuit-core/jemalloc_conf",
"conduwuit-database/jemalloc_conf",
]
jemalloc_prof = [
"conduwuit-core/jemalloc_prof",
"conduwuit-database/jemalloc_prof",
"conduwuit-core/jemalloc_prof",
"conduwuit-database/jemalloc_prof",
]
jemalloc_stats = [
"conduwuit-core/jemalloc_stats",
"conduwuit-database/jemalloc_stats",
"conduwuit-core/jemalloc_stats",
"conduwuit-database/jemalloc_stats",
]
media_thumbnail = [
"dep:image",
"dep:image",
]
release_max_log_level = [
"conduwuit-core/release_max_log_level",
"conduwuit-database/release_max_log_level",
"log/max_level_trace",
"log/release_max_level_info",
"tracing/max_level_trace",
"tracing/release_max_level_info",
"conduwuit-core/release_max_log_level",
"conduwuit-database/release_max_log_level",
"log/max_level_trace",
"log/release_max_level_info",
"tracing/max_level_trace",
"tracing/release_max_level_info",
]
systemd = [
"dep:sd-notify",
"dep:sd-notify",
]
url_preview = [
"dep:image",
"dep:webpage",
"dep:image",
"dep:webpage",
]
zstd_compression = [
"conduwuit-core/zstd_compression",
"conduwuit-database/zstd_compression",
"conduwuit-core/zstd_compression",
"conduwuit-database/zstd_compression",
"reqwest/zstd",
]
@@ -135,6 +135,7 @@ openidconnect.workspace = true
# which is necessary to call `danger_accept_invalid_certs`.
reqwest_0_12.workspace = true
rand.workspace = true
opentelemetry.workspace = true
[target.'cfg(all(unix, target_os = "linux"))'.dependencies]
sd-notify.workspace = true
+1 -1
View File
@@ -534,7 +534,7 @@ impl Service {
return state;
},
};
if !pdu_fits(&value) {
if !pdu_fits(&value.clone()) {
warn!(
"dropping incoming PDU {event_id} in room {room_id} from room join \
because it exceeds 65535 bytes or is otherwise too large."
+2
View File
@@ -7,6 +7,7 @@ pub mod membership;
pub mod metadata;
pub mod outlier;
pub mod pdu_metadata;
pub mod queue;
pub mod read_receipt;
pub mod search;
pub mod short;
@@ -32,6 +33,7 @@ pub struct Service {
pub metadata: Arc<metadata::Service>,
pub outlier: Arc<outlier::Service>,
pub pdu_metadata: Arc<pdu_metadata::Service>,
pub queue: Arc<queue::Service>,
pub read_receipt: Arc<read_receipt::Service>,
pub search: Arc<search::Service>,
pub short: Arc<short::Service>,
+240
View File
@@ -0,0 +1,240 @@
use std::{
collections::{HashMap, hash_map::Entry},
sync::Arc,
time::{Duration, Instant},
};
use async_trait::async_trait;
use conduwuit::{
Error, Result, Server, SyncMutex, debug, err, error, info, utils::millis_since_unix_epoch,
};
use opentelemetry::KeyValue;
use ruma::{
CanonicalJsonObject, CanonicalJsonValue, OwnedEventId, OwnedRoomId, OwnedServerName,
api::error::ErrorKind, events::TimelineEventType,
};
use tokio::{
sync::{
Notify, mpsc,
mpsc::{Sender, UnboundedReceiver, UnboundedSender},
},
task::JoinSet,
};
use crate::{
rooms,
service::{Args, Dep},
};
pub struct Services {
event_handler: Dep<rooms::event_handler::Service>,
server: Arc<Server>,
}
pub struct Service {
queues: SyncMutex<HashMap<OwnedRoomId, UnboundedSender<QueueJob>>>,
send: Sender<QueueJob>,
recv: tokio::sync::Mutex<mpsc::Receiver<QueueJob>>,
shutdown: Notify,
services: Services,
}
#[async_trait]
impl crate::Service for Service {
fn build(args: Args<'_>) -> Result<Arc<Self>>
where
Self: Sized,
{
let (send, recv) = mpsc::channel(1);
Ok(Arc::new(Self {
queues: SyncMutex::new(HashMap::new()),
shutdown: Notify::new(),
send,
recv: tokio::sync::Mutex::new(recv),
services: Services {
event_handler: args.depend("rooms::event_handler"),
server: args.server.clone(),
},
}))
}
async fn worker(self: Arc<Self>) -> Result<()> {
let mut recv = self.recv.lock().await;
let mut handles = JoinSet::new();
let (yielder, mut yielding) = mpsc::channel(5);
loop {
let job = tokio::select! {
() = self.shutdown.notified() => {
info!("Shutting down");
yielding.close();
recv.close();
break;
},
room_id = yielding.recv() => {
if let Some(room_id) = room_id {
self.queues.lock().remove(&room_id);
}
continue;
}
job = recv.recv() => job
};
let Some(job) = job else {
debug!("No job (channel closed)");
break;
};
let mut queues = self.queues.lock();
match queues.entry(job.room_id.clone()) {
| Entry::Occupied(entry) => {
entry.get().send(job).unwrap();
// TODO: handle error
// It might be possible for a self-reaping worker to close
// at the same time we try to send to it, which will cause
// this send to return a "channel closed" error.
},
| Entry::Vacant(entry) => {
let room_id = entry.key().to_owned();
let (sender, receiver) = mpsc::unbounded_channel();
sender.send(job).unwrap(); // TODO: handle error
handles.spawn_on(
Self::room_worker(self.clone(), room_id, receiver, yielder.clone()),
self.services.server.runtime(),
);
entry.insert(sender);
},
}
}
// If the loop broke, make sure that the shutdown signal was sent, so
// that any room workers are guaranteed to shut down as soon as
// possible.
self.interrupt();
while let Some(ret) = handles.join_next_with_id().await {
match ret {
| Ok((id, ())) => {
debug!(?id, "room queue worker finished");
},
| Err(error) => {
error!(id = ?error.id(), ?error, "room queue worker failed");
},
}
}
Ok(())
}
fn interrupt(&self) { self.shutdown.notify_waiters(); }
fn name(&self) -> &'static str { module_path!() }
}
impl Service {
pub async fn new_job(&self, job: QueueJob) -> Result<()> {
self.send
.send(job)
.await
.map_err(|e| err!("failed to send PDU to worker: {e}"))
}
#[tracing::instrument(skip(self,channel,yielder), fields(%room_id))]
async fn room_worker(
self: Arc<Self>,
room_id: OwnedRoomId,
mut channel: UnboundedReceiver<QueueJob>,
yielder: Sender<OwnedRoomId>,
) {
debug!("Room worker starting up");
loop {
let job = tokio::select! {
() = self.shutdown.notified() => {
debug!("Room worker shutting down");
channel.close();
return;
},
() = tokio::time::sleep(Duration::from_mins(5)) => {
debug!("Room worker self-reaping (no activity in 5 minutes)");
yielder.send(room_id).await.ok();
debug!("Room worker reaped. Goodbye.");
return;
},
job = channel.recv() => job
};
let Some(job) = job else {
debug!("Room worker channel closed without shutdown?");
break;
};
debug!(
event_id=%job.event_id,
origin=%job.origin,
backpressure=%channel.len(),
"Handling incoming job"
);
let _room_lock = self
.services
.event_handler
.mutex_federation
.lock(room_id.as_str())
.await;
debug!(event_id=%job.event_id, origin=%job.origin, "Acquired room federation lock");
let event_type = KeyValue::new(
"type",
pdu_type_label(job.object.get("type").and_then(CanonicalJsonValue::as_str)),
);
let origin_server_ts = job
.object
.get("origin_server_ts")
.and_then(CanonicalJsonValue::as_integer)
.and_then(|ts| u64::try_from(i64::from(ts)).ok());
let start = Instant::now();
let result = self
.services
.event_handler
.handle_incoming_pdu(&job.origin, &job.room_id, &job.event_id, job.object, false)
.await;
let outcome = KeyValue::new("outcome", match &result {
| Ok(_) => "accepted",
| Err(Error::BadRequest(ErrorKind::Forbidden, ..)) => "forbidden",
| Err(Error::BadRequest(ErrorKind::InvalidParam | ErrorKind::BadJson, ..)) =>
"invalid",
| Err(_) => "error",
});
let instruments = &self.services.server.metrics.instruments;
instruments
.federation_incoming_pdu_duration
.record(start.elapsed().as_secs_f64(), std::slice::from_ref(&outcome));
if let (Ok(_), Some(ts)) = (&result, origin_server_ts) {
let lag = millis_since_unix_epoch().saturating_sub(ts);
instruments
.federation_incoming_pdu_lag
.record(Duration::from_millis(lag).as_secs_f64(), &[]);
}
instruments
.federation_incoming_pdus
.add(1, &[event_type, outcome]);
debug!(event_id=%job.event_id, origin=%job.origin, "Job finished");
}
}
}
pub struct QueueJob {
pub origin: OwnedServerName,
pub event_id: OwnedEventId,
pub room_id: OwnedRoomId,
pub object: CanonicalJsonObject,
}
/// Known event types, or `other`, so remote servers cannot create new
/// attribute values.
fn pdu_type_label(event_type: Option<&str>) -> String {
match event_type.map(TimelineEventType::from) {
| Some(TimelineEventType::_Custom(_)) | None => "other".to_owned(),
| Some(event_type) => event_type.to_string(),
}
}
+4 -4
View File
@@ -54,7 +54,7 @@ pub fn pdu_fits(owned_obj: &CanonicalJsonObject) -> bool {
}
// Now check the full PDU size
match serde_json::to_string(owned_obj) {
| Ok(s) => s.len() <= 65536,
| Ok(s) => s.len() <= 65535,
| Err(_) => false,
}
}
@@ -305,7 +305,7 @@ impl super::Service {
{
return match e {
| Error::SignatureJson(ruma::signatures::JsonError::PduTooLarge) => {
Err!(Request(TooLarge("Message/PDU is too long (exceeds 65536 bytes)")))
Err!(Request(TooLarge("Message/PDU is too long (exceeds 65535 bytes)")))
},
| _ => Err!(Request(Unknown(warn!("Signing event failed: {e}")))),
};
@@ -330,9 +330,9 @@ impl super::Service {
pdu_json
.insert("event_id".into(), CanonicalJsonValue::String(pdu.event_id.clone().into()));
// Verify that the *full* PDU isn't over 64KiB.
if !pdu_fits(&pdu_json) {
if !pdu_fits(&pdu_json.clone()) {
// feckin huge PDU mate
return Err!(Request(TooLarge("Message/PDU is too long (exceeds 65536 bytes)")));
return Err!(Request(TooLarge("Message/PDU is too long (exceeds 65535 bytes)")));
}
// Check with the policy server
+1
View File
@@ -99,6 +99,7 @@ impl Services {
metadata: build!(rooms::metadata::Service),
outlier: build!(rooms::outlier::Service),
pdu_metadata: build!(rooms::pdu_metadata::Service),
queue: build!(rooms::queue::Service),
read_receipt: build!(rooms::read_receipt::Service),
search: build!(rooms::search::Service),
short: build!(rooms::short::Service),