rhg: exit with relevant code for unsupported requirements

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

rust/hg-core/src/requirements.rs

@@ -1,53 +1,72
 use std::io;
 use std::path::Path;
 
 #[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>, ()> {
     // 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() {
                 Ok(String::from_utf8(line.into()).unwrap())
             } else {
                 Err(())
             }
         })
         .collect()
 }
 
 pub fn load(repo_root: &Path) -> Result<Vec<String>, RequirementsError> {
     match std::fs::read(repo_root.join(".hg").join("requires")) {
         Ok(bytes) => parse(&bytes).map_err(|()| RequirementsError::Corrupted),
 
         // 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_root: &Path) -> Result<(), RequirementsError> {
+    for feature in load(repo_root)? {
+        if !SUPPORTED.contains(&&*feature) {
+            return Err(RequirementsError::Unsupported { feature })
+        }
+    }
+    Ok(())
+}
+
+// TODO: set this to actually-supported features
+const SUPPORTED: &[&str] = &[
+    "dotencode",
+    "fncache",
+    "generaldelta",
+    "revlogv1",
+    "sparserevlog",
+    "store",
+];

rust/rhg/src/commands/cat.rs

@@ -1,99 +1,101
 use crate::commands::Command;
 use crate::error::{CommandError, CommandErrorKind};
 use crate::ui::utf8_to_local;
 use crate::ui::Ui;
 use hg::operations::FindRoot;
 use hg::operations::{CatRev, CatRevError, CatRevErrorKind};
+use hg::requirements;
 use hg::utils::hg_path::HgPathBuf;
 use micro_timer::timed;
 use std::convert::TryFrom;
 
 pub const HELP_TEXT: &str = "
 Output the current or given revision of files
 ";
 
 pub struct CatCommand<'a> {
     rev: Option<&'a str>,
     files: Vec<&'a str>,
 }
 
 impl<'a> CatCommand<'a> {
     pub fn new(rev: Option<&'a str>, files: Vec<&'a str>) -> Self {
         Self { rev, files }
     }
 
     fn display(&self, ui: &Ui, data: &[u8]) -> Result<(), CommandError> {
         ui.write_stdout(data)?;
         Ok(())
     }
 }
 
 impl<'a> Command for CatCommand<'a> {
     #[timed]
     fn run(&self, ui: &Ui) -> Result<(), CommandError> {
         let root = FindRoot::new().run()?;
+        requirements::check(&root)?;
         let cwd = std::env::current_dir()
             .or_else(|e| Err(CommandErrorKind::CurrentDirNotFound(e)))?;
 
         let mut files = vec![];
         for file in self.files.iter() {
             let normalized = cwd.join(&file);
             let stripped = normalized
                 .strip_prefix(&root)
                 .or(Err(CommandErrorKind::Abort(None)))?;
             let hg_file = HgPathBuf::try_from(stripped.to_path_buf())
                 .or(Err(CommandErrorKind::Abort(None)))?;
             files.push(hg_file);
         }
 
         match self.rev {
             Some(rev) => {
                 let mut operation = CatRev::new(&root, rev, &files)
                     .map_err(|e| map_rev_error(rev, e))?;
                 let data =
                     operation.run().map_err(|e| map_rev_error(rev, e))?;
                 self.display(ui, &data)
             }
             None => Err(CommandErrorKind::Unimplemented.into()),
         }
     }
 }
 
 /// Convert `CatRevErrorKind` to `CommandError`
 fn map_rev_error(rev: &str, err: CatRevError) -> CommandError {
     CommandError {
         kind: match err.kind {
             CatRevErrorKind::IoError(err) => CommandErrorKind::Abort(Some(
                 utf8_to_local(&format!("abort: {}\n", err)).into(),
             )),
             CatRevErrorKind::InvalidRevision => CommandErrorKind::Abort(Some(
                 utf8_to_local(&format!(
                     "abort: invalid revision identifier{}\n",
                     rev
                 ))
                 .into(),
             )),
             CatRevErrorKind::UnsuportedRevlogVersion(version) => {
                 CommandErrorKind::Abort(Some(
                     utf8_to_local(&format!(
                         "abort: unsupported revlog version {}\n",
                         version
                     ))
                     .into(),
                 ))
             }
             CatRevErrorKind::CorruptedRevlog => CommandErrorKind::Abort(Some(
                 "abort: corrupted revlog\n".into(),
             )),
             CatRevErrorKind::UnknowRevlogDataFormat(format) => {
                 CommandErrorKind::Abort(Some(
                     utf8_to_local(&format!(
                         "abort: unknow revlog dataformat {:?}\n",
                         format
                     ))
                     .into(),
                 ))
             }
         },
     }
 }

rust/rhg/src/commands/files.rs

@@ -1,136 +1,138
 use crate::commands::Command;
 use crate::error::{CommandError, CommandErrorKind};
 use crate::ui::utf8_to_local;
 use crate::ui::Ui;
 use hg::operations::FindRoot;
 use hg::operations::{
     ListDirstateTrackedFiles, ListDirstateTrackedFilesError,
     ListDirstateTrackedFilesErrorKind,
 };
 use hg::operations::{
     ListRevTrackedFiles, ListRevTrackedFilesError,
     ListRevTrackedFilesErrorKind,
 };
+use hg::requirements;
 use hg::utils::files::{get_bytes_from_path, relativize_path};
 use hg::utils::hg_path::{HgPath, HgPathBuf};
 use std::path::PathBuf;
 
 pub const HELP_TEXT: &str = "
 List tracked files.
 
 Returns 0 on success.
 ";
 
 pub struct FilesCommand<'a> {
     rev: Option<&'a str>,
 }
 
 impl<'a> FilesCommand<'a> {
     pub fn new(rev: Option<&'a str>) -> Self {
         FilesCommand { rev }
     }
 
     fn display_files(
         &self,
         ui: &Ui,
         root: &PathBuf,
         files: impl IntoIterator<Item = &'a HgPath>,
     ) -> Result<(), CommandError> {
         let cwd = std::env::current_dir()
             .or_else(|e| Err(CommandErrorKind::CurrentDirNotFound(e)))?;
         let rooted_cwd = cwd
             .strip_prefix(&root)
             .expect("cwd was already checked within the repository");
         let rooted_cwd = HgPathBuf::from(get_bytes_from_path(rooted_cwd));
 
         let mut stdout = ui.stdout_buffer();
 
         for file in files {
             stdout.write_all(relativize_path(file, &rooted_cwd).as_ref())?;
             stdout.write_all(b"\n")?;
         }
         stdout.flush()?;
         Ok(())
     }
 }
 
 impl<'a> Command for FilesCommand<'a> {
     fn run(&self, ui: &Ui) -> Result<(), CommandError> {
         let root = FindRoot::new().run()?;
+        requirements::check(&root)?;
         if let Some(rev) = self.rev {
             let mut operation = ListRevTrackedFiles::new(&root, rev)
                 .map_err(|e| map_rev_error(rev, e))?;
             let files = operation.run().map_err(|e| map_rev_error(rev, e))?;
             self.display_files(ui, &root, files)
         } else {
             let mut operation = ListDirstateTrackedFiles::new(&root)
                 .map_err(map_dirstate_error)?;
             let files = operation.run().map_err(map_dirstate_error)?;
             self.display_files(ui, &root, files)
         }
     }
 }
 
 /// Convert `ListRevTrackedFilesErrorKind` to `CommandError`
 fn map_rev_error(rev: &str, err: ListRevTrackedFilesError) -> CommandError {
     CommandError {
         kind: match err.kind {
             ListRevTrackedFilesErrorKind::IoError(err) => {
                 CommandErrorKind::Abort(Some(
                     utf8_to_local(&format!("abort: {}\n", err)).into(),
                 ))
             }
             ListRevTrackedFilesErrorKind::InvalidRevision => {
                 CommandErrorKind::Abort(Some(
                     utf8_to_local(&format!(
                         "abort: invalid revision identifier{}\n",
                         rev
                     ))
                     .into(),
                 ))
             }
             ListRevTrackedFilesErrorKind::UnsuportedRevlogVersion(version) => {
                 CommandErrorKind::Abort(Some(
                     utf8_to_local(&format!(
                         "abort: unsupported revlog version {}\n",
                         version
                     ))
                     .into(),
                 ))
             }
             ListRevTrackedFilesErrorKind::CorruptedRevlog => {
                 CommandErrorKind::Abort(Some(
                     "abort: corrupted revlog\n".into(),
                 ))
             }
             ListRevTrackedFilesErrorKind::UnknowRevlogDataFormat(format) => {
                 CommandErrorKind::Abort(Some(
                     utf8_to_local(&format!(
                         "abort: unknow revlog dataformat {:?}\n",
                         format
                     ))
                     .into(),
                 ))
             }
         },
     }
 }
 
 /// Convert `ListDirstateTrackedFilesError` to `CommandError`
 fn map_dirstate_error(err: ListDirstateTrackedFilesError) -> CommandError {
     CommandError {
         kind: match err.kind {
             ListDirstateTrackedFilesErrorKind::IoError(err) => {
                 CommandErrorKind::Abort(Some(
                     utf8_to_local(&format!("abort: {}\n", err)).into(),
                 ))
             }
             ListDirstateTrackedFilesErrorKind::ParseError(_) => {
                 CommandErrorKind::Abort(Some(
                     // TODO find a better error message
                     b"abort: parse error\n".to_vec(),
                 ))
             }
         },
     }
 }

rust/rhg/src/error.rs

@@ -1,130 +1,133
 use crate::exitcode;
 use crate::ui::UiError;
 use hg::operations::{FindRootError, FindRootErrorKind};
 use hg::requirements::RequirementsError;
 use hg::utils::files::get_bytes_from_path;
 use std::convert::From;
 use std::path::PathBuf;
 
 /// The kind of command error
 #[derive(Debug)]
 pub enum CommandErrorKind {
     /// The root of the repository cannot be found
     RootNotFound(PathBuf),
     /// The current directory cannot be found
     CurrentDirNotFound(std::io::Error),
     /// `.hg/requires`
     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,
 }
 
 impl CommandErrorKind {
     pub fn get_exit_code(&self) -> exitcode::ExitCode {
         match self {
             CommandErrorKind::RootNotFound(_) => exitcode::ABORT,
             CommandErrorKind::CurrentDirNotFound(_) => exitcode::ABORT,
+            CommandErrorKind::RequirementsError(
+                RequirementsError::Unsupported { .. },
+            ) => exitcode::UNIMPLEMENTED_COMMAND,
             CommandErrorKind::RequirementsError(_) => exitcode::ABORT,
             CommandErrorKind::StdoutError => exitcode::ABORT,
             CommandErrorKind::StderrError => exitcode::ABORT,
             CommandErrorKind::Abort(_) => exitcode::ABORT,
             CommandErrorKind::Unimplemented => exitcode::UNIMPLEMENTED_COMMAND,
         }
     }
 
     /// Return the message corresponding to the error kind if any
     pub fn get_error_message_bytes(&self) -> Option<Vec<u8>> {
         match self {
             // TODO use formating macro
             CommandErrorKind::RootNotFound(path) => {
                 let bytes = get_bytes_from_path(path);
                 Some(
                     [
                         b"abort: no repository found in '",
                         bytes.as_slice(),
                         b"' (.hg not found)!\n",
                     ]
                     .concat(),
                 )
             }
             // TODO use formating macro
             CommandErrorKind::CurrentDirNotFound(e) => Some(
                 [
                     b"abort: error getting current working directory: ",
                     e.to_string().as_bytes(),
                     b"\n",
                 ]
                 .concat(),
             ),
             CommandErrorKind::RequirementsError(
                 RequirementsError::Corrupted,
             ) => Some(
                 "abort: .hg/requires is corrupted\n".as_bytes().to_owned(),
             ),
             CommandErrorKind::Abort(message) => message.to_owned(),
             _ => None,
         }
     }
 }
 
 /// The error type for the Command trait
 #[derive(Debug)]
 pub struct CommandError {
     pub kind: CommandErrorKind,
 }
 
 impl CommandError {
     /// Exist the process with the corresponding exit code.
     pub fn exit(&self) {
         std::process::exit(self.kind.get_exit_code())
     }
 
     /// Return the message corresponding to the command error if any
     pub fn get_error_message_bytes(&self) -> Option<Vec<u8>> {
         self.kind.get_error_message_bytes()
     }
 }
 
 impl From<CommandErrorKind> for CommandError {
     fn from(kind: CommandErrorKind) -> Self {
         CommandError { kind }
     }
 }
 
 impl From<UiError> for CommandError {
     fn from(error: UiError) -> Self {
         CommandError {
             kind: match error {
                 UiError::StdoutError(_) => CommandErrorKind::StdoutError,
                 UiError::StderrError(_) => CommandErrorKind::StderrError,
             },
         }
     }
 }
 
 impl From<FindRootError> for CommandError {
     fn from(err: FindRootError) -> Self {
         match err.kind {
             FindRootErrorKind::RootNotFound(path) => CommandError {
                 kind: CommandErrorKind::RootNotFound(path),
             },
             FindRootErrorKind::GetCurrentDirError(e) => CommandError {
                 kind: CommandErrorKind::CurrentDirNotFound(e),
             },
         }
     }
 }
 
 impl From<RequirementsError> for CommandError {
     fn from(err: RequirementsError) -> Self {
         CommandError {
             kind: CommandErrorKind::RequirementsError(err),
         }
     }
 }

tests/test-rhg.t

@@ -1,126 +1,142
 #require rust
 
 Define an rhg function that will only run if rhg exists
   $ rhg() {
   > if [ -f "$RUNTESTDIR/../rust/target/debug/rhg" ]; then
   >   "$RUNTESTDIR/../rust/target/debug/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; do
   >   echo $i >> file$i
   >   hg add file$i
   >   hg commit -m "commit $i" -q
   > done
   $ rhg debugdata -c 2
   e36fa63d37a576b27a69057598351db6ee5746bd
   test
   0 0
   file3
   
   commit 3 (no-eol)
   $ rhg debugdata -m 2
   file1\x00b8e02f6433738021a065f94175c7cd23db5f05be (esc)
   file2\x005d9299349fc01ddd25d0070d149b124d8f10411e (esc)
   file3\x002661d26c649684b482d10f91960cc3db683c38b4 (esc)
 
 Debuging with full node id
   $ rhg debugdata -c `hg log -r 0 -T '{node}'`
   c8e64718e1ca0312eeee0f59d37f8dc612793856
   test
   0 0
   file1
   
   commit 1 (no-eol)
 
 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