rust: replace RequirementsError with HgError

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

rust/hg-core/src/repo.rs

@@ -1,92 +1,91 b''
+use crate::errors::HgError;
 use crate::operations::{find_root, FindRootError};
 use crate::requirements;
 use memmap::{Mmap, MmapOptions};
 use std::path::{Path, PathBuf};
 
 /// A repository on disk
 pub struct Repo {
     working_directory: PathBuf,
     dot_hg: PathBuf,
     store: PathBuf,
 }
 
 /// Filesystem access abstraction for the contents of a given "base" diretory
 #[derive(Clone, Copy)]
 pub(crate) struct Vfs<'a> {
     base: &'a Path,
 }
 
 impl Repo {
     /// Returns `None` if the given path doesn’t look like a repository
     /// (doesn’t contain a `.hg` sub-directory).
     pub fn for_path(root: impl Into<PathBuf>) -> Self {
         let working_directory = root.into();
         let dot_hg = working_directory.join(".hg");
         Self {
             store: dot_hg.join("store"),
             dot_hg,
             working_directory,
         }
     }
 
     pub fn find() -> Result<Self, FindRootError> {
         find_root().map(Self::for_path)
     }
 
-    pub fn check_requirements(
-        &self,
-    ) -> Result<(), requirements::RequirementsError> {
+    pub fn check_requirements(&self) -> Result<(), HgError> {
         requirements::check(self)
     }
 
     pub fn working_directory_path(&self) -> &Path {
         &self.working_directory
     }
 
     /// For accessing repository files (in `.hg`), except for the store
     /// (`.hg/store`).
     pub(crate) fn hg_vfs(&self) -> Vfs<'_> {
         Vfs { base: &self.dot_hg }
     }
 
     /// For accessing repository store files (in `.hg/store`)
     pub(crate) fn store_vfs(&self) -> Vfs<'_> {
         Vfs { base: &self.store }
     }
 
     /// For accessing the working copy
 
     // The undescore prefix silences the "never used" warning. Remove before
     // using.
     pub(crate) fn _working_directory_vfs(&self) -> Vfs<'_> {
         Vfs {
             base: &self.working_directory,
         }
     }
 }
 
 impl Vfs<'_> {
     pub(crate) fn read(
         &self,
         relative_path: impl AsRef<Path>,
     ) -> std::io::Result<Vec<u8>> {
         std::fs::read(self.base.join(relative_path))
     }
 
     pub(crate) fn open(
         &self,
         relative_path: impl AsRef<Path>,
     ) -> std::io::Result<std::fs::File> {
         std::fs::File::open(self.base.join(relative_path))
     }
 
     pub(crate) fn mmap_open(
         &self,
         relative_path: impl AsRef<Path>,
     ) -> std::io::Result<Mmap> {
         let file = self.open(relative_path)?;
         // TODO: what are the safety requirements here?
         let mmap = unsafe { MmapOptions::new().map(&file) }?;
         Ok(mmap)
     }
 }

rust/hg-core/src/requirements.rs

@@ -1,76 +1,70 b''
+use crate::errors::{HgError, HgResultExt, IoResultExt};
 use crate::repo::Repo;
-use std::io;
 
-#[derive(Debug)]
-pub enum RequirementsError {
-    // TODO: include a path?
-    Io(io::Error),
-    /// The `requires` file is corrupted
-    Corrupted,
-    /// The repository requires a feature that we don't support
-    Unsupported {
-        feature: String,
-    },
-}
-
-fn parse(bytes: &[u8]) -> Result<Vec<String>, ()> {
+fn parse(bytes: &[u8]) -> Result<Vec<String>, HgError> {
     // The Python code reading this file uses `str.splitlines`
     // which looks for a number of line separators (even including a couple of
     // non-ASCII ones), but Python code writing it always uses `\n`.
     let lines = bytes.split(|&byte| byte == b'\n');
 
     lines
         .filter(|line| !line.is_empty())
         .map(|line| {
             // Python uses Unicode `str.isalnum` but feature names are all
             // ASCII
             if line[0].is_ascii_alphanumeric() && line.is_ascii() {
                 Ok(String::from_utf8(line.into()).unwrap())
             } else {
-                Err(())
+                Err(HgError::corrupted("parse error in 'requires' file"))
             }
         })
         .collect()
 }
 
-pub fn load(repo: &Repo) -> Result<Vec<String>, RequirementsError> {
-    match repo.hg_vfs().read("requires") {
-        Ok(bytes) => parse(&bytes).map_err(|()| RequirementsError::Corrupted),
-
+pub fn load(repo: &Repo) -> Result<Vec<String>, HgError> {
+    if let Some(bytes) = repo
+        .hg_vfs()
+        .read("requires")
+        .for_file("requires".as_ref())
+        .io_not_found_as_none()?
+    {
+        parse(&bytes)
+    } else {
         // Treat a missing file the same as an empty file.
         // From `mercurial/localrepo.py`:
         // > requires file contains a newline-delimited list of
         // > features/capabilities the opener (us) must have in order to use
         // > the repository. This file was introduced in Mercurial 0.9.2,
         // > which means very old repositories may not have one. We assume
         // > a missing file translates to no requirements.
-        Err(error) if error.kind() == std::io::ErrorKind::NotFound => {
             Ok(Vec::new())
         }
-
-        Err(error) => Err(RequirementsError::Io(error))?,
-    }
 }
 
-pub fn check(repo: &Repo) -> Result<(), RequirementsError> {
+pub fn check(repo: &Repo) -> Result<(), HgError> {
     for feature in load(repo)? {
         if !SUPPORTED.contains(&&*feature) {
-            return Err(RequirementsError::Unsupported { feature });
+            // TODO: collect and all unknown features and include them in the
+            // error message?
+            return Err(HgError::UnsupportedFeature(format!(
+                "repository requires feature unknown to this Mercurial: {}",
+                feature
+            )));
         }
     }
     Ok(())
 }
 
 // TODO: set this to actually-supported features
 const SUPPORTED: &[&str] = &[
     "dotencode",
     "fncache",
     "generaldelta",
     "revlogv1",
     "sparserevlog",
     "store",
     // As of this writing everything rhg does is read-only.
     // When it starts writing to the repository, it’ll need to either keep the
     // persistent nodemap up to date or remove this entry:
     "persistent-nodemap",
 ];

rust/rhg/src/error.rs

@@ -1,160 +1,146 b''
 use crate::exitcode;
 use crate::ui::utf8_to_local;
 use crate::ui::UiError;
 use format_bytes::format_bytes;
 use hg::errors::HgError;
 use hg::operations::FindRootError;
-use hg::requirements::RequirementsError;
 use hg::revlog::revlog::RevlogError;
 use hg::utils::files::get_bytes_from_path;
 use std::convert::From;
 use std::path::PathBuf;
 
 /// The kind of command error
 #[derive(Debug, derive_more::From)]
 pub enum CommandError {
     /// The root of the repository cannot be found
     RootNotFound(PathBuf),
     /// The current directory cannot be found
     CurrentDirNotFound(std::io::Error),
-    /// `.hg/requires`
-    #[from]
-    RequirementsError(RequirementsError),
     /// The standard output stream cannot be written to
     StdoutError,
     /// The standard error stream cannot be written to
     StderrError,
     /// The command aborted
     Abort(Option<Vec<u8>>),
     /// A mercurial capability as not been implemented.
     Unimplemented,
     /// Common cases
     #[from]
     Other(HgError),
 }
 
 impl CommandError {
     pub fn get_exit_code(&self) -> exitcode::ExitCode {
         match self {
             CommandError::RootNotFound(_) => exitcode::ABORT,
             CommandError::CurrentDirNotFound(_) => exitcode::ABORT,
-            CommandError::RequirementsError(
-                RequirementsError::Unsupported { .. },
-            ) => exitcode::UNIMPLEMENTED_COMMAND,
-            CommandError::RequirementsError(_) => exitcode::ABORT,
             CommandError::StdoutError => exitcode::ABORT,
             CommandError::StderrError => exitcode::ABORT,
             CommandError::Abort(_) => exitcode::ABORT,
             CommandError::Unimplemented => exitcode::UNIMPLEMENTED_COMMAND,
             CommandError::Other(HgError::UnsupportedFeature(_)) => {
                 exitcode::UNIMPLEMENTED_COMMAND
             }
             CommandError::Other(_) => exitcode::ABORT,
         }
     }
 
     /// Return the message corresponding to the error if any
     pub fn get_error_message_bytes(&self) -> Option<Vec<u8>> {
         match self {
             CommandError::RootNotFound(path) => {
                 let bytes = get_bytes_from_path(path);
                 Some(format_bytes!(
                     b"abort: no repository found in '{}' (.hg not found)!\n",
                     bytes.as_slice()
                 ))
             }
             CommandError::CurrentDirNotFound(e) => Some(format_bytes!(
                 b"abort: error getting current working directory: {}\n",
                 e.to_string().as_bytes(),
             )),
-            CommandError::RequirementsError(RequirementsError::Corrupted) => {
-                Some(
-                    "abort: .hg/requires is corrupted\n".as_bytes().to_owned(),
-                )
-            }
             CommandError::Abort(message) => message.to_owned(),
 
-            CommandError::RequirementsError(_)
-            | CommandError::StdoutError
+            CommandError::StdoutError
             | CommandError::StderrError
             | CommandError::Unimplemented
             | CommandError::Other(HgError::UnsupportedFeature(_)) => None,
 
             CommandError::Other(e) => {
                 Some(format_bytes!(b"{}\n", e.to_string().as_bytes()))
             }
         }
     }
 
     /// Exist the process with the corresponding exit code.
     pub fn exit(&self) {
         std::process::exit(self.get_exit_code())
     }
 }
 
 impl From<UiError> for CommandError {
     fn from(error: UiError) -> Self {
         match error {
             UiError::StdoutError(_) => CommandError::StdoutError,
             UiError::StderrError(_) => CommandError::StderrError,
         }
     }
 }
 
 impl From<FindRootError> for CommandError {
     fn from(err: FindRootError) -> Self {
         match err {
             FindRootError::RootNotFound(path) => {
                 CommandError::RootNotFound(path)
             }
             FindRootError::GetCurrentDirError(e) => {
                 CommandError::CurrentDirNotFound(e)
             }
         }
     }
 }
 
 impl From<(RevlogError, &str)> for CommandError {
     fn from((err, rev): (RevlogError, &str)) -> CommandError {
         match err {
             RevlogError::IoError(err) => CommandError::Abort(Some(
                 utf8_to_local(&format!("abort: {}\n", err)).into(),
             )),
             RevlogError::InvalidRevision => CommandError::Abort(Some(
                 utf8_to_local(&format!(
                     "abort: invalid revision identifier {}\n",
                     rev
                 ))
                 .into(),
             )),
             RevlogError::AmbiguousPrefix => CommandError::Abort(Some(
                 utf8_to_local(&format!(
                     "abort: ambiguous revision identifier {}\n",
                     rev
                 ))
                 .into(),
             )),
             RevlogError::UnsuportedVersion(version) => {
                 CommandError::Abort(Some(
                     utf8_to_local(&format!(
                         "abort: unsupported revlog version {}\n",
                         version
                     ))
                     .into(),
                 ))
             }
             RevlogError::Corrupted => {
                 CommandError::Abort(Some("abort: corrupted revlog\n".into()))
             }
             RevlogError::UnknowDataFormat(format) => {
                 CommandError::Abort(Some(
                     utf8_to_local(&format!(
                         "abort: unknow revlog dataformat {:?}\n",
                         format
                     ))
                     .into(),
                 ))
             }
         }
     }
 }

tests/test-rhg.t

@@ -1,204 +1,204 b''
 #require rust
 
 Define an rhg function that will only run if rhg exists
   $ rhg() {
   > if [ -f "$RUNTESTDIR/../rust/target/release/rhg" ]; then
   >   "$RUNTESTDIR/../rust/target/release/rhg" "$@"
   > else
   >   echo "skipped: Cannot find rhg. Try to run cargo build in rust/rhg."
   >   exit 80
   > fi
   > }
 
 Unimplemented command
   $ rhg unimplemented-command
   error: Found argument 'unimplemented-command' which wasn't expected, or isn't valid in this context
   
   USAGE:
       rhg <SUBCOMMAND>
   
   For more information try --help
   [252]
 
 Finding root
   $ rhg root
   abort: no repository found in '$TESTTMP' (.hg not found)!
   [255]
 
   $ hg init repository
   $ cd repository
   $ rhg root
   $TESTTMP/repository
 
 Unwritable file descriptor
   $ rhg root > /dev/full
   abort: No space left on device (os error 28)
   [255]
 
 Deleted repository
   $ rm -rf `pwd`
   $ rhg root
   abort: error getting current working directory: $ENOENT$
   [255]
 
 Listing tracked files
   $ cd $TESTTMP
   $ hg init repository
   $ cd repository
   $ for i in 1 2 3; do
   >   echo $i >> file$i
   >   hg add file$i
   > done
   > hg commit -m "commit $i" -q
 
 Listing tracked files from root
   $ rhg files
   file1
   file2
   file3
 
 Listing tracked files from subdirectory
   $ mkdir -p path/to/directory
   $ cd path/to/directory
   $ rhg files
   ../../../file1
   ../../../file2
   ../../../file3
 
 Listing tracked files through broken pipe
   $ rhg files | head -n 1
   ../../../file1
 
 Debuging data in inline index
   $ cd $TESTTMP
   $ rm -rf repository
   $ hg init repository
   $ cd repository
   $ for i in 1 2 3 4 5 6; do
   >   echo $i >> file-$i
   >   hg add file-$i
   >   hg commit -m "Commit $i" -q
   > done
   $ rhg debugdata -c 2
   8d0267cb034247ebfa5ee58ce59e22e57a492297
   test
   0 0
   file-3
   
   Commit 3 (no-eol)
   $ rhg debugdata -m 2
   file-1\x00b8e02f6433738021a065f94175c7cd23db5f05be (esc)
   file-2\x005d9299349fc01ddd25d0070d149b124d8f10411e (esc)
   file-3\x002661d26c649684b482d10f91960cc3db683c38b4 (esc)
 
 Debuging with full node id
   $ rhg debugdata -c `hg log -r 0 -T '{node}'`
   d1d1c679d3053e8926061b6f45ca52009f011e3f
   test
   0 0
   file-1
   
   Commit 1 (no-eol)
 
 Specifying revisions by changeset ID
   $ hg log -T '{node}\n'
   c6ad58c44207b6ff8a4fbbca7045a5edaa7e908b
   d654274993d0149eecc3cc03214f598320211900
   f646af7e96481d3a5470b695cf30ad8e3ab6c575
   cf8b83f14ead62b374b6e91a0e9303b85dfd9ed7
   91c6f6e73e39318534dc415ea4e8a09c99cd74d6
   6ae9681c6d30389694d8701faf24b583cf3ccafe
   $ rhg files -r cf8b83
   file-1
   file-2
   file-3
   $ rhg cat -r cf8b83 file-2
   2
   $ rhg cat -r c file-2
   abort: ambiguous revision identifier c
   [255]
   $ rhg cat -r d file-2
   2
 
 Cat files
   $ cd $TESTTMP
   $ rm -rf repository
   $ hg init repository
   $ cd repository
   $ echo "original content" > original
   $ hg add original
   $ hg commit -m "add original" original
   $ rhg cat -r 0 original
   original content
 Cat copied file should not display copy metadata
   $ hg copy original copy_of_original
   $ hg commit -m "add copy of original"
   $ rhg cat -r 1 copy_of_original
   original content
 
 Requirements
   $ rhg debugrequirements
   dotencode
   fncache
   generaldelta
   revlogv1
   sparserevlog
   store
 
   $ echo indoor-pool >> .hg/requires
   $ rhg files
   [252]
 
   $ rhg cat -r 1 copy_of_original
   [252]
 
   $ rhg debugrequirements
   dotencode
   fncache
   generaldelta
   revlogv1
   sparserevlog
   store
   indoor-pool
 
   $ echo -e '\xFF' >> .hg/requires
   $ rhg debugrequirements
-  abort: .hg/requires is corrupted
+  corrupted repository: parse error in 'requires' file
   [255]
 
 Persistent nodemap
   $ cd $TESTTMP
   $ rm -rf repository
   $ hg init repository
   $ cd repository
   $ rhg debugrequirements | grep nodemap
   [1]
   $ hg debugbuilddag .+5000 --overwritten-file --config "storage.revlog.nodemap.mode=warn"
   $ hg id -r tip
   c3ae8dec9fad tip
   $ ls .hg/store/00changelog*
   .hg/store/00changelog.d
   .hg/store/00changelog.i
   $ rhg files -r c3ae8dec9fad
   of
 
   $ cd $TESTTMP
   $ rm -rf repository
   $ hg --config format.use-persistent-nodemap=True init repository
   $ cd repository
   $ rhg debugrequirements | grep nodemap
   persistent-nodemap
   $ hg debugbuilddag .+5000 --overwritten-file --config "storage.revlog.nodemap.mode=warn"
   $ hg id -r tip
   c3ae8dec9fad tip
   $ ls .hg/store/00changelog*
   .hg/store/00changelog-*.nd (glob)
   .hg/store/00changelog.d
   .hg/store/00changelog.i
   .hg/store/00changelog.n
 
 Specifying revisions by changeset ID
   $ rhg files -r c3ae8dec9fad
   of
   $ rhg cat -r c3ae8dec9fad of
   r5000