use super::*;
const LEASE_FILE: &str = "workspace.lease";
#[derive(Clone, Debug, Deserialize, Serialize)]
#[serde(deny_unknown_fields)]
pub struct SavedReplayWorkspace {
storage_root: PathBuf,
receipt: SeedReceipt,
limits: SeedLimits,
}
impl SavedReplayWorkspace {
pub fn storage_path(&self) -> &Path {
&self.storage_root
}
pub fn receipt(&self) -> &SeedReceipt {
&self.receipt
}
}
impl ReplayWorkspace {
pub fn persist(&mut self) -> SavedReplayWorkspace {
self.storage.retain();
SavedReplayWorkspace {
storage_root: self.storage.path().to_path_buf(),
receipt: self.receipt.clone(),
limits: self.limits,
}
}
pub fn restore_saved(saved: &SavedReplayWorkspace) -> Result<Self, SeedError> {
let root = &saved.storage_root;
let metadata = std::fs::symlink_metadata(root)
.map_err(|error| io("inspect saved storage", root, error))?;
if !metadata.is_dir()
|| root
.canonicalize()
.map_err(|error| io("resolve saved storage", root, error))?
!= *root
{
return Err(SeedError::Unsupported {
path: root.clone(),
reason: "saved storage must remain at its original canonical directory",
});
}
#[cfg(unix)]
if std::os::unix::fs::PermissionsExt::mode(&metadata.permissions()) & 0o077 != 0 {
return Err(SeedError::Unsupported {
path: root.clone(),
reason: "saved storage is no longer private to its owner",
});
}
let parent = open_dir(root)?;
let held = lease(&parent, root, false)?;
let mut workspace = Self {
_lease: held,
storage: storage::PrivateStorage::retained(root.clone()),
workspace: root.join("workspace"),
receipt: saved.receipt.clone(),
limits: saved.limits,
};
workspace.restore()?;
Ok(workspace)
}
}
pub(super) fn lease(parent: &Dir, root: &Path, create: bool) -> Result<std::fs::File, SeedError> {
if !create {
let metadata = parent
.symlink_metadata(LEASE_FILE)
.map_err(|error| io("inspect lease", Path::new(LEASE_FILE), error))?;
if !metadata.is_file() {
return Err(SeedError::Unsupported {
path: root.join(LEASE_FILE),
reason: "workspace lease must be its original regular file",
});
}
}
let file = parent
.open_with(
LEASE_FILE,
cap_std::fs::OpenOptions::new()
.read(true)
.write(true)
.create_new(create),
)
.map_err(|error| io("open workspace lease", root, error))?
.into_std();
match file.try_lock() {
Ok(()) => Ok(file),
Err(std::fs::TryLockError::WouldBlock) => Err(SeedError::InUse {
path: root.to_path_buf(),
}),
Err(std::fs::TryLockError::Error(error)) => Err(io("lock workspace", root, error)),
}
}
pub(super) fn require_directory(parent: &Dir, name: &str) -> Result<(), SeedError> {
let metadata = parent
.symlink_metadata(name)
.map_err(|error| io("inspect directory", Path::new(name), error))?;
if !metadata.is_dir() {
return Err(SeedError::Unsupported {
path: PathBuf::from(name),
reason: "the captured seed must remain a directory, not a symbolic link",
});
}
Ok(())
}