use std::panic::AssertUnwindSafe;
use std::sync::atomic::{AtomicU64, Ordering};
use std::sync::{Arc, Mutex};
use async_trait::async_trait;
use bytes::Bytes;
use futures_util::FutureExt;
use futures_util::future::{BoxFuture, Shared};
use crate::error::Error;
use crate::http::header::AUTHORIZATION;
use crate::http::{HeaderValue, Request};
use crate::types::SensitiveString;
#[async_trait]
pub trait TokenProvider: Send + Sync {
async fn access_token(&self) -> Result<String, Error>;
fn refreshable(&self) -> bool {
false
}
async fn refresh(&self) -> Result<bool, Error> {
Ok(false)
}
}
#[derive(Debug, Clone)]
pub struct StaticTokenProvider {
token: SensitiveString,
}
impl StaticTokenProvider {
pub fn new(token: impl Into<SensitiveString>) -> StaticTokenProvider {
StaticTokenProvider {
token: token.into(),
}
}
}
#[async_trait]
impl TokenProvider for StaticTokenProvider {
async fn access_token(&self) -> Result<String, Error> {
if self.token.is_empty() {
Err(Error::new(
crate::ErrorCode::AuthRequired,
"no access token configured",
))
} else {
Ok(self.token.expose().to_string())
}
}
}
#[async_trait]
pub trait AuthStrategy: Send + Sync {
async fn authenticate(&self, request: &mut Request<Bytes>) -> Result<(), Error>;
fn refreshable(&self) -> bool {
false
}
fn generation(&self) -> u64 {
0
}
async fn refresh(&self, seen: u64) -> Result<bool, Error> {
let _ = seen;
Ok(false)
}
}
pub struct BearerAuth<P: TokenProvider> {
provider: Arc<P>,
generation: AtomicU64,
state: Mutex<RefreshState>,
}
type RefreshOutcome = Result<bool, Arc<Error>>;
struct RefreshState {
last_renewed: bool,
in_flight: Option<Shared<BoxFuture<'static, RefreshOutcome>>>,
}
impl<P: TokenProvider> BearerAuth<P> {
pub fn new(provider: P) -> BearerAuth<P> {
BearerAuth {
provider: Arc::new(provider),
generation: AtomicU64::new(0),
state: Mutex::new(RefreshState {
last_renewed: false,
in_flight: None,
}),
}
}
pub fn provider(&self) -> &P {
&self.provider
}
}
impl<P: TokenProvider + std::fmt::Debug> std::fmt::Debug for BearerAuth<P> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("BearerAuth")
.field("provider", &self.provider)
.finish_non_exhaustive()
}
}
#[async_trait]
impl<P: TokenProvider + 'static> AuthStrategy for BearerAuth<P> {
async fn authenticate(&self, request: &mut Request<Bytes>) -> Result<(), Error> {
let token = self.provider.access_token().await?;
let mut value = HeaderValue::from_str(&format!("Bearer {token}")).map_err(|_| {
Error::new(
crate::ErrorCode::AuthRequired,
"access token is not a valid header value",
)
})?;
value.set_sensitive(true);
request.headers_mut().insert(AUTHORIZATION, value);
Ok(())
}
fn refreshable(&self) -> bool {
self.provider.refreshable()
}
fn generation(&self) -> u64 {
self.generation.load(Ordering::Acquire)
}
async fn refresh(&self, seen: u64) -> Result<bool, Error> {
let refresh = {
let mut state = self
.state
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner);
if self.generation.load(Ordering::Acquire) != seen {
return Ok(state.last_renewed);
}
state
.in_flight
.get_or_insert_with(|| {
let provider = self.provider.clone();
AssertUnwindSafe(async move { provider.refresh().await })
.catch_unwind()
.map(|caught| match caught {
Ok(outcome) => outcome.map_err(Arc::new),
Err(_) => Err(Arc::new(Error::new(
crate::ErrorCode::AuthRequired,
"the token provider panicked while refreshing",
))),
})
.boxed()
.shared()
})
.clone()
};
let outcome = refresh.await;
{
let mut state = self
.state
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner);
if self.generation.load(Ordering::Acquire) == seen {
state.last_renewed = matches!(outcome, Ok(true));
state.in_flight = None;
self.generation.fetch_add(1, Ordering::AcqRel);
}
}
outcome.map_err(|error| {
Error::new(error.code(), error.message())
.with_status(error.http_status().unwrap_or(401))
.with_source(error)
})
}
}
#[async_trait]
impl<S: AuthStrategy + ?Sized> AuthStrategy for Arc<S> {
async fn authenticate(&self, request: &mut Request<Bytes>) -> Result<(), Error> {
(**self).authenticate(request).await
}
fn refreshable(&self) -> bool {
(**self).refreshable()
}
fn generation(&self) -> u64 {
(**self).generation()
}
async fn refresh(&self, seen: u64) -> Result<bool, Error> {
(**self).refresh(seen).await
}
}
#[async_trait]
impl<P: TokenProvider + ?Sized> TokenProvider for Arc<P> {
async fn access_token(&self) -> Result<String, Error> {
(**self).access_token().await
}
fn refreshable(&self) -> bool {
(**self).refreshable()
}
async fn refresh(&self) -> Result<bool, Error> {
(**self).refresh().await
}
}