use chrono::{DateTime, Utc};
use cpa_common::gostr::GoStr;
use cpa_core::config::Config;
use cpa_core::credential::{Credential, MetadataPatch};
use cpa_core::exec::{ExecError, FailureScope};
use cpa_plugin::hostauth::SavedRefresh;
use serde_json::{Map, Value};
use std::collections::HashMap;
use std::sync::{Arc, Mutex};
use crate::Runtime;
pub(crate) enum Route {
Executor,
Compat { identifier: String },
}
pub(crate) fn route(rt: &Runtime, c: &Credential, cfg: &Config) -> Option<Route> {
let provider = c.provider.trim().go_lower();
if super::BUILTIN.contains(&provider.as_str()) {
return None;
}
if rt.plugin_runtime().executor(c, cfg).is_some() {
return Some(Route::Executor);
}
let home = rt.remote_dispatch().is_some()
|| cfg
.document
.get("home")
.and_then(|h| h.get("enabled"))
.and_then(serde_yaml_ng::Value::as_bool)
.unwrap_or(false);
if home {
return None;
}
let attr = |k: &str| c.attributes.get(k).map_or("", |v| v.trim());
let identifier = if !attr("compat_name").is_empty() {
let key = if attr("provider_key").is_empty() {
attr("compat_name")
} else {
attr("provider_key")
};
cpa_core::config::credentials::openai_compat_provider(key)
} else if provider == "openai-compatibility" {
cpa_core::config::credentials::openai_compat_provider(&c.label)
} else if provider.is_empty() {
"openai-compatibility".to_owned()
} else {
provider.clone()
};
let host = rt.plugins();
[
provider.as_str(),
attr("provider_key"),
attr("compat_name"),
identifier.as_str(),
]
.iter()
.any(|key| !key.is_empty() && host.has_auth_provider(key))
.then_some(Route::Compat { identifier })
}
pub(crate) fn due_at(rt: &Runtime, c: &Credential, cfg: &Config) -> Option<DateTime<Utc>> {
let interval = cpa_exec::preferred_interval(c)?;
route(rt, c, cfg)?;
let schedule = lock(rt.store().refresh_schedules())
.get(&c.id)
.copied()
.unwrap_or_default();
if schedule.provisional {
return None;
}
let by_last = schedule
.last
.or_else(|| cpa_exec::last_refresh(c))
.map_or(DateTime::<Utc>::MIN_UTC, |last| {
last.checked_add_signed(interval).unwrap_or(DateTime::<Utc>::MAX_UTC)
});
let by_expiry =
cpa_exec::expiration(c).map(|expiry| expiry.checked_sub_signed(interval).unwrap_or(DateTime::<Utc>::MIN_UTC));
let due = by_expiry.map_or(by_last, |at| at.min(by_last));
Some(schedule.next_after.map_or(due, |after| due.max(after)))
}
#[derive(Clone, Copy, Default, Debug, PartialEq)]
pub(crate) struct Schedule {
pub last: Option<DateTime<Utc>>,
pub next_after: Option<DateTime<Utc>>,
pub provisional: bool,
pub registration: u64,
pub credential_version: u64,
}
#[derive(Clone, Copy, Default, Debug, PartialEq, Eq)]
pub(crate) struct Registered {
pub registration: u64,
pub credential_version: u64,
}
static REGISTRATIONS: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(1);
pub(crate) type Schedules = Arc<Mutex<HashMap<String, Schedule>>>;
fn lock(schedules: &Schedules) -> std::sync::MutexGuard<'_, HashMap<String, Schedule>> {
schedules.lock().unwrap_or_else(std::sync::PoisonError::into_inner)
}
pub(crate) fn register(
schedules: &Schedules,
before: &[Arc<Credential>],
after: &[Arc<Credential>],
saved: &[SavedRefresh],
) {
let mut schedules = lock(schedules);
let previous: HashMap<&str, &Credential> = before.iter().map(|c| (c.id.as_str(), &**c)).collect();
let mut registered = Vec::new();
for c in after {
let previous = previous.get(c.id.as_str());
if previous.is_some_and(|p| p.revision == c.revision) {
continue;
}
let kept = previous.and_then(|_| schedules.get(&c.id).copied());
let (registration, credential_version) = match (kept, previous) {
(Some(kept), Some(previous)) => (
kept.registration,
kept.credential_version + u64::from(crate::runtime::credentials_changed(previous, c)),
),
_ => (REGISTRATIONS.fetch_add(1, std::sync::atomic::Ordering::Relaxed), 1),
};
let own = Schedule {
last: None,
next_after: c.next_refresh_after.map(DateTime::<Utc>::from),
provisional: false,
registration,
credential_version,
};
let schedule = match saved.iter().find(|s| s.id == c.id) {
Some(SavedRefresh { donor: Some(donor), .. }) if !c.disabled => Schedule {
provisional: false,
registration,
credential_version,
..schedules.get(donor).copied().unwrap_or_default()
},
Some(_) => own,
None => match kept {
Some(kept) if previous.is_some_and(|p| !p.disabled && !c.disabled) && !kept.provisional => Schedule {
credential_version,
..kept
},
_ => own,
},
};
registered.push((c.id.clone(), schedule));
}
let live: std::collections::HashSet<&str> = after.iter().map(|c| c.id.as_str()).collect();
for id in previous.keys().filter(|id| !live.contains(*id)) {
schedules.remove(*id);
}
schedules.extend(registered);
}
pub(crate) fn begin_bootstrap(schedules: &Schedules) {
for schedule in lock(schedules).values_mut() {
schedule.provisional = true;
}
}
pub(crate) fn end_bootstrap(schedules: &Schedules) -> bool {
let mut ended = false;
for schedule in lock(schedules).values_mut() {
ended |= std::mem::take(&mut schedule.provisional);
}
ended
}
pub(crate) fn provisional(schedules: &Schedules) -> std::collections::HashSet<String> {
lock(schedules)
.iter()
.filter(|(_, s)| s.provisional)
.map(|(id, _)| id.clone())
.collect()
}
pub(crate) fn registered(schedules: &Schedules, id: &str) -> Option<Registered> {
lock(schedules).get(id).map(|s| Registered {
registration: s.registration,
credential_version: s.credential_version,
})
}
pub(crate) fn record(schedules: &Schedules, c: &Credential, record: impl FnOnce(&Credential, &mut Schedule)) {
if let Some(schedule) = lock(schedules).get_mut(&c.id) {
record(c, schedule);
}
}
pub(crate) fn committed(c: &Credential, schedule: &mut Schedule, now: DateTime<Utc>) {
let still_due = cpa_exec::preferred_interval(c).is_some_and(|interval| {
cpa_exec::expiration(c).is_some_and(|expiry| expiry.checked_sub_signed(interval).is_none_or(|at| at <= now))
});
schedule.last = Some(now);
schedule.next_after = still_due.then(|| now + chrono::Duration::seconds(30));
}
pub(crate) fn failed(store: &crate::runtime::CredentialStore, id: &str, registration: u64, now: DateTime<Utc>) {
let _ = store.record_refresh(id, registration, None, |c, schedule| {
let mut at = now + chrono::Duration::minutes(5);
if let Some(expiry) = cpa_exec::expiration(c).filter(|expiry| *expiry > now) {
at = at.min(expiry);
}
schedule.next_after = Some(at);
});
}
pub(crate) const PLUGIN_ERROR: &str = "x-cpa-plugin-refresh-error";
pub(crate) fn call_error(e: cpa_plugin::rpc::CallError) -> ExecError {
let status = match e.status() {
0 => 500,
status => status,
};
let code = cpa_exec::oauth::known_error_code(e.code().trim()).unwrap_or_default();
let mut error = ExecError::local(status, FailureScope::Credential, e.to_string());
error
.headers
.insert(PLUGIN_ERROR, axum::http::HeaderValue::from_static(code));
error
}
pub(crate) struct Refreshed {
pub patch: MetadataPatch,
pub answered: bool,
}
pub(crate) async fn refresh(
rt: &Runtime,
route: &Route,
c: &Credential,
stored: &Credential,
registration: u64,
) -> Result<Refreshed, ExecError> {
let result = refresh_once(rt, route, c, stored).await;
if result.is_err() {
failed(rt.store(), &c.id, registration, Utc::now());
}
result
}
async fn refresh_once(
rt: &Runtime,
route: &Route,
c: &Credential,
stored: &Credential,
) -> Result<Refreshed, ExecError> {
let metadata: cpa_plugin::gojson::Metadata = c.metadata.clone().into_iter().collect();
let view = cpa_plugin::auth::AuthView {
id: c.id.clone(),
provider: c.provider.clone(),
file_name: c
.attributes
.get("path")
.and_then(|p| std::path::Path::new(p).file_name())
.map(|n| n.to_string_lossy().into_owned())
.unwrap_or_default(),
label: c.label.clone(),
prefix: c.attributes.get("prefix").cloned().unwrap_or_default(),
proxy_url: c.attributes.get("proxy_url").cloned().unwrap_or_default(),
storage_json: bytes::Bytes::from(cpa_plugin::gojson::to_vec(&metadata)),
metadata,
attributes: crate::management::quota::go_attributes(c),
..Default::default()
};
let refreshed = rt
.plugins()
.refresh_auth(&view, &Default::default())
.await
.map_err(call_error)?;
let own_proxy = stored.attributes.get("proxy_url").map_or("", |p| p.trim()).to_owned();
let Some(mut refreshed) = refreshed else {
let unchanged = Refreshed {
patch: MetadataPatch::default(),
answered: false,
};
return match route {
Route::Executor => Ok(unchanged),
Route::Compat { identifier } => {
let filled = |k: &str| c.str(k).is_some_and(|v| !v.trim().is_empty());
if filled("refresh_token") || filled("refreshToken") {
Err(ExecError::local(
500,
FailureScope::Credential,
format!("plugin auth provider refresh is unavailable for provider {identifier}"),
))
} else {
Ok(unchanged)
}
}
};
};
let (from, to) = (
cpa_plugin::host::normalize_provider(&c.provider),
cpa_plugin::host::normalize_provider(&refreshed.provider),
);
if to != from || refreshed.id != c.id {
let change = if to != from {
format!("provider from {from} to {to}")
} else {
format!("ID to {}", refreshed.id)
};
return Err(ExecError::local(
500,
FailureScope::Credential,
format!("plugin auth refresh changed the credential's {change}; refusing to save it"),
));
}
let base = (view.proxy_url.trim(), c.str("proxy_url").unwrap_or_default().trim());
let proxy_meta = refreshed
.metadata
.get("proxy_url")
.and_then(Value::as_str)
.unwrap_or_default();
let updated = (refreshed.proxy_url.trim().to_owned(), proxy_meta.trim().to_owned());
let proxy = match (updated.0 != base.0, updated.1 != base.1) {
(true, false) => updated.0.as_str(),
(false, true) => updated.1.as_str(),
(true, true) if !updated.0.is_empty() => updated.0.as_str(),
(true, true) => updated.1.as_str(),
(false, false) => {
if own_proxy.is_empty() {
base.1
} else {
own_proxy.as_str()
}
}
}
.to_owned();
if proxy.is_empty() {
refreshed.metadata.remove("proxy_url");
} else {
refreshed.metadata.insert("proxy_url".into(), proxy.into());
}
refreshed.metadata.insert("disabled".into(), refreshed.disabled.into());
let mut ignored = Vec::new();
if refreshed.prefix.trim() != view.prefix.trim() {
ignored.push("prefix".to_owned());
}
if refreshed.label.trim() != view.label.trim() {
ignored.push("label".to_owned());
}
ignored.extend(
refreshed
.attributes
.iter()
.filter(|(k, v)| {
!matches!(k.as_str(), "path" | "source" | "source_backend") && view.attributes.get(*k) != Some(*v)
})
.map(|(k, _)| format!("attributes.{k}")),
);
if !ignored.is_empty() {
tracing::warn!(
credential = %c.id,
fields = %ignored.join(", "),
"plugin refresh response changes not applied until the file is next loaded; the refreshed tokens and document are saved"
);
}
let next: Map<String, Value> = refreshed
.storage_payload()
.and_then(|payload| serde_json::from_slice(&payload).map_err(|e| e.to_string()))
.map_err(|e| ExecError::local(500, FailureScope::Credential, format!("persist refreshed auth: {e}")))?;
Ok(Refreshed {
patch: diff(&c.metadata, &next),
answered: true,
})
}
fn diff(current: &Map<String, Value>, next: &Map<String, Value>) -> MetadataPatch {
let kept = |k: &str| k != "type";
MetadataPatch {
set: next
.iter()
.filter(|(k, v)| kept(k) && current.get(*k) != Some(v))
.map(|(k, v)| (k.clone(), v.clone()))
.collect(),
remove: current
.keys()
.filter(|k| kept(k) && !next.contains_key(*k))
.cloned()
.collect(),
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn a_late_refresh_result_leaves_no_schedule_behind() {
let credential = |id: &str| {
let metadata = serde_json::json!({"type":"pp","access_token":"t","refresh_interval":"1h"});
Credential::from_file(
std::path::Path::new("/auths"),
&std::path::Path::new("/auths").join(id),
metadata.as_object().cloned().unwrap(),
)
.unwrap()
};
let store = crate::runtime::CredentialStore::new(vec![credential("a.json")]);
store.end_bootstrap();
let now = Utc::now();
let schedule = |id: &str| lock(store.refresh_schedules()).get(id).copied();
let commit = |registration| {
let _ = store.record_refresh("a.json", registration, None, |c, s| committed(c, s, now));
};
for round in 0..3 {
let registration = store.get_registered("a.json").unwrap().1.registration;
store.reconcile(vec![credential(&format!("b{round}.json"))]);
commit(registration);
failed(&store, "a.json", registration, now);
let ids: Vec<String> = lock(store.refresh_schedules()).keys().cloned().collect();
assert_eq!(ids, [format!("b{round}.json")], "round {round}");
store.reconcile(vec![credential("a.json")]);
let fresh = schedule("a.json").unwrap();
assert_ne!(fresh.registration, registration, "round {round}");
commit(registration);
failed(&store, "a.json", registration, now);
assert_eq!(
schedule("a.json"),
Some(fresh),
"round {round}: the new registration's own"
);
}
let registration = store.get_registered("a.json").unwrap().1.registration;
for disabled in [false, true] {
let mut edited = credential("a.json");
edited
.metadata
.insert("note".into(), format!("edited {disabled}").into());
edited.metadata.insert("disabled".into(), disabled.into());
edited.refresh_derived();
store.reconcile(vec![edited]);
assert_eq!(store.get("a.json").unwrap().disabled, disabled);
commit(registration);
assert_eq!(schedule("a.json").unwrap().last, Some(now), "disabled {disabled}");
}
}
#[test]
fn a_refresh_commit_publishes_its_schedule_with_the_credential() {
let dir = std::env::temp_dir().join(format!("cpa-refresh-commit-{}", uuid::Uuid::new_v4()));
std::fs::create_dir_all(&dir).unwrap();
let credential = |token: &str, disabled: bool| {
let metadata =
serde_json::json!({"type":"pp","access_token":token,"refresh_interval":"1h","disabled":disabled});
let path = dir.join("a.json");
std::fs::write(&path, metadata.to_string()).unwrap();
Credential::from_file(&dir, &path, metadata.as_object().cloned().unwrap()).unwrap()
};
let store = crate::runtime::CredentialStore::new(vec![credential("q", false)]);
store.end_bootstrap();
let schedule = || lock(store.refresh_schedules()).get("a.json").copied().unwrap();
let mut patch = MetadataPatch::default();
patch.set.insert("access_token".into(), "p2".into());
let (current, registered) = store.get_registered("a.json").unwrap();
let fence = crate::runtime::RefreshFence {
registered,
plugin: true,
};
let (committed, _) = store
.apply_refresh(
"a.json",
current.revision,
fence,
&patch,
|_| {},
|_| {
assert!(schedule().last.is_some(), "recorded with the commit");
for disabled in [true, false] {
store.reconcile(vec![credential("p2", disabled)]);
}
true
},
)
.unwrap();
assert_eq!(committed.metadata["access_token"], "p2");
assert!(!store.get("a.json").unwrap().disabled);
assert_eq!(schedule().last, None, "the enabling reload's own");
store.reconcile(vec![]);
store.reconcile(vec![credential("q", false)]);
let current = store.get("a.json").unwrap();
let refused = store.apply_refresh("a.json", current.revision, fence, &patch, |_| {}, |_| true);
assert!(
matches!(refused, Err(crate::runtime::PatchError::NotFound)),
"{refused:?}"
);
let on_disk: serde_json::Value = serde_json::from_slice(&std::fs::read(dir.join("a.json")).unwrap()).unwrap();
assert_eq!(on_disk["access_token"], "q");
assert_eq!(store.get("a.json").unwrap().metadata["access_token"], "q");
assert_eq!(schedule().last, None);
std::fs::remove_dir_all(&dir).unwrap();
}
}