This is an archive of the discontinued Mercurial Phabricator instance.

	/// interleaved.			/// interleaved.
	#[timed]			#[timed]
	pub fn open(			pub fn open(
	repo: &Repo,			repo: &Repo,
	index_path: impl AsRef<Path>,			index_path: impl AsRef<Path>,
	data_path: Option<&Path>,			data_path: Option<&Path>,
	) -> Result<Self, HgError> {			) -> Result<Self, HgError> {
	let index_path = index_path.as_ref();			let index_path = index_path.as_ref();
	let index_mmap = repo.store_vfs().mmap_open(&index_path)?;			let index = {
				match repo.store_vfs().mmap_open_opt(&index_path)? {
				None => Index::new(Box::new(vec![])),
				Some(index_mmap) => {
	let version = get_version(&index_mmap)?;			let version = get_version(&index_mmap)?;
	if version != 1 {			if version != 1 {
	// A proper new version should have had a repo/store requirement.			// A proper new version should have had a repo/store requirement.
	return Err(HgError::corrupted("corrupted revlog"));			return Err(HgError::corrupted("corrupted revlog"));
	}			}

	let index = Index::new(Box::new(index_mmap))?;			let index = Index::new(Box::new(index_mmap))?;
				Ok(index)
				}
				}
				}?;

	let default_data_path = index_path.with_extension("d");			let default_data_path = index_path.with_extension("d");

	// type annotation required			// type annotation required
	// won't recognize Mmap as Deref<Target = [u8]>			// won't recognize Mmap as Deref<Target = [u8]>
	let data_bytes: Option<Box<dyn Deref<Target = [u8]> + Send>> =			let data_bytes: Option<Box<dyn Deref<Target = [u8]> + Send>> =
	if index.is_inline() {			if index.is_inline() {
	None			None

rust/hg-core/src/vfs.rs

	use crate::errors::{HgError, IoErrorContext, IoResultExt};			use crate::errors::{HgError, IoErrorContext, IoResultExt};
	use memmap2::{Mmap, MmapOptions};			use memmap2::{Mmap, MmapOptions};
	use std::io::ErrorKind;			use std::io::ErrorKind;
	use std::path::{Path, PathBuf};			use std::path::{Path, PathBuf};

	/// Filesystem access abstraction for the contents of a given "base" diretory			/// Filesystem access abstraction for the contents of a given "base" diretory
	#[derive(Clone, Copy)]			#[derive(Clone, Copy)]
	pub struct Vfs<'a> {			pub struct Vfs<'a> {
	pub(crate) base: &'a Path,			pub(crate) base: &'a Path,
	}			}

				struct FileNotFound(std::io::Error, PathBuf);

	impl Vfs<'_> {			impl Vfs<'_> {
	pub fn join(&self, relative_path: impl AsRef<Path>) -> PathBuf {			pub fn join(&self, relative_path: impl AsRef<Path>) -> PathBuf {
	self.base.join(relative_path)			self.base.join(relative_path)
	}			}

	pub fn read(			pub fn read(
	&self,			&self,
	relative_path: impl AsRef<Path>,			relative_path: impl AsRef<Path>,
	) -> Result<Vec<u8>, HgError> {			) -> Result<Vec<u8>, HgError> {
	let path = self.join(relative_path);			let path = self.join(relative_path);
	std::fs::read(&path).when_reading_file(&path)			std::fs::read(&path).when_reading_file(&path)
	}			}

	pub fn mmap_open(			fn mmap_open_gen(
	&self,			&self,
	relative_path: impl AsRef<Path>,			relative_path: impl AsRef<Path>,
	) -> Result<Mmap, HgError> {			) -> Result<Result<Mmap, FileNotFound>, HgError> {
	let path = self.base.join(relative_path);			let path = self.join(relative_path);
	let file = std::fs::File::open(&path).when_reading_file(&path)?;			let file = match std::fs::File::open(&path) {
				Err(err) => {
				if let ErrorKind::NotFound = err.kind() {
				return Ok(Err(FileNotFound(err, path)));
				};
				return (Err(err)).when_reading_file(&path);
				}
				Ok(file) => file,
				};
	// TODO: what are the safety requirements here?			// TODO: what are the safety requirements here?
	let mmap = unsafe { MmapOptions::new().map(&file) }			let mmap = unsafe { MmapOptions::new().map(&file) }
	.when_reading_file(&path)?;			.when_reading_file(&path)?;
	Ok(mmap)			Ok(Ok(mmap))
				}

				pub fn mmap_open_opt(
				&self,
				relative_path: impl AsRef<Path>,
				) -> Result<Option<Mmap>, HgError> {
				self.mmap_open_gen(relative_path).map(\|res\| res.ok())
				}

				pub fn mmap_open(
				&self,
				relative_path: impl AsRef<Path>,
				) -> Result<Mmap, HgError> {
				match self.mmap_open_gen(relative_path)? {
				Err(FileNotFound(err, path)) => Err(err).when_reading_file(&path),
				Ok(res) => Ok(res),
				}
	}			}

	pub fn rename(			pub fn rename(
	&self,			&self,
	relative_from: impl AsRef<Path>,			relative_from: impl AsRef<Path>,
	relative_to: impl AsRef<Path>,			relative_to: impl AsRef<Path>,
	) -> Result<(), HgError> {			) -> Result<(), HgError> {
	let from = self.join(relative_from);			let from = self.join(relative_from);

tests/test-empty-manifest-index.t

	Create a repo such that the changelog entry refers to a null manifest node:			Test null revisions (node 0000000000000000000000000000000000000000, aka rev -1)
				in various circumstances.

				Make an empty repo:

	$ hg init a			$ hg init a
	$ cd a			$ cd a
	$ hg log
	$ touch x
	$ hg add x
	$ hg commit -m "init"
	$ hg rm x
	$ hg commit -q --amend

	$ wc -c < .hg/store/00manifest.i			$ hg files -r 0000000000000000000000000000000000000000
	0			[1]
				$ hg files -r .
				[1]

				Add an empty commit (this makes the changelog refer to a null manifest node):


	Make sure that the manifest can be read (and is empty):			$ hg commit -m "init" --config ui.allowemptycommit=true

	$ hg --config rhg.on-unsupported=abort files -r .			$ hg files -r .
	[1]			[1]

	Test a null changelog rev, too:			Strip that empty commit (this makes the changelog file empty, as opposed to missing):

				$ hg --config 'extensions.strip=' strip . > /dev/null

	$ hg --config rhg.on-unsupported=abort files -r 0000000000000000000000000000000000000000			$ hg files -r .
	[1]			[1]

Diff	ID	Description	Created	Lint	Unit
Base		Base
Diff 1	30766		Oct 12 2021, 4:07 PM	★	★
Diff 2	30771	rHGeb753dd284a96afa373447bad0718ea80c25e9b9	Oct 12 2021, 4:06 PM	★	★

This is an archive of the discontinued Mercurial Phabricator instance.

rhg: do not fail when the repo is emptyClosedPublic

Details

Diff Detail

Event Timeline

Revision ContentsChangeset List

Diff 30766

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

rust/hg-core/src/vfs.rs

tests/test-empty-manifest-index.t

rhg: do not fail when the repo is empty
ClosedPublic

Revision Contents
Changeset List