tuwunel_service/sending/sender/dispatch/
federation.rs1use 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#[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}