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
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Revision Contents
Changeset List

Diff 25984

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(())
}
}