use std::io::Write as _;
use std::path::{Path, PathBuf};
use std::sync::{PoisonError, RwLock};
#[derive(Debug)]
pub(super) struct EnvironmentFiles {
directory: PathBuf,
open: RwLock<bool>,
}
impl EnvironmentFiles {
pub(super) fn create(socket_path: &Path) -> std::io::Result<Self> {
use std::os::unix::fs::DirBuilderExt as _;
let directory = socket_path.with_extension("env.d");
remove(&directory)?;
std::fs::DirBuilder::new().mode(0o700).create(&directory)?;
Ok(Self {
directory,
open: RwLock::new(true),
})
}
pub(super) fn write(&self, service: Option<&str>, text: &str) -> std::io::Result<PathBuf> {
let open = self.open.read().unwrap_or_else(PoisonError::into_inner);
if !*open {
return Err(std::io::Error::other("the session is stopping"));
}
let path = self.directory.join(match service {
Some(service) => format!("service-{service}.env"),
None => "session.env".to_string(),
});
let mut file = tempfile::Builder::new()
.prefix(".")
.suffix(".tmp")
.tempfile_in(&self.directory)?;
file.write_all(text.as_bytes())?;
file.persist(&path).map_err(|err| err.error)?;
Ok(path)
}
pub(super) fn close(&self) -> std::io::Result<()> {
let mut open = self.open.write().unwrap_or_else(PoisonError::into_inner);
*open = false;
remove(&self.directory)
}
pub(super) fn directory(&self) -> &Path {
&self.directory
}
}
fn remove(directory: &Path) -> std::io::Result<()> {
match std::fs::remove_dir_all(directory) {
Err(err) if err.kind() == std::io::ErrorKind::NotFound => Ok(()),
result => result,
}
}
#[cfg(test)]
mod tests {
use std::os::unix::fs::PermissionsExt as _;
use std::sync::PoisonError;
use std::time::Duration;
use color_eyre::eyre;
use similar_asserts::assert_eq;
use super::EnvironmentFiles;
fn mode(path: &std::path::Path) -> eyre::Result<u32> {
Ok(std::fs::metadata(path)?.permissions().mode() & 0o777)
}
#[test]
fn environment_files_are_private_replaced_and_removed() -> eyre::Result<()> {
let runtime = tempfile::tempdir()?;
let socket = runtime.path().join("0123456789abcdef.sock");
let directory = runtime.path().join("0123456789abcdef.env.d");
std::fs::create_dir(&directory)?;
std::fs::write(directory.join("session.env"), "STALE=\"1\"\n")?;
let files = EnvironmentFiles::create(&socket)?;
assert_eq!(
files.directory(),
directory,
"the directory sits next to the socket"
);
assert_eq!(std::fs::read_dir(&directory)?.count(), 0);
assert_eq!(mode(&directory)?, 0o700);
let session = files.write(None, "A=\"1\"\n")?;
assert_eq!(session, directory.join("session.env"));
assert_eq!(std::fs::read_to_string(&session)?, "A=\"1\"\n");
assert_eq!(mode(&session)?, 0o600);
assert_eq!(files.write(None, "A=\"2\"\n")?, session);
assert_eq!(std::fs::read_to_string(&session)?, "A=\"2\"\n");
let service = files.write(Some("api"), "B=\"3\"\n")?;
assert_eq!(service, directory.join("service-api.env"));
let mut names = std::fs::read_dir(&directory)?
.map(|entry| Ok(entry?.file_name().to_string_lossy().into_owned()))
.collect::<eyre::Result<Vec<_>>>()?;
names.sort();
assert_eq!(names, ["service-api.env", "session.env"]);
files.close()?;
assert!(!directory.exists());
assert!(files.write(None, "A=\"4\"\n").is_err());
assert!(!directory.exists());
files.close()?;
Ok(())
}
#[test]
fn closing_waits_for_a_running_write() -> eyre::Result<()> {
let runtime = tempfile::tempdir()?;
let files = EnvironmentFiles::create(&runtime.path().join("0123456789abcdef.sock"))?;
let directory = files.directory().to_path_buf();
std::thread::scope(|scope| -> eyre::Result<()> {
let writing = files.open.read().unwrap_or_else(PoisonError::into_inner);
let closing = scope.spawn(|| files.close());
std::thread::sleep(Duration::from_millis(100));
std::fs::write(directory.join(".late.tmp"), "SECRET=\"1\"\n")?;
drop(writing);
closing
.join()
.map_err(|_| eyre::eyre!("closing panicked"))??;
Ok(())
})?;
assert!(!directory.exists(), "the late file outlived the session");
Ok(())
}
}