tuwunel_service/server_keys/
request.rs1use std::{collections::BTreeMap, convert::identity, fmt::Debug};
8
9use futures::{StreamExt, TryFutureExt};
10use ruma::{
11 OwnedServerName, OwnedServerSigningKeyId, ServerName, ServerSigningKeyId,
12 api::federation::discovery::{
13 ServerSigningKeys, get_remote_server_keys,
14 get_remote_server_keys_batch::{self, v2::QueryCriteria},
15 get_server_keys,
16 },
17};
18use tuwunel_core::{
19 Err, Result, error, implement, info, trace,
20 utils::stream::{IterStream, ReadyExt, TryBroadbandExt, TryReadyExt},
21};
22
23#[implement(super::Service)]
28pub(super) async fn batch_notary_request<'a, S, K>(
29 &self,
30 notary: &ServerName,
31 batch: S,
32) -> Result<Vec<ServerSigningKeys>>
33where
34 S: Iterator<Item = (&'a ServerName, K)> + Send,
35 K: Iterator<Item = &'a ServerSigningKeyId> + Send,
36{
37 use get_remote_server_keys_batch::v2::Request;
38 type RumaBatch = BTreeMap<OwnedServerName, BTreeMap<OwnedServerSigningKeyId, QueryCriteria>>;
39
40 let criteria = QueryCriteria {
41 minimum_valid_until_ts: Some(self.minimum_valid_ts()),
42 };
43
44 let mut server_keys = batch.fold(RumaBatch::new(), |mut batch, (server, key_ids)| {
45 batch
46 .entry(server.into())
47 .or_default()
48 .extend(key_ids.map(|key_id| (key_id.into(), criteria.clone())));
49
50 batch
51 });
52
53 let total_keys = server_keys
54 .values()
55 .flat_map(|ids| ids.iter())
56 .count();
57
58 debug_assert!(total_keys > 0, "empty batch request to notary");
59
60 let batch_max = self
61 .services
62 .server
63 .config
64 .federation
65 .keys
66 .trusted_server_batch_size;
67
68 let batch_concurrency = self
69 .services
70 .server
71 .config
72 .federation
73 .keys
74 .trusted_server_batch_concurrency;
75
76 let batches: Vec<_> = server_keys
77 .keys()
78 .rev()
79 .step_by(batch_max.saturating_sub(1))
80 .skip(1)
81 .chain(server_keys.keys().next())
82 .cloned()
83 .collect();
84
85 batches
86 .iter()
87 .stream()
88 .enumerate()
89 .map(|(i, batch)| {
90 let request = Request {
91 server_keys: server_keys.split_off(batch),
92 };
93
94 if request.server_keys.is_empty() {
95 return None;
96 }
97
98 trace!(
99 %i, %notary, ?batch,
100 remaining = ?server_keys,
101 requesting = ?request.server_keys.keys(),
102 "Request to notary server."
103 );
104
105 info!(
106 %notary,
107 remaining = %server_keys.len(),
108 requesting = %request.server_keys.len(),
109 "Sending request to notary server..."
110 );
111
112 Some(Ok(request))
113 })
114 .ready_filter_map(identity)
115 .broadn_and_then(batch_concurrency, |request| {
116 self.services
117 .federation
118 .execute_synapse(notary, request)
119 })
120 .ready_try_fold(Vec::new(), |mut results, response| {
121 let response = response
122 .server_keys
123 .into_iter()
124 .map(|key| key.deserialize())
125 .filter_map(Result::ok);
126
127 trace!(
128 %notary, ?response,
129 "Response from notary server."
130 );
131
132 results.extend(response);
133
134 info!(
135 "Received {0} keys out of {1} from notary server so far...",
136 results.len(),
137 total_keys,
138 );
139
140 Ok(results)
141 })
142 .inspect_err(|e| {
143 error!(
144 ?notary, %batch_max, %batch_concurrency, %total_keys,
145 "Requesting keys from notary server failed: {e}",
146 );
147 })
148 .await
149}
150
151#[implement(super::Service)]
156pub async fn notary_request(
157 &self,
158 notary: &ServerName,
159 target: &ServerName,
160) -> Result<impl Iterator<Item = ServerSigningKeys> + Clone + Debug + Send + use<>> {
161 use get_remote_server_keys::v2::Request;
162
163 let request = Request {
164 server_name: target.into(),
165 minimum_valid_until_ts: self.minimum_valid_ts(),
166 };
167
168 let response = self
169 .services
170 .federation
171 .execute(notary, request)
172 .await?
173 .server_keys
174 .into_iter()
175 .map(|key| key.deserialize())
176 .filter_map(Result::ok);
177
178 Ok(response)
179}
180
181#[implement(super::Service)]
186pub async fn server_request(&self, target: &ServerName) -> Result<ServerSigningKeys> {
187 use get_server_keys::v2::Request;
188
189 let server_signing_key = self
190 .services
191 .federation
192 .execute(target, Request::new())
193 .await
194 .map(|response| response.server_key)
195 .and_then(|key| key.deserialize().map_err(Into::into))?;
196
197 if server_signing_key.server_name != target {
198 return Err!(BadServerResponse(debug_warn!(
199 requested = ?target,
200 response = ?server_signing_key.server_name,
201 "Server responded with bogus server_name"
202 )));
203 }
204
205 Ok(server_signing_key)
206}