( )⚙ D10076 rhg: Check .hg/requires for absence of required features

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D10076

rhg: Check .hg/requires for absence of required features
ClosedPublic

Authored by SimonSapin on Feb 25 2021, 3:32 PM.

Details

Reviewers
pulkit
Group Reviewers
hg-reviewers
Commits
rHGa069639783a0: rhg: Check .hg/requires for absence of required features
Summary

Some old repository layouts are not supported.

Diff Detail

Repository
rHG Mercurial
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

Revision Contents
Changeset List

Diff 25969

rust/hg-core/src/requirements.rs

use crate::errors::{HgError, HgResultExt}; use crate::errors::{HgError, HgResultExt};
use crate::repo::{Repo, Vfs}; use crate::repo::{Repo, Vfs};
use crate::utils::join_display;
use std::collections::HashSet; use std::collections::HashSet;
fn parse(bytes: &[u8]) -> Result<HashSet<String>, HgError> { fn parse(bytes: &[u8]) -> Result<HashSet<String>, HgError> {
// The Python code reading this file uses `str.splitlines` // The Python code reading this file uses `str.splitlines`
// which looks for a number of line separators (even including a couple of // which looks for a number of line separators (even including a couple of
// non-ASCII ones), but Python code writing it always uses `\n`. // non-ASCII ones), but Python code writing it always uses `\n`.
let lines = bytes.split(|&byte| byte == b'\n'); let lines = bytes.split(|&byte| byte == b'\n');
// > the repository. This file was introduced in Mercurial 0.9.2, // > the repository. This file was introduced in Mercurial 0.9.2,
// > which means very old repositories may not have one. We assume // > which means very old repositories may not have one. We assume
// > a missing file translates to no requirements. // > a missing file translates to no requirements.
Ok(HashSet::new()) Ok(HashSet::new())
} }
} }
pub(crate) fn check(repo: &Repo) -> Result<(), HgError> { pub(crate) fn check(repo: &Repo) -> Result<(), HgError> {
for feature in repo.requirements() { let unknown: Vec<_> = repo
if !SUPPORTED.contains(&feature.as_str()) { .requirements()
// TODO: collect and all unknown features and include them in the .iter()
// error message? .map(String::as_str)
return Err(HgError::UnsupportedFeature(format!( // .filter(|feature| !ALL_SUPPORTED.contains(feature.as_str()))
.filter(|feature| {
!REQUIRED.contains(feature) && !SUPPORTED.contains(feature)
})
.collect();
if !unknown.is_empty() {
return Err(HgError::unsupported(format!(
"repository requires feature unknown to this Mercurial: {}", "repository requires feature unknown to this Mercurial: {}",
feature join_display(&unknown, ", ")
))); )));
} }
let missing: Vec<_> = REQUIRED
.iter()
.filter(|&&feature| !repo.requirements().contains(feature))
.collect();
if !missing.is_empty() {
return Err(HgError::unsupported(format!(
"repository is missing feature required by this Mercurial: {}",
join_display(&missing, ", ")
)));
} }
Ok(()) Ok(())
} }
// TODO: set this to actually-supported features /// rhg does not support repositories that are *missing* any of these features
const REQUIRED: &[&str] = &["revlogv1", "store", "fncache", "dotencode"];
/// rhg supports repository with or without these
const SUPPORTED: &[&str] = &[ const SUPPORTED: &[&str] = &[
"dotencode",
"fncache",
"generaldelta", "generaldelta",
"revlogv1",
SHARED_REQUIREMENT, SHARED_REQUIREMENT,
SHARESAFE_REQUIREMENT, SHARESAFE_REQUIREMENT,
SPARSEREVLOG_REQUIREMENT, SPARSEREVLOG_REQUIREMENT,
RELATIVE_SHARED_REQUIREMENT, RELATIVE_SHARED_REQUIREMENT,
"store",
// As of this writing everything rhg does is read-only. // As of this writing everything rhg does is read-only.
// When it starts writing to the repository, it’ll need to either keep the // 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 up to date or remove this entry:
"persistent-nodemap", NODEMAP_REQUIREMENT,
]; ];
// Copied from mercurial/requirements.py: // Copied from mercurial/requirements.py:
/// When narrowing is finalized and no longer subject to format changes, /// When narrowing is finalized and no longer subject to format changes,
/// we should move this to just "narrow" or similar. /// we should move this to just "narrow" or similar.
#[allow(unused)] #[allow(unused)]
pub(crate) const NARROW_REQUIREMENT: &str = "narrowhg-experimental"; pub(crate) const NARROW_REQUIREMENT: &str = "narrowhg-experimental";

rust/hg-core/src/utils.rs

// utils module // utils module
// //
// Copyright 2019 Raphaël Gomès <rgomes@octobus.net> // Copyright 2019 Raphaël Gomès <rgomes@octobus.net>
// //
// This software may be used and distributed according to the terms of the // This software may be used and distributed according to the terms of the
// GNU General Public License version 2 or any later version. // GNU General Public License version 2 or any later version.
//! Contains useful functions, traits, structs, etc. for use in core. //! Contains useful functions, traits, structs, etc. for use in core.
use crate::errors::{HgError, IoErrorContext}; use crate::errors::{HgError, IoErrorContext};
use crate::utils::hg_path::HgPath; use crate::utils::hg_path::HgPath;
use im_rc::ordmap::DiffItem; use im_rc::ordmap::DiffItem;
use im_rc::ordmap::OrdMap; use im_rc::ordmap::OrdMap;
use std::cell::Cell;
use std::fmt;
use std::{io::Write, ops::Deref}; use std::{io::Write, ops::Deref};
pub mod files; pub mod files;
pub mod hg_path; pub mod hg_path;
pub mod path_auditor; pub mod path_auditor;
/// Useful until rust/issues/56345 is stable /// Useful until rust/issues/56345 is stable
/// ///
left left
} else { } else {
for (key, value) in right_updates { for (key, value) in right_updates {
right.insert(key, value); right.insert(key, value);
} }
right right
} }
} }
/// Join items of the iterable with the given separator, similar to Python’s
/// `separator.join(iter)`.
///
/// Formatting the return value consumes the iterator.
/// Formatting it again will produce an empty string.
pub fn join_display(
iter: impl IntoIterator<Item = impl fmt::Display>,
separator: impl fmt::Display,
) -> impl fmt::Display {
JoinDisplay {
iter: Cell::new(Some(iter.into_iter())),
separator,
}
}
struct JoinDisplay<I, S> {
iter: Cell<Option<I>>,
separator: S,
}
impl<I, T, S> fmt::Display for JoinDisplay<I, S>
where
I: Iterator<Item = T>,
T: fmt::Display,
S: fmt::Display,
{
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
if let Some(mut iter) = self.iter.take() {
if let Some(first) = iter.next() {
first.fmt(f)?;
}
for value in iter {
self.separator.fmt(f)?;
value.fmt(f)?;
}
}
Ok(())
}
}