use std::fs::{self, File, OpenOptions};
use std::io::Write;
use std::path::{Path, PathBuf};
use std::sync::atomic::{AtomicU64, Ordering};
use std::sync::{Mutex, MutexGuard, PoisonError};
use crate::auth::Session;
use crate::error::StorageError;
use super::CredentialStore;
const BACKEND_NAME: &str = "file";
pub struct FileStore {
path: PathBuf,
op_lock: Mutex<()>,
}
impl std::fmt::Debug for FileStore {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("FileStore")
.field("path", &self.path)
.finish_non_exhaustive()
}
}
impl FileStore {
#[must_use]
pub fn new(path: impl Into<PathBuf>) -> Self {
Self {
path: path.into(),
op_lock: Mutex::new(()),
}
}
#[must_use]
pub fn path(&self) -> &Path {
&self.path
}
fn lock_operations(&self) -> MutexGuard<'_, ()> {
self.op_lock.lock().unwrap_or_else(PoisonError::into_inner)
}
fn load_unlocked(&self) -> Result<Session, StorageError> {
match fs::read_to_string(&self.path) {
Err(err) if err.kind() == std::io::ErrorKind::NotFound => Ok(Session::empty()),
Err(err) => Err(StorageError::Io(err)),
Ok(contents) => {
warn_if_permissions_are_loose(&self.path);
let (session, migrated) = Session::from_json_migrating(&contents)?;
if migrated {
super::migrate_and_verify(&session, BACKEND_NAME, |migrated| {
self.save_unlocked(migrated)
});
}
Ok(session)
}
}
}
fn save_unlocked(&self, session: &Session) -> Result<(), StorageError> {
let outcome = self.write_and_verify(session);
match &outcome {
Ok(()) => tracing::debug!("Saved authentication data to {}", self.path.display()),
Err(StorageError::NotRetained { .. }) => {}
Err(err) => tracing::error!("Error saving to file: {err}"),
}
outcome
}
fn write_and_verify(&self, session: &Session) -> Result<(), StorageError> {
if let Some(parent) = self.path.parent()
&& !parent.as_os_str().is_empty()
{
create_private_dir_all(parent)?;
}
let json = session.to_json()?;
write_private_atomically(&self.path, json.as_bytes())?;
verify_file_retains(&self.path, session)
}
fn clear_unlocked(&self) -> Result<(), StorageError> {
let result = match fs::remove_file(&self.path) {
Ok(()) => Ok(()),
Err(err) if err.kind() == std::io::ErrorKind::NotFound => Ok(()),
Err(err) => {
tracing::warn!("Error removing cookie file: {err}");
Err(StorageError::Io(err))
}
};
remove_orphaned_temp_files(&self.path);
result
}
}
impl CredentialStore for FileStore {
fn load(&self) -> Result<Session, StorageError> {
let _guard = self.lock_operations();
self.load_unlocked()
}
fn save(&self, session: &Session) -> Result<(), StorageError> {
let _guard = self.lock_operations();
self.save_unlocked(session)
}
fn clear(&self) -> Result<(), StorageError> {
let _guard = self.lock_operations();
self.clear_unlocked()
}
fn reports_failures(&self) -> bool {
true
}
}
fn verify_file_retains(path: &Path, saved: &Session) -> Result<(), StorageError> {
let retained = match fs::read_to_string(path) {
Ok(contents) => Session::from_json(&contents)
.is_ok_and(|stored| stored.expose_token() == saved.expose_token()),
Err(err) if err.kind() == std::io::ErrorKind::NotFound => false,
Err(err) => return Err(StorageError::Io(err)),
};
if retained {
Ok(())
} else {
tracing::warn!("Credential file did not retain the saved session");
Err(StorageError::NotRetained {
backend: BACKEND_NAME.to_owned(),
})
}
}
fn write_private_atomically(path: &Path, contents: &[u8]) -> Result<(), StorageError> {
let tmp_path = unique_temp_path(path);
let result = write_to_temp_and_rename(&tmp_path, path, contents);
if result.is_err() {
let _ = fs::remove_file(&tmp_path);
}
result.map_err(StorageError::Io)
}
fn write_to_temp_and_rename(tmp_path: &Path, path: &Path, contents: &[u8]) -> std::io::Result<()> {
let mut file = create_private_file(tmp_path)?;
file.write_all(contents)?;
file.sync_all()?;
fs::rename(tmp_path, path)?;
Ok(())
}
static TEMP_FILE_COUNTER: AtomicU64 = AtomicU64::new(0);
fn temp_file_prefix(path: &Path) -> String {
let base = path
.file_name()
.unwrap_or_else(|| std::ffi::OsStr::new("rusteero-session"));
format!("{}.", base.to_string_lossy())
}
fn unique_temp_path(path: &Path) -> PathBuf {
let counter = TEMP_FILE_COUNTER.fetch_add(1, Ordering::Relaxed);
let file_name = format!(
"{}{}-{counter}.tmp",
temp_file_prefix(path),
std::process::id()
);
path.with_file_name(file_name)
}
fn remove_orphaned_temp_files(path: &Path) {
let parent = match path.parent() {
Some(parent) if !parent.as_os_str().is_empty() => parent,
_ => Path::new("."),
};
let prefix = temp_file_prefix(path);
let Ok(entries) = fs::read_dir(parent) else {
return;
};
for entry in entries.flatten() {
let name = entry.file_name().to_string_lossy().into_owned();
let has_tmp_extension = Path::new(&name)
.extension()
.is_some_and(|ext| ext.eq_ignore_ascii_case("tmp"));
if name.starts_with(&prefix) && has_tmp_extension {
let _ = fs::remove_file(entry.path());
}
}
}
#[cfg(unix)]
fn create_private_file(path: &Path) -> std::io::Result<File> {
use std::os::unix::fs::OpenOptionsExt;
OpenOptions::new()
.write(true)
.create_new(true)
.mode(0o600)
.open(path)
}
#[cfg(not(unix))]
fn create_private_file(path: &Path) -> std::io::Result<File> {
OpenOptions::new().write(true).create_new(true).open(path)
}
#[cfg(unix)]
fn create_private_dir_all(parent: &Path) -> std::io::Result<()> {
use std::os::unix::fs::DirBuilderExt;
fs::DirBuilder::new()
.recursive(true)
.mode(0o700)
.create(parent)
}
#[cfg(not(unix))]
fn create_private_dir_all(parent: &Path) -> std::io::Result<()> {
fs::create_dir_all(parent)
}
#[cfg(unix)]
fn has_loose_permissions(path: &Path) -> bool {
use std::os::unix::fs::PermissionsExt;
fs::metadata(path).is_ok_and(|meta| meta.permissions().mode() & 0o077 != 0)
}
#[cfg(unix)]
fn warn_if_permissions_are_loose(path: &Path) {
if has_loose_permissions(path) {
tracing::warn!(
path = %path.display(),
"credential file has group/other-accessible permissions; expected owner-only (0600)"
);
}
}
#[cfg(not(unix))]
fn warn_if_permissions_are_loose(_path: &Path) {}
#[cfg(test)]
mod tests {
use std::ffi::OsString;
use std::fs;
use std::path::Path;
use std::sync::Arc;
use std::sync::mpsc;
use std::time::{Duration, Instant};
use tracing::Level;
use super::{BACKEND_NAME, CredentialStore, FileStore, verify_file_retains};
use crate::auth::Session;
use crate::error::StorageError;
use crate::storage::test_support::capture_logs;
use crate::storage::{load_async, save_async};
#[test]
fn save_then_load_round_trips_the_session() {
let dir = tempfile::tempdir().expect("tempdir");
let store = FileStore::new(dir.path().join("cookies.json"));
let session = Session::from_token("tok-123");
store.save(&session).expect("save succeeds");
let loaded = store.load().expect("load succeeds");
assert_eq!(loaded.expose_token(), "tok-123");
assert!(loaded.is_valid());
}
#[test]
fn round_trip_through_v8_0_4_cookies_json_shape() {
let dir = tempfile::tempdir().expect("tempdir");
let path = dir.path().join("cookies.json");
let python_written = r#"{"session_id": "session_valid_id", "schema_version": 2}"#;
fs_write(&path, python_written);
let store = FileStore::new(&path);
let session = store.load().expect("load succeeds");
assert_eq!(session.expose_token(), "session_valid_id");
store.save(&session).expect("save succeeds");
let reloaded = store.load().expect("load succeeds");
assert_eq!(reloaded.expose_token(), "session_valid_id");
}
#[test]
fn load_migrates_a_legacy_record_and_the_migration_read_back_matches() {
let dir = tempfile::tempdir().expect("tempdir");
let path = dir.path().join("cookies.json");
fs_write(
&path,
r#"{"session_id":"legacy-token","refresh_token":"rt-1","session_expiry":"2099-01-01T00:00:00"}"#,
);
let store = FileStore::new(&path);
let session = store
.load()
.expect("load succeeds, legacy record tolerated");
assert_eq!(session.expose_token(), "legacy-token");
let on_disk = fs::read_to_string(&path).expect("file still exists");
assert!(on_disk.contains("\"schema_version\":2"));
assert!(!on_disk.contains("refresh_token"));
assert!(!on_disk.contains("session_expiry"));
let reloaded = store.load().expect("second load succeeds");
assert_eq!(reloaded.expose_token(), "legacy-token");
}
#[test]
fn load_of_a_current_schema_record_is_not_treated_as_a_migration() {
let dir = tempfile::tempdir().expect("tempdir");
let path = dir.path().join("cookies.json");
fs_write(&path, r#"{"session_id":"tok","schema_version":2}"#);
let store = FileStore::new(&path);
let before = fs::read_to_string(&path).expect("file exists");
let session = store.load().expect("load succeeds");
assert_eq!(session.expose_token(), "tok");
let after = fs::read_to_string(&path).expect("file still exists");
assert_eq!(
before, after,
"a current-schema record must not be rewritten"
);
}
#[cfg(unix)]
#[test]
fn save_replaces_a_symlink_at_the_destination_rather_than_following_it() {
let dir = tempfile::tempdir().expect("tempdir");
let real_target = dir.path().join("attacker-owned-target.json");
fs_write(&real_target, "should never be written to");
let cookie_path = dir.path().join("cookies.json");
std::os::unix::fs::symlink(&real_target, &cookie_path).expect("symlink created");
let store = FileStore::new(&cookie_path);
store
.save(&Session::from_token("tok"))
.expect("save succeeds even though the destination is a symlink");
assert!(
!cookie_path.is_symlink(),
"save must replace the symlink, not write through it"
);
let target_contents =
fs::read_to_string(&real_target).expect("the original target file still exists");
assert_eq!(target_contents, "should never be written to");
}
#[cfg(unix)]
#[test]
fn save_creates_the_file_with_owner_only_permissions() {
use std::os::unix::fs::PermissionsExt;
let dir = tempfile::tempdir().expect("tempdir");
let path = dir.path().join("cookies.json");
let store = FileStore::new(&path);
store
.save(&Session::from_token("tok"))
.expect("save succeeds");
let mode = std::fs::metadata(&path)
.expect("file exists")
.permissions()
.mode()
& 0o777;
assert_eq!(mode, 0o600, "expected owner-only permissions, got {mode:o}");
}
#[cfg(unix)]
#[test]
fn overwriting_an_existing_looser_file_still_ends_up_0600() {
use std::os::unix::fs::PermissionsExt;
let dir = tempfile::tempdir().expect("tempdir");
let path = dir.path().join("cookies.json");
fs_write(&path, "{}");
std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o644))
.expect("chmod succeeds");
let store = FileStore::new(&path);
store
.save(&Session::from_token("tok"))
.expect("save succeeds");
let mode = std::fs::metadata(&path)
.expect("file exists")
.permissions()
.mode()
& 0o777;
assert_eq!(
mode, 0o600,
"expected save() to tighten permissions, got {mode:o}"
);
}
#[test]
fn save_creates_missing_parent_directories() {
let dir = tempfile::tempdir().expect("tempdir");
let path = dir.path().join("nested").join("dirs").join("cookies.json");
let store = FileStore::new(&path);
store
.save(&Session::from_token("tok"))
.expect("save succeeds");
assert!(path.exists());
}
#[cfg(unix)]
#[test]
fn save_creates_every_missing_parent_directory_with_owner_only_permissions() {
use std::os::unix::fs::PermissionsExt;
let dir = tempfile::tempdir().expect("tempdir");
let path = dir.path().join("nested").join("dirs").join("cookies.json");
let store = FileStore::new(&path);
store
.save(&Session::from_token("tok"))
.expect("save succeeds");
for created in [dir.path().join("nested"), dir.path().join("nested/dirs")] {
let mode = fs::metadata(&created)
.expect("directory exists")
.permissions()
.mode()
& 0o777;
assert_eq!(
mode, 0o700,
"expected {created:?} to be owner-only, got {mode:o}"
);
}
}
#[cfg(unix)]
#[test]
fn has_loose_permissions_is_false_for_a_freshly_saved_file() {
let dir = tempfile::tempdir().expect("tempdir");
let path = dir.path().join("cookies.json");
let store = FileStore::new(&path);
store
.save(&Session::from_token("tok"))
.expect("save succeeds");
assert!(!super::has_loose_permissions(&path));
}
#[cfg(unix)]
#[test]
fn has_loose_permissions_is_true_for_a_world_readable_file_and_load_still_succeeds() {
use std::os::unix::fs::PermissionsExt;
let dir = tempfile::tempdir().expect("tempdir");
let path = dir.path().join("cookies.json");
fs_write(&path, r#"{"session_id":"tok","schema_version":2}"#);
std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o644))
.expect("chmod succeeds");
assert!(super::has_loose_permissions(&path));
let store = FileStore::new(&path);
let session = store.load().expect(
"a loosely-permissioned file must still load — this is a warning, not a failure",
);
assert_eq!(session.expose_token(), "tok");
}
#[test]
fn load_missing_file_returns_an_empty_session_not_an_error() {
let dir = tempfile::tempdir().expect("tempdir");
let store = FileStore::new(dir.path().join("does-not-exist.json"));
let session = store.load().expect("missing file is not an error");
assert!(!session.is_valid());
assert_eq!(session.expose_token(), "");
}
#[test]
fn load_malformed_json_returns_a_storage_error() {
let dir = tempfile::tempdir().expect("tempdir");
let path = dir.path().join("cookies.json");
fs_write(&path, "not json");
let store = FileStore::new(&path);
let err = store.load().expect_err("malformed json is an error");
assert!(matches!(err, StorageError::Serde(_)));
}
#[test]
fn load_accepts_the_legacy_user_token_key() {
let dir = tempfile::tempdir().expect("tempdir");
let path = dir.path().join("cookies.json");
fs_write(&path, r#"{"user_token":"old_token_123","session_id":null}"#);
let store = FileStore::new(&path);
let session = store.load().expect("load succeeds");
assert_eq!(session.expose_token(), "old_token_123");
}
#[test]
fn clear_on_a_missing_file_is_ok() {
let dir = tempfile::tempdir().expect("tempdir");
let store = FileStore::new(dir.path().join("does-not-exist.json"));
store
.clear()
.expect("clearing a missing file is not an error");
}
#[test]
fn clear_removes_an_existing_file() {
let dir = tempfile::tempdir().expect("tempdir");
let path = dir.path().join("cookies.json");
let store = FileStore::new(&path);
store
.save(&Session::from_token("tok"))
.expect("save succeeds");
assert!(path.exists());
store.clear().expect("clear succeeds");
assert!(!path.exists());
}
#[test]
fn clear_removes_a_stale_temporary_file_left_by_a_crashed_write() {
let dir = tempfile::tempdir().expect("tempdir");
let path = dir.path().join("cookies.json");
let store = FileStore::new(&path);
store
.save(&Session::from_token("tok"))
.expect("save succeeds");
let orphan = dir.path().join("cookies.json.99999-7.tmp");
fs_write(&orphan, "leftover plaintext credential");
store.clear().expect("clear succeeds");
assert!(!path.exists());
assert!(
!orphan.exists(),
"clear() must remove orphaned temp files too, not just the main file"
);
}
#[test]
fn clear_with_no_file_and_no_orphan_is_still_ok() {
let dir = tempfile::tempdir().expect("tempdir");
let store = FileStore::new(dir.path().join("does-not-exist.json"));
store
.clear()
.expect("clearing with nothing on disk at all is not an error");
}
#[test]
fn failed_write_leaves_no_temporary_file_behind() {
let dir = tempfile::tempdir().expect("tempdir");
let path = dir.path().join("cookies.json");
fs::create_dir(&path).expect("create a directory at the target path");
let store = FileStore::new(&path);
store
.save(&Session::from_token("tok"))
.expect_err("rename onto an existing directory must fail");
let leftovers: Vec<OsString> = fs::read_dir(dir.path())
.expect("read dir")
.filter_map(Result::ok)
.map(|entry| entry.file_name())
.collect();
assert_eq!(
leftovers,
vec![OsString::from("cookies.json")],
"a failed write must not leave any temporary file behind, got {leftovers:?}"
);
}
#[test]
fn a_failed_write_is_logged_once_at_error_without_the_token() {
let (_guard, logs) = capture_logs();
let dir = tempfile::tempdir().expect("tempdir");
let path = dir.path().join("cookies.json");
fs::create_dir(&path).expect("create a directory at the target path");
let err = FileStore::new(&path)
.save(&Session::from_token("file_token"))
.expect_err("the rename onto a directory must fail");
assert!(matches!(err, StorageError::Io(_)), "got {err:?}");
let errors = logs.messages(Level::ERROR);
assert_eq!(errors.len(), 1, "{errors:?}");
assert!(
errors[0].starts_with("Error saving to file: "),
"{errors:?}"
);
assert!(logs.messages(Level::WARN).is_empty());
assert!(!logs.mentions("file_token"));
}
#[test]
fn a_failed_clear_is_logged_once_at_warn() {
let (_guard, logs) = capture_logs();
let dir = tempfile::tempdir().expect("tempdir");
let path = dir.path().join("cookies.json");
fs::create_dir(&path).expect("create a directory at the target path");
let err = FileStore::new(&path)
.clear()
.expect_err("a directory is not a credential file");
assert!(matches!(err, StorageError::Io(_)), "got {err:?}");
let warnings = logs.messages(Level::WARN);
assert_eq!(warnings.len(), 1, "{warnings:?}");
assert!(
warnings[0].starts_with("Error removing cookie file: "),
"{warnings:?}"
);
assert!(logs.messages(Level::ERROR).is_empty());
}
#[test]
fn clearing_a_file_that_was_never_there_logs_nothing_above_debug() {
let (_guard, logs) = capture_logs();
let dir = tempfile::tempdir().expect("tempdir");
FileStore::new(dir.path().join("cookies.json"))
.clear()
.expect("an entry that was never there is not an error");
assert!(logs.messages(Level::WARN).is_empty());
assert!(logs.messages(Level::ERROR).is_empty());
}
#[test]
fn the_file_store_reports_its_own_failures() {
assert!(FileStore::new("cookies.json").reports_failures());
}
#[test]
fn a_successful_save_is_ok_and_logs_no_warning() {
let (_guard, logs) = capture_logs();
let dir = tempfile::tempdir().expect("tempdir");
let store = FileStore::new(dir.path().join("cookies.json"));
store
.save(&Session::from_token("file_token"))
.expect("save succeeds");
assert!(logs.messages(Level::WARN).is_empty());
assert_eq!(logs.count(Level::DEBUG, "Saved authentication data to"), 1);
assert!(!logs.mentions("file_token"));
}
#[test]
fn a_read_back_that_finds_another_token_is_not_retained() {
let (_guard, logs) = capture_logs();
let dir = tempfile::tempdir().expect("tempdir");
let path = dir.path().join("cookies.json");
fs_write(&path, r#"{"session_id":"other","schema_version":2}"#);
let err = verify_file_retains(&path, &Session::from_token("file_token"))
.expect_err("another token is on disk");
assert!(
matches!(&err, StorageError::NotRetained { backend } if backend == BACKEND_NAME),
"got {err:?}"
);
assert_eq!(
logs.messages(Level::WARN),
vec!["Credential file did not retain the saved session".to_owned()]
);
assert!(!logs.mentions("file_token") && !logs.mentions("other"));
assert!(!err.to_string().contains("file_token"));
}
#[test]
fn a_read_back_that_finds_the_same_token_is_retained_even_for_a_legacy_record() {
let (_guard, logs) = capture_logs();
let dir = tempfile::tempdir().expect("tempdir");
let path = dir.path().join("cookies.json");
fs_write(&path, r#"{"session_id":"file_token","schema_version":2}"#);
verify_file_retains(&path, &Session::from_token("file_token")).expect("same token");
fs_write(&path, r#"{"user_token":"file_token"}"#);
verify_file_retains(&path, &Session::from_token("file_token"))
.expect("a legacy record is parsed like a load would parse it");
assert!(logs.messages(Level::WARN).is_empty());
}
#[test]
fn a_missing_or_unparseable_file_is_not_retained() {
let (_guard, logs) = capture_logs();
let dir = tempfile::tempdir().expect("tempdir");
let path = dir.path().join("cookies.json");
let saved = Session::from_token("file_token");
let missing = verify_file_retains(&path, &saved).expect_err("nothing on disk");
assert!(matches!(missing, StorageError::NotRetained { .. }));
fs_write(&path, "not json");
let garbled = verify_file_retains(&path, &saved).expect_err("not a record");
assert!(matches!(garbled, StorageError::NotRetained { .. }));
assert_eq!(
logs.count(
Level::WARN,
"Credential file did not retain the saved session"
),
2,
"one fixed WARN per failure"
);
}
#[test]
fn a_read_back_that_fails_for_another_reason_is_an_io_error() {
let (_guard, logs) = capture_logs();
let dir = tempfile::tempdir().expect("tempdir");
let err = verify_file_retains(dir.path(), &Session::from_token("file_token"))
.expect_err("a directory cannot be read as the record");
assert!(matches!(err, StorageError::Io(_)), "got {err:?}");
assert!(logs.messages(Level::WARN).is_empty());
}
#[test]
fn save_under_a_parent_that_is_a_regular_file_is_an_io_error() {
let dir = tempfile::tempdir().expect("tempdir");
let blocker = dir.path().join("not-a-directory");
fs_write(&blocker, "blocking");
let store = FileStore::new(blocker.join("cookies.json"));
let err = store
.save(&Session::from_token("tok"))
.expect_err("the parent directory cannot be created");
assert!(matches!(err, StorageError::Io(_)), "got {err:?}");
}
#[test]
fn a_legacy_load_logs_the_migration_and_its_verified_read_back() {
let (_guard, logs) = capture_logs();
let dir = tempfile::tempdir().expect("tempdir");
let path = dir.path().join("cookies.json");
fs_write(&path, r#"{"user_token":"legacy_token"}"#);
#[cfg(unix)]
{
use std::os::unix::fs::PermissionsExt;
fs::set_permissions(&path, fs::Permissions::from_mode(0o600)).expect("chmod");
}
let session = FileStore::new(&path).load().expect("load succeeds");
assert_eq!(session.expose_token(), "legacy_token");
assert_eq!(
logs.count(
Level::DEBUG,
"Migrated legacy credential record in file storage"
),
1
);
assert_eq!(
logs.count(
Level::DEBUG,
"Migration read-back verified for file storage"
),
1
);
assert!(logs.messages(Level::WARN).is_empty());
assert!(!logs.mentions("legacy_token"));
}
#[cfg(unix)]
#[test]
fn a_migration_that_cannot_be_written_still_returns_the_session_with_a_warning() {
use std::os::unix::fs::PermissionsExt;
let (_guard, logs) = capture_logs();
let dir = tempfile::tempdir().expect("tempdir");
let path = dir.path().join("cookies.json");
fs_write(&path, r#"{"user_token":"legacy_token"}"#);
fs::set_permissions(dir.path(), fs::Permissions::from_mode(0o500)).expect("chmod");
let restore = RestoreMode(dir.path().to_path_buf());
if fs::File::create(dir.path().join("probe")).is_ok() {
return;
}
let session = FileStore::new(&path)
.load()
.expect("a failed migration write must not fail the load");
assert_eq!(session.expose_token(), "legacy_token");
assert_eq!(
logs.count(
Level::WARN,
"Migration read-back did not match for file storage; in-memory credentials are \
still returned to the caller"
),
1
);
assert!(!logs.mentions("legacy_token"));
drop(restore);
}
#[cfg(unix)]
struct RestoreMode(std::path::PathBuf);
#[cfg(unix)]
impl Drop for RestoreMode {
fn drop(&mut self) {
use std::os::unix::fs::PermissionsExt;
let _ = fs::set_permissions(&self.0, fs::Permissions::from_mode(0o700));
}
}
struct LockHolder {
release: mpsc::Sender<()>,
thread: std::thread::JoinHandle<()>,
}
impl LockHolder {
fn hold(store: &Arc<FileStore>) -> Self {
let (locked_tx, locked_rx) = mpsc::channel();
let (release_tx, release_rx) = mpsc::channel::<()>();
let store = Arc::clone(store);
let thread = std::thread::spawn(move || {
let _guard = store.lock_operations();
locked_tx.send(()).expect("the test is waiting");
let _ = release_rx.recv();
});
locked_rx
.recv_timeout(Duration::from_secs(5))
.expect("the holder takes the lock");
Self {
release: release_tx,
thread,
}
}
fn release(self) {
let _ = self.release.send(());
self.thread.join().expect("the holder thread finishes");
}
}
fn new_store(dir: &tempfile::TempDir) -> Arc<FileStore> {
Arc::new(FileStore::new(dir.path().join("cookies.json")))
}
fn assert_waits_for_the_lock(operation: impl FnOnce(&FileStore) + Send + 'static) {
let dir = tempfile::tempdir().expect("tempdir");
let store = new_store(&dir);
let holder = LockHolder::hold(&store);
let (done_tx, done_rx) = mpsc::channel();
let worker = Arc::clone(&store);
let thread = std::thread::spawn(move || {
operation(&worker);
let _ = done_tx.send(());
});
assert!(
done_rx.recv_timeout(Duration::from_millis(50)).is_err(),
"the operation ran while another one held the lock"
);
holder.release();
done_rx
.recv_timeout(Duration::from_secs(5))
.expect("the operation completes once the lock is free");
thread.join().expect("the operation thread finishes");
}
#[test]
fn load_waits_for_the_operation_lock() {
assert_waits_for_the_lock(|store| {
store.load().expect("load succeeds");
});
}
#[test]
fn save_waits_for_the_operation_lock() {
assert_waits_for_the_lock(|store| {
store
.save(&Session::from_token("tok"))
.expect("save succeeds");
});
}
#[test]
fn clear_waits_for_the_operation_lock() {
assert_waits_for_the_lock(|store| {
store.clear().expect("clear succeeds");
});
}
#[test]
fn operations_on_one_instance_are_serialised() {
let dir = tempfile::tempdir().expect("tempdir");
let store = new_store(&dir);
let guard = store.lock_operations();
let (done_tx, done_rx) = mpsc::channel();
let worker = Arc::clone(&store);
let thread = std::thread::spawn(move || {
worker.clear().expect("clear succeeds");
let _ = done_tx.send(());
});
assert!(done_rx.recv_timeout(Duration::from_millis(50)).is_err());
drop(guard);
done_rx
.recv_timeout(Duration::from_secs(5))
.expect("the clear completes once the guard is dropped");
thread.join().expect("the clear thread finishes");
}
#[test]
fn save_then_clear_ends_cleared() {
let dir = tempfile::tempdir().expect("tempdir");
let store = new_store(&dir);
let path = store.path().to_path_buf();
let guard = store.lock_operations();
store
.save_unlocked(&Session::from_token("saved"))
.expect("the in-flight save works");
let worker = Arc::clone(&store);
let clearer = std::thread::spawn(move || worker.clear().expect("clear succeeds"));
std::thread::sleep(Duration::from_millis(50));
assert!(path.exists(), "the queued clear waits behind the save");
assert!(!clearer.is_finished());
drop(guard);
clearer.join().expect("the clear thread finishes");
assert!(
!path.exists(),
"call order decides: save, then clear, ends cleared"
);
}
#[test]
fn clear_then_save_ends_saved() {
let dir = tempfile::tempdir().expect("tempdir");
let store = new_store(&dir);
let path = store.path().to_path_buf();
store
.save(&Session::from_token("old"))
.expect("seed save succeeds");
let guard = store.lock_operations();
store.clear_unlocked().expect("the in-flight clear works");
let worker = Arc::clone(&store);
let saver = std::thread::spawn(move || {
worker
.save(&Session::from_token("new"))
.expect("save succeeds");
});
std::thread::sleep(Duration::from_millis(50));
assert!(!path.exists(), "the queued save waits behind the clear");
assert!(!saver.is_finished());
drop(guard);
saver.join().expect("the save thread finishes");
assert_eq!(
store.load().expect("load succeeds").expose_token(),
"new",
"call order decides: clear, then save, ends saved"
);
}
#[test]
fn a_panic_while_the_lock_is_held_does_not_wedge_the_store() {
let dir = tempfile::tempdir().expect("tempdir");
let store = new_store(&dir);
let poisoner = Arc::clone(&store);
let result = std::thread::spawn(move || {
let _guard = poisoner.lock_operations();
panic!("a store operation panicked");
})
.join();
assert!(result.is_err());
store
.save(&Session::from_token("tok"))
.expect("a poisoned lock is recovered, not propagated");
assert_eq!(store.load().expect("load").expose_token(), "tok");
}
fn token_on_disk(path: &Path) -> Option<String> {
let contents = fs::read_to_string(path).ok()?;
let session = Session::from_json(&contents).ok()?;
Some(session.expose_token().to_owned())
}
async fn wait_until(what: &str, mut done: impl FnMut() -> bool) {
let deadline = Instant::now() + Duration::from_secs(5);
while !done() {
assert!(Instant::now() < deadline, "timed out waiting for {what}");
tokio::time::sleep(Duration::from_millis(5)).await;
}
}
#[tokio::test]
async fn a_follow_up_async_load_waits_behind_the_running_operation() {
let dir = tempfile::tempdir().expect("tempdir");
let store = new_store(&dir);
store
.save(&Session::from_token("old"))
.expect("seed save succeeds");
let holder = LockHolder::hold(&store);
let load = tokio::spawn(load_async(Arc::clone(&store) as _));
for _ in 0..10 {
tokio::task::yield_now().await;
}
assert!(
!load.is_finished(),
"a follow-up operation waits instead of racing the running one"
);
holder.release();
let session = load
.await
.expect("the load task finishes")
.expect("load succeeds");
assert_eq!(session.expose_token(), "old");
}
#[tokio::test]
async fn an_aborted_save_async_still_waiting_for_the_lock_still_lands() {
let dir = tempfile::tempdir().expect("tempdir");
let store = new_store(&dir);
let path = store.path().to_path_buf();
store
.save(&Session::from_token("old"))
.expect("seed save succeeds");
let holder = LockHolder::hold(&store);
let queued = tokio::spawn(save_async(
Arc::clone(&store) as _,
Session::from_token("queued"),
));
for _ in 0..10 {
tokio::task::yield_now().await;
}
queued.abort();
assert!(
queued
.await
.expect_err("the awaiting task was aborted")
.is_cancelled()
);
assert_eq!(token_on_disk(&path).as_deref(), Some("old"));
holder.release();
wait_until("the aborted save to land", || {
token_on_disk(&path).as_deref() == Some("queued")
})
.await;
}
#[test]
fn debug_only_ever_prints_the_path() {
let store = FileStore::new("/tmp/example/cookies.json");
let debug = format!("{store:?}");
assert!(debug.contains("cookies.json"));
assert!(debug.contains("FileStore"));
}
fn fs_write(path: &std::path::Path, contents: &str) {
std::fs::write(path, contents).expect("write succeeds");
}
}