Skip to main content

moq_wasm/
token.rs

1use std::{
2    future::Future,
3    pin::Pin,
4    sync::Arc,
5    time::{Duration, SystemTime, UNIX_EPOCH},
6};
7
8use anyhow::Context;
9use auth_token::Claims;
10
11/// A token is refreshed this long before it expires, as the browser pages
12/// and the Python SDK do.
13const REFRESH_MARGIN: Duration = Duration::from_secs(5 * 60);
14const RETRY_INTERVAL: Duration = Duration::from_secs(30);
15
16type RefreshFuture = Pin<Box<dyn Future<Output = anyhow::Result<String>> + Send>>;
17
18/// Gets a later token of the same app, given the current one, typically
19/// from the application's app server.
20#[derive(Clone)]
21pub struct RefreshToken(Arc<dyn Fn(String) -> RefreshFuture + Send + Sync>);
22
23impl RefreshToken {
24    pub fn new<F, Fut>(refresh: F) -> Self
25    where
26        F: Fn(String) -> Fut + Send + Sync + 'static,
27        Fut: Future<Output = anyhow::Result<String>> + Send + 'static,
28    {
29        Self(Arc::new(move |token| Box::pin(refresh(token))))
30    }
31}
32
33/// The claims the session reads from its token, without verifying it: the
34/// relay verifies the token, and the session only needs to know when to
35/// refresh it.
36#[derive(Debug, Clone, PartialEq, Eq)]
37pub(crate) struct TokenClaims {
38    pub(crate) app_id: String,
39    /// Unix seconds; `None` for a token that does not expire.
40    pub(crate) expires_at: Option<u64>,
41}
42
43impl TokenClaims {
44    pub(crate) fn read(token: &str) -> anyhow::Result<Self> {
45        let payload =
46            auth_token::decode_unverified_payload(token).context("the token is not a JWT")?;
47        let claims: Claims =
48            serde_json::from_value(payload.into()).context("the token has no appId claim")?;
49        Ok(Self {
50            app_id: claims.app_id,
51            expires_at: claims.exp,
52        })
53    }
54}
55
56/// The token expired before `RefreshToken` returned a later one.
57#[derive(Debug)]
58pub(crate) struct TokenExpired;
59
60/// Refreshes a session's token `REFRESH_MARGIN` before it expires, retrying
61/// every `RETRY_INTERVAL` until it expires.
62pub(crate) struct TokenKeeper {
63    token: String,
64    claims: TokenClaims,
65    refresh: RefreshToken,
66}
67
68impl TokenKeeper {
69    pub(crate) fn new(token: String, refresh: RefreshToken) -> anyhow::Result<Self> {
70        Ok(Self {
71            claims: TokenClaims::read(&token)?,
72            token,
73            refresh,
74        })
75    }
76
77    /// Calls `hand_over` with each new token and its app ID. Returns
78    /// `Ok(())` once the current token does not expire, and `Err` once it
79    /// expired unrefreshed.
80    pub(crate) async fn keep_fresh<F, Fut>(mut self, hand_over: F) -> Result<(), TokenExpired>
81    where
82        F: Fn(String, String) -> Fut,
83        Fut: Future<Output = ()>,
84    {
85        while let Some(expires_at) = self.claims.expires_at {
86            tokio::time::sleep(refresh_delay(expires_at, unix_now())).await;
87            self.renew().await?;
88            hand_over(self.token.clone(), self.claims.app_id.clone()).await;
89        }
90        Ok(())
91    }
92
93    async fn renew(&mut self) -> Result<(), TokenExpired> {
94        loop {
95            let refreshed = (self.refresh.0)(self.token.clone())
96                .await
97                .and_then(|token| Ok((TokenClaims::read(&token)?, token)));
98            match refreshed {
99                Ok((claims, token)) => {
100                    self.claims = claims;
101                    self.token = token;
102                    return Ok(());
103                }
104                Err(error) => {
105                    let app_id = &self.claims.app_id;
106                    if self.claims.expires_at.is_some_and(|expires_at| {
107                        unix_now() + RETRY_INTERVAL.as_secs() >= expires_at
108                    }) {
109                        tracing::error!(error = %format!("{error:#}"), app_id, "the token expired");
110                        return Err(TokenExpired);
111                    }
112                    tracing::warn!(error = %format!("{error:#}"), app_id, "cannot refresh the token yet");
113                    tokio::time::sleep(RETRY_INTERVAL).await;
114                }
115            }
116        }
117    }
118}
119
120fn refresh_delay(expires_at: u64, now: u64) -> Duration {
121    Duration::from_secs(
122        expires_at
123            .saturating_sub(REFRESH_MARGIN.as_secs())
124            .saturating_sub(now),
125    )
126}
127
128fn unix_now() -> u64 {
129    SystemTime::now()
130        .duration_since(UNIX_EPOCH)
131        .map_or(0, |elapsed| elapsed.as_secs())
132}
133
134#[cfg(test)]
135mod tests {
136    use std::sync::Mutex;
137
138    use auth_token::sign_token;
139
140    use super::*;
141
142    fn token(app_id: &str, exp: Option<u64>) -> String {
143        let claims = Claims {
144            app_id: app_id.to_string(),
145            publish: None,
146            subscribe: None,
147            bots: None,
148            iat: None,
149            exp,
150            relay_id: None,
151        };
152        sign_token(&claims, "secret").unwrap()
153    }
154
155    #[test]
156    fn the_claims_are_read_without_the_secret() {
157        // Arrange
158        let token = token("app", Some(1_000));
159
160        // Act
161        let claims = TokenClaims::read(&token).unwrap();
162
163        // Assert
164        assert_eq!(
165            claims,
166            TokenClaims {
167                app_id: "app".to_string(),
168                expires_at: Some(1_000),
169            }
170        );
171    }
172
173    #[test]
174    fn what_is_not_a_token_is_refused() {
175        // Act / Assert
176        assert!(TokenClaims::read("not a token").is_err());
177    }
178
179    #[test]
180    fn a_token_is_refreshed_five_minutes_before_it_expires_or_at_once() {
181        // Act / Assert
182        assert_eq!(refresh_delay(1_000, 600), Duration::from_secs(100));
183        assert_eq!(refresh_delay(1_000, 900), Duration::ZERO);
184    }
185
186    #[tokio::test]
187    async fn each_refreshed_token_is_handed_over() {
188        // Arrange: the first token is due now, the second never expires
189        let first = token("app", Some(unix_now() + 60));
190        let second = token("app", None);
191        let refreshed = second.clone();
192        let keeper = TokenKeeper::new(
193            first,
194            RefreshToken::new(move |_| {
195                let refreshed = refreshed.clone();
196                async move { Ok(refreshed) }
197            }),
198        )
199        .unwrap();
200        let handed_over = Mutex::new(Vec::new());
201
202        // Act
203        let result = keeper
204            .keep_fresh(|token, app_id| {
205                handed_over.lock().unwrap().push((token, app_id));
206                async {}
207            })
208            .await;
209
210        // Assert
211        assert!(result.is_ok());
212        assert_eq!(
213            handed_over.into_inner().unwrap(),
214            vec![(second, "app".to_string())]
215        );
216    }
217
218    #[tokio::test]
219    async fn the_keeper_fails_once_the_token_expires_while_refreshing_fails() {
220        // Arrange: the token expires within the retry interval
221        let keeper = TokenKeeper::new(
222            token("app", Some(unix_now() + 10)),
223            RefreshToken::new(|_| async { anyhow::bail!("app server down") }),
224        )
225        .unwrap();
226
227        // Act
228        let result = keeper.keep_fresh(|_, _| async {}).await;
229
230        // Assert
231        assert!(result.is_err());
232    }
233}