AI media harness for planning, generating, and editing locally
TypeScript
use std::{
fs, io,
path::{Path, PathBuf},
};
#[cfg(not(windows))]
pub fn atomic_replace(temporary: &Path, destination: &Path) -> io::Result<()> {
fs::rename(temporary, destination)?;
fs::File::open(destination.parent().expect("project file has a parent"))?.sync_all()
}
#[cfg(windows)]
pub fn atomic_replace(temporary: &Path, destination: &Path) -> io::Result<()> {
use std::os::windows::ffi::OsStrExt;
use windows_sys::Win32::{
Foundation::GetLastError,
Storage::FileSystem::{
MoveFileExW, ReplaceFileW, MOVEFILE_WRITE_THROUGH, REPLACEFILE_WRITE_THROUGH,
},
};
let temporary_wide: Vec<u16> = temporary.as_os_str().encode_wide().chain(Some(0)).collect();
let destination_wide: Vec<u16> = destination
.as_os_str()
.encode_wide()
.chain(Some(0))
.collect();
let succeeded = unsafe {
if destination.exists() {
ReplaceFileW(
destination_wide.as_ptr(),
temporary_wide.as_ptr(),
std::ptr::null(),
REPLACEFILE_WRITE_THROUGH,
std::ptr::null_mut(),
std::ptr::null_mut(),
)
} else {
MoveFileExW(
temporary_wide.as_ptr(),
destination_wide.as_ptr(),
MOVEFILE_WRITE_THROUGH,
)
}
};
if succeeded == 0 {
let code = unsafe { GetLastError() };
Err(io::Error::from_raw_os_error(code as i32))
} else {
Ok(())
}
}
static NEXT_TEMPORARY: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);
struct TemporaryFile(PathBuf);
impl Drop for TemporaryFile {
fn drop(&mut self) {
let _ = fs::remove_file(&self.0);
}
}
pub fn write_with_replacer<F>(
destination: &Path,
bytes: &[u8],
replacer: F,
) -> io::Result<()>
where
F: FnOnce(&Path, &Path) -> io::Result<()>,
{
use io::Write;
use std::sync::atomic::Ordering;
let parent = destination
.parent()
.ok_or_else(|| io::Error::other("Destination has no parent"))?;
let name = destination
.file_name()
.ok_or_else(|| io::Error::other("Destination has no filename"))?;
let (temporary, mut file) = loop {
let sequence = NEXT_TEMPORARY.fetch_add(1, Ordering::Relaxed);
let path = parent.join(format!(
".{}.{}.{}.tmp",
name.to_string_lossy(),
std::process::id(),
sequence
));
match fs::OpenOptions::new()
.write(true)
.create_new(true)
.open(&path)
{
Ok(file) => break (TemporaryFile(path), file),
Err(error) if error.kind() == io::ErrorKind::AlreadyExists => continue,
Err(error) => return Err(error),
}
};
file.write_all(bytes)?;
file.sync_all()?;
drop(file);
replacer(&temporary.0, destination)
}
pub fn write_atomically(destination: &Path, bytes: &[u8]) -> Result<(), String> {
write_with_replacer(destination, bytes, atomic_replace)
.map_err(|error| format!("Could not save {}: {error}", destination.display()))
}