This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11752

rhg: allow rhg in sparse repos when the operations only need the store
AbandonedPublic

Authored by aalekseyev on Nov 11 2021, 2:24 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers

Diff Detail

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

Event Timeline

aalekseyev created this revision.Nov 11 2021, 2:24 PM
aalekseyev abandoned this revision.Nov 16 2021, 7:19 AM

I'm abandoning this in favor of: https://phab.mercurial-scm.org/D11764
That's less conservative (it does the checks at the level of individual commands, not at the level of hg-core), but it's simpler and more useful.

Revision Contents
Changeset List

Diff 31060

rust/hg-core/src/operations/list_tracked_files.rs

pub struct Dirstate { pub struct Dirstate {
/// The `dirstate` content. /// The `dirstate` content.
content: Vec<u8>, content: Vec<u8>,
v2_metadata: Option<Vec<u8>>, v2_metadata: Option<Vec<u8>>,
} }
impl Dirstate { impl Dirstate {
pub fn new(repo: &Repo) -> Result<Self, HgError> { pub fn new(repo: &Repo) -> Result<Self, HgError> {
let mut content = repo.hg_vfs().read("dirstate")?; let hg_vfs = repo.hg_vfs_for_dirstate()?;
let mut content = hg_vfs.read("dirstate")?;
let v2_metadata = if repo.has_dirstate_v2() { let v2_metadata = if repo.has_dirstate_v2() {
let docket = read_docket(&content)?; let docket = read_docket(&content)?;
let meta = docket.tree_metadata().to_vec(); let meta = docket.tree_metadata().to_vec();
content = repo.hg_vfs().read(docket.data_filename())?; content = hg_vfs.read(docket.data_filename())?;
Some(meta) Some(meta)
} else { } else {
None None
}; };
Ok(Self { Ok(Self {
content, content,
v2_metadata, v2_metadata,
}) })

rust/hg-core/src/repo.rs

} }
pub fn config(&self) -> &Config { pub fn config(&self) -> &Config {
&self.config &self.config
} }
/// For accessing repository files (in `.hg`), except for the store /// For accessing repository files (in `.hg`), except for the store
/// (`.hg/store`). /// (`.hg/store`).
pub fn hg_vfs(&self) -> Vfs<'_> { fn hg_vfs(&self) -> Vfs<'_> {
Vfs { base: &self.dot_hg }
}
fn has_sparse(&self) -> bool {
self.requirements.contains(requirements::SPARSE_REQUIREMENT)
}
fn check_not_sparse(&self) -> Result<(), HgError> {
if self.has_sparse() {
Err(HgError::unsupported(format!(
"repository uses a sparse working copy, this is not supported by rhg",
)))
} else {
Ok(())
}
}
/// For accessing the dirstate.
pub fn hg_vfs_for_dirstate(&self) -> Result<Vfs<'_>, HgError> {
let () = self.check_not_sparse()?;
Ok(Vfs { base: &self.dot_hg })
}
pub fn hg_vfs_not_using_dirstate(&self) -> Vfs<'_> {
Vfs { base: &self.dot_hg } Vfs { base: &self.dot_hg }
} }
/// For accessing repository store files (in `.hg/store`) /// For accessing repository store files (in `.hg/store`)
pub fn store_vfs(&self) -> Vfs<'_> { pub fn store_vfs(&self) -> Vfs<'_> {
Vfs { base: &self.store } Vfs { base: &self.store }
} }
/// For accessing the working copy /// For accessing the working copy
pub fn working_directory_vfs(&self) -> Vfs<'_> { pub fn working_directory_vfs(&self) -> Result<Vfs<'_>, HgError> {
Vfs { let () = self.check_not_sparse()?;
Ok(Vfs {
base: &self.working_directory, base: &self.working_directory,
})
} }
pub fn is_a_subrepo(&self) -> bool {
(Vfs {
base: &self.working_directory,
})
.join(".hgsub")
.exists()
} }
pub fn has_dirstate_v2(&self) -> bool { pub fn has_dirstate_v2(&self) -> bool {
self.requirements self.requirements
.contains(requirements::DIRSTATE_V2_REQUIREMENT) .contains(requirements::DIRSTATE_V2_REQUIREMENT)
} }
fn dirstate_file_contents(&self) -> Result<Vec<u8>, HgError> { fn dirstate_file_contents(&self) -> Result<Vec<u8>, HgError> {

rust/hg-core/src/requirements.rs

SPARSEREVLOG_REQUIREMENT, SPARSEREVLOG_REQUIREMENT,
RELATIVE_SHARED_REQUIREMENT, RELATIVE_SHARED_REQUIREMENT,
REVLOG_COMPRESSION_ZSTD, REVLOG_COMPRESSION_ZSTD,
DIRSTATE_V2_REQUIREMENT, DIRSTATE_V2_REQUIREMENT,
// 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:
NODEMAP_REQUIREMENT, NODEMAP_REQUIREMENT,
// We don't understand sparse working copies, but we understand
// how to use the store because it's not affected by sparse.
SPARSE_REQUIREMENT,
]; ];
// Copied from mercurial/requirements.py: // Copied from mercurial/requirements.py:
pub(crate) const DIRSTATE_V2_REQUIREMENT: &str = "dirstate-v2"; pub(crate) const DIRSTATE_V2_REQUIREMENT: &str = "dirstate-v2";
/// 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.

rust/rhg/src/blackbox.rs

let line = format_bytes!( let line = format_bytes!(
b"{} {} @{} ({})> {}\n", b"{} {} @{} ({})> {}\n",
date, date,
user, user,
rev, rev,
pid, pid,
message message
); );
let result = let result = hg::logging::LogFile::new(
hg::logging::LogFile::new(self.repo.hg_vfs(), "blackbox.log") self.repo.hg_vfs_not_using_dirstate(),
"blackbox.log",
)
.max_size(Some(self.max_size)) .max_size(Some(self.max_size))
.max_files(self.max_files) .max_files(self.max_files)
.write(&line); .write(&line);
match result { match result {
Ok(()) => {} Ok(()) => {}
Err(_io_error) => { Err(_io_error) => {
// TODO: log a non-fatal warning to stderr // TODO: log a non-fatal warning to stderr
} }
} }
} }
} }

rust/rhg/src/commands/status.rs

// we're currently supporting file systems with exec flags only // we're currently supporting file systems with exec flags only
// anyway // anyway
check_exec: true, check_exec: true,
list_clean: display_states.clean, list_clean: display_states.clean,
list_unknown: display_states.unknown, list_unknown: display_states.unknown,
list_ignored: display_states.ignored, list_ignored: display_states.ignored,
collect_traversed_dirs: false, collect_traversed_dirs: false,
}; };
let ignore_file = repo.working_directory_vfs().join(".hgignore"); // TODO hardcoded let ignore_file = repo.working_directory_vfs()?.join(".hgignore"); // TODO hardcoded
let (mut ds_status, pattern_warnings) = dmap.status( let (mut ds_status, pattern_warnings) = dmap.status(
&AlwaysMatcher, &AlwaysMatcher,
repo.working_directory_path().to_owned(), repo.working_directory_path().to_owned(),
vec![ignore_file], vec![ignore_file],
options, options,
)?; )?;
if !pattern_warnings.is_empty() { if !pattern_warnings.is_empty() {
warn!("Pattern warnings: {:?}", &pattern_warnings); warn!("Pattern warnings: {:?}", &pattern_warnings);
.expect("ambgious file not in p1"); .expect("ambgious file not in p1");
let filelog = repo.filelog(hg_path)?; let filelog = repo.filelog(hg_path)?;
let filelog_entry = filelog.data_for_node(file_node).map_err(|_| { let filelog_entry = filelog.data_for_node(file_node).map_err(|_| {
HgError::corrupted("filelog missing node from manifest") HgError::corrupted("filelog missing node from manifest")
})?; })?;
let contents_in_p1 = filelog_entry.data()?; let contents_in_p1 = filelog_entry.data()?;
let fs_path = hg_path_to_os_string(hg_path).expect("HgPath conversion"); let fs_path = hg_path_to_os_string(hg_path).expect("HgPath conversion");
let fs_contents = repo.working_directory_vfs().read(fs_path)?; let fs_contents = repo.working_directory_vfs()?.read(fs_path)?;
return Ok(contents_in_p1 != &*fs_contents); return Ok(contents_in_p1 != &*fs_contents);
} }

rust/rhg/src/main.rs

ui, ui,
subcommand_args, subcommand_args,
config, config,
repo, repo,
}; };
if let Ok(repo) = repo { if let Ok(repo) = repo {
// We don't support subrepos, fallback if the subrepos file is present // We don't support subrepos, fallback if the subrepos file is present
if repo.working_directory_vfs().join(".hgsub").exists() { if repo.is_a_subrepo() {
let msg = "subrepos (.hgsub is present)"; let msg = "subrepos (.hgsub is present)";
return Err(CommandError::unsupported(msg)); return Err(CommandError::unsupported(msg));
} }
} }
let blackbox = blackbox::Blackbox::new(&invocation, process_start_time)?; let blackbox = blackbox::Blackbox::new(&invocation, process_start_time)?;
blackbox.log_command_start(); blackbox.log_command_start();
let result = run(&invocation); let result = run(&invocation);
Some(_) => { Some(_) => {
// TODO: warn about unknown config value // TODO: warn about unknown config value
Self::DEFAULT Self::DEFAULT
} }
} }
} }
} }
const SUPPORTED_EXTENSIONS: &[&[u8]] = &[b"blackbox", b"share"]; const SUPPORTED_EXTENSIONS: &[&[u8]] =
&[b"blackbox", b"share", b"sparse", b"narrow"];
fn check_extensions(config: &Config) -> Result<(), CommandError> { fn check_extensions(config: &Config) -> Result<(), CommandError> {
let enabled = config.get_section_keys(b"extensions"); let enabled = config.get_section_keys(b"extensions");
let mut unsupported = enabled; let mut unsupported = enabled;
for supported in SUPPORTED_EXTENSIONS { for supported in SUPPORTED_EXTENSIONS {
unsupported.remove(supported); unsupported.remove(supported);
} }

tests/test-rhg-sparse.t

  • This file was added.
#require rhg
$ NO_FALLBACK="env RHG_ON_UNSUPPORTED=abort"
Even though sparse working copy is not supported, the commands
that operate on the store still work even if the working copy is sparse.
$ cd "$TESTTMP"
$ hg init repo-sparse
$ cd repo-sparse
$ cat > .hg/hgrc <<EOF
> [extensions]
> sparse=
> EOF
$ echo a > show
$ echo x > hide
$ hg ci -Aqm 'initial'
$ hg debugsparse --include 'show'
$ ls -A
.hg
show
$ tip=$(hg log -r . --template '{node}')
$ $NO_FALLBACK rhg files -r "$tip"
hide
show
$ $NO_FALLBACK rhg files
unsupported feature: repository uses a sparse working copy, this is not supported by rhg
[252]
$ $NO_FALLBACK rhg cat -r "$tip" hide
x