This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11410

rust: Return HgError instead of RevlogError in revlog constructors
ClosedPublic

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

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHG001d747c2baf: rust: Return HgError instead of RevlogError in revlog constructors
Summary

This leaves fewer cases for callers to handle, as RevlogError is more general

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

SimonSapin created this revision.Sep 13 2021, 2:14 PM
Alphare added a subscriber: Alphare.Sep 13 2021, 4:32 PM

as RevlogError is more general

Don't you mean the opposite?

SimonSapin added a comment.Sep 13 2021, 4:38 PM

There are strictly more error cases that can be represented by RevlogError so it is more general. (Since it has an Other variant that contains an HgError, plus some other variants.)

Alphare accepted this revision.Sep 14 2021, 3:48 AM
This revision is now accepted and ready to land.Sep 14 2021, 3:48 AM

Revision Contents
Changeset List

Diff 30238

rust/hg-core/src/repo.rs

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>, changelog: LazyCell<Changelog, HgError>,
manifestlog: LazyCell<Manifestlog, RevlogError>, manifestlog: LazyCell<Manifestlog, HgError>,
} }
#[derive(Debug, derive_more::From)] #[derive(Debug, derive_more::From)]
pub enum RepoError { pub enum RepoError {
NotFound { NotFound {
at: PathBuf, at: PathBuf,
}, },
#[from] #[from]
} }
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> { pub fn changelog(&self) -> Result<Ref<Changelog>, HgError> {
self.changelog.get_or_init(self) self.changelog.get_or_init(self)
} }
pub fn changelog_mut(&self) -> Result<RefMut<Changelog>, RevlogError> { pub fn changelog_mut(&self) -> Result<RefMut<Changelog>, HgError> {
self.changelog.get_mut_or_init(self) self.changelog.get_mut_or_init(self)
} }
pub fn manifestlog(&self) -> Result<Ref<Manifestlog>, RevlogError> { 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>, RevlogError> { 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 revision /// Returns the manifest of the given revision
pub fn manifest( pub fn manifest(
&self, &self,
revision: Revision, revision: Revision,
) -> Result<Manifest, RevlogError> { ) -> Result<Manifest, RevlogError> {
let changelog = self.changelog()?; let changelog = self.changelog()?;
let manifest = self.manifestlog()?; let manifest = self.manifestlog()?;
let changelog_entry = changelog.get_rev(revision)?; let changelog_entry = changelog.get_rev(revision)?;
let manifest_node = let manifest_node =
Node::from_hex_for_repo(&changelog_entry.manifest_node()?)?; Node::from_hex_for_repo(&changelog_entry.manifest_node()?)?;
manifest.get_node(manifest_node.into()) manifest.get_node(manifest_node.into())
} }
pub fn filelog(&self, path: &HgPath) -> Result<Filelog, RevlogError> { 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
/// ///
/// 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`.

rust/hg-core/src/revlog/changelog.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::Revision; use crate::revlog::Revision;
use crate::revlog::{Node, NodePrefix}; use crate::revlog::{Node, NodePrefix};
/// A specialized `Revlog` to work with `changelog` data format. /// A specialized `Revlog` to work with `changelog` data format.
pub struct Changelog { pub struct Changelog {
/// The generic `revlog` format. /// The generic `revlog` format.
pub(crate) revlog: Revlog, pub(crate) revlog: Revlog,
} }
impl Changelog { impl Changelog {
/// Open the `changelog` of a repository given by its root. /// Open the `changelog` of a repository given by its root.
pub fn open(repo: &Repo) -> Result<Self, RevlogError> { pub fn open(repo: &Repo) -> Result<Self, HgError> {
let revlog = Revlog::open(repo, "00changelog.i", None)?; let revlog = Revlog::open(repo, "00changelog.i", None)?;
Ok(Self { revlog }) Ok(Self { revlog })
} }
/// Return the `ChangelogEntry` a given node id. /// Return the `ChangelogEntry` a given node id.
pub fn get_node( pub fn get_node(
&self, &self,
node: NodePrefix, node: NodePrefix,

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

/// A specialized `Revlog` to work with file data logs. /// A specialized `Revlog` to work with file data logs.
pub struct Filelog { pub struct Filelog {
/// The generic `revlog` format. /// The generic `revlog` format.
revlog: Revlog, revlog: Revlog,
} }
impl Filelog { impl Filelog {
pub fn open(repo: &Repo, file_path: &HgPath) -> Result<Self, RevlogError> { pub fn open(repo: &Repo, file_path: &HgPath) -> Result<Self, HgError> {
let index_path = store_path(file_path, b".i"); let index_path = store_path(file_path, b".i");
let data_path = store_path(file_path, b".d"); let data_path = store_path(file_path, b".d");
let revlog = Revlog::open(repo, index_path, Some(&data_path))?; let revlog = Revlog::open(repo, index_path, Some(&data_path))?;
Ok(Self { revlog }) Ok(Self { revlog })
} }
/// The given node ID is that of the file as found in a manifest, not of a /// The given node ID is that of the file as found in a manifest, not of a
/// changeset. /// changeset.

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

use std::convert::TryInto; use std::convert::TryInto;
use std::ops::Deref; use std::ops::Deref;
use byteorder::{BigEndian, ByteOrder}; use byteorder::{BigEndian, ByteOrder};
use crate::errors::HgError; use crate::errors::HgError;
use crate::revlog::node::Node; use crate::revlog::node::Node;
use crate::revlog::revlog::RevlogError;
use crate::revlog::{Revision, NULL_REVISION}; use crate::revlog::{Revision, NULL_REVISION};
pub const INDEX_ENTRY_SIZE: usize = 64; pub const INDEX_ENTRY_SIZE: usize = 64;
/// A Revlog index /// A Revlog index
pub struct Index { pub struct Index {
bytes: Box<dyn Deref<Target = [u8]> + Send>, bytes: Box<dyn Deref<Target = [u8]> + Send>,
/// Offsets of starts of index blocks. /// Offsets of starts of index blocks.
/// Only needed when the index is interleaved with data. /// Only needed when the index is interleaved with data.
offsets: Option<Vec<usize>>, offsets: Option<Vec<usize>>,
} }
impl Index { impl Index {
/// Create an index from bytes. /// Create an index from bytes.
/// Calculate the start of each entry when is_inline is true. /// Calculate the start of each entry when is_inline is true.
pub fn new( pub fn new(
bytes: Box<dyn Deref<Target = [u8]> + Send>, bytes: Box<dyn Deref<Target = [u8]> + Send>,
) -> Result<Self, RevlogError> { ) -> Result<Self, HgError> {
if is_inline(&bytes) { if is_inline(&bytes) {
let mut offset: usize = 0; let mut offset: usize = 0;
let mut offsets = Vec::new(); let mut offsets = Vec::new();
while offset + INDEX_ENTRY_SIZE <= bytes.len() { while offset + INDEX_ENTRY_SIZE <= bytes.len() {
offsets.push(offset); offsets.push(offset);
let end = offset + INDEX_ENTRY_SIZE; let end = offset + INDEX_ENTRY_SIZE;
let entry = IndexEntry { let entry = IndexEntry {

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

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::NodePrefix;
use crate::revlog::Revision; use crate::revlog::Revision;
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,
} }
impl Manifestlog { impl Manifestlog {
/// Open the `manifest` of a repository given by its root. /// Open the `manifest` of a repository given by its root.
pub fn open(repo: &Repo) -> Result<Self, RevlogError> { pub fn open(repo: &Repo) -> Result<Self, HgError> {
let revlog = Revlog::open(repo, "00manifest.i", None)?; let revlog = Revlog::open(repo, "00manifest.i", None)?;
Ok(Self { revlog }) Ok(Self { revlog })
} }
/// Return the `ManifestEntry` of a given node id. /// Return the `ManifestEntry` of a given node id.
pub fn get_node(&self, node: NodePrefix) -> Result<Manifest, RevlogError> { pub fn get_node(&self, node: NodePrefix) -> Result<Manifest, RevlogError> {
let rev = self.revlog.get_node_rev(node)?; let rev = self.revlog.get_node_rev(node)?;
self.get_rev(rev) self.get_rev(rev)

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

use crate::errors::{HgError, HgResultExt}; use crate::errors::{HgError, HgResultExt};
use crate::requirements; use crate::requirements;
use bytes_cast::{unaligned, BytesCast}; use bytes_cast::{unaligned, BytesCast};
use memmap2::Mmap; use memmap2::Mmap;
use std::path::{Path, PathBuf}; use std::path::{Path, PathBuf};
use super::revlog::RevlogError;
use crate::repo::Repo; use crate::repo::Repo;
use crate::utils::strip_suffix; use crate::utils::strip_suffix;
const ONDISK_VERSION: u8 = 1; const ONDISK_VERSION: u8 = 1;
pub(super) struct NodeMapDocket { pub(super) struct NodeMapDocket {
pub data_length: usize, pub data_length: usize,
// TODO: keep here more of the data from `parse()` when we need it // TODO: keep here more of the data from `parse()` when we need it
/// small revlogs), or /// small revlogs), or
/// * The docket has an unsupported version number (repositories created by /// * The docket has an unsupported version number (repositories created by
/// later hg, maybe that should be a requirement instead?), or /// later hg, maybe that should be a requirement instead?), or
/// * The docket file points to a missing (likely deleted) data file (this /// * The docket file points to a missing (likely deleted) data file (this
/// can happen in a rare race condition). /// can happen in a rare race condition).
pub fn read_from_file( pub fn read_from_file(
repo: &Repo, repo: &Repo,
index_path: &Path, index_path: &Path,
) -> Result<Option<(Self, Mmap)>, RevlogError> { ) -> Result<Option<(Self, Mmap)>, HgError> {
if !repo if !repo
.requirements() .requirements()
.contains(requirements::NODEMAP_REQUIREMENT) .contains(requirements::NODEMAP_REQUIREMENT)
{ {
// If .hg/requires does not opt it, don’t try to open a nodemap // If .hg/requires does not opt it, don’t try to open a nodemap
return Ok(None); return Ok(None);
} }
docket_bytes.split_first() docket_bytes.split_first()
{ {
rest rest
} else { } else {
return Ok(None); return Ok(None);
}; };
/// Treat any error as a parse error /// Treat any error as a parse error
fn parse<T, E>(result: Result<T, E>) -> Result<T, RevlogError> { fn parse<T, E>(result: Result<T, E>) -> Result<T, HgError> {
result.map_err(|_| { result
HgError::corrupted("nodemap docket parse error").into() .map_err(|_| HgError::corrupted("nodemap docket parse error"))
})
} }
let (header, rest) = parse(DocketHeader::from_bytes(input))?; let (header, rest) = parse(DocketHeader::from_bytes(input))?;
let uid_size = header.uid_size as usize; let uid_size = header.uid_size as usize;
// TODO: do we care about overflow for 4 GB+ nodemap files on 32-bit // TODO: do we care about overflow for 4 GB+ nodemap files on 32-bit
// systems? // systems?
let tip_node_size = header.tip_node_size.get() as usize; let tip_node_size = header.tip_node_size.get() as usize;
let data_length = header.data_length.get() as usize; let data_length = header.data_length.get() as usize;
if let Some(mmap) = repo if let Some(mmap) = repo
.store_vfs() .store_vfs()
.mmap_open(&data_path) .mmap_open(&data_path)
.io_not_found_as_none()? .io_not_found_as_none()?
{ {
if mmap.len() >= data_length { if mmap.len() >= data_length {
Ok(Some((docket, mmap))) Ok(Some((docket, mmap)))
} else { } else {
Err(HgError::corrupted("persistent nodemap too short").into()) Err(HgError::corrupted("persistent nodemap too short"))
} }
} else { } else {
// Even if .hg/requires opted in, some revlogs are deemed small // Even if .hg/requires opted in, some revlogs are deemed small
// enough to not need a persistent nodemap. // enough to not need a persistent nodemap.
Ok(None) Ok(None)
} }
} }
} }

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

/// ///
/// It will also open the associated data file if index and data are not /// It will also open the associated data file if index and data are not
/// 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, RevlogError> { ) -> 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_mmap = repo.store_vfs().mmap_open(&index_path)?;
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(RevlogError::corrupted()); return Err(HgError::corrupted("corrupted revlog"));
} }
let index = Index::new(Box::new(index_mmap))?; let index = Index::new(Box::new(index_mmap))?;
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]>