This is an archive of the discontinued Mercurial Phabricator instance.

Diff	ID	Description	Created	Lint	Unit
Base		Base
Diff 1	31266		Dec 2 2021, 11:48 AM	★	★
Diff 2	31318		Dec 6 2021, 5:03 AM	★	★
Diff 3	31352	rHGc8659e61073d31cddcb517281ea56a7c0d505b50	Nov 29 2021, 1:00 PM	★	★

Status	Author	Revision
Closed	SimonSapin	D11840 rhg: Update the dirstate on disk after status
Closed	SimonSapin	D11839 rhg: Add Repo::write_dirstate
Closed	SimonSapin	D11838 rhg: Add lazy/cached dirstate data file ID parsing on Repo
Closed	SimonSapin	D11837 rhg: Make Repo::dirstate_parents a LazyCell
Closed	SimonSapin	D11836 rust: Add Vfs::write_atomic
Closed	SimonSapin	D11835 rhg: Initial repository locking
Closed	SimonSapin	D11834 rust: Serializing a DirstateMap does not mutate it anymore

Diff 31352

rust/hg-core/src/repo.rs

	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::{requirements, NodePrefix};			use crate::{requirements, NodePrefix};
	use crate::{DirstateError, Revision};			use crate::{DirstateError, Revision};
	use std::cell::{Cell, Ref, RefCell, RefMut};			use std::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			dirstate_parents: LazyCell<DirstateParents, HgError>,
	dirstate_parents: Cell<Option<DirstateParents>>,
	dirstate_map: LazyCell<OwningDirstateMap, DirstateError>,			dirstate_map: LazyCell<OwningDirstateMap, DirstateError>,
	changelog: LazyCell<Changelog, HgError>,			changelog: LazyCell<Changelog, HgError>,
	manifestlog: LazyCell<Manifestlog, HgError>,			manifestlog: LazyCell<Manifestlog, HgError>,
	}			}

	#[derive(Debug, derive_more::From)]			#[derive(Debug, derive_more::From)]
	pub enum RepoError {			pub enum RepoError {
	NotFound {			NotFound {
	};			};

	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: LazyCell::new(Self::read_dirstate_parents),
	dirstate_map: LazyCell::new(Self::new_dirstate_map),			dirstate_map: LazyCell::new(Self::new_dirstate_map),
	changelog: LazyCell::new(Changelog::open),			changelog: LazyCell::new(Changelog::open),
	manifestlog: LazyCell::new(Manifestlog::open),			manifestlog: LazyCell::new(Manifestlog::open),
	};			};

	requirements::check(&repo)?;			requirements::check(&repo)?;

	Ok(repo)			Ok(repo)
	Ok(self			Ok(self
	.hg_vfs()			.hg_vfs()
	.read("dirstate")			.read("dirstate")
	.io_not_found_as_none()?			.io_not_found_as_none()?
	.unwrap_or(Vec::new()))			.unwrap_or(Vec::new()))
	}			}

	pub fn dirstate_parents(&self) -> Result<DirstateParents, HgError> {			pub fn dirstate_parents(&self) -> Result<DirstateParents, HgError> {
	if let Some(parents) = self.dirstate_parents.get() {			Ok(*self.dirstate_parents.get_or_init(self)?)
	return Ok(parents);
	}			}

				fn read_dirstate_parents(&self) -> Result<DirstateParents, HgError> {
	let dirstate = self.dirstate_file_contents()?;			let dirstate = self.dirstate_file_contents()?;
	let parents = if dirstate.is_empty() {			let parents = if dirstate.is_empty() {
	DirstateParents::NULL			DirstateParents::NULL
	} else if self.has_dirstate_v2() {			} else if self.has_dirstate_v2() {
	crate::dirstate_tree::on_disk::read_docket(&dirstate)?.parents()			crate::dirstate_tree::on_disk::read_docket(&dirstate)?.parents()
	} else {			} else {
	crate::dirstate::parsers::parse_dirstate_parents(&dirstate)?			crate::dirstate::parsers::parse_dirstate_parents(&dirstate)?
	.clone()			.clone()
	};			};
	self.dirstate_parents.set(Some(parents));			self.dirstate_parents.set(parents);
	Ok(parents)			Ok(parents)
	}			}

	fn new_dirstate_map(&self) -> Result<OwningDirstateMap, DirstateError> {			fn new_dirstate_map(&self) -> Result<OwningDirstateMap, DirstateError> {
	let dirstate_file_contents = self.dirstate_file_contents()?;			let dirstate_file_contents = self.dirstate_file_contents()?;
	if dirstate_file_contents.is_empty() {			if dirstate_file_contents.is_empty() {
	self.dirstate_parents.set(Some(DirstateParents::NULL));			self.dirstate_parents.set(DirstateParents::NULL);
	Ok(OwningDirstateMap::new_empty(Vec::new()))			Ok(OwningDirstateMap::new_empty(Vec::new()))
	} else if self.has_dirstate_v2() {			} else if self.has_dirstate_v2() {
	let docket = crate::dirstate_tree::on_disk::read_docket(			let docket = crate::dirstate_tree::on_disk::read_docket(
	&dirstate_file_contents,			&dirstate_file_contents,
	)?;			)?;
	self.dirstate_parents.set(Some(docket.parents()));			self.dirstate_parents.set(docket.parents());
	let data_size = docket.data_size();			let data_size = docket.data_size();
	let metadata = docket.tree_metadata();			let metadata = docket.tree_metadata();
	let mut map = if let Some(data_mmap) = self			let mut map = if let Some(data_mmap) = self
	.hg_vfs()			.hg_vfs()
	.mmap_open(docket.data_filename())			.mmap_open(docket.data_filename())
	.io_not_found_as_none()?			.io_not_found_as_none()?
	{			{
	OwningDirstateMap::new_empty(data_mmap)			OwningDirstateMap::new_empty(data_mmap)
	} else {			} else {
	OwningDirstateMap::new_empty(Vec::new())			OwningDirstateMap::new_empty(Vec::new())
	};			};
	let (on_disk, placeholder) = map.get_pair_mut();			let (on_disk, placeholder) = map.get_pair_mut();
	*placeholder = DirstateMap::new_v2(on_disk, data_size, metadata)?;			*placeholder = DirstateMap::new_v2(on_disk, data_size, metadata)?;
	Ok(map)			Ok(map)
	} else {			} else {
	let mut map = OwningDirstateMap::new_empty(dirstate_file_contents);			let mut map = OwningDirstateMap::new_empty(dirstate_file_contents);
	let (on_disk, placeholder) = map.get_pair_mut();			let (on_disk, placeholder) = map.get_pair_mut();
	let (inner, parents) = DirstateMap::new_v1(on_disk)?;			let (inner, parents) = DirstateMap::new_v1(on_disk)?;
	self.dirstate_parents			self.dirstate_parents
	.set(Some(parents.unwrap_or(DirstateParents::NULL)));			.set(parents.unwrap_or(DirstateParents::NULL));
	*placeholder = inner;			*placeholder = inner;
	Ok(map)			Ok(map)
	}			}
	}			}

	pub fn dirstate_map(			pub fn dirstate_map(
	&self,			&self,
	) -> Result<Ref<OwningDirstateMap>, DirstateError> {			) -> Result<Ref<OwningDirstateMap>, DirstateError> {
	impl<T, E> LazyCell<T, E> {			impl<T, E> LazyCell<T, E> {
	fn new(init: impl Fn(&Repo) -> Result<T, E> + 'static) -> Self {			fn new(init: impl Fn(&Repo) -> Result<T, E> + 'static) -> Self {
	Self {			Self {
	value: RefCell::new(None),			value: RefCell::new(None),
	init: Box::new(init),			init: Box::new(init),
	}			}
	}			}

				fn set(&self, value: T) {
				*self.value.borrow_mut() = Some(value)
				}

	fn get_or_init(&self, repo: &Repo) -> Result<Ref<T>, E> {			fn get_or_init(&self, repo: &Repo) -> Result<Ref<T>, E> {
	let mut borrowed = self.value.borrow();			let mut borrowed = self.value.borrow();
	if borrowed.is_none() {			if borrowed.is_none() {
	drop(borrowed);			drop(borrowed);
	// Only use `borrow_mut` if it is really needed to avoid panic in			// Only use `borrow_mut` if it is really needed to avoid panic in
	// case there is another outstanding borrow but mutation is not			// case there is another outstanding borrow but mutation is not
	// needed.			// needed.
	*self.value.borrow_mut() = Some((self.init)(repo)?);			*self.value.borrow_mut() = Some((self.init)(repo)?);
	borrowed = self.value.borrow()			borrowed = self.value.borrow()
	}			}
	Ok(Ref::map(borrowed, \|option\| option.as_ref().unwrap()))			Ok(Ref::map(borrowed, \|option\| option.as_ref().unwrap()))
	}			}

	pub fn get_mut_or_init(&self, repo: &Repo) -> Result<RefMut<T>, E> {			fn get_mut_or_init(&self, repo: &Repo) -> Result<RefMut<T>, E> {
	let mut borrowed = self.value.borrow_mut();			let mut borrowed = self.value.borrow_mut();
	if borrowed.is_none() {			if borrowed.is_none() {
	*borrowed = Some((self.init)(repo)?);			*borrowed = Some((self.init)(repo)?);
	}			}
	Ok(RefMut::map(borrowed, \|option\| option.as_mut().unwrap()))			Ok(RefMut::map(borrowed, \|option\| option.as_mut().unwrap()))
	}			}
	}			}

This is an archive of the discontinued Mercurial Phabricator instance.

rhg: Make Repo::dirstate_parents a LazyCellClosedPublic

Details

Diff Detail

Event Timeline

Revision ContentsChangeset List

Diff 31352

rust/hg-core/src/repo.rs

rhg: Make Repo::dirstate_parents a LazyCell
ClosedPublic

Revision Contents
Changeset List