Skip to main content

tuwunel_service/rooms/spaces/
local.rs

1use futures::{FutureExt, StreamExt, TryFutureExt, future::join5};
2use ruma::{
3	RoomId, api::federation::space::SpaceHierarchyParentSummary as ParentSummary,
4	events::space::child::HierarchySpaceChildEvent, room::RoomSummary, serde::Raw,
5};
6use tuwunel_core::{
7	Err, Error, Result, debug, error, implement,
8	utils::{future::TryExtExt, timepoint_has_passed},
9};
10use tuwunel_matrix::Event;
11
12use super::{Accessibility, Cached, Identifier, cache::Provenance};
13
14/// Gets the summary of a space using solely local information.
15#[implement(super::Service)]
16#[tracing::instrument(name = "local", level = "debug", skip_all)]
17pub(super) async fn get_summary_and_children_local(
18	&self,
19	current_room: &RoomId,
20	sender: &Identifier<'_>,
21) -> Result<Accessibility> {
22	use Accessibility::{Accessible, Inaccessible};
23
24	let local = self
25		.services
26		.state_cache
27		.server_in_room_result(self.services.server.name.as_ref(), current_room)
28		.await?;
29
30	match self.cache_get(current_room).await {
31		| Err(e) if !e.is_not_found() => {
32			error!(?current_room, "cache error: {e}");
33			return Err(e);
34		},
35		| Ok(Cached {
36			expires,
37			summary: Some(cached),
38			provenance,
39		}) if !timepoint_has_passed(expires)
40			&& cached.summary.room_id == current_room
41			&& matches!(
42				(local, provenance),
43				(true, Provenance::Local) | (false, Provenance::Remote)
44			) =>
45		{
46			debug!(?current_room, ?expires, "cache hit");
47			let accessible = self
48				.is_accessible_child(current_room, &cached.summary.join_rule, sender)
49				.await;
50
51			#[cfg(test)]
52			let accessible = super::tests::after_cached_access(accessible).await;
53
54			let still_local = self
55				.services
56				.state_cache
57				.server_in_room_result(self.services.server.name.as_ref(), current_room)
58				.await?;
59
60			if local == still_local {
61				return Ok(accessible
62					.then_some(Accessible(cached))
63					.unwrap_or(Inaccessible));
64			}
65
66			if !still_local {
67				return Err!(Request(NotFound("Space room not found locally.")));
68			}
69		},
70		| Ok(Cached { expires, summary: None, .. }) if !timepoint_has_passed(expires) => {
71			// Cache negative: try local computation below.
72			debug!(?current_room, ?expires, "negative cache hit");
73		},
74		| _ => {
75			// Cache miss, expired, or negative: try local computation below.
76			debug!(?current_room, "no usable cache entry");
77		},
78	}
79
80	let local = self
81		.services
82		.state_cache
83		.server_in_room_result(self.services.server.name.as_ref(), current_room)
84		.await?;
85
86	if !local {
87		debug!(?current_room, "no local membership; defer to federation");
88		return Err!(Request(NotFound("Space room not found locally.")));
89	}
90
91	let children_state: Vec<_> = self
92		.get_space_child_events(current_room)
93		.map(Event::into_format)
94		.collect()
95		.await;
96
97	let summary = self
98		.get_room_summary(current_room, children_state, sender)
99		.boxed() // size firewall
100		.await;
101
102	match summary {
103		| Ok(Inaccessible) => self.cache_put(current_room, None, Provenance::Local),
104		| Ok(Accessible(ref summary)) =>
105			self.cache_put(current_room, Some(summary), Provenance::Local),
106		| _ => (),
107	}
108
109	summary
110}
111
112#[implement(super::Service)]
113pub(super) async fn get_room_summary(
114	&self,
115	room_id: &RoomId,
116	children_state: Vec<Raw<HierarchySpaceChildEvent>>,
117	sender: &Identifier<'_>,
118) -> Result<Accessibility, Error> {
119	let join_rule = self
120		.services
121		.state_accessor
122		.get_join_rules(room_id)
123		.await;
124
125	let is_accessible_child = self
126		.is_accessible_child(room_id, &join_rule.clone().into(), sender)
127		.await;
128
129	if !is_accessible_child {
130		return Ok(Accessibility::Inaccessible);
131	}
132
133	let canonical_alias = self
134		.services
135		.state_accessor
136		.get_canonical_alias(room_id)
137		.ok();
138
139	let name = self
140		.services
141		.state_accessor
142		.get_name(room_id)
143		.ok();
144
145	let topic = self
146		.services
147		.state_accessor
148		.get_room_topic(room_id)
149		.ok();
150
151	let avatar_url = self
152		.services
153		.state_accessor
154		.get_avatar(room_id)
155		.map_ok(|content| content.url)
156		.ok();
157
158	let room_type = self
159		.services
160		.state_accessor
161		.get_room_type(room_id)
162		.ok();
163
164	let (canonical_alias, name, topic, avatar_url, room_type) =
165		join5(canonical_alias, name, topic, avatar_url, room_type).await;
166
167	// Two rounds overlay in the layout; one ten-way join holds every read at once.
168	let world_readable = self
169		.services
170		.state_accessor
171		.is_world_readable(room_id);
172
173	let guest_can_join = self
174		.services
175		.state_accessor
176		.guest_can_join(room_id);
177
178	let num_joined_members = self
179		.services
180		.state_cache
181		.room_joined_count(room_id)
182		.unwrap_or(0);
183
184	let room_version = self.services.state.get_room_version(room_id).ok();
185
186	let encryption = self
187		.services
188		.state_accessor
189		.get_room_encryption(room_id)
190		.ok();
191
192	let (world_readable, guest_can_join, num_joined_members, room_version, encryption) =
193		join5(world_readable, guest_can_join, num_joined_members, room_version, encryption).await;
194
195	let summary = ParentSummary {
196		children_state,
197		summary: RoomSummary {
198			avatar_url: avatar_url.flatten(),
199			canonical_alias,
200			name,
201			topic,
202			world_readable,
203			guest_can_join,
204			room_type,
205			encryption,
206			room_version,
207			room_id: room_id.to_owned(),
208			num_joined_members: num_joined_members.try_into().unwrap_or_default(),
209			join_rule: join_rule.clone().into(),
210		},
211	};
212
213	Ok(Accessibility::Accessible(summary))
214}