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
11const 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#[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#[derive(Debug, Clone, PartialEq, Eq)]
37pub(crate) struct TokenClaims {
38 pub(crate) app_id: String,
39 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#[derive(Debug)]
58pub(crate) struct TokenExpired;
59
60pub(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 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 let token = token("app", Some(1_000));
159
160 let claims = TokenClaims::read(&token).unwrap();
162
163 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 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 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 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 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!(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 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 let result = keeper.keep_fresh(|_, _| async {}).await;
229
230 assert!(result.is_err());
232 }
233}