tuwunel_service/migrations/
token_expiry.rs1use std::{pin::pin, sync::Arc};
2
3use futures::{TryFutureExt, TryStreamExt};
4use ruma::{DeviceId, UserId};
5use tuwunel_core::{Result, debug_warn, err, info, warn};
6use tuwunel_database::Map;
7
8use crate::{
9 Services,
10 integrity::token_expiry::{Row, Token, origin, rows, token},
11};
12
13pub(super) const ADOPT_MARKER: &str = "adopt_foreign_token_expiry";
18
19pub(super) const RESTORE_MARKER: &str = "restore_foreign_token_expiry";
24
25#[derive(Default)]
31struct Tally {
32 applied: usize,
33 skipped: usize,
34 unreadable: usize,
35}
36
37#[derive(Clone, Copy)]
43enum Mode {
44 Probe,
46
47 Adopt,
49
50 Restore,
52}
53
54pub(super) enum Restore {
59 Finished,
61
62 Waiting,
64
65 Due(Arc<Map>),
67}
68
69#[tracing::instrument(level = "debug", skip_all)]
82pub(super) async fn migrate(services: &Services) -> Result<bool> {
83 let Some(tokenexpires) = origin(services)? else {
84 return Ok(true);
85 };
86
87 adopt(services, &tokenexpires).await
88}
89
90#[tracing::instrument(level = "debug", skip_all)]
96pub(super) async fn adopt(services: &Services, tokenexpires: &Arc<Map>) -> Result<bool> {
97 if services.oauth.get_server().is_err() {
98 let waiting = probe(services, tokenexpires).await?;
99
100 if waiting {
101 info!("Migrated OAuth sessions keep their origin lifetime; no OIDC provider");
102 }
103
104 return Ok(!waiting);
105 }
106
107 let Tally { applied: adopted, skipped, .. } =
108 walk(services, tokenexpires, Mode::Adopt).await?;
109
110 if adopted > 0 || skipped > 0 {
113 info!(%adopted, %skipped, "Adopted token expiry from a foreign database");
114 }
115
116 Ok(true)
117}
118
119pub(super) fn restore_due(services: &Services) -> Result<Restore> {
129 let Some(tokenexpires) = origin(services)? else {
130 return Ok(Restore::Finished);
131 };
132
133 if services.oauth.get_server().is_ok() {
134 return Ok(Restore::Waiting);
135 }
136
137 Ok(Restore::Due(tokenexpires))
138}
139
140#[tracing::instrument(level = "debug", skip_all)]
147pub(super) async fn restore(services: &Services, tokenexpires: &Arc<Map>) -> Result {
148 let Tally { applied: restored, skipped, .. } =
149 walk(services, tokenexpires, Mode::Restore).await?;
150
151 if restored > 0 || skipped > 0 {
152 info!(
153 %restored,
154 %skipped,
155 "Restored the origin lifetime of adopted OAuth sessions; no OIDC provider"
156 );
157 }
158
159 Ok(())
160}
161
162async fn probe(services: &Services, tokenexpires: &Arc<Map>) -> Result<bool> {
167 let mut adoptable = pin!(rows(services, tokenexpires).try_filter_map(|row| {
168 apply_one(services, row, Mode::Probe).map_ok(|adoptable| adoptable.then_some(()))
169 }));
170
171 adoptable
172 .try_next()
173 .map_ok(|hit| hit.is_some())
174 .await
175}
176
177async fn walk(services: &Services, tokenexpires: &Arc<Map>, mode: Mode) -> Result<Tally> {
186 let cork = services.db.cork_and_sync();
187
188 let tally = rows(services, tokenexpires)
189 .try_fold(Tally::default(), async |tally, row| {
190 let result = apply_one(services, row, mode)
191 .inspect_err(|e| warn!(error = %e, "a token expiry could not be read"))
192 .await;
193
194 Ok(tally.record(&result))
195 })
196 .await?;
197
198 drop(cork);
199
200 let unreadable = tally.unreadable;
201
202 unreadable
203 .eq(&0)
204 .then_some(tally)
205 .ok_or_else(|| err!(Database("{unreadable} token expiries could not be read")))
206}
207
208impl Tally {
209 fn record(mut self, result: &Result<bool>) -> Self {
210 let count = match result {
211 | Ok(true) => &mut self.applied,
212 | Ok(false) => &mut self.skipped,
213 | Err(_) => &mut self.unreadable,
214 };
215
216 *count = count.saturating_add(1);
217 self
218 }
219}
220
221async fn apply_one(services: &Services, row: Row, mode: Mode) -> Result<bool> {
230 let (user_id, device_id, expires) = match row {
231 | Row::Expiry { user_id, device_id, expires, .. } => (user_id, device_id, expires),
232 | Row::UnparsableDevice { .. } => {
233 warn!("skipping a foreign token expiry whose device could not be read");
234 return Ok(false);
235 },
236 | Row::UnparsableExpiry { user_id, device_id } => {
237 warn!(%user_id, %device_id, "skipping a foreign token expiry that could not be read");
238 return Ok(false);
239 },
240 };
241
242 let held = match (token(services, &user_id, &device_id, expires).await?, mode) {
243 | (Token::Adoptable(held), Mode::Probe | Mode::Adopt)
244 | (Token::Adopted(held), Mode::Restore) => held,
245 | (token, _) => {
246 skip(&token, &user_id, &device_id);
247 return Ok(false);
248 },
249 };
250
251 let token_owners = &services.db["token_userdeviceid"];
252 let (owner, device) = (&*held.user_id, &*held.device_id);
253
254 match mode {
255 | Mode::Probe => {},
256 | Mode::Adopt => {
257 token_owners.raw_put(held.token.as_str(), (owner, device, Some(expires)));
258 info!(%user_id, %device_id, "adopted the origin expiry of an access token");
259 },
260 | Mode::Restore => {
261 token_owners.raw_put(held.token.as_str(), (owner, device));
262 info!(%user_id, %device_id, "restored the origin lifetime of an access token");
263 },
264 }
265
266 Ok(true)
267}
268
269fn skip(token: &Token, user_id: &UserId, device_id: &DeviceId) {
270 match token {
271 | Token::Absent => {
272 debug_warn!(%user_id, %device_id, "skipping a device holding no access token here");
273 },
274 | Token::Unparsable => {
275 warn!(%user_id, %device_id, "skipping a device whose stored token could not be read");
276 },
277 | Token::Unheld => {
278 debug_warn!(%user_id, %device_id, "skipping an access token this server does not hold");
279 },
280 | Token::UnparsableValue => {
281 warn!(%user_id, %device_id, "skipping a token value that could not be read");
282 },
283 | Token::Adoptable(_) | Token::Adopted(_) | Token::Kept => {
284 debug_warn!(%user_id, %device_id, "skipping a token value this pass leaves as stored");
285 },
286 }
287}