This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11406

rust: Keep lazily-initialized Changelog and Manifest log on the Repo object
ClosedPublic

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

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHG21d25e9ee58e: rust: Keep lazily-initialized Changelog and Manifest log on the Repo object
Summary

That way if one of them is accessed multiple times it won’t be reopened
from the filesystem.

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 30234

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

// list_tracked_files.rs // list_tracked_files.rs
// //
// Copyright 2020 Antoine Cezar <antoine.cezar@octobus.net> // Copyright 2020 Antoine Cezar <antoine.cezar@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 std::path::PathBuf; use std::path::PathBuf;
use crate::repo::Repo; use crate::repo::Repo;
use crate::revlog::changelog::Changelog;
use crate::revlog::manifest::Manifestlog;
use crate::revlog::path_encode::path_encode; use crate::revlog::path_encode::path_encode;
use crate::revlog::revlog::Revlog; use crate::revlog::revlog::Revlog;
use crate::revlog::revlog::RevlogError; use crate::revlog::revlog::RevlogError;
use crate::revlog::Node; use crate::revlog::Node;
use crate::utils::files::get_path_from_bytes; use crate::utils::files::get_path_from_bytes;
use crate::utils::hg_path::{HgPath, HgPathBuf}; use crate::utils::hg_path::{HgPath, HgPathBuf};
pub struct CatOutput { pub struct CatOutput {
/// * `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 changelog = Changelog::open(repo)?; let changelog = repo.changelog()?;
let manifest = Manifestlog::open(repo)?; let manifest = repo.manifestlog()?;
let changelog_entry = changelog.get_rev(rev)?; let changelog_entry = changelog.get_rev(rev)?;
let node = *changelog let node = *changelog
.node_from_rev(rev) .node_from_rev(rev)
.expect("should succeed when changelog.get_rev did"); .expect("should succeed when changelog.get_rev did");
let manifest_node = let manifest_node =
Node::from_hex_for_repo(&changelog_entry.manifest_node()?)?; Node::from_hex_for_repo(&changelog_entry.manifest_node()?)?;
let manifest_entry = manifest.get_node(manifest_node.into())?; let manifest_entry = manifest.get_node(manifest_node.into())?;
let mut bytes = vec![]; let mut bytes = vec![];

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

// list_tracked_files.rs // list_tracked_files.rs
// //
// Copyright 2020 Antoine Cezar <antoine.cezar@octobus.net> // Copyright 2020 Antoine Cezar <antoine.cezar@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::dirstate::parsers::parse_dirstate_entries; use crate::dirstate::parsers::parse_dirstate_entries;
use crate::dirstate_tree::on_disk::{for_each_tracked_path, read_docket}; use crate::dirstate_tree::on_disk::{for_each_tracked_path, read_docket};
use crate::errors::HgError; use crate::errors::HgError;
use crate::repo::Repo; use crate::repo::Repo;
use crate::revlog::changelog::Changelog; use crate::revlog::manifest::Manifest;
use crate::revlog::manifest::{Manifest, Manifestlog};
use crate::revlog::node::Node; use crate::revlog::node::Node;
use crate::revlog::revlog::RevlogError; use crate::revlog::revlog::RevlogError;
use crate::utils::hg_path::HgPath; use crate::utils::hg_path::HgPath;
use crate::DirstateError; use crate::DirstateError;
use rayon::prelude::*; use rayon::prelude::*;
/// List files under Mercurial control in the working directory /// List files under Mercurial control in the working directory
/// by reading the dirstate /// by reading the dirstate
} }
/// 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)?;
let changelog = Changelog::open(repo)?; let changelog = repo.changelog()?;
let manifest = Manifestlog::open(repo)?; let manifest = repo.manifestlog()?;
let changelog_entry = changelog.get_rev(rev)?; let changelog_entry = changelog.get_rev(rev)?;
let manifest_node = let manifest_node =
Node::from_hex_for_repo(&changelog_entry.manifest_node()?)?; Node::from_hex_for_repo(&changelog_entry.manifest_node()?)?;
let manifest_entry = manifest.get_node(manifest_node.into())?; let manifest_entry = manifest.get_node(manifest_node.into())?;
Ok(FilesForRev(manifest_entry)) Ok(FilesForRev(manifest_entry))
} }
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::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::exit_codes;
use crate::manifest::Manifestlog;
use crate::requirements; use crate::requirements;
use crate::revlog::revlog::RevlogError;
use crate::utils::files::get_path_from_bytes; use crate::utils::files::get_path_from_bytes;
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::DirstateError; use crate::DirstateError;
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,
dot_hg: PathBuf, dot_hg: PathBuf,
store: PathBuf, store: PathBuf,
requirements: HashSet<String>, requirements: HashSet<String>,
config: Config, config: Config,
// None means not known/initialized yet // None means not known/initialized yet
dirstate_parents: Cell<Option<DirstateParents>>, dirstate_parents: Cell<Option<DirstateParents>>,
dirstate_map: LazyCell<OwningDirstateMap, DirstateError>, dirstate_map: LazyCell<OwningDirstateMap, DirstateError>,
changelog: LazyCell<Changelog, RevlogError>,
manifestlog: LazyCell<Manifestlog, RevlogError>,
} }
#[derive(Debug, derive_more::From)] #[derive(Debug, derive_more::From)]
pub enum RepoError { pub enum RepoError {
NotFound { NotFound {
at: PathBuf, at: PathBuf,
}, },
#[from] #[from]
let repo = Self { let repo = Self {
requirements: reqs, requirements: reqs,
working_directory, working_directory,
store: store_path, store: store_path,
dot_hg, dot_hg,
config: repo_config, config: repo_config,
dirstate_parents: Cell::new(None), dirstate_parents: Cell::new(None),
dirstate_map: LazyCell::new(Self::new_dirstate_map), dirstate_map: LazyCell::new(Self::new_dirstate_map),
changelog: LazyCell::new(Changelog::open),
manifestlog: LazyCell::new(Manifestlog::open),
}; };
requirements::check(&repo)?; requirements::check(&repo)?;
Ok(repo) Ok(repo)
} }
pub fn working_directory_path(&self) -> &Path { pub fn working_directory_path(&self) -> &Path {
self.dirstate_map.get_or_init(self) self.dirstate_map.get_or_init(self)
} }
pub fn dirstate_map_mut( pub fn dirstate_map_mut(
&self, &self,
) -> Result<RefMut<OwningDirstateMap>, DirstateError> { ) -> Result<RefMut<OwningDirstateMap>, DirstateError> {
self.dirstate_map.get_mut_or_init(self) self.dirstate_map.get_mut_or_init(self)
} }
pub fn changelog(&self) -> Result<Ref<Changelog>, RevlogError> {
self.changelog.get_or_init(self)
}
pub fn changelog_mut(&self) -> Result<RefMut<Changelog>, RevlogError> {
self.changelog.get_mut_or_init(self)
}
pub fn manifestlog(&self) -> Result<Ref<Manifestlog>, RevlogError> {
self.manifestlog.get_or_init(self)
}
pub fn manifestlog_mut(&self) -> Result<RefMut<Manifestlog>, RevlogError> {
self.manifestlog.get_mut_or_init(self)
}
} }
/// Lazily-initialized component of `Repo` with interior mutability /// Lazily-initialized component of `Repo` with interior mutability
/// ///
/// This differs from `OnceCell` in that the value can still be "deinitialized" /// This differs from `OnceCell` in that the value can still be "deinitialized"
/// later by setting its inner `Option` to `None`. /// later by setting its inner `Option` to `None`.
struct LazyCell<T, E> { struct LazyCell<T, E> {
value: RefCell<Option<T>>, value: RefCell<Option<T>>,

rust/hg-core/src/revset.rs

//! The revset query language //! The revset query language
//! //!
//! <https://www.mercurial-scm.org/repo/hg/help/revsets> //! <https://www.mercurial-scm.org/repo/hg/help/revsets>
use crate::errors::HgError; use crate::errors::HgError;
use crate::repo::Repo; use crate::repo::Repo;
use crate::revlog::changelog::Changelog;
use crate::revlog::revlog::{Revlog, RevlogError}; use crate::revlog::revlog::{Revlog, RevlogError};
use crate::revlog::NodePrefix; use crate::revlog::NodePrefix;
use crate::revlog::{Revision, NULL_REVISION, WORKING_DIRECTORY_HEX}; use crate::revlog::{Revision, NULL_REVISION, WORKING_DIRECTORY_HEX};
use crate::Node; use crate::Node;
/// Resolve a query string into a single revision. /// Resolve a query string into a single revision.
/// ///
/// Only some of the revset language is implemented yet. /// Only some of the revset language is implemented yet.
pub fn resolve_single( pub fn resolve_single(
input: &str, input: &str,
repo: &Repo, repo: &Repo,
) -> Result<Revision, RevlogError> { ) -> Result<Revision, RevlogError> {
let changelog = Changelog::open(repo)?; let changelog = repo.changelog()?;
match resolve_rev_number_or_hex_prefix(input, &changelog.revlog) { match resolve_rev_number_or_hex_prefix(input, &changelog.revlog) {
Err(RevlogError::InvalidRevision) => {} // Try other syntax Err(RevlogError::InvalidRevision) => {} // Try other syntax
result => return result, result => return result,
} }
if input == "null" { if input == "null" {
return Ok(NULL_REVISION); return Ok(NULL_REVISION);