use std::collections::HashMap;
use std::sync::{Arc, Mutex, OnceLock};
use anyhow::Result;
use super::{Credential, CredentialKind};
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct CredentialInfo {
pub provider_id: String,
pub(crate) kind: CredentialKind,
}
pub trait CredentialStore: Send + Sync {
fn read(&self, provider_id: &str) -> Result<Option<Credential>>;
fn list(&self) -> Result<Vec<CredentialInfo>>;
fn modify(
&self,
provider_id: &str,
f: &mut dyn FnMut(Option<Credential>) -> Result<Option<Credential>>,
) -> Result<Option<Credential>>;
fn delete(&self, provider_id: &str) -> Result<()>;
}
fn provider_lock(provider_id: &str) -> Arc<Mutex<()>> {
static LOCKS: OnceLock<Mutex<HashMap<String, Arc<Mutex<()>>>>> = OnceLock::new();
let locks = LOCKS.get_or_init(|| Mutex::new(HashMap::new()));
let mut guard = locks
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner);
Arc::clone(
guard
.entry(provider_id.to_string())
.or_insert_with(|| Arc::new(Mutex::new(()))),
)
}
pub fn with_provider_write_lock<T>(provider_id: &str, body: impl FnOnce() -> T) -> T {
let lock = provider_lock(provider_id);
let _guard = lock
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner);
body()
}
pub fn with_provider_write_locks<T>(
provider_ids: impl IntoIterator<Item = impl AsRef<str>>,
body: impl FnOnce() -> T,
) -> T {
let mut ids: Vec<String> = provider_ids
.into_iter()
.map(|id| id.as_ref().to_string())
.collect();
ids.sort();
ids.dedup();
let locks: Vec<Arc<Mutex<()>>> = ids.iter().map(|id| provider_lock(id)).collect();
let _guards: Vec<_> = locks
.iter()
.map(|lock| {
lock.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner)
})
.collect();
body()
}
#[derive(Debug, Default)]
pub(crate) struct InMemoryCredentialStore {
entries: Mutex<HashMap<String, Credential>>,
}
impl InMemoryCredentialStore {
#[cfg_attr(not(test), expect(dead_code))]
pub(crate) fn new() -> Self {
Self::default()
}
}
impl CredentialStore for InMemoryCredentialStore {
fn read(&self, provider_id: &str) -> Result<Option<Credential>> {
Ok(self
.entries
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner)
.get(provider_id)
.cloned())
}
fn list(&self) -> Result<Vec<CredentialInfo>> {
let entries = self
.entries
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner);
let mut infos: Vec<CredentialInfo> = entries
.iter()
.map(|(provider_id, credential)| CredentialInfo {
provider_id: provider_id.clone(),
kind: credential.kind(),
})
.collect();
infos.sort_by(|left, right| left.provider_id.cmp(&right.provider_id));
Ok(infos)
}
fn modify(
&self,
provider_id: &str,
f: &mut dyn FnMut(Option<Credential>) -> Result<Option<Credential>>,
) -> Result<Option<Credential>> {
with_provider_write_lock(provider_id, || {
let current = self.read(provider_id)?;
let next = f(current.clone())?;
match next {
Some(credential) => {
self.entries
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner)
.insert(provider_id.to_string(), credential.clone());
Ok(Some(credential))
}
None => Ok(current),
}
})
}
fn delete(&self, provider_id: &str) -> Result<()> {
with_provider_write_lock(provider_id, || {
self.entries
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner)
.remove(provider_id);
Ok(())
})
}
}
pub struct SecretStoreCredentials {
secrets: codewhale_secrets::Secrets,
known_slots: Vec<String>,
}
impl SecretStoreCredentials {
pub fn new(secrets: codewhale_secrets::Secrets, known_slots: Vec<String>) -> Self {
Self {
secrets,
known_slots,
}
}
}
impl std::fmt::Debug for SecretStoreCredentials {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("SecretStoreCredentials")
.field("backend", &self.secrets.backend_name())
.field("known_slots", &self.known_slots.len())
.finish()
}
}
impl CredentialStore for SecretStoreCredentials {
fn read(&self, provider_id: &str) -> Result<Option<Credential>> {
Ok(self
.secrets
.get(provider_id)?
.filter(|value| !value.trim().is_empty())
.map(|key| Credential::ApiKey { key }))
}
fn list(&self) -> Result<Vec<CredentialInfo>> {
let mut infos = Vec::new();
for slot in &self.known_slots {
match self.read(slot) {
Ok(Some(_)) => infos.push(CredentialInfo {
provider_id: slot.clone(),
kind: CredentialKind::ApiKey,
}),
Ok(None) => {}
Err(error) => {
tracing::warn!(
slot,
error = %error,
"skipping unreadable credential slot during enumeration"
);
}
}
}
Ok(infos)
}
fn modify(
&self,
provider_id: &str,
f: &mut dyn FnMut(Option<Credential>) -> Result<Option<Credential>>,
) -> Result<Option<Credential>> {
with_provider_write_lock(provider_id, || {
let current = self.read(provider_id)?;
let next = f(current.clone())?;
match next {
Some(credential) => {
self.secrets.set(provider_id, credential.expose_secret())?;
Ok(Some(credential))
}
None => Ok(current),
}
})
}
fn delete(&self, provider_id: &str) -> Result<()> {
with_provider_write_lock(provider_id, || {
self.secrets.delete(provider_id)?;
Ok(())
})
}
}