use std::sync::{Arc, Mutex};
use tokio::sync::watch;
use super::{Error, Token};
use crate::sync::lock;
pub(super) type Source = Arc<dyn Fn() -> Result<Token, Error> + Send + Sync>;
type Read = Option<Result<Token, String>>;
pub(super) struct Tokens {
source: Source,
state: Arc<Mutex<Hold>>,
}
enum Hold {
Missing,
Held(Token),
Reading(watch::Receiver<Read>),
}
impl Tokens {
pub(super) fn new(source: Source) -> Tokens {
Tokens {
source,
state: Arc::new(Mutex::new(Hold::Missing)),
}
}
pub(super) async fn get(&self, refused: Option<&Token>) -> Result<Token, Error> {
let mut answer = {
let mut state = lock(&self.state);
match &*state {
Hold::Held(token) if refused.is_none_or(|refused| refused.0 != token.0) => {
return Ok(token.clone());
}
Hold::Reading(answer) => answer.clone(),
Hold::Held(_) | Hold::Missing => self.start(&mut state)?,
}
};
let read = answer
.wait_for(Option::is_some)
.await
.map_err(|_| Error::Token("the token read stopped".to_owned()))?
.clone();
match read {
Some(Ok(token)) => Ok(token),
Some(Err(message)) => Err(Error::Token(message)),
None => Err(Error::Token("the token read gave nothing".to_owned())),
}
}
fn start(&self, state: &mut Hold) -> Result<watch::Receiver<Read>, Error> {
let (send, answer) = watch::channel(None);
let source = self.source.clone();
let shared = self.state.clone();
std::thread::Builder::new()
.name("github-token".to_owned())
.spawn(move || {
let read = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| source()))
.unwrap_or_else(|_| Err(Error::Token("the token read failed".to_owned())));
*lock(&shared) = match &read {
Ok(token) => Hold::Held(token.clone()),
Err(_) => Hold::Missing,
};
send.send_replace(Some(read.map_err(|error| match error {
Error::Token(message) => message,
other => other.to_string(),
})));
})
.map_err(|error| Error::Token(format!("cannot start the token read: {error}")))?;
*state = Hold::Reading(answer.clone());
Ok(answer)
}
}