This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11651

rhg: do not fail when the repo is empty
ClosedPublic

Authored by aalekseyev on Oct 12 2021, 4:07 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHG9d0e5629cfbf: rhg: do not fail when the repo is empty
rHGeb753dd284a9: rhg: do not fail when the repo is empty

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.

Event Timeline

aalekseyev created this revision.Oct 12 2021, 4:07 PM
aalekseyev added a commit: rHGeb753dd284a9: rhg: do not fail when the repo is empty.Oct 13 2021, 11:44 AM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHGeb753dd284a9: rhg: do not fail when the repo is empty (authored by aalekseyev). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 30771

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

/// 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]