Skip to main content

tuwunel_service/sending/sender/dispatch/push/
mod.rs

1mod suppressed;
2
3use futures::{FutureExt, TryFutureExt, future::try_join3};
4use ruma::{OwnedUserId, api::error::ErrorKind};
5use tuwunel_core::{
6	Error, debug, error,
7	error::error_chain,
8	extract_variant, implement,
9	smallvec::SmallVec,
10	utils::{BoolExt, IterStream, ReadyExt, stream::WidebandExt},
11	warn,
12};
13use tuwunel_matrix::Event;
14
15use super::SendingResult;
16use crate::{
17	rooms::timeline::RawPduId,
18	sending::{Destination, SendingEvent, Service},
19};
20
21type FailedIds = SmallVec<[RawPduId; 1]>;
22
23// Notices in flight to one push gateway at once.
24pub(super) const PUSH_WIDTH: usize = 4;
25
26/// The PDUs a push transaction failed to deliver, with the first error.
27///
28/// Permanent errors are dropped before they reach here; the retained IDs keep
29/// their active rows for the retry.
30#[derive(Default)]
31struct Failures {
32	ids: FailedIds,
33	error: Option<Error>,
34}
35
36#[implement(Service)]
37#[tracing::instrument(
38	name = "push",
39	level = "info",
40	skip(self, events),
41	fields(
42		events = events.len(),
43	),
44)]
45pub(super) async fn send_events_dest_push(
46	&self,
47	user_id: OwnedUserId,
48	pushkey: String,
49	events: Vec<SendingEvent>,
50) -> SendingResult {
51	let has_pdu = events
52		.iter()
53		.any(|event| matches!(event, SendingEvent::Pdu(_)));
54
55	let destination = || Destination::Push(user_id.clone(), pushkey.clone());
56	let suppressed = self.pushing_suppressed(&user_id).map(Ok);
57	let pusher = self
58		.services
59		.pusher
60		.get_pusher(&user_id, &pushkey)
61		.map(|result| match result {
62			| Ok(pusher) => Ok(Some(pusher)),
63			| Err(error) if error.is_not_found() => {
64				error!(%user_id, %pushkey, "Pusher disappeared before delivery");
65
66				Ok(None)
67			},
68			| Err(error) => Err((destination(), error)),
69		});
70
71	let ruleset = has_pdu
72		.then_async(|| self.services.pusher.ruleset(&user_id))
73		.map(Ok);
74
75	let (pusher, ruleset, suppressed) = try_join3(pusher, ruleset, suppressed).await?;
76
77	let Some(pusher) = pusher else {
78		return Ok(Destination::Push(user_id, pushkey));
79	};
80
81	// Reconciliation, not an alert: a suppressed drop strands a stale badge.
82	if events.contains(&SendingEvent::BadgeRefresh) {
83		let result = self
84			.services
85			.pusher
86			.send_badge_notice(&user_id, &pusher)
87			.await;
88
89		match result {
90			| Ok(()) => (),
91			| Err(error) if is_permanent_error(&error) => warn!(
92				%user_id,
93				%pushkey,
94				chain = %error_chain(&error),
95				"Dropping a badge push with a permanent local error",
96			),
97			| Err(error) => return Err((destination(), error)),
98		}
99	}
100
101	if suppressed {
102		let queued = self
103			.enqueue_suppressed_push_events(&user_id, &pushkey, &events)
104			.await;
105
106		debug!(
107			%user_id,
108			%pushkey,
109			queued,
110			events = events.len(),
111			"Push suppressed; queued events"
112		);
113
114		return Ok(Destination::Push(user_id, pushkey));
115	}
116
117	self.schedule_flush_suppressed_for_pushkey(
118		user_id.clone(),
119		pushkey.clone(),
120		"non-suppressed push",
121	);
122
123	let Some(ruleset) = ruleset else {
124		return Ok(Destination::Push(user_id, pushkey));
125	};
126
127	let pdu_ids = || {
128		events
129			.iter()
130			.filter_map(|event| extract_variant!(event, SendingEvent::Pdu))
131	};
132
133	let failures = pdu_ids()
134		.stream()
135		.wide_filter_map(async |pdu_id| {
136			self.services
137				.timeline
138				.get_pdu_from_id(pdu_id)
139				.map_ok(|pdu| (*pdu_id, pdu))
140				.await
141				.ok()
142		})
143		.ready_filter(|(_, pdu)| !pdu.is_redacted())
144		.widen_then(Some(PUSH_WIDTH), async |(pdu_id, pdu)| {
145			let result = self
146				.services
147				.pusher
148				.send_push_notice(&user_id, &pusher, &ruleset, &pdu)
149				.await;
150
151			(pdu_id, result)
152		})
153		.ready_fold(Failures::default(), |failures, (pdu_id, result)| match result {
154			| Ok(()) => failures,
155			| Err(error) if is_permanent_error(&error) => {
156				warn!(
157					%user_id,
158					%pushkey,
159					?pdu_id,
160					chain = %error_chain(&error),
161					"Dropping a push with a permanent local error",
162				);
163
164				failures
165			},
166			| Err(error) => failures.retain(pdu_id, error),
167		})
168		.await;
169
170	let Failures { ids, error: Some(error) } = failures else {
171		return Ok(Destination::Push(user_id, pushkey));
172	};
173
174	let destination = Destination::Push(user_id, pushkey);
175
176	pdu_ids()
177		.filter(|pdu_id| !ids.contains(*pdu_id))
178		.for_each(|pdu_id| {
179			self.db
180				.delete_active_request(&destination.event_key(pdu_id));
181		});
182
183	Err((destination, error))
184}
185
186impl Failures {
187	fn retain(mut self, pdu_id: RawPduId, error: Error) -> Self {
188		self.ids.push(pdu_id);
189		self.error = self.error.or(Some(error));
190
191		self
192	}
193}
194
195#[inline]
196fn is_permanent_error(error: &Error) -> bool {
197	matches!(error, Error::Request(ErrorKind::InvalidParam, ..))
198}