Skip to main content

tuwunel_service/sending/sender/dispatch/
federation.rs

1use base64::{Engine as _, engine::general_purpose::URL_SAFE_NO_PAD};
2use futures::StreamExt;
3use ruma::{
4	MilliSecondsSinceUnixEpoch, OwnedServerName,
5	api::federation::transactions::{edu::Edu, send_transaction_message::v1::Request},
6	serde::Raw,
7};
8use tuwunel_core::{
9	debug_warn, extract_variant, implement,
10	utils::{IterStream, budget, calculate_hash, future::TryExtExt, stream::WidebandExt},
11	warn,
12};
13
14use super::SendingResult;
15use crate::sending::{Destination, EduBuf, SendingEvent, Service, sender::EDU_BYTES_LIMIT};
16
17/// Send a federation transaction, reporting whether one went out at all.
18///
19/// Rows that all fail to load leave nothing to send; they still succeed, so
20/// their keys are acknowledged. EDUs past `EDU_BYTES_LIMIT` are left out and
21/// acknowledged the same way.
22#[implement(Service)]
23#[tracing::instrument(
24	name = "federation",
25	level = "debug",
26	skip(self, events),
27	fields(
28		events = %events.len(),
29	),
30)]
31pub(super) async fn send_events_dest_federation(
32	&self,
33	server: OwnedServerName,
34	events: Vec<SendingEvent>,
35) -> (SendingResult, bool) {
36	let pdus: Vec<_> = events
37		.iter()
38		.filter_map(|event| extract_variant!(event, SendingEvent::Pdu))
39		.stream()
40		.wide_filter_map(|pdu_id| {
41			self.services
42				.timeline
43				.get_pdu_json_from_id(pdu_id)
44				.ok()
45		})
46		.wide_then(|pdu| {
47			self.services
48				.state_accessor
49				.erased_for_server(&server, pdu)
50		})
51		.wide_then(|pdu| {
52			self.services
53				.federation
54				.format_pdu_into(pdu, None)
55		})
56		.collect()
57		.await;
58
59	let edus = events
60		.iter()
61		.filter_map(|event| extract_variant!(event, SendingEvent::Edu))
62		.map(EduBuf::as_slice)
63		.map(serde_json::from_slice)
64		.filter_map(Result::ok);
65
66	let size = |edu: &Raw<Edu>| edu.json().get().len();
67	let dropped = |edu: &Raw<Edu>| {
68		debug_warn!(%server, len = size(edu), "Dropping an EDU past the transaction budget.");
69	};
70
71	let edus: Vec<_> = budget(edus, EDU_BYTES_LIMIT, size)
72		.filter_map(|edu| edu.inspect_err(dropped).ok())
73		.collect();
74
75	if pdus.is_empty() && edus.is_empty() {
76		return (Ok(Destination::Federation(server)), false);
77	}
78
79	let preimage = pdus
80		.iter()
81		.map(|raw| raw.get().as_bytes())
82		.chain(edus.iter().map(|raw| raw.json().get().as_bytes()));
83
84	let txn_hash = calculate_hash(preimage);
85	let txn_id = &*URL_SAFE_NO_PAD.encode(txn_hash);
86	let request = Request {
87		transaction_id: txn_id.into(),
88		origin: self.server.name.clone(),
89		origin_server_ts: MilliSecondsSinceUnixEpoch::now(),
90		pdus,
91		edus,
92	};
93
94	let result = self
95		.services
96		.federation
97		.execute_on(&self.services.client.sender, &server, request)
98		.await;
99
100	result
101		.iter()
102		.flat_map(|resp| resp.pdus.iter())
103		.filter_map(|(event_id, result)| {
104			result
105				.as_ref()
106				.err()
107				.map(|error| (event_id, error))
108		})
109		.for_each(|(event_id, error)| {
110			warn!(%txn_id, %server, %event_id, %error, "error sending PDU to remote server");
111		});
112
113	let result = match result {
114		| Ok(_) => Ok(Destination::Federation(server)),
115		| Err(error) => Err((Destination::Federation(server), error)),
116	};
117
118	(result, true)
119}