use crate::auth::types::TokenSet;
use crate::shared::errors::{Error, Result};
use async_trait::async_trait;
use std::path::PathBuf;
use std::time::{Duration, SystemTime};
#[derive(Debug, Clone, Copy)]
pub struct FileLockDefaults {
pub acquire_timeout_ms: u64,
pub stale_ms: u64,
pub retry_base_ms: u64,
pub retry_jitter_ms: u64,
}
pub const FILE_LOCK_DEFAULTS: FileLockDefaults = FileLockDefaults {
acquire_timeout_ms: 30_000,
stale_ms: 60_000,
retry_base_ms: 30,
retry_jitter_ms: 70,
};
#[async_trait]
pub trait TokenStore: Send + Sync {
async fn save(&self, tokens: &TokenSet) -> Result<()>;
async fn load(&self) -> Result<Option<TokenSet>>;
async fn clear(&self) -> Result<()>;
async fn lock(&self) -> Result<Box<dyn Send>> {
Ok(Box::new(()))
}
}
pub struct FileTokenStore {
path: Option<PathBuf>,
chain: tokio::sync::Mutex<()>,
}
impl FileTokenStore {
pub fn new(path: Option<PathBuf>) -> Self {
Self {
path,
chain: tokio::sync::Mutex::new(()),
}
}
fn resolve_path(&self) -> Result<PathBuf> {
if let Some(p) = &self.path {
if !p.as_os_str().is_empty() {
return Ok(p.clone());
}
}
let home = home_dir()
.ok_or_else(|| Error::other("FileTokenStore: cannot resolve home directory"))?;
Ok(home.join(".acosmi").join("tokens.json"))
}
}
struct FileLockGuard {
lock_path: PathBuf,
}
impl Drop for FileLockGuard {
fn drop(&mut self) {
let _ = std::fs::remove_file(&self.lock_path);
}
}
#[async_trait]
impl TokenStore for FileTokenStore {
async fn save(&self, tokens: &TokenSet) -> Result<()> {
let _chain = self.chain.lock().await;
let p = self.resolve_path()?;
let dir = p
.parent()
.ok_or_else(|| Error::other("token path has no parent dir"))?
.to_path_buf();
let data = serde_json::to_vec_pretty(tokens)?;
let p2 = p.clone();
tokio::task::spawn_blocking(move || -> Result<()> {
use std::io::Write;
std::fs::create_dir_all(&dir)?;
let tmp = dir.join(format!(
"tokens.json.tmp.{}.{}",
std::process::id(),
now_nanos()
));
{
let mut fh = std::fs::File::create(&tmp)?;
fh.write_all(&data)?;
fh.sync_all()?; }
if let Err(e) = std::fs::rename(&tmp, &p2) {
let _ = std::fs::remove_file(&tmp);
return Err(e.into());
}
if let Ok(dh) = std::fs::File::open(&dir) {
let _ = dh.sync_all();
}
Ok(())
})
.await
.map_err(|e| Error::other(format!("join save task: {e}")))?
}
async fn load(&self) -> Result<Option<TokenSet>> {
let _chain = self.chain.lock().await;
let p = self.resolve_path()?;
let data = match tokio::fs::read(&p).await {
Ok(d) => d,
Err(e) if e.kind() == std::io::ErrorKind::NotFound => return Ok(None),
Err(e) => return Err(Error::other(format!("read token file: {e}"))),
};
Ok(serde_json::from_slice::<TokenSet>(&data).ok())
}
async fn clear(&self) -> Result<()> {
let _chain = self.chain.lock().await;
let p = self.resolve_path()?;
match tokio::fs::remove_file(&p).await {
Ok(()) => Ok(()),
Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(()),
Err(e) => Err(e.into()),
}
}
async fn lock(&self) -> Result<Box<dyn Send>> {
let p = self.resolve_path()?;
let lock_path = PathBuf::from(format!("{}.lock", p.display()));
let dir = p
.parent()
.ok_or_else(|| Error::other("token path has no parent dir"))?
.to_path_buf();
tokio::fs::create_dir_all(&dir).await?;
let start = SystemTime::now();
loop {
match std::fs::OpenOptions::new()
.write(true)
.create_new(true)
.open(&lock_path)
{
Ok(mut fh) => {
use std::io::Write;
let _ = write!(fh, "{}\n{}\n", std::process::id(), now_millis());
return Ok(Box::new(FileLockGuard { lock_path }));
}
Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => {
if let Ok(meta) = std::fs::metadata(&lock_path) {
if let Ok(modified) = meta.modified() {
if let Ok(age) = SystemTime::now().duration_since(modified) {
if age.as_millis() as u64 > FILE_LOCK_DEFAULTS.stale_ms {
let _ = std::fs::remove_file(&lock_path);
continue;
}
}
}
} else {
continue;
}
if elapsed_ms(start) > FILE_LOCK_DEFAULTS.acquire_timeout_ms {
return Err(Error::other(format!(
"acquire token file lock timeout ({}ms): {}",
FILE_LOCK_DEFAULTS.acquire_timeout_ms,
lock_path.display()
)));
}
let jitter = now_nanos() % FILE_LOCK_DEFAULTS.retry_jitter_ms.max(1);
let wait = FILE_LOCK_DEFAULTS.retry_base_ms + jitter;
tokio::time::sleep(Duration::from_millis(wait)).await;
}
Err(e) => return Err(e.into()),
}
}
}
}
pub fn new_file_token_store(path: Option<PathBuf>) -> FileTokenStore {
FileTokenStore::new(path)
}
#[derive(Default)]
pub struct InMemoryTokenStore {
tokens: std::sync::Mutex<Option<TokenSet>>,
}
impl InMemoryTokenStore {
pub fn new() -> Self {
Self::default()
}
}
#[async_trait]
impl TokenStore for InMemoryTokenStore {
async fn save(&self, tokens: &TokenSet) -> Result<()> {
*self.tokens.lock().unwrap() = Some(tokens.clone());
Ok(())
}
async fn load(&self) -> Result<Option<TokenSet>> {
Ok(self.tokens.lock().unwrap().clone())
}
async fn clear(&self) -> Result<()> {
*self.tokens.lock().unwrap() = None;
Ok(())
}
}
fn home_dir() -> Option<PathBuf> {
std::env::var_os("HOME")
.or_else(|| std::env::var_os("USERPROFILE"))
.map(PathBuf::from)
.filter(|p| !p.as_os_str().is_empty())
}
fn now_nanos() -> u64 {
SystemTime::now()
.duration_since(SystemTime::UNIX_EPOCH)
.map(|d| d.subsec_nanos() as u64)
.unwrap_or(0)
}
fn now_millis() -> u128 {
SystemTime::now()
.duration_since(SystemTime::UNIX_EPOCH)
.map(|d| d.as_millis())
.unwrap_or(0)
}
fn elapsed_ms(start: SystemTime) -> u64 {
SystemTime::now()
.duration_since(start)
.map(|d| d.as_millis() as u64)
.unwrap_or(0)
}