refactor(ocr): integrate shared authentication primitives

This commit is contained in:
Yujong Lee 2026-09-04 11:49:03 -07:00
parent 98f05d52d7
commit a13ef695ec
5 changed files with 146 additions and 27 deletions

View file

@ -7,6 +7,8 @@ repository.workspace = true
[dependencies]
async-trait = "0.1"
azure_core = "1.0.0"
azure_identity = { version = "1.0.0", features = ["tokio"] }
base64.workspace = true
google-cloud-auth = { version = "=1.15.0", default-features = false, features = ["default-rustls-provider"] }
rand.workspace = true
@ -14,9 +16,8 @@ reqwest.workspace = true
serde.workspace = true
serde_json.workspace = true
thiserror.workspace = true
tokio = { workspace = true, features = ["net", "sync", "time"] }
tokio = { workspace = true, features = ["net", "rt", "sync", "time"] }
tracing.workspace = true
tokio = { workspace = true, features = ["sync", "rt"] }
tracing-subscriber = { workspace = true, optional = true }
sha2.workspace = true
aws-config = { version = "1.9.0", default-features = false, features = ["rustls", "rt-tokio"], optional = true }

View file

@ -57,6 +57,96 @@ impl fmt::Debug for SecretString {
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum AuthHeaderKind {
Bearer,
Header(&'static str),
}
impl AuthHeaderKind {
pub fn header_name(self) -> &'static str {
match self {
Self::Bearer => "authorization",
Self::Header(name) => name,
}
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum ResolvedAuth {
Bearer(SecretString),
Header {
name: &'static str,
value: SecretString,
},
}
impl ResolvedAuth {
pub fn from_credential(kind: AuthHeaderKind, credential: impl Into<String>) -> Self {
let credential = SecretString::new(credential);
match kind {
AuthHeaderKind::Bearer => Self::Bearer(credential),
AuthHeaderKind::Header(name) => Self::Header {
name,
value: credential,
},
}
}
pub fn header_name(&self) -> &'static str {
match self {
Self::Bearer(_) => "authorization",
Self::Header { name, .. } => name,
}
}
pub fn credential_header(&self) -> (String, String) {
match self {
Self::Bearer(token) => (
"Authorization".to_string(),
format!("Bearer {}", token.expose()),
),
Self::Header { name, value } => ((*name).to_string(), value.expose().to_string()),
}
}
pub fn from_header(kind: AuthHeaderKind, value: &str) -> Option<Self> {
match kind {
AuthHeaderKind::Bearer => value
.trim()
.split_once(char::is_whitespace)
.filter(|(scheme, token)| {
scheme.eq_ignore_ascii_case("bearer") && !token.trim().is_empty()
})
.map(|(_, token)| Self::Bearer(SecretString::new(token.trim()))),
AuthHeaderKind::Header(name) if !value.trim().is_empty() => Some(Self::Header {
name,
value: SecretString::new(value),
}),
AuthHeaderKind::Header(_) => None,
}
}
pub fn apply_preserving_existing(
&self,
mut headers: Vec<(String, String)>,
) -> Vec<(String, String)> {
if !crate::http_utils::has_header(&headers, self.header_name()) {
headers.push(self.credential_header());
}
headers
}
pub fn apply_replacing_existing(
&self,
mut headers: Vec<(String, String)>,
) -> Vec<(String, String)> {
headers.retain(|(name, _)| !name.eq_ignore_ascii_case(self.header_name()));
headers.push(self.credential_header());
headers
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum AuthErrorKind {
MissingCredential,
@ -103,9 +193,11 @@ pub struct TokenLease {
pub expires_at: Instant,
}
pub type ExpiringToken = TokenLease;
#[async_trait]
pub trait TokenProvider: Send + Sync {
async fn token(&self) -> Result<TokenLease, AuthError>;
async fn token(&self) -> Result<TokenLease, Error>;
}
#[derive(Clone, PartialEq, Eq, Hash)]
@ -174,11 +266,11 @@ impl TokenCache {
.clone()
}
pub async fn token(
pub async fn token_cached(
self: &Arc<Self>,
key: TokenCacheKey,
provider: Arc<dyn TokenProvider>,
) -> Result<SecretString, AuthError> {
) -> Result<SecretString, Error> {
let entry = self.entry(key).await;
let now = self.clock.now();
let cached = entry.lease.read().await.clone();
@ -213,7 +305,7 @@ impl TokenCache {
&self,
entry: Arc<TokenEntry>,
provider: Arc<dyn TokenProvider>,
) -> Result<SecretString, AuthError> {
) -> Result<SecretString, Error> {
let _guard = entry.refresh.lock().await;
let now = self.clock.now();
if let Some(lease) = entry.lease.read().await.as_ref()
@ -223,10 +315,8 @@ impl TokenCache {
}
let lease = provider.token().await?;
if lease.expires_at <= self.clock.now() {
return Err(AuthError::new(
AuthErrorKind::CredentialUnavailable,
"expired_token",
"credential provider returned an expired token",
return Err(Error::Auth(
"credential provider returned an expired token".to_string(),
));
}
let token = lease.token.clone();
@ -239,6 +329,31 @@ impl TokenCache {
*entry.lease.write().await = None;
}
}
pub async fn token(
&self,
key: String,
provider: &dyn TokenProvider,
) -> Result<SecretString, Error> {
let key = TokenCacheKey::fingerprint([key.as_bytes()]);
let entry = self.entry(key).await;
let _guard = entry.refresh.lock().await;
let now = self.clock.now();
if let Some(lease) = entry.lease.read().await.as_ref()
&& lease.expires_at.saturating_duration_since(now) > self.refresh_before
{
return Ok(lease.token.clone());
}
let lease = provider.token().await?;
if lease.expires_at <= self.clock.now() {
return Err(Error::Auth(
"credential provider returned an expired token".to_string(),
));
}
let token = lease.token.clone();
*entry.lease.write().await = Some(lease);
Ok(token)
}
}
#[derive(Clone)]
@ -393,7 +508,7 @@ mod tests {
#[async_trait]
impl TokenProvider for CountingProvider {
async fn token(&self) -> Result<TokenLease, AuthError> {
async fn token(&self) -> Result<TokenLease, Error> {
let call = self.calls.fetch_add(1, Ordering::SeqCst) + 1;
Ok(TokenLease {
token: SecretString::new(format!("token-{call}")),
@ -415,7 +530,7 @@ mod tests {
let cache = cache.clone();
let provider = provider.clone();
let key = key.clone();
tokio::spawn(async move { cache.token(key, provider).await.unwrap() })
tokio::spawn(async move { cache.token_cached(key, provider).await.unwrap() })
});
for request in requests {
assert_eq!(request.await.unwrap().expose(), "token-1");

View file

@ -15,8 +15,8 @@ use sha2::{Digest, Sha256};
use crate::Error;
use crate::auth::{
AuthHeaderKind, Environment, ExpiringToken, ResolvedAuth, SecretString, TokenCache,
TokenProvider,
AuthHeaderKind, Environment, ExpiringToken, ResolvedAuth, SecretString, SystemClock,
TokenCache, TokenProvider,
};
use crate::constants::{AZURE_AUTH_DEFAULT_SCOPE, AZURE_AUTH_TOKEN_REFRESH_WINDOW_SECS};
@ -417,7 +417,10 @@ pub async fn resolve_azure_auth(input: AzureAuthInput<'_>) -> Result<ResolvedAut
let provider = AzureTokenProvider { credential, scope };
let token = TOKENS
.get_or_init(|| {
TokenCache::new(Duration::from_secs(AZURE_AUTH_TOKEN_REFRESH_WINDOW_SECS))
TokenCache::new(
Duration::from_secs(AZURE_AUTH_TOKEN_REFRESH_WINDOW_SECS),
Arc::new(SystemClock),
)
})
.token(key, &provider)
.await?;

View file

@ -1,5 +1,5 @@
use std::collections::HashMap;
use std::sync::OnceLock;
use std::sync::{Arc, OnceLock};
use std::time::{Duration, Instant};
use async_trait::async_trait;
@ -13,7 +13,7 @@ use tokio::sync::Mutex;
use crate::Error;
use crate::auth::{
Environment, ExpiringToken, ResolvedAuth, SecretString, TokenCache, TokenProvider,
Environment, ExpiringToken, ResolvedAuth, SecretString, SystemClock, TokenCache, TokenProvider,
};
use crate::constants::{
VERTEX_AUTH_CLOUD_PLATFORM_SCOPE, VERTEX_AUTH_SDK_TOKEN_CACHE_TTL_SECS,
@ -225,7 +225,10 @@ pub async fn resolve_vertex_auth(
};
TOKENS
.get_or_init(|| {
TokenCache::new(Duration::from_secs(VERTEX_AUTH_TOKEN_REFRESH_WINDOW_SECS))
TokenCache::new(
Duration::from_secs(VERTEX_AUTH_TOKEN_REFRESH_WINDOW_SECS),
Arc::new(SystemClock),
)
})
.token(key, &provider)
.await?

View file

@ -1,7 +1,8 @@
use std::time::{Duration, Instant, SystemTime};
use async_trait::async_trait;
use litellm_core::auth::{AuthError, AuthErrorKind, SecretString, TokenLease, TokenProvider};
use litellm_core::Error;
use litellm_core::auth::{SecretString, TokenLease, TokenProvider};
use pyo3::exceptions::{PyRuntimeError, PyTypeError};
use pyo3::prelude::*;
use pyo3::types::{PyAny, PyTuple};
@ -90,14 +91,10 @@ fn parse_token_result(value: &Bound<'_, PyAny>) -> PyResult<Option<TokenLease>>
#[async_trait]
impl TokenProvider for PythonTokenProvider {
async fn token(&self) -> Result<TokenLease, AuthError> {
self.resolve().await.map_err(|_| {
AuthError::new(
AuthErrorKind::ExternalProviderFailed,
"python_token_provider_failed",
"Python token provider failed",
)
})
async fn token(&self) -> Result<TokenLease, Error> {
self.resolve()
.await
.map_err(|_| Error::Auth("Python token provider failed".to_string()))
}
}