use crate::time::{Duration, Instant};
use std::collections::HashMap;
use std::sync::Arc;
use serde::{Deserialize, Serialize};
use tokio::sync::{OnceCell, RwLock};
use crate::AxiamError;
use crate::client::AxiamClient;
pub const DISCOVERY_PATH: &str = "/.well-known/openid-configuration";
pub const MIN_DISCOVERY_TTL: Duration = Duration::from_secs(300);
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct MtlsEndpointAliases {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub token_endpoint: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub userinfo_endpoint: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub revocation_endpoint: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub introspection_endpoint: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub device_authorization_endpoint: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub pushed_authorization_request_endpoint: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub backchannel_authentication_endpoint: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct OidcConfiguration {
pub issuer: String,
pub authorization_endpoint: String,
pub token_endpoint: String,
pub userinfo_endpoint: String,
pub jwks_uri: String,
pub revocation_endpoint: String,
pub introspection_endpoint: String,
pub response_types_supported: Vec<String>,
pub subject_types_supported: Vec<String>,
pub id_token_signing_alg_values_supported: Vec<String>,
pub scopes_supported: Vec<String>,
pub token_endpoint_auth_methods_supported: Vec<String>,
pub claims_supported: Vec<String>,
pub grant_types_supported: Vec<String>,
#[serde(default)]
pub code_challenge_methods_supported: Option<Vec<String>>,
#[serde(default)]
pub token_endpoint_auth_signing_alg_values_supported: Option<Vec<String>>,
#[serde(default)]
pub revocation_endpoint_auth_methods_supported: Option<Vec<String>>,
#[serde(default)]
pub introspection_endpoint_auth_methods_supported: Option<Vec<String>>,
#[serde(default)]
pub revocation_endpoint_auth_signing_alg_values_supported: Option<Vec<String>>,
#[serde(default)]
pub introspection_endpoint_auth_signing_alg_values_supported: Option<Vec<String>>,
#[serde(default)]
pub device_authorization_endpoint: Option<String>,
#[serde(default)]
pub pushed_authorization_request_endpoint: Option<String>,
#[serde(default)]
pub backchannel_authentication_endpoint: Option<String>,
#[serde(default)]
pub backchannel_token_delivery_modes_supported: Option<Vec<String>>,
#[serde(default)]
pub backchannel_user_code_parameter_supported: Option<bool>,
#[serde(default)]
pub backchannel_authentication_request_signing_alg_values_supported: Option<Vec<String>>,
#[serde(default)]
pub end_session_endpoint: Option<String>,
#[serde(default)]
pub backchannel_logout_supported: Option<bool>,
#[serde(default)]
pub backchannel_logout_session_supported: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub mtls_endpoint_aliases: Option<MtlsEndpointAliases>,
}
pub(crate) fn normalize_origin(url: &url::Url) -> String {
let scheme = url.scheme().to_ascii_lowercase();
let host = url.host_str().unwrap_or_default().to_ascii_lowercase();
let default_port = match scheme.as_str() {
"https" => 443,
"http" => 80,
_ => 0,
};
let port = url.port().unwrap_or(default_port);
format!("{scheme}://{host}:{port}")
}
struct CacheEntry {
cell: OnceCell<OidcConfiguration>,
created_at: Instant,
}
pub(crate) struct DiscoveryCache {
entries: RwLock<HashMap<String, Arc<CacheEntry>>>,
ttl: Duration,
}
impl DiscoveryCache {
pub(crate) fn new(ttl: Duration) -> Self {
Self {
entries: RwLock::new(HashMap::new()),
ttl: ttl.max(MIN_DISCOVERY_TTL),
}
}
pub(crate) async fn get<F, Fut>(
&self,
origin_key: &str,
fetcher: F,
) -> Result<OidcConfiguration, AxiamError>
where
F: FnOnce() -> Fut,
Fut: std::future::Future<Output = Result<OidcConfiguration, AxiamError>>,
{
{
let entries = self.entries.read().await;
if let Some(entry) = entries.get(origin_key)
&& entry.created_at.elapsed() < self.ttl
{
let entry = Arc::clone(entry);
drop(entries);
let doc = entry.cell.get_or_try_init(fetcher).await?;
return Ok(doc.clone());
}
}
let entry = {
let mut entries = self.entries.write().await;
let fresh = entries
.get(origin_key)
.is_some_and(|e| e.created_at.elapsed() < self.ttl);
if !fresh {
entries.insert(
origin_key.to_string(),
Arc::new(CacheEntry {
cell: OnceCell::new(),
created_at: Instant::now(),
}),
);
}
Arc::clone(
entries
.get(origin_key)
.expect("just inserted or already fresh"),
)
};
let doc = entry.cell.get_or_try_init(fetcher).await?;
Ok(doc.clone())
}
}
impl AxiamClient {
pub async fn oidc_discover(&self) -> Result<OidcConfiguration, AxiamError> {
let origin_key = normalize_origin(self.base_url());
let url = self
.base_url()
.join(DISCOVERY_PATH)
.map_err(|e| AxiamError::Network {
message: format!("invalid discovery URL: {e}"),
source: None,
})?;
let http = self.http().clone();
self.oidc_discovery_cache()
.get(&origin_key, move || async move {
let response = http
.get(url)
.send()
.await
.map_err(|e| AxiamError::Network {
message: format!("oidc discovery request failed: {e}"),
source: Some(Box::new(e)),
})?;
if !response.status().is_success() {
let status = response.status().as_u16();
let message = response
.text()
.await
.unwrap_or_else(|_| "no response body".to_string());
return Err(AxiamError::from_http_status(status, message));
}
response
.json::<OidcConfiguration>()
.await
.map_err(|e| AxiamError::Network {
message: format!("failed to parse discovery document: {e}"),
source: Some(Box::new(e)),
})
})
.await
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn normalize_origin_lowercases_and_fills_default_port() {
let a = url::Url::parse("https://IAM.example.com/").unwrap();
let b = url::Url::parse("https://iam.example.com:443/x").unwrap();
assert_eq!(normalize_origin(&a), normalize_origin(&b));
let c = url::Url::parse("http://iam.example.com").unwrap();
assert_ne!(normalize_origin(&a), normalize_origin(&c));
}
#[test]
fn normalize_origin_handles_a_scheme_with_no_default_port() {
let explicit = url::Url::parse("ftp://iam.example.com:2121/").unwrap();
assert_eq!(normalize_origin(&explicit), "ftp://iam.example.com:2121");
let implicit = url::Url::parse("ftp://iam.example.com/").unwrap();
assert_eq!(normalize_origin(&implicit), "ftp://iam.example.com:0");
assert_ne!(
normalize_origin(&implicit),
normalize_origin(&url::Url::parse("https://iam.example.com/").unwrap())
);
}
}