tuwunel_service/rooms/spaces/
local.rs1use 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#[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 debug!(?current_room, ?expires, "negative cache hit");
73 },
74 | _ => {
75 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() .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 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}