use std::sync::{Arc, Mutex, MutexGuard, PoisonError};
use tokio::sync::watch;
use crate::AxiamError;
use super::exchange::OidcTokenSet;
pub(crate) type OidcRefreshOutcome = Result<OidcTokenSet, Arc<AxiamError>>;
enum OidcRefreshState {
Running,
Settled(Box<OidcRefreshOutcome>),
Cancelled,
}
struct OidcRefreshPublication {
tx: watch::Sender<OidcRefreshState>,
}
impl OidcRefreshPublication {
fn running() -> Self {
Self {
tx: watch::channel(OidcRefreshState::Running).0,
}
}
fn subscribe_if_joinable(&self) -> Option<watch::Receiver<OidcRefreshState>> {
let cancelled = matches!(*self.tx.borrow(), OidcRefreshState::Cancelled);
if cancelled {
None
} else {
Some(self.tx.subscribe())
}
}
fn publish(&self, state: OidcRefreshState) {
let _previous = self.tx.send_replace(state);
}
}
type OidcRefreshSlot = Mutex<Option<Arc<OidcRefreshPublication>>>;
#[cfg(test)]
type AfterPublishHook = Arc<dyn Fn(&OidcRefreshInflight) + Send + Sync>;
pub(crate) struct OidcRefreshInflight {
slot: OidcRefreshSlot,
#[cfg(test)]
after_publish: Mutex<Option<AfterPublishHook>>,
}
pub(crate) enum OidcRefreshElection<'a> {
Leader(OidcRefreshLeader<'a>),
Waiter(OidcRefreshWaiter),
}
pub(crate) struct OidcRefreshWaiter {
rx: watch::Receiver<OidcRefreshState>,
}
#[derive(Debug)]
pub(crate) struct OidcRefreshCancelled;
impl OidcRefreshWaiter {
pub(crate) async fn wait(mut self) -> Result<OidcRefreshOutcome, OidcRefreshCancelled> {
match self
.rx
.wait_for(|state| !matches!(state, OidcRefreshState::Running))
.await
{
Ok(state) => match &*state {
OidcRefreshState::Settled(outcome) => Ok((**outcome).clone()),
OidcRefreshState::Cancelled | OidcRefreshState::Running => {
Err(OidcRefreshCancelled)
}
},
Err(_) => Err(OidcRefreshCancelled),
}
}
}
impl OidcRefreshInflight {
pub(crate) fn new() -> Self {
Self {
slot: Mutex::new(None),
#[cfg(test)]
after_publish: Mutex::new(None),
}
}
fn lock(&self) -> MutexGuard<'_, Option<Arc<OidcRefreshPublication>>> {
self.slot.lock().unwrap_or_else(PoisonError::into_inner)
}
pub(crate) fn elect(&self) -> OidcRefreshElection<'_> {
let mut slot = self.lock();
if let Some(current) = slot.as_ref()
&& let Some(rx) = current.subscribe_if_joinable()
{
return OidcRefreshElection::Waiter(OidcRefreshWaiter { rx });
}
let publication = Arc::new(OidcRefreshPublication::running());
*slot = Some(Arc::clone(&publication));
OidcRefreshElection::Leader(OidcRefreshLeader {
inflight: self,
publication: Some(publication),
})
}
fn retire(&self, mine: &Arc<OidcRefreshPublication>) {
let mut slot = self.lock();
if slot
.as_ref()
.is_some_and(|current| Arc::ptr_eq(current, mine))
{
*slot = None;
}
}
#[cfg(test)]
fn set_after_publish_hook(&self, hook: AfterPublishHook) {
*self
.after_publish
.lock()
.unwrap_or_else(PoisonError::into_inner) = Some(hook);
}
#[cfg(test)]
fn run_after_publish_hook(&self) {
let hook = self
.after_publish
.lock()
.unwrap_or_else(PoisonError::into_inner)
.take();
if let Some(hook) = hook {
hook(self);
}
}
}
pub(crate) struct OidcRefreshLeader<'a> {
inflight: &'a OidcRefreshInflight,
publication: Option<Arc<OidcRefreshPublication>>,
}
impl OidcRefreshLeader<'_> {
pub(crate) fn publish(mut self, result: &Result<OidcTokenSet, AxiamError>) {
let Some(publication) = self.publication.take() else {
return;
};
let shared: OidcRefreshOutcome = match result {
Ok(tokens) => Ok(tokens.clone()),
Err(e) => Err(Arc::new(e.clone_for_waiter())),
};
publication.publish(OidcRefreshState::Settled(Box::new(shared)));
#[cfg(test)]
self.inflight.run_after_publish_hook();
self.inflight.retire(&publication);
}
}
impl Drop for OidcRefreshLeader<'_> {
fn drop(&mut self) {
if let Some(publication) = self.publication.take() {
publication.publish(OidcRefreshState::Cancelled);
#[cfg(test)]
self.inflight.run_after_publish_hook();
self.inflight.retire(&publication);
}
}
}
#[cfg(test)]
mod tests {
use std::sync::atomic::{AtomicUsize, Ordering};
use super::*;
fn token_set(access: &str) -> OidcTokenSet {
OidcTokenSet {
access_token: crate::Sensitive::new(access.to_string()),
token_type: "Bearer".into(),
expires_in: 900,
scope: None,
refresh_token: None,
id_token: None,
id_claims: None,
}
}
async fn coalesced_refresh(
inflight: &OidcRefreshInflight,
wire_calls: &AtomicUsize,
access: &str,
) -> Result<OidcTokenSet, AxiamError> {
match inflight.elect() {
OidcRefreshElection::Waiter(waiter) => match waiter.wait().await {
Ok(Ok(tokens)) => Ok(tokens),
Ok(Err(shared)) => Err(shared.clone_for_waiter()),
Err(OidcRefreshCancelled) => Err(AxiamError::auth("the leader was cancelled")),
},
OidcRefreshElection::Leader(leader) => {
wire_calls.fetch_add(1, Ordering::SeqCst);
let result = Ok(token_set(access));
leader.publish(&result);
result
}
}
}
#[test]
fn the_first_caller_leads_and_the_next_ones_wait() {
let inflight = OidcRefreshInflight::new();
let leader = match inflight.elect() {
OidcRefreshElection::Leader(l) => l,
OidcRefreshElection::Waiter(_) => panic!("first caller must lead"),
};
for _ in 0..4 {
assert!(matches!(inflight.elect(), OidcRefreshElection::Waiter(_)));
}
leader.publish(&Ok(token_set("a")));
assert!(matches!(inflight.elect(), OidcRefreshElection::Leader(_)));
}
#[tokio::test]
async fn waiters_receive_the_leaders_success() {
let inflight = OidcRefreshInflight::new();
let leader = match inflight.elect() {
OidcRefreshElection::Leader(l) => l,
OidcRefreshElection::Waiter(_) => unreachable!(),
};
let mut waiters = Vec::new();
for _ in 0..5 {
match inflight.elect() {
OidcRefreshElection::Waiter(w) => waiters.push(w),
OidcRefreshElection::Leader(_) => panic!("only one leader per burst"),
}
}
leader.publish(&Ok(token_set("shared-access")));
for waiter in waiters {
let outcome = waiter.wait().await.expect("leader published");
assert_eq!(
outcome.expect("success").access_token.expose(),
"shared-access"
);
}
}
#[tokio::test]
async fn waiters_receive_the_leaders_failure_with_the_oauth_payload_intact() {
let inflight = OidcRefreshInflight::new();
let leader = match inflight.elect() {
OidcRefreshElection::Leader(l) => l,
OidcRefreshElection::Waiter(_) => unreachable!(),
};
let waiter = match inflight.elect() {
OidcRefreshElection::Waiter(w) => w,
OidcRefreshElection::Leader(_) => unreachable!(),
};
leader.publish(&Err(AxiamError::oauth_protocol_error(
"invalid_grant",
"refresh token already used",
)));
let err = waiter.wait().await.expect("leader published").unwrap_err();
assert_eq!(
err.as_oauth_protocol_error().map(|o| o.error.as_str()),
Some("invalid_grant")
);
}
#[tokio::test]
async fn a_cancelled_leader_frees_the_slot_and_wakes_waiters() {
let inflight = OidcRefreshInflight::new();
let leader = match inflight.elect() {
OidcRefreshElection::Leader(l) => l,
OidcRefreshElection::Waiter(_) => unreachable!(),
};
let waiter = match inflight.elect() {
OidcRefreshElection::Waiter(w) => w,
OidcRefreshElection::Leader(_) => unreachable!(),
};
drop(leader);
assert!(
matches!(waiter.wait().await, Err(OidcRefreshCancelled)),
"a waiter must not hang when its leader is cancelled"
);
assert!(
matches!(inflight.elect(), OidcRefreshElection::Leader(_)),
"the slot must be free again after a cancelled leader"
);
}
#[tokio::test]
async fn a_caller_inside_the_publish_retire_window_joins_instead_of_calling_the_wire() {
let inflight = OidcRefreshInflight::new();
let wire_calls = Arc::new(AtomicUsize::new(0));
let window_waiter: Arc<Mutex<Option<OidcRefreshWaiter>>> = Arc::new(Mutex::new(None));
let elected_a_second_leader = Arc::new(AtomicUsize::new(0));
let stash = Arc::clone(&window_waiter);
let second_leaders = Arc::clone(&elected_a_second_leader);
inflight.set_after_publish_hook(Arc::new(move |inflight: &OidcRefreshInflight| {
match inflight.elect() {
OidcRefreshElection::Waiter(w) => {
*stash.lock().unwrap() = Some(w);
}
OidcRefreshElection::Leader(_) => {
second_leaders.fetch_add(1, Ordering::SeqCst);
}
}
}));
let leader_tokens = coalesced_refresh(&inflight, &wire_calls, "leader-access")
.await
.expect("the leader's refresh succeeds");
assert_eq!(leader_tokens.access_token.expose(), "leader-access");
assert_eq!(
elected_a_second_leader.load(Ordering::SeqCst),
0,
"a caller inside the publish->retire window must join the burst, not lead a new one"
);
let waiter = window_waiter
.lock()
.unwrap()
.take()
.expect("the window caller became a waiter");
let outcome = waiter
.wait()
.await
.expect("the settled publication is value-retaining")
.expect("and carries the leader's success");
assert_eq!(
outcome.access_token.expose(),
"leader-access",
"the window caller must receive THAT ONE call's outcome (§9 rule 2)"
);
assert_eq!(
wire_calls.load(Ordering::SeqCst),
1,
"exactly one wire call for the whole burst, window caller included (§9 rules 1+2)"
);
}
#[tokio::test]
async fn a_caller_arriving_after_the_burst_settled_starts_a_fresh_refresh() {
let inflight = OidcRefreshInflight::new();
let wire_calls = AtomicUsize::new(0);
let first = coalesced_refresh(&inflight, &wire_calls, "first-burst-access")
.await
.expect("first refresh succeeds");
assert_eq!(first.access_token.expose(), "first-burst-access");
assert_eq!(wire_calls.load(Ordering::SeqCst), 1);
assert!(
inflight.lock().is_none(),
"the leader must vacate the slot before returning"
);
let second = coalesced_refresh(&inflight, &wire_calls, "second-burst-access")
.await
.expect("second refresh succeeds");
assert_eq!(
second.access_token.expose(),
"second-burst-access",
"a caller arriving after the burst settled must get its OWN refresh's tokens"
);
assert_eq!(
wire_calls.load(Ordering::SeqCst),
2,
"a caller arriving after the burst settled must make a fresh wire call"
);
}
#[tokio::test]
async fn a_caller_inside_the_cancel_retire_window_leads_a_fresh_burst() {
let inflight = OidcRefreshInflight::new();
let window_election: Arc<Mutex<Option<&'static str>>> = Arc::new(Mutex::new(None));
let seen = Arc::clone(&window_election);
inflight.set_after_publish_hook(Arc::new(move |inflight: &OidcRefreshInflight| {
let kind = match inflight.elect() {
OidcRefreshElection::Leader(leader) => {
std::mem::forget(leader);
"leader"
}
OidcRefreshElection::Waiter(_) => "waiter",
};
*seen.lock().unwrap() = Some(kind);
}));
let leader = match inflight.elect() {
OidcRefreshElection::Leader(l) => l,
OidcRefreshElection::Waiter(_) => unreachable!(),
};
drop(leader);
assert_eq!(
window_election.lock().unwrap().take(),
Some("leader"),
"a cancelled publication must never be joined"
);
assert!(
inflight.lock().is_some(),
"the cancelled leader's retire must not clear the replacement publication"
);
}
#[tokio::test(flavor = "multi_thread", worker_threads = 8)]
async fn a_multi_thread_burst_of_thirty_two_makes_exactly_one_wire_call() {
const BURST: usize = 32;
let inflight = Arc::new(OidcRefreshInflight::new());
let wire_calls = Arc::new(AtomicUsize::new(0));
let elected = Arc::new(AtomicUsize::new(0));
let mut handles = Vec::with_capacity(BURST);
for _ in 0..BURST {
let inflight = Arc::clone(&inflight);
let wire_calls = Arc::clone(&wire_calls);
let elected = Arc::clone(&elected);
handles.push(tokio::spawn(async move {
let election = inflight.elect();
elected.fetch_add(1, Ordering::SeqCst);
match election {
OidcRefreshElection::Waiter(waiter) => waiter
.wait()
.await
.expect("no leader is cancelled here")
.expect("the leader succeeds"),
OidcRefreshElection::Leader(leader) => {
wire_calls.fetch_add(1, Ordering::SeqCst);
while elected.load(Ordering::SeqCst) < BURST {
tokio::task::yield_now().await;
}
let tokens = token_set("one-and-only-access");
leader.publish(&Ok(tokens.clone()));
tokens
}
}
}));
}
for handle in handles {
let tokens = handle.await.expect("task must not panic");
assert_eq!(
tokens.access_token.expose(),
"one-and-only-access",
"every caller in the burst gets that one call's outcome (§9 rule 2)"
);
}
assert_eq!(
wire_calls.load(Ordering::SeqCst),
1,
"a burst of {BURST} concurrent callers must make exactly one wire call (§9 rules 1+2)"
);
assert!(
inflight.lock().is_none(),
"the slot must be empty once the burst is over"
);
}
}