Skip to main content

tuwunel_service/rooms/spaces/
federation.rs

1use futures::{StreamExt, TryStreamExt};
2use ruma::{
3	OwnedServerName, RoomId,
4	api::federation::space::{
5		SpaceHierarchyParentSummary as ParentSummary,
6		get_hierarchy::v1::{Request, Response},
7	},
8	room::RoomType,
9};
10use tuwunel_core::{
11	Err, Error, Result, debug, implement,
12	utils::{IterStream, stream::WidebandExt},
13};
14
15use super::{
16	Accessibility,
17	Accessibility::{Accessible, Inaccessible},
18	Identifier,
19	cache::Provenance,
20};
21use crate::federation::feds::{Fault, Opts, OutcomeExt, Record};
22
23/// Gets the summary of a space using solely federation.
24#[implement(super::Service)]
25#[tracing::instrument(
26	name = "federation",
27	level = "debug",
28	err(level = "debug"),
29	ret(level = "trace"),
30	skip(self)
31)]
32pub(super) async fn get_summary_and_children_federation(
33	&self,
34	current_room: &RoomId,
35	sender: &Identifier<'_>,
36	via: &[OwnedServerName],
37) -> Result<Accessibility> {
38	let request = Request {
39		room_id: current_room.to_owned(),
40		suggested_only: false,
41	};
42
43	debug!(
44		?current_room,
45		?sender,
46		?via,
47		requests = via.len(),
48		"waiting for federation response"
49	);
50	let opts = Opts {
51		record: Record::Contribute,
52		..Default::default()
53	};
54
55	let response = self
56		.services
57		.federation
58		.fanout_to(via.iter().cloned().stream(), move |_| request.clone(), opts)
59		.inspect(|outcome| match &outcome.result {
60			| Ok(response) => debug!(?response, "federation response"),
61			| Err(Fault::Error(error)) => debug!(?error, "federation error"),
62			| Err(fault) => debug!(?fault, "federation error"),
63		})
64		.first_acceptable(|response| summary_matches_room(&response.room, current_room))
65		.await
66		.map(|(_, response)| response);
67
68	let Some(Response { room, children, inaccessible_children }) = response else {
69		if self
70			.services
71			.state_cache
72			.server_in_room_result(self.services.server.name.as_ref(), current_room)
73			.await?
74		{
75			return self
76				.get_summary_and_children_local(current_room, sender)
77				.await;
78		}
79
80		self.cache_put(current_room, None, Provenance::Remote);
81		return Err!(Request(NotFound("Space room not found over federation.")));
82	};
83
84	if self
85		.services
86		.state_cache
87		.server_in_room_result(self.services.server.name.as_ref(), current_room)
88		.await?
89	{
90		return self
91			.get_summary_and_children_local(current_room, sender)
92			.await;
93	}
94
95	let accessible = self
96		.is_accessible_child(current_room, &room.summary.join_rule, sender)
97		.await;
98
99	let inaccessible_children: Vec<_> = inaccessible_children
100		.into_iter()
101		.stream()
102		.wide_then(async |room_id| {
103			Ok::<_, Error>(
104				self.remote_room(&room_id)
105					.await?
106					.then_some(room_id),
107			)
108		})
109		.try_collect()
110		.await?;
111
112	let children: Vec<_> = children
113		.into_iter()
114		.filter(|child| child.room_type.ne(&Some(RoomType::Space)))
115		.stream()
116		.wide_then(async |summary| {
117			Ok::<_, Error>(
118				self.remote_room(&summary.room_id)
119					.await?
120					.then_some(summary),
121			)
122		})
123		.try_collect()
124		.await?;
125
126	if self
127		.services
128		.state_cache
129		.server_in_room_result(self.services.server.name.as_ref(), current_room)
130		.await?
131	{
132		return self
133			.get_summary_and_children_local(current_room, sender)
134			.await;
135	}
136
137	inaccessible_children
138		.into_iter()
139		.flatten()
140		.for_each(|room_id| self.cache_put(&room_id, None, Provenance::Remote));
141
142	children
143		.into_iter()
144		.flatten()
145		.for_each(|summary| {
146			let summary = ParentSummary {
147				summary,
148				children_state: Default::default(),
149			};
150
151			self.cache_put(&summary.summary.room_id, Some(&summary), Provenance::Remote);
152		});
153
154	self.cache_put(current_room, Some(&room), Provenance::Remote);
155
156	accessible
157		.then(|| Ok(Accessible(room)))
158		.unwrap_or(Ok(Inaccessible))
159}
160
161#[implement(super::Service)]
162#[tracing::instrument(level = "trace", skip(self))]
163pub(super) async fn remote_room(&self, room_id: &RoomId) -> Result<bool> {
164	let remote = !self
165		.services
166		.state_cache
167		.server_in_room_result(self.services.server.name.as_ref(), room_id)
168		.await?;
169
170	#[cfg(test)]
171	let remote = super::tests::after_remote_room(remote).await;
172
173	Ok(remote)
174}
175
176#[inline]
177pub(super) fn summary_matches_room(summary: &ParentSummary, room_id: &RoomId) -> bool {
178	summary.summary.room_id == room_id
179}