tuwunel_service/sending/sender/dispatch/push/
mod.rs1mod 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
23pub(super) const PUSH_WIDTH: usize = 4;
25
26#[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 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}