( )⚙ D11411 rhg: Reuse manifest when checking status of multiple ambiguous files

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11411

rhg: Reuse manifest when checking status of multiple ambiguous files
ClosedPublic

Authored by SimonSapin on Sep 13 2021, 2:14 PM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHG796206e74b10: rhg: Reuse manifest when checking status of multiple ambiguous files
Summary

When rhg status cannot determine whether a file is clean based on mtime and
size alone, it needs to compare its contents with those found in the parent
commit. Previously, rhg would find the (same) manifest of that commit again
for every such file. This is lifted out of the loop and reused.

Diff Detail

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

Revision Contents
Changeset List

Diff 30229

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

/// * `rev`: The revision to cat the files from. /// * `rev`: The revision to cat the files from.
/// * `files`: The files to output. /// * `files`: The files to output.
pub fn cat<'a>( pub fn cat<'a>(
repo: &Repo, repo: &Repo,
revset: &str, revset: &str,
files: &'a [HgPathBuf], files: &'a [HgPathBuf],
) -> Result<CatOutput, RevlogError> { ) -> Result<CatOutput, RevlogError> {
let rev = crate::revset::resolve_single(revset, repo)?; let rev = crate::revset::resolve_single(revset, repo)?;
let manifest = repo.manifest(rev)?; let manifest = repo.manifest_for_rev(rev)?;
let node = *repo let node = *repo
.changelog()? .changelog()?
.node_from_rev(rev) .node_from_rev(rev)
.expect("should succeed when repo.manifest did"); .expect("should succeed when repo.manifest did");
let mut bytes = vec![]; let mut bytes = vec![];
let mut matched = vec![false; files.len()]; let mut matched = vec![false; files.len()];
let mut found_any = false; let mut found_any = false;

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

} }
/// List files under Mercurial control at a given revision. /// List files under Mercurial control at a given revision.
pub fn list_rev_tracked_files( pub fn list_rev_tracked_files(
repo: &Repo, repo: &Repo,
revset: &str, revset: &str,
) -> Result<FilesForRev, RevlogError> { ) -> Result<FilesForRev, RevlogError> {
let rev = crate::revset::resolve_single(revset, repo)?; let rev = crate::revset::resolve_single(revset, repo)?;
Ok(FilesForRev(repo.manifest(rev)?)) Ok(FilesForRev(repo.manifest_for_rev(rev)?))
} }
pub struct FilesForRev(Manifest); pub struct FilesForRev(Manifest);
impl FilesForRev { impl FilesForRev {
pub fn iter(&self) -> impl Iterator<Item = &HgPath> { pub fn iter(&self) -> impl Iterator<Item = &HgPath> {
self.0.files() self.0.files()
} }
} }

rust/hg-core/src/repo.rs

use crate::changelog::Changelog; use crate::changelog::Changelog;
use crate::config::{Config, ConfigError, ConfigParseError}; use crate::config::{Config, ConfigError, ConfigParseError};
use crate::dirstate::DirstateParents; use crate::dirstate::DirstateParents;
use crate::dirstate_tree::dirstate_map::DirstateMap; use crate::dirstate_tree::dirstate_map::DirstateMap;
use crate::dirstate_tree::owning::OwningDirstateMap; use crate::dirstate_tree::owning::OwningDirstateMap;
use crate::errors::HgError; use crate::errors::HgError;
use crate::errors::HgResultExt; use crate::errors::HgResultExt;
use crate::exit_codes;
use crate::manifest::{Manifest, Manifestlog}; use crate::manifest::{Manifest, Manifestlog};
use crate::requirements;
use crate::revlog::filelog::Filelog; use crate::revlog::filelog::Filelog;
use crate::revlog::revlog::RevlogError; use crate::revlog::revlog::RevlogError;
use crate::utils::files::get_path_from_bytes; use crate::utils::files::get_path_from_bytes;
use crate::utils::hg_path::HgPath; use crate::utils::hg_path::HgPath;
use crate::utils::SliceExt; use crate::utils::SliceExt;
use crate::vfs::{is_dir, is_file, Vfs}; use crate::vfs::{is_dir, is_file, Vfs};
use crate::{exit_codes, Node}; use crate::{requirements, NodePrefix};
use crate::{DirstateError, Revision}; use crate::{DirstateError, Revision};
use std::cell::{Cell, Ref, RefCell, RefMut}; use std::cell::{Cell, Ref, RefCell, RefMut};
use std::collections::HashSet; use std::collections::HashSet;
use std::path::{Path, PathBuf}; use std::path::{Path, PathBuf};
/// A repository on disk /// A repository on disk
pub struct Repo { pub struct Repo {
working_directory: PathBuf, working_directory: PathBuf,
pub fn manifestlog(&self) -> Result<Ref<Manifestlog>, HgError> { pub fn manifestlog(&self) -> Result<Ref<Manifestlog>, HgError> {
self.manifestlog.get_or_init(self) self.manifestlog.get_or_init(self)
} }
pub fn manifestlog_mut(&self) -> Result<RefMut<Manifestlog>, HgError> { pub fn manifestlog_mut(&self) -> Result<RefMut<Manifestlog>, HgError> {
self.manifestlog.get_mut_or_init(self) self.manifestlog.get_mut_or_init(self)
} }
/// Returns the manifest of the given node ID
pub fn manifest_for_node(
&self,
node: impl Into<NodePrefix>,
) -> Result<Manifest, RevlogError> {
self.manifestlog()?.get_node(
self.changelog()?
.get_node(node.into())?
.manifest_node()?
.into(),
)
}
/// Returns the manifest of the given revision /// Returns the manifest of the given revision
pub fn manifest( pub fn manifest_for_rev(
&self, &self,
revision: Revision, revision: Revision,
) -> Result<Manifest, RevlogError> { ) -> Result<Manifest, RevlogError> {
let changelog = self.changelog()?; self.manifestlog()?.get_node(
let manifest = self.manifestlog()?; self.changelog()?.get_rev(revision)?.manifest_node()?.into(),
let changelog_entry = changelog.get_rev(revision)?; )
let manifest_node =
Node::from_hex_for_repo(&changelog_entry.manifest_node()?)?;
manifest.get_node(manifest_node.into())
} }
pub fn filelog(&self, path: &HgPath) -> Result<Filelog, HgError> { pub fn filelog(&self, path: &HgPath) -> Result<Filelog, HgError> {
Filelog::open(self, path) Filelog::open(self, path)
} }
} }
/// Lazily-initialized component of `Repo` with interior mutability /// Lazily-initialized component of `Repo` with interior mutability

rust/hg-core/src/revlog/changelog.rs

pub fn lines(&self) -> impl Iterator<Item = &[u8]> { pub fn lines(&self) -> impl Iterator<Item = &[u8]> {
self.bytes self.bytes
.split(|b| b == &b'\n') .split(|b| b == &b'\n')
.filter(|line| !line.is_empty()) .filter(|line| !line.is_empty())
} }
/// Return the node id of the `manifest` referenced by this `changelog` /// Return the node id of the `manifest` referenced by this `changelog`
/// entry. /// entry.
pub fn manifest_node(&self) -> Result<&[u8], RevlogError> { pub fn manifest_node(&self) -> Result<Node, HgError> {
Node::from_hex_for_repo(
self.lines() self.lines()
.next() .next()
.ok_or_else(|| HgError::corrupted("empty changelog entry").into()) .ok_or_else(|| HgError::corrupted("empty changelog entry"))?,
)
} }
} }

rust/hg-core/src/revlog/manifest.rs

use crate::errors::HgError; use crate::errors::HgError;
use crate::repo::Repo; use crate::repo::Repo;
use crate::revlog::revlog::{Revlog, RevlogError}; use crate::revlog::revlog::{Revlog, RevlogError};
use crate::revlog::NodePrefix;
use crate::revlog::Revision; use crate::revlog::Revision;
use crate::revlog::{Node, NodePrefix};
use crate::utils::hg_path::HgPath; use crate::utils::hg_path::HgPath;
/// A specialized `Revlog` to work with `manifest` data format. /// A specialized `Revlog` to work with `manifest` data format.
pub struct Manifestlog { pub struct Manifestlog {
/// The generic `revlog` format. /// The generic `revlog` format.
revlog: Revlog, revlog: Revlog,
} }
.iter() .iter()
.position(|x| x == &b'\0') .position(|x| x == &b'\0')
.expect("manifest line should contain \\0"); .expect("manifest line should contain \\0");
let hash_start = pos + 1; let hash_start = pos + 1;
let hash_end = hash_start + 40; let hash_end = hash_start + 40;
(HgPath::new(&line[..pos]), &line[hash_start..hash_end]) (HgPath::new(&line[..pos]), &line[hash_start..hash_end])
}) })
} }
/// If the given path is in this manifest, return its filelog node ID
pub fn find_file(&self, path: &HgPath) -> Result<Option<Node>, HgError> {
// TODO: use binary search instead of linear scan. This may involve
// building (and caching) an index of the byte indicex of each manifest
// line.
for (manifest_path, node) in self.files_with_nodes() {
if manifest_path == path {
return Ok(Some(Node::from_hex_for_repo(node)?));
}
}
Ok(None)
}
} }

rust/rhg/src/commands/status.rs

// status.rs // status.rs
// //
// Copyright 2020, Georges Racinet <georges.racinets@octobus.net> // Copyright 2020, Georges Racinet <georges.racinets@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.
use crate::error::CommandError; use crate::error::CommandError;
use crate::ui::Ui; use crate::ui::Ui;
use clap::{Arg, SubCommand}; use clap::{Arg, SubCommand};
use hg; use hg;
use hg::dirstate_tree::dispatch::DirstateMapMethods; use hg::dirstate_tree::dispatch::DirstateMapMethods;
use hg::errors::IoResultExt; use hg::errors::{HgError, IoResultExt};
use hg::manifest::Manifest;
use hg::matchers::AlwaysMatcher; use hg::matchers::AlwaysMatcher;
use hg::operations::cat;
use hg::repo::Repo; use hg::repo::Repo;
use hg::revlog::node::Node;
use hg::utils::hg_path::{hg_path_to_os_string, HgPath}; use hg::utils::hg_path::{hg_path_to_os_string, HgPath};
use hg::StatusError;
use hg::{HgPathCow, StatusOptions}; use hg::{HgPathCow, StatusOptions};
use log::{info, warn}; use log::{info, warn};
use std::convert::TryInto; use std::convert::TryInto;
use std::fs; use std::fs;
use std::io::BufReader; use std::io::BufReader;
use std::io::Read; use std::io::Read;
pub const HELP_TEXT: &str = " pub const HELP_TEXT: &str = "
info!( info!(
"Files to be rechecked by retrieval from filelog: {:?}", "Files to be rechecked by retrieval from filelog: {:?}",
&ds_status.unsure &ds_status.unsure
); );
} }
if !ds_status.unsure.is_empty() if !ds_status.unsure.is_empty()
&& (display_states.modified || display_states.clean) && (display_states.modified || display_states.clean)
{ {
let p1: Node = repo.dirstate_parents()?.p1.into(); let p1 = repo.dirstate_parents()?.p1;
let p1_hex = format!("{:x}", p1); let manifest = repo.manifest_for_node(p1).map_err(|e| {
CommandError::from((e, &*format!("{:x}", p1.short())))
})?;
for to_check in ds_status.unsure { for to_check in ds_status.unsure {
if cat_file_is_modified(repo, &to_check, &p1_hex)? { if cat_file_is_modified(repo, &manifest, &to_check)? {
if display_states.modified { if display_states.modified {
ds_status.modified.push(to_check); ds_status.modified.push(to_check);
} }
} else { } else {
if display_states.clean { if display_states.clean {
ds_status.clean.push(to_check); ds_status.clean.push(to_check);
} }
} }
/// Check if a file is modified by comparing actual repo store and file system. /// Check if a file is modified by comparing actual repo store and file system.
/// ///
/// This meant to be used for those that the dirstate cannot resolve, due /// This meant to be used for those that the dirstate cannot resolve, due
/// to time resolution limits. /// to time resolution limits.
/// ///
/// TODO: detect permission bits and similar metadata modifications /// TODO: detect permission bits and similar metadata modifications
fn cat_file_is_modified( fn cat_file_is_modified(
repo: &Repo, repo: &Repo,
manifest: &Manifest,
hg_path: &HgPath, hg_path: &HgPath,
rev: &str, ) -> Result<bool, HgError> {
) -> Result<bool, CommandError> { let file_node = manifest
// TODO CatRev expects &[HgPathBuf], something like .find_file(hg_path)?
// &[impl Deref<HgPath>] would be nicer and should avoid the copy .expect("ambgious file not in p1");
let path_bufs = [hg_path.into()]; let filelog = repo.filelog(hg_path)?;
// TODO IIUC CatRev returns a simple Vec<u8> for all files let filelog_entry = filelog.get_node(file_node).map_err(|_| {
// being able to tell them apart as (path, bytes) would be nicer HgError::corrupted("filelog missing node from manifest")
// and OPTIM would allow manifest resolution just once. })?;
let output = cat(repo, rev, &path_bufs).map_err(|e| (e, rev))?; let contents_in_p1 = filelog_entry.data()?;
let fs_path = repo let fs_path = repo
.working_directory_vfs() .working_directory_vfs()
.join(hg_path_to_os_string(hg_path).expect("HgPath conversion")); .join(hg_path_to_os_string(hg_path).expect("HgPath conversion"));
let hg_data_len: u64 = match output.concatenated.len().try_into() { let hg_data_len: u64 = match contents_in_p1.len().try_into() {
Ok(v) => v, Ok(v) => v,
Err(_) => { Err(_) => {
// conversion of data length to u64 failed, // conversion of data length to u64 failed,
// good luck for any file to have this content // good luck for any file to have this content
return Ok(true); return Ok(true);
} }
}; };
let fobj = fs::File::open(&fs_path).when_reading_file(&fs_path)?; let fobj = fs::File::open(&fs_path).when_reading_file(&fs_path)?;
if fobj.metadata().map_err(|e| StatusError::from(e))?.len() != hg_data_len if fobj.metadata().when_reading_file(&fs_path)?.len() != hg_data_len {
{
return Ok(true); return Ok(true);
} }
for (fs_byte, hg_byte) in for (fs_byte, &hg_byte) in BufReader::new(fobj).bytes().zip(contents_in_p1)
BufReader::new(fobj).bytes().zip(output.concatenated)
{ {
if fs_byte.map_err(|e| StatusError::from(e))? != hg_byte { if fs_byte.when_reading_file(&fs_path)? != hg_byte {
return Ok(true); return Ok(true);
} }
} }
Ok(false) Ok(false)
} }