rust: Add Vfs::write_atomic

This method writes to a temporary file then renames in place

Differential Revision: https://phab.mercurial-scm.org/D11836

rust/hg-core/src/errors.rs

@@ -1,199 +1,205 b''
 use crate::config::ConfigValueParseError;
 use crate::exit_codes;
 use std::fmt;
 
 /// Common error cases that can happen in many different APIs
 #[derive(Debug, derive_more::From)]
 pub enum HgError {
     IoError {
         error: std::io::Error,
         context: IoErrorContext,
     },
 
     /// A file under `.hg/` normally only written by Mercurial is not in the
     /// expected format. This indicates a bug in Mercurial, filesystem
     /// corruption, or hardware failure.
     ///
     /// The given string is a short explanation for users, not intended to be
     /// machine-readable.
     CorruptedRepository(String),
 
     /// The respository or requested operation involves a feature not
     /// supported by the Rust implementation. Falling back to the Python
     /// implementation may or may not work.
     ///
     /// The given string is a short explanation for users, not intended to be
     /// machine-readable.
     UnsupportedFeature(String),
 
     /// Operation cannot proceed for some other reason.
     ///
     /// The message is a short explanation for users, not intended to be
     /// machine-readable.
     Abort {
         message: String,
         detailed_exit_code: exit_codes::ExitCode,
     },
 
     /// A configuration value is not in the expected syntax.
     ///
     /// These errors can happen in many places in the code because values are
     /// parsed lazily as the file-level parser does not know the expected type
     /// and syntax of each value.
     #[from]
     ConfigValueParseError(ConfigValueParseError),
 }
 
 /// Details about where an I/O error happened
 #[derive(Debug)]
 pub enum IoErrorContext {
     /// `std::fs::metadata`
     ReadingMetadata(std::path::PathBuf),
     ReadingFile(std::path::PathBuf),
     WritingFile(std::path::PathBuf),
     RemovingFile(std::path::PathBuf),
     RenamingFile {
         from: std::path::PathBuf,
         to: std::path::PathBuf,
     },
     /// `std::fs::canonicalize`
     CanonicalizingPath(std::path::PathBuf),
     /// `std::env::current_dir`
     CurrentDir,
     /// `std::env::current_exe`
     CurrentExe,
 }
 
 impl HgError {
     pub fn corrupted(explanation: impl Into<String>) -> Self {
         // TODO: capture a backtrace here and keep it in the error value
         // to aid debugging?
         // https://doc.rust-lang.org/std/backtrace/struct.Backtrace.html
         HgError::CorruptedRepository(explanation.into())
     }
 
     pub fn unsupported(explanation: impl Into<String>) -> Self {
         HgError::UnsupportedFeature(explanation.into())
     }
 
     pub fn abort(
         explanation: impl Into<String>,
         exit_code: exit_codes::ExitCode,
     ) -> Self {
         HgError::Abort {
             message: explanation.into(),
             detailed_exit_code: exit_code,
         }
     }
 }
 
 // TODO: use `DisplayBytes` instead to show non-Unicode filenames losslessly?
 impl fmt::Display for HgError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
             HgError::Abort { message, .. } => write!(f, "{}", message),
             HgError::IoError { error, context } => {
                 write!(f, "abort: {}: {}", context, error)
             }
             HgError::CorruptedRepository(explanation) => {
                 write!(f, "abort: {}", explanation)
             }
             HgError::UnsupportedFeature(explanation) => {
                 write!(f, "unsupported feature: {}", explanation)
             }
             HgError::ConfigValueParseError(error) => error.fmt(f),
         }
     }
 }
 
 // TODO: use `DisplayBytes` instead to show non-Unicode filenames losslessly?
 impl fmt::Display for IoErrorContext {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
             IoErrorContext::ReadingMetadata(path) => {
                 write!(f, "when reading metadata of {}", path.display())
             }
             IoErrorContext::ReadingFile(path) => {
                 write!(f, "when reading {}", path.display())
             }
             IoErrorContext::WritingFile(path) => {
                 write!(f, "when writing {}", path.display())
             }
             IoErrorContext::RemovingFile(path) => {
                 write!(f, "when removing {}", path.display())
             }
             IoErrorContext::RenamingFile { from, to } => write!(
                 f,
                 "when renaming {} to {}",
                 from.display(),
                 to.display()
             ),
             IoErrorContext::CanonicalizingPath(path) => {
                 write!(f, "when canonicalizing {}", path.display())
             }
             IoErrorContext::CurrentDir => {
                 write!(f, "error getting current working directory")
             }
             IoErrorContext::CurrentExe => {
                 write!(f, "error getting current executable")
             }
         }
     }
 }
 
 pub trait IoResultExt<T> {
     /// Annotate a possible I/O error as related to a reading a file at the
     /// given path.
     ///
     /// This allows printing something like “File not found when reading
     /// example.txt” instead of just “File not found”.
     ///
     /// Converts a `Result` with `std::io::Error` into one with `HgError`.
     fn when_reading_file(self, path: &std::path::Path) -> Result<T, HgError>;
 
+    fn when_writing_file(self, path: &std::path::Path) -> Result<T, HgError>;
+
     fn with_context(
         self,
         context: impl FnOnce() -> IoErrorContext,
     ) -> Result<T, HgError>;
 }
 
 impl<T> IoResultExt<T> for std::io::Result<T> {
     fn when_reading_file(self, path: &std::path::Path) -> Result<T, HgError> {
         self.with_context(|| IoErrorContext::ReadingFile(path.to_owned()))
     }
 
+    fn when_writing_file(self, path: &std::path::Path) -> Result<T, HgError> {
+        self.with_context(|| IoErrorContext::WritingFile(path.to_owned()))
+    }
+
     fn with_context(
         self,
         context: impl FnOnce() -> IoErrorContext,
     ) -> Result<T, HgError> {
         self.map_err(|error| HgError::IoError {
             error,
             context: context(),
         })
     }
 }
 
 pub trait HgResultExt<T> {
     /// Handle missing files separately from other I/O error cases.
     ///
     /// Wraps the `Ok` type in an `Option`:
     ///
     /// * `Ok(x)` becomes `Ok(Some(x))`
     /// * An I/O "not found" error becomes `Ok(None)`
     /// * Other errors are unchanged
     fn io_not_found_as_none(self) -> Result<Option<T>, HgError>;
 }
 
 impl<T> HgResultExt<T> for Result<T, HgError> {
     fn io_not_found_as_none(self) -> Result<Option<T>, HgError> {
         match self {
             Ok(x) => Ok(Some(x)),
             Err(HgError::IoError { error, .. })
                 if error.kind() == std::io::ErrorKind::NotFound =>
             {
                 Ok(None)
             }
             Err(other_error) => Err(other_error),
         }
     }
 }

rust/hg-core/src/vfs.rs

@@ -1,136 +1,157 b''
 use crate::errors::{HgError, IoErrorContext, IoResultExt};
 use memmap2::{Mmap, MmapOptions};
-use std::io::ErrorKind;
+use std::io::{ErrorKind, Write};
 use std::path::{Path, PathBuf};
 
 /// Filesystem access abstraction for the contents of a given "base" diretory
 #[derive(Clone, Copy)]
 pub struct Vfs<'a> {
     pub(crate) base: &'a Path,
 }
 
 struct FileNotFound(std::io::Error, PathBuf);
 
 impl Vfs<'_> {
     pub fn join(&self, relative_path: impl AsRef<Path>) -> PathBuf {
         self.base.join(relative_path)
     }
 
     pub fn symlink_metadata(
         &self,
         relative_path: impl AsRef<Path>,
     ) -> Result<std::fs::Metadata, HgError> {
         let path = self.join(relative_path);
         std::fs::symlink_metadata(&path).when_reading_file(&path)
     }
 
     pub fn read_link(
         &self,
         relative_path: impl AsRef<Path>,
     ) -> Result<PathBuf, HgError> {
         let path = self.join(relative_path);
         std::fs::read_link(&path).when_reading_file(&path)
     }
 
     pub fn read(
         &self,
         relative_path: impl AsRef<Path>,
     ) -> Result<Vec<u8>, HgError> {
         let path = self.join(relative_path);
         std::fs::read(&path).when_reading_file(&path)
     }
 
     fn mmap_open_gen(
         &self,
         relative_path: impl AsRef<Path>,
     ) -> Result<Result<Mmap, FileNotFound>, HgError> {
         let path = self.join(relative_path);
         let file = match std::fs::File::open(&path) {
             Err(err) => {
                 if let ErrorKind::NotFound = err.kind() {
                     return Ok(Err(FileNotFound(err, path)));
                 };
                 return (Err(err)).when_reading_file(&path);
             }
             Ok(file) => file,
         };
         // TODO: what are the safety requirements here?
         let mmap = unsafe { MmapOptions::new().map(&file) }
             .when_reading_file(&path)?;
         Ok(Ok(mmap))
     }
 
     pub fn mmap_open_opt(
         &self,
         relative_path: impl AsRef<Path>,
     ) -> Result<Option<Mmap>, HgError> {
         self.mmap_open_gen(relative_path).map(|res| res.ok())
     }
 
     pub fn mmap_open(
         &self,
         relative_path: impl AsRef<Path>,
     ) -> Result<Mmap, HgError> {
         match self.mmap_open_gen(relative_path)? {
             Err(FileNotFound(err, path)) => Err(err).when_reading_file(&path),
             Ok(res) => Ok(res),
         }
     }
 
     pub fn rename(
         &self,
         relative_from: impl AsRef<Path>,
         relative_to: impl AsRef<Path>,
     ) -> Result<(), HgError> {
         let from = self.join(relative_from);
         let to = self.join(relative_to);
         std::fs::rename(&from, &to)
             .with_context(|| IoErrorContext::RenamingFile { from, to })
     }
 
     pub fn remove_file(
         &self,
         relative_path: impl AsRef<Path>,
     ) -> Result<(), HgError> {
         let path = self.join(relative_path);
         std::fs::remove_file(&path)
             .with_context(|| IoErrorContext::RemovingFile(path))
     }
 
     #[cfg(unix)]
     pub fn create_symlink(
         &self,
         relative_link_path: impl AsRef<Path>,
         target_path: impl AsRef<Path>,
     ) -> Result<(), HgError> {
         let link_path = self.join(relative_link_path);
         std::os::unix::fs::symlink(target_path, &link_path)
-            .with_context(|| IoErrorContext::WritingFile(link_path))
+            .when_writing_file(&link_path)
+    }
+
+    /// Write `contents` into a temporary file, then rename to `relative_path`.
+    /// This makes writing to a file "atomic": a reader opening that path will
+    /// see either the previous contents of the file or the complete new
+    /// content, never a partial write.
+    pub fn atomic_write(
+        &self,
+        relative_path: impl AsRef<Path>,
+        contents: &[u8],
+    ) -> Result<(), HgError> {
+        let mut tmp = tempfile::NamedTempFile::new_in(self.base)
+            .when_writing_file(self.base)?;
+        tmp.write_all(contents)
+            .and_then(|()| tmp.flush())
+            .when_writing_file(tmp.path())?;
+        let path = self.join(relative_path);
+        tmp.persist(&path)
+            .map_err(|e| e.error)
+            .when_writing_file(&path)?;
+        Ok(())
     }
 }
 
 fn fs_metadata(
     path: impl AsRef<Path>,
 ) -> Result<Option<std::fs::Metadata>, HgError> {
     let path = path.as_ref();
     match std::fs::metadata(path) {
         Ok(meta) => Ok(Some(meta)),
         Err(error) => match error.kind() {
             // TODO: when we require a Rust version where `NotADirectory` is
             // stable, invert this logic and return None for it and `NotFound`
             // and propagate any other error.
             ErrorKind::PermissionDenied => Err(error).with_context(|| {
                 IoErrorContext::ReadingMetadata(path.to_owned())
             }),
             _ => Ok(None),
         },
     }
 }
 
 pub(crate) fn is_dir(path: impl AsRef<Path>) -> Result<bool, HgError> {
     Ok(fs_metadata(path)?.map_or(false, |meta| meta.is_dir()))
 }
 
 pub(crate) fn is_file(path: impl AsRef<Path>) -> Result<bool, HgError> {
     Ok(fs_metadata(path)?.map_or(false, |meta| meta.is_file()))
 }