use super::*;
static RETIREMENT: std::sync::RwLock<()> = std::sync::RwLock::new(());
thread_local! {
static OPERATION_HOLD: std::cell::RefCell<(usize, Option<std::sync::RwLockReadGuard<'static, ()>>)> =
const { std::cell::RefCell::new((0, None)) };
}
pub(super) struct OperationGuard;
pub(super) fn operation() -> OperationGuard {
OPERATION_HOLD.with(|hold| {
let mut hold = hold.borrow_mut();
if hold.0 == 0 {
let shared = match RETIREMENT.try_read() {
Ok(shared) => shared,
Err(std::sync::TryLockError::Poisoned(e)) => e.into_inner(),
Err(std::sync::TryLockError::WouldBlock) => {
#[cfg(all(test, unix))]
super::tests::gate_wait_hook();
RETIREMENT.read().unwrap_or_else(|e| e.into_inner())
}
};
hold.1 = Some(shared);
}
hold.0 += 1;
});
OperationGuard
}
impl Drop for OperationGuard {
fn drop(&mut self) {
OPERATION_HOLD.with(|hold| {
let mut hold = hold.borrow_mut();
hold.0 -= 1;
if hold.0 == 0 {
hold.1 = None;
}
});
}
}
pub fn drop_session(session_id: &str) -> DropReceipt {
if OPERATION_HOLD.with(|hold| hold.borrow().0 > 0) {
return DropReceipt {
dropped: false,
error: Some(
"a checkpoint session cannot be dropped from inside a checkpoint operation"
.to_string(),
),
};
}
let _retiring = RETIREMENT.write().unwrap_or_else(|e| e.into_inner());
let Some(session) = find_session(session_id) else {
return DropReceipt {
dropped: false,
error: None,
};
};
let receipt = retire_record(session_id, &session);
if receipt.dropped {
sessions()
.lock()
.expect("workspace checkpoint registry poisoned")
.remove(session_id);
}
receipt
}
fn retire_record(session_id: &str, session: &SharedSession) -> DropReceipt {
#[cfg(all(test, unix))]
tests::retirement_hook();
let root = lock(session).root.clone();
let dir = session_dir(&root, session_id);
let removal = match stdfs::remove_dir_all(&dir) {
Err(e) if e.kind() != std::io::ErrorKind::NotFound => e,
_ => {
return DropReceipt {
dropped: true,
error: None,
}
}
};
let aside = dir.with_file_name(format!(
".dropped-{}-{}",
std::process::id(),
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map_or(0, |elapsed| elapsed.as_nanos())
));
match stdfs::rename(&dir, &aside) {
Ok(()) => {
let _ = stdfs::remove_dir_all(&aside);
DropReceipt {
dropped: true,
error: None,
}
}
Err(e) if e.kind() == std::io::ErrorKind::NotFound => DropReceipt {
dropped: true,
error: None,
},
Err(rename) => {
let error = format!(
"the checkpoint record could not be removed ({removal}) or moved aside ({rename}), so a later load could resume it"
);
lock(session).interrupted = Some(error.clone());
DropReceipt {
dropped: false,
error: Some(error),
}
}
}
}