Files
continuwuity/src/service/rooms/event_handler/fetch_prev.rs
T

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

130 lines
3.4 KiB
Rust
Raw Normal View History

use std::{
2025-08-02 09:32:21 +00:00
collections::{HashMap, HashSet},
iter::once,
};
2024-11-08 07:30:52 +00:00
2025-08-02 09:32:21 +00:00
use futures::{FutureExt, StreamExt, stream::FuturesOrdered};
2024-11-08 07:30:52 +00:00
use ruma::{
CanonicalJsonObject, EventId, MilliSecondsSinceUnixEpoch, OwnedEventId, RoomId,
RoomVersionId, ServerName, int, uint,
2024-11-08 07:30:52 +00:00
};
2025-04-22 01:41:02 +00:00
use tuwunel_core::{
Result, debug_warn, err, implement,
matrix::{Event, PduEvent},
2025-04-22 01:41:02 +00:00
state_res::{self},
};
2024-11-08 07:30:52 +00:00
use super::check_room_id;
#[implement(super::Service)]
2025-01-02 05:30:51 +00:00
#[tracing::instrument(
2026-01-19 05:02:55 +00:00
level = "debug",
2025-01-02 05:30:51 +00:00
skip_all,
fields(%origin),
)]
2024-11-08 07:30:52 +00:00
#[allow(clippy::type_complexity)]
pub(super) async fn fetch_prev<'a, Events>(
&self,
origin: &ServerName,
room_id: &RoomId,
initial_set: Events,
room_version: &RoomVersionId,
first_ts_in_room: MilliSecondsSinceUnixEpoch,
) -> Result<(Vec<OwnedEventId>, HashMap<OwnedEventId, (PduEvent, CanonicalJsonObject)>)>
where
2025-08-02 09:32:21 +00:00
Events: Iterator<Item = &'a EventId> + Send,
{
2025-08-02 09:32:21 +00:00
let mut todo_outlier_stack: FuturesOrdered<_> = initial_set
.map(ToOwned::to_owned)
.map(async |event_id| {
let fetch = self.fetch_auth(origin, room_id, once(event_id.as_ref()), room_version);
(event_id.clone(), fetch.await)
})
.map(FutureExt::boxed)
.collect();
2024-11-08 07:30:52 +00:00
let mut amount = 0;
2025-08-02 09:32:21 +00:00
let mut eventid_info = HashMap::new();
let mut graph: HashMap<OwnedEventId, _> = HashMap::with_capacity(todo_outlier_stack.len());
while let Some((prev_event_id, mut outlier)) = todo_outlier_stack.next().await {
let Some((pdu, mut json_opt)) = outlier.pop() else {
// Fetch and handle failed
graph.insert(prev_event_id.clone(), HashSet::new());
continue;
};
2024-11-08 07:30:52 +00:00
2025-08-02 09:32:21 +00:00
check_room_id(room_id, &pdu)?;
2024-11-08 07:30:52 +00:00
2025-08-02 09:32:21 +00:00
let limit = self.services.server.config.max_fetch_prev_events;
if amount > limit {
debug_warn!(?limit, "Max prev event limit reached!");
graph.insert(prev_event_id.clone(), HashSet::new());
continue;
2024-11-08 07:30:52 +00:00
}
2025-08-02 09:32:21 +00:00
if json_opt.is_none() {
json_opt = self
.services
.timeline
.get_outlier_pdu_json(&prev_event_id)
.await
.ok();
}
let Some(json) = json_opt else {
// Get json failed, so this was not fetched over federation
graph.insert(prev_event_id.clone(), HashSet::new());
continue;
};
if pdu.origin_server_ts() > first_ts_in_room {
amount = amount.saturating_add(1);
for prev_prev in pdu.prev_events() {
if !graph.contains_key(prev_prev) {
let prev_prev = prev_prev.to_owned();
let fetch = async move {
let fetch = self.fetch_auth(
origin,
room_id,
once(prev_prev.as_ref()),
room_version,
);
(prev_prev.clone(), fetch.await)
};
todo_outlier_stack.push_back(fetch.boxed());
}
}
graph.insert(
prev_event_id.clone(),
pdu.prev_events().map(ToOwned::to_owned).collect(),
);
} else {
// Time based check failed
graph.insert(prev_event_id.clone(), HashSet::new());
}
eventid_info.insert(prev_event_id.clone(), (pdu, json));
self.services.server.check_running()?;
2024-11-08 07:30:52 +00:00
}
2025-07-08 11:08:58 +00:00
let event_fetch = async |event_id: OwnedEventId| {
2024-11-08 07:30:52 +00:00
let origin_server_ts = eventid_info
.get(&event_id)
.map_or_else(|| uint!(0), |info| info.0.origin_server_ts().get());
2024-11-08 07:30:52 +00:00
// This return value is the key used for sorting events,
// events are then sorted by power level, time,
// and lexically by event_id.
2025-06-29 03:33:29 +00:00
Ok((int!(0).into(), MilliSecondsSinceUnixEpoch(origin_server_ts)))
2024-11-08 07:30:52 +00:00
};
2025-06-29 03:33:29 +00:00
let sorted = state_res::topological_sort(&graph, &event_fetch)
2024-11-08 07:30:52 +00:00
.await
.map_err(|e| err!(Database(error!("Error sorting prev events: {e}"))))?;
Ok((sorted, eventid_info))
}