tuwunel_service/rooms/spaces/
federation.rs1use 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#[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}