1mod evaluate;
11mod render;
12#[cfg(test)]
13mod tests;
14
15use std::{collections::BTreeMap, pin::pin, time::Duration};
16
17use futures::{
18 FutureExt, StreamExt,
19 future::{Either, select},
20 stream::unfold,
21};
22use loole::{Receiver, Sender, unbounded};
23use ruma::{
24 OwnedUserId, UserId,
25 api::client::push::{PusherKind, set_pusher::v3::PusherAction},
26};
27use tokio::time::{Instant, sleep_until};
28use tuwunel_core::{
29 Result, implement,
30 result::NotFound,
31 smallstr::SmallString,
32 utils::{
33 MutexMap, MutexMapGuard, OptionExt, exponential_backoff_remaining, stream::TryIgnore,
34 time::now_millis,
35 },
36 warn,
37};
38use tuwunel_database::{Deserialized, Interfix, Json};
39
40pub use self::evaluate::Outcome;
41
42type PusherKey = (OwnedUserId, PushKey);
46
47type PushKey = SmallString<[u8; 48]>;
48
49pub(super) type Locks = MutexMap<PusherKey, ()>;
55
56type Schedule = BTreeMap<PusherKey, Entry>;
65
66type Wake = (PusherKey, u64);
71
72pub(super) struct Wakes {
76 sender: Sender<Wake>,
77 receiver: Receiver<Wake>,
78}
79
80#[derive(Clone, Copy, Debug)]
81struct Entry {
82 due: Instant,
83 failures: u32,
84
85 frontier: Option<u64>,
88}
89
90enum Next {
91 Wake(Wake),
92 Due(PusherKey),
93}
94
95const BOOT_GRACE: Duration = Duration::from_mins(1);
99
100const RETRY_MIN: Duration = Duration::from_mins(1);
101
102const RETRY_MAX: Duration = Duration::from_hours(6);
103
104const WAIT_MAX: Duration = Duration::from_hours(30 * 24);
108
109impl Default for Wakes {
110 fn default() -> Self {
111 let (sender, receiver) = unbounded();
112
113 Self { sender, receiver }
114 }
115}
116
117#[implement(super::Service)]
126pub(super) async fn put_pusher(&self, user_id: &UserId, pushkey: &str, action: &PusherAction) {
127 let email = matches!(
128 action,
129 PusherAction::Post(data) if matches!(data.pusher.kind, PusherKind::Email(_))
130 );
131
132 let _lock = self.email_lock(user_id, pushkey).await;
133 let created = email && matches!(self.email_pusher(user_id, pushkey).await, Ok(None));
134
135 if created {
136 let cursor = self.services.globals.pending_count().end;
137
138 self.forget_throttles(user_id, pushkey).await;
139 self.put_cursor(user_id, pushkey, cursor);
140 }
141
142 self.db
143 .senderkey_pusher
144 .put((user_id, pushkey), Json(action));
145}
146
147#[implement(super::Service)]
148pub(super) async fn email_lock(
149 &self,
150 user_id: &UserId,
151 pushkey: &str,
152) -> MutexMapGuard<PusherKey, ()> {
153 self.email_locks
154 .lock(&pusher_key(user_id, pushkey))
155 .await
156}
157
158fn pusher_key(user_id: &UserId, pushkey: &str) -> PusherKey {
159 (user_id.to_owned(), pushkey.into())
160}
161
162#[implement(super::Service)]
166pub(super) async fn forget_email_state(&self, user_id: &UserId, pushkey: &str) {
167 self.db
168 .senderkey_emailcursor
169 .del((user_id, pushkey));
170
171 self.forget_throttles(user_id, pushkey).await;
172}
173
174#[implement(super::Service)]
178async fn forget_throttles(&self, user_id: &UserId, pushkey: &str) {
179 self.db
180 .senderkeyroom_emailthrottle
181 .del_prefix(&(user_id, pushkey, Interfix))
182 .await;
183}
184
185#[implement(super::Service)]
190fn put_cursor(&self, user_id: &UserId, pushkey: &str, cursor: u64) {
191 self.db
192 .senderkey_emailcursor
193 .put((user_id, pushkey), cursor);
194}
195
196#[implement(super::Service)]
202pub(super) fn wake_email(&self, user_id: &UserId, pushkey: &str) {
203 if !self.services.sendmail.is_enabled() {
204 return;
205 }
206
207 let frontier = self.services.globals.current_count();
208 let wake = (pusher_key(user_id, pushkey), frontier);
209
210 self.email_wakes.sender.send(wake).ok();
211}
212
213#[implement(super::Service)]
217pub(super) fn close_email_wakes(&self) { self.email_wakes.sender.close(); }
218
219#[implement(super::Service)]
225#[tracing::instrument(name = "email", level = "debug", skip_all)]
226pub(super) async fn email_worker(&self) {
227 let schedule = self.boot_schedule().await;
228
229 unfold(schedule, async |schedule| {
230 let schedule = match self.wait_next(&schedule).await? {
231 | Next::Wake(wake) => self.schedule_wake(schedule, wake).await,
232 | Next::Due(key) => self.evaluate_due(schedule, key).await,
233 };
234
235 Some(((), schedule))
236 })
237 .collect::<()>()
238 .await;
239}
240
241#[implement(super::Service)]
246#[tracing::instrument(level = "debug", skip_all)]
247async fn boot_schedule(&self) -> Schedule {
248 let entry = entry_in(BOOT_GRACE, 0);
249
250 self.db
251 .senderkey_emailcursor
252 .keys()
253 .ignore_err()
254 .map(|(user_id, pushkey): (&UserId, &str)| (pusher_key(user_id, pushkey), entry))
255 .collect()
256 .await
257}
258
259#[implement(super::Service)]
265async fn wait_next(&self, schedule: &Schedule) -> Option<Next> {
266 let receiver = &self.email_wakes.receiver;
267 let received = receiver
268 .recv_async()
269 .map(|wake| wake.ok().map(Next::Wake));
270
271 let Some((key, entry)) = schedule
272 .iter()
273 .min_by_key(|(_, entry)| entry.due)
274 .filter(|_| !receiver.is_closed())
275 else {
276 return received.await;
277 };
278
279 match select(pin!(sleep_until(entry.due)), pin!(received)).await {
280 | Either::Left(((), _)) if !receiver.is_closed() => Some(Next::Due(key.clone())),
281 | Either::Left(((), received)) => received.await,
282 | Either::Right((wake, _)) => wake,
283 }
284}
285
286#[implement(super::Service)]
292async fn schedule_wake(&self, schedule: Schedule, (key, frontier): Wake) -> Schedule {
293 let frontier = kept_frontier(&schedule, &key).map_or(frontier, |kept| kept.min(frontier));
294 let kept = self.start_cursor(&key, frontier).await;
295 let delay = Duration::from_secs(self.services.config.push.email_delay);
296
297 woken(schedule, key, Entry { frontier: kept, ..entry_in(delay, 0) })
298}
299
300fn kept_frontier(schedule: &Schedule, key: &PusherKey) -> Option<u64> {
302 schedule.get(key)?.frontier
303}
304
305#[implement(super::Service)]
315async fn start_cursor(&self, key: &PusherKey, frontier: u64) -> Option<u64> {
316 let _lock = self.email_locks.lock(key).await;
317 let (user_id, pushkey) = key;
318
319 match self.email_cursor(user_id, pushkey).await {
320 | Ok(Some(_)) => None,
321 | Err(error) => error.is_transient_io().then_some(frontier),
322 | Ok(None) => {
323 self.put_cursor(user_id, pushkey, frontier);
324
325 None
326 },
327 }
328}
329
330#[implement(super::Service)]
335async fn email_cursor(&self, user_id: &UserId, pushkey: &str) -> Result<Option<u64>> {
336 self.db
337 .senderkey_emailcursor
338 .qry(&(user_id, pushkey))
339 .await
340 .deserialized()
341 .present()
342 .inspect_err(|error| warn!(%user_id, %error, "Failed to read an email cursor"))
343}
344
345#[implement(super::Service)]
350async fn evaluate_due(&self, schedule: Schedule, key: PusherKey) -> Schedule {
351 let kept = kept_frontier(&schedule, &key)
352 .map_async(|frontier| self.start_cursor(&key, frontier))
353 .await
354 .flatten();
355
356 if kept.is_some() {
357 return reschedule(schedule, key, Outcome::Failed, kept);
358 }
359
360 let (user_id, pushkey) = &key;
361 let outcome = self
362 .evaluate_email(user_id, pushkey, now_millis())
363 .await;
364
365 reschedule(schedule, key, outcome, None)
366}
367
368fn woken(mut schedule: Schedule, key: PusherKey, entry: Entry) -> Schedule {
373 schedule
374 .entry(key)
375 .and_modify(|current| {
376 current.frontier = entry.frontier;
377 if current.failures == 0 {
378 current.due = current.due.min(entry.due);
379 }
380 })
381 .or_insert(entry);
382
383 schedule
384}
385
386fn reschedule(
392 mut schedule: Schedule,
393 key: PusherKey,
394 outcome: Outcome,
395 kept: Option<u64>,
396) -> Schedule {
397 let failures = schedule
398 .remove(&key)
399 .map_or(0, |entry| entry.failures);
400
401 let entry = next_entry(outcome, failures).map(|entry| Entry { frontier: kept, ..entry });
402
403 schedule.extend(entry.map(|entry| (key, entry)));
404 schedule
405}
406
407fn next_entry(outcome: Outcome, failures: u32) -> Option<Entry> {
412 match outcome {
413 | Outcome::Sent | Outcome::Idle => None,
414 | Outcome::Pending(due) => {
415 let wait = Duration::from_millis(due.saturating_sub(now_millis()));
416
417 Some(entry_in(wait, 0))
418 },
419 | Outcome::Failed => {
420 let failures = failures.saturating_add(1);
421 let wait =
422 exponential_backoff_remaining(RETRY_MIN, RETRY_MAX, Duration::ZERO, failures)
423 .unwrap_or(RETRY_MIN);
424
425 Some(entry_in(wait, failures))
426 },
427 }
428}
429
430fn entry_in(wait: Duration, failures: u32) -> Entry {
431 let now = Instant::now();
432 let due = now.checked_add(wait.min(WAIT_MAX)).unwrap_or(now);
433
434 Entry { due, failures, frontier: None }
435}