This is an archive of the discontinued Mercurial Phabricator instance.

Differential D9596

rust: introduce Repo and Vfs types for filesystem abstraction
ClosedPublic

Authored by SimonSapin on Dec 14 2020, 11:27 AM.

Details

Reviewers
pulkit
Group Reviewers
hg-reviewers
Commits
rHG8a4914397d02: rust: introduce Repo and Vfs types for filesystem abstraction
Summary

This is similar to the corresponding Python classes.

Repo represents a repository and knows the path to the .hg directory,
the store directory, and the working directory.
Separating these will enable supporting the share extension.

A Vfs is created from a Repo for one of these three directories.
It has filesystem access APIs that take a relative std::path::Path
as a parameter.

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.Dec 14 2020, 11:27 AM
pulkit accepted this revision.Dec 17 2020, 5:56 AM
This revision is now accepted and ready to land.Dec 17 2020, 5:56 AM
pulkit requested changes to this revision.Dec 18 2020, 3:51 AM

This needs to be rebased on current head of default branch.

This revision now requires changes to proceed.Dec 18 2020, 3:51 AM
SimonSapin updated this revision to Diff 24444.Dec 19 2020, 4:41 PM
pulkit accepted this revision.Dec 21 2020, 6:53 AM
This revision is now accepted and ready to land.Dec 21 2020, 6:53 AM

Revision Contents
Changeset List

Diff 24460

rust/hg-core/src/lib.rs

status, BadMatch, BadType, DirstateStatus, StatusError, StatusOptions, status, BadMatch, BadType, DirstateStatus, StatusError, StatusOptions,
}, },
CopyMap, CopyMapIter, DirstateEntry, DirstateParents, EntryState, CopyMap, CopyMapIter, DirstateEntry, DirstateParents, EntryState,
StateMap, StateMapIter, StateMap, StateMapIter,
}; };
pub mod copy_tracing; pub mod copy_tracing;
mod filepatterns; mod filepatterns;
pub mod matchers; pub mod matchers;
pub mod repo;
pub mod revlog; pub mod revlog;
pub use revlog::*; pub use revlog::*;
pub mod operations; pub mod operations;
pub mod utils; pub mod utils;
// Remove this to see (potential) non-artificial compile failures. MacOS // Remove this to see (potential) non-artificial compile failures. MacOS
// *should* compile, but fail to compile tests for example as of 2020-03-06 // *should* compile, but fail to compile tests for example as of 2020-03-06
#[cfg(not(target_os = "linux"))] #[cfg(not(target_os = "linux"))]

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::convert::From; use std::convert::From;
use std::path::{Path, PathBuf}; use std::path::PathBuf;
use crate::repo::Repo;
use crate::revlog::changelog::Changelog; use crate::revlog::changelog::Changelog;
use crate::revlog::manifest::Manifest; use crate::revlog::manifest::Manifest;
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::revlog::NodePrefix; use crate::revlog::NodePrefix;
use crate::revlog::Revision; use crate::revlog::Revision;
} }
/// List files under Mercurial control at a given revision. /// List files under Mercurial control at a given revision.
/// ///
/// * `root`: Repository root /// * `root`: Repository root
/// * `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( pub fn cat(
root: &Path, repo: &Repo,
rev: &str, rev: &str,
files: &[HgPathBuf], files: &[HgPathBuf],
) -> Result<Vec<u8>, CatRevError> { ) -> Result<Vec<u8>, CatRevError> {
let changelog = Changelog::open(&root)?; let changelog = Changelog::open(repo)?;
let manifest = Manifest::open(&root)?; let manifest = Manifest::open(repo)?;
let changelog_entry = match rev.parse::<Revision>() { let changelog_entry = match rev.parse::<Revision>() {
Ok(rev) => changelog.get_rev(rev)?, Ok(rev) => changelog.get_rev(rev)?,
_ => { _ => {
let changelog_node = NodePrefix::from_hex(&rev) let changelog_node = NodePrefix::from_hex(&rev)
.map_err(|_| CatRevErrorKind::InvalidRevision)?; .map_err(|_| CatRevErrorKind::InvalidRevision)?;
changelog.get_node(changelog_node.borrow())? changelog.get_node(changelog_node.borrow())?
} }
}; };
let manifest_node = Node::from_hex(&changelog_entry.manifest_node()?) let manifest_node = Node::from_hex(&changelog_entry.manifest_node()?)
.map_err(|_| CatRevErrorKind::CorruptedRevlog)?; .map_err(|_| CatRevErrorKind::CorruptedRevlog)?;
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![];
for (manifest_file, node_bytes) in manifest_entry.files_with_nodes() { for (manifest_file, node_bytes) in manifest_entry.files_with_nodes() {
for cat_file in files.iter() { for cat_file in files.iter() {
if cat_file.as_bytes() == manifest_file.as_bytes() { if cat_file.as_bytes() == manifest_file.as_bytes() {
let index_path = store_path(root, manifest_file, b".i"); let index_path = store_path(manifest_file, b".i");
let data_path = store_path(root, manifest_file, b".d"); let data_path = store_path(manifest_file, b".d");
let file_log = Revlog::open(&index_path, Some(&data_path))?; let file_log =
Revlog::open(repo, &index_path, Some(&data_path))?;
let file_node = Node::from_hex(node_bytes) let file_node = Node::from_hex(node_bytes)
.map_err(|_| CatRevErrorKind::CorruptedRevlog)?; .map_err(|_| CatRevErrorKind::CorruptedRevlog)?;
let file_rev = file_log.get_node_rev((&file_node).into())?; let file_rev = file_log.get_node_rev((&file_node).into())?;
let data = file_log.get_rev_data(file_rev)?; let data = file_log.get_rev_data(file_rev)?;
if data.starts_with(&METADATA_DELIMITER) { if data.starts_with(&METADATA_DELIMITER) {
let end_delimiter_position = data let end_delimiter_position = data
[METADATA_DELIMITER.len()..] [METADATA_DELIMITER.len()..]
.windows(METADATA_DELIMITER.len()) .windows(METADATA_DELIMITER.len())
.position(|bytes| bytes == METADATA_DELIMITER); .position(|bytes| bytes == METADATA_DELIMITER);
if let Some(position) = end_delimiter_position { if let Some(position) = end_delimiter_position {
let offset = METADATA_DELIMITER.len() * 2; let offset = METADATA_DELIMITER.len() * 2;
bytes.extend(data[position + offset..].iter()); bytes.extend(data[position + offset..].iter());
} }
} else { } else {
bytes.extend(data); bytes.extend(data);
} }
} }
} }
} }
Ok(bytes) Ok(bytes)
} }
fn store_path(root: &Path, hg_path: &HgPath, suffix: &[u8]) -> PathBuf { fn store_path(hg_path: &HgPath, suffix: &[u8]) -> PathBuf {
let encoded_bytes = let encoded_bytes =
path_encode(&[b"data/", hg_path.as_bytes(), suffix].concat()); path_encode(&[b"data/", hg_path.as_bytes(), suffix].concat());
[ get_path_from_bytes(&encoded_bytes).into()
root,
&Path::new(".hg/store/"),
get_path_from_bytes(&encoded_bytes),
]
.iter()
.collect()
} }

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

// debugdata.rs // debugdata.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::Path; 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;
/// Kind of data to debug /// Kind of data to debug
#[derive(Debug, Copy, Clone)] #[derive(Debug, Copy, Clone)]
pub enum DebugDataKind { pub enum DebugDataKind {
Changelog, Changelog,
} }
} }
.into() .into()
} }
} }
/// Dump the contents data of a revision. /// Dump the contents data of a revision.
pub fn debug_data( pub fn debug_data(
root: &Path, repo: &Repo,
rev: &str, rev: &str,
kind: DebugDataKind, kind: DebugDataKind,
) -> Result<Vec<u8>, DebugDataError> { ) -> Result<Vec<u8>, DebugDataError> {
let index_file = match kind { let index_file = match kind {
DebugDataKind::Changelog => root.join(".hg/store/00changelog.i"), DebugDataKind::Changelog => "00changelog.i",
DebugDataKind::Manifest => root.join(".hg/store/00manifest.i"), DebugDataKind::Manifest => "00manifest.i",
}; };
let revlog = Revlog::open(&index_file, None)?; let revlog = Revlog::open(repo, index_file, None)?;
let data = match rev.parse::<Revision>() { let data = match rev.parse::<Revision>() {
Ok(rev) => revlog.get_rev_data(rev)?, Ok(rev) => revlog.get_rev_data(rev)?,
_ => { _ => {
let node = NodePrefix::from_hex(&rev) let node = NodePrefix::from_hex(&rev)
.map_err(|_| DebugDataErrorKind::InvalidRevision)?; .map_err(|_| DebugDataErrorKind::InvalidRevision)?;
let rev = revlog.get_node_rev(node.borrow())?; let rev = revlog.get_node_rev(node.borrow())?;
revlog.get_rev_data(rev)? revlog.get_rev_data(rev)?
} }
}; };
Ok(data) Ok(data)
} }

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; use crate::dirstate::parsers::parse_dirstate;
use crate::repo::Repo;
use crate::revlog::changelog::Changelog; use crate::revlog::changelog::Changelog;
use crate::revlog::manifest::{Manifest, ManifestEntry}; use crate::revlog::manifest::{Manifest, ManifestEntry};
use crate::revlog::node::{Node, NodePrefix}; use crate::revlog::node::{Node, NodePrefix};
use crate::revlog::revlog::RevlogError; use crate::revlog::revlog::RevlogError;
use crate::revlog::Revision; use crate::revlog::Revision;
use crate::utils::hg_path::HgPath; use crate::utils::hg_path::HgPath;
use crate::{DirstateParseError, EntryState}; use crate::{DirstateParseError, EntryState};
use rayon::prelude::*; use rayon::prelude::*;
use std::convert::From; use std::convert::From;
use std::fs;
use std::path::Path;
/// Kind of error encountered by `ListDirstateTrackedFiles` /// Kind of error encountered by `ListDirstateTrackedFiles`
#[derive(Debug)] #[derive(Debug)]
pub enum ListDirstateTrackedFilesErrorKind { pub enum ListDirstateTrackedFilesErrorKind {
/// Error when reading the `dirstate` file /// Error when reading the `dirstate` file
IoError(std::io::Error), IoError(std::io::Error),
/// Error when parsing the `dirstate` file /// Error when parsing the `dirstate` file
ParseError(DirstateParseError), ParseError(DirstateParseError),
/// 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
pub struct Dirstate { pub struct Dirstate {
/// The `dirstate` content. /// The `dirstate` content.
content: Vec<u8>, content: Vec<u8>,
} }
impl Dirstate { impl Dirstate {
pub fn new(root: &Path) -> Result<Self, ListDirstateTrackedFilesError> { pub fn new(repo: &Repo) -> Result<Self, ListDirstateTrackedFilesError> {
let dirstate = root.join(".hg/dirstate"); let content = repo.hg_vfs().read("dirstate")?;
let content = fs::read(&dirstate)?;
Ok(Self { content }) Ok(Self { content })
} }
pub fn tracked_files( pub fn tracked_files(
&self, &self,
) -> Result<Vec<&HgPath>, ListDirstateTrackedFilesError> { ) -> Result<Vec<&HgPath>, ListDirstateTrackedFilesError> {
let (_, entries, _) = parse_dirstate(&self.content) let (_, entries, _) = parse_dirstate(&self.content)
.map_err(ListDirstateTrackedFilesErrorKind::ParseError)?; .map_err(ListDirstateTrackedFilesErrorKind::ParseError)?;
} }
} }
.into() .into()
} }
} }
/// 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(
root: &Path, repo: &Repo,
rev: &str, rev: &str,
) -> Result<FilesForRev, ListRevTrackedFilesError> { ) -> Result<FilesForRev, ListRevTrackedFilesError> {
let changelog = Changelog::open(root)?; let changelog = Changelog::open(repo)?;
let manifest = Manifest::open(root)?; let manifest = Manifest::open(repo)?;
let changelog_entry = match rev.parse::<Revision>() { let changelog_entry = match rev.parse::<Revision>() {
Ok(rev) => changelog.get_rev(rev)?, Ok(rev) => changelog.get_rev(rev)?,
_ => { _ => {
let changelog_node = NodePrefix::from_hex(&rev) let changelog_node = NodePrefix::from_hex(&rev)
.or(Err(ListRevTrackedFilesErrorKind::InvalidRevision))?; .or(Err(ListRevTrackedFilesErrorKind::InvalidRevision))?;
changelog.get_node(changelog_node.borrow())? changelog.get_node(changelog_node.borrow())?
} }

rust/hg-core/src/repo.rs

  • This file was added.
use crate::operations::{find_root, FindRootError};
use crate::requirements;
use memmap::{Mmap, MmapOptions};
use std::path::{Path, PathBuf};
/// A repository on disk
pub struct Repo {
working_directory: PathBuf,
dot_hg: PathBuf,
store: PathBuf,
}
/// Filesystem access abstraction for the contents of a given "base" diretory
#[derive(Clone, Copy)]
pub(crate) struct Vfs<'a> {
base: &'a Path,
}
impl Repo {
/// Returns `None` if the given path doesn’t look like a repository
/// (doesn’t contain a `.hg` sub-directory).
pub fn for_path(root: impl Into<PathBuf>) -> Self {
let working_directory = root.into();
let dot_hg = working_directory.join(".hg");
Self {
store: dot_hg.join("store"),
dot_hg,
working_directory,
}
}
pub fn find() -> Result<Self, FindRootError> {
find_root().map(Self::for_path)
}
pub fn check_requirements(
&self,
) -> Result<(), requirements::RequirementsError> {
requirements::check(self)
}
pub fn working_directory_path(&self) -> &Path {
&self.working_directory
}
/// For accessing repository files (in `.hg`), except for the store
/// (`.hg/store`).
pub(crate) fn hg_vfs(&self) -> Vfs<'_> {
Vfs { base: &self.dot_hg }
}
/// For accessing repository store files (in `.hg/store`)
pub(crate) fn store_vfs(&self) -> Vfs<'_> {
Vfs { base: &self.store }
}
/// For accessing the working copy
// The undescore prefix silences the "never used" warning. Remove before
// using.
pub(crate) fn _working_directory_vfs(&self) -> Vfs<'_> {
Vfs {
base: &self.working_directory,
}
}
}
impl Vfs<'_> {
pub(crate) fn read(
&self,
relative_path: impl AsRef<Path>,
) -> std::io::Result<Vec<u8>> {
std::fs::read(self.base.join(relative_path))
}
pub(crate) fn open(
&self,
relative_path: impl AsRef<Path>,
) -> std::io::Result<std::fs::File> {
std::fs::File::open(self.base.join(relative_path))
}
pub(crate) fn mmap_open(
&self,
relative_path: impl AsRef<Path>,
) -> std::io::Result<Mmap> {
let file = self.open(relative_path)?;
// TODO: what are the safety requirements here?
let mmap = unsafe { MmapOptions::new().map(&file) }?;
Ok(mmap)
}
}

rust/hg-core/src/requirements.rs

use crate::repo::Repo;
use std::io; use std::io;
use std::path::Path;
#[derive(Debug)] #[derive(Debug)]
pub enum RequirementsError { pub enum RequirementsError {
// TODO: include a path? // TODO: include a path?
Io(io::Error), Io(io::Error),
/// The `requires` file is corrupted /// The `requires` file is corrupted
Corrupted, Corrupted,
/// The repository requires a feature that we don't support /// The repository requires a feature that we don't support
Ok(String::from_utf8(line.into()).unwrap()) Ok(String::from_utf8(line.into()).unwrap())
} else { } else {
Err(()) Err(())
} }
}) })
.collect() .collect()
} }
pub fn load(repo_root: &Path) -> Result<Vec<String>, RequirementsError> { pub fn load(repo: &Repo) -> Result<Vec<String>, RequirementsError> {
match std::fs::read(repo_root.join(".hg").join("requires")) { match repo.hg_vfs().read("requires") {
Ok(bytes) => parse(&bytes).map_err(|()| RequirementsError::Corrupted), Ok(bytes) => parse(&bytes).map_err(|()| RequirementsError::Corrupted),
// Treat a missing file the same as an empty file. // Treat a missing file the same as an empty file.
// From `mercurial/localrepo.py`: // From `mercurial/localrepo.py`:
// > requires file contains a newline-delimited list of // > requires file contains a newline-delimited list of
// > features/capabilities the opener (us) must have in order to use // > features/capabilities the opener (us) must have in order to use
// > the repository. This file was introduced in Mercurial 0.9.2, // > the repository. This file was introduced in Mercurial 0.9.2,
// > which means very old repositories may not have one. We assume // > which means very old repositories may not have one. We assume
// > a missing file translates to no requirements. // > a missing file translates to no requirements.
Err(error) if error.kind() == std::io::ErrorKind::NotFound => { Err(error) if error.kind() == std::io::ErrorKind::NotFound => {
Ok(Vec::new()) Ok(Vec::new())
} }
Err(error) => Err(RequirementsError::Io(error))?, Err(error) => Err(RequirementsError::Io(error))?,
} }
} }
pub fn check(repo_root: &Path) -> Result<(), RequirementsError> { pub fn check(repo: &Repo) -> Result<(), RequirementsError> {
for feature in load(repo_root)? { for feature in load(repo)? {
if !SUPPORTED.contains(&&*feature) { if !SUPPORTED.contains(&&*feature) {
return Err(RequirementsError::Unsupported { feature }); return Err(RequirementsError::Unsupported { feature });
} }
} }
Ok(()) Ok(())
} }
// TODO: set this to actually-supported features // TODO: set this to actually-supported features

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

use crate::repo::Repo;
use crate::revlog::revlog::{Revlog, RevlogError}; use crate::revlog::revlog::{Revlog, RevlogError};
use crate::revlog::NodePrefixRef; use crate::revlog::NodePrefixRef;
use crate::revlog::Revision; use crate::revlog::Revision;
use std::path::Path;
/// 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.
revlog: Revlog, 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(root: &Path) -> Result<Self, RevlogError> { pub fn open(repo: &Repo) -> Result<Self, RevlogError> {
let index_file = root.join(".hg/store/00changelog.i"); let revlog = Revlog::open(repo, "00changelog.i", None)?;
let revlog = Revlog::open(&index_file, 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: NodePrefixRef, node: NodePrefixRef,
) -> Result<ChangelogEntry, RevlogError> { ) -> Result<ChangelogEntry, RevlogError> {

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

use crate::repo::Repo;
use crate::revlog::revlog::{Revlog, RevlogError}; use crate::revlog::revlog::{Revlog, RevlogError};
use crate::revlog::NodePrefixRef; use crate::revlog::NodePrefixRef;
use crate::revlog::Revision; use crate::revlog::Revision;
use crate::utils::hg_path::HgPath; use crate::utils::hg_path::HgPath;
use std::path::Path;
/// A specialized `Revlog` to work with `manifest` data format. /// A specialized `Revlog` to work with `manifest` data format.
pub struct Manifest { pub struct Manifest {
/// The generic `revlog` format. /// The generic `revlog` format.
revlog: Revlog, revlog: Revlog,
} }
impl Manifest { impl Manifest {
/// Open the `manifest` of a repository given by its root. /// Open the `manifest` of a repository given by its root.
pub fn open(root: &Path) -> Result<Self, RevlogError> { pub fn open(repo: &Repo) -> Result<Self, RevlogError> {
let index_file = root.join(".hg/store/00manifest.i"); let revlog = Revlog::open(repo, "00manifest.i", None)?;
let revlog = Revlog::open(&index_file, 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( pub fn get_node(
&self, &self,
node: NodePrefixRef, node: NodePrefixRef,
) -> Result<ManifestEntry, RevlogError> { ) -> Result<ManifestEntry, RevlogError> {

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

use memmap::Mmap; use memmap::Mmap;
use std::convert::TryInto; use std::convert::TryInto;
use std::path::{Path, PathBuf}; use std::path::{Path, PathBuf};
use super::revlog::{mmap_open, RevlogError}; use super::revlog::RevlogError;
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
} }
impl NodeMapDocket { impl NodeMapDocket {
/// Return `Ok(None)` when the caller should proceed without a persistent /// Return `Ok(None)` when the caller should proceed without a persistent
/// nodemap: /// nodemap:
/// ///
/// * This revlog does not have a `.n` docket file (it is not generated for /// * This revlog does not have a `.n` docket file (it is not generated for
/// 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,
index_path: &Path, index_path: &Path,
) -> Result<Option<(Self, Mmap)>, RevlogError> { ) -> Result<Option<(Self, Mmap)>, RevlogError> {
let docket_path = index_path.with_extension("n"); let docket_path = index_path.with_extension("n");
let docket_bytes = match std::fs::read(&docket_path) { let docket_bytes = match repo.store_vfs().read(&docket_path) {
Err(e) if e.kind() == std::io::ErrorKind::NotFound => { Err(e) if e.kind() == std::io::ErrorKind::NotFound => {
return Ok(None) return Ok(None)
} }
Err(e) => return Err(RevlogError::IoError(e)), Err(e) => return Err(RevlogError::IoError(e)),
Ok(bytes) => bytes, Ok(bytes) => bytes,
}; };
let mut input = if let Some((&ONDISK_VERSION, rest)) = let mut input = if let Some((&ONDISK_VERSION, rest)) =
let uid = let uid =
std::str::from_utf8(uid).map_err(|_| RevlogError::Corrupted)?; std::str::from_utf8(uid).map_err(|_| RevlogError::Corrupted)?;
let docket = NodeMapDocket { data_length }; let docket = NodeMapDocket { data_length };
let data_path = rawdata_path(&docket_path, uid); let data_path = rawdata_path(&docket_path, uid);
// TODO: use `std::fs::read` here when the `persistent-nodemap.mmap` // TODO: use `std::fs::read` here when the `persistent-nodemap.mmap`
// config is false? // config is false?
match mmap_open(&data_path) { match repo.store_vfs().mmap_open(&data_path) {
Ok(mmap) => { Ok(mmap) => {
if mmap.len() >= data_length { if mmap.len() >= data_length {
Ok(Some((docket, mmap))) Ok(Some((docket, mmap)))
} else { } else {
Err(RevlogError::Corrupted) Err(RevlogError::Corrupted)
} }
} }
Err(error) => { Err(error) => {

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

use std::borrow::Cow; use std::borrow::Cow;
use std::fs::File;
use std::io::Read; use std::io::Read;
use std::ops::Deref; use std::ops::Deref;
use std::path::Path; use std::path::Path;
use byteorder::{BigEndian, ByteOrder}; use byteorder::{BigEndian, ByteOrder};
use crypto::digest::Digest; use crypto::digest::Digest;
use crypto::sha1::Sha1; use crypto::sha1::Sha1;
use flate2::read::ZlibDecoder; use flate2::read::ZlibDecoder;
use memmap::{Mmap, MmapOptions};
use micro_timer::timed; use micro_timer::timed;
use zstd; use zstd;
use super::index::Index; use super::index::Index;
use super::node::{NodePrefixRef, NODE_BYTES_LENGTH, NULL_NODE}; use super::node::{NodePrefixRef, NODE_BYTES_LENGTH, NULL_NODE};
use super::nodemap; use super::nodemap;
use super::nodemap::NodeMap; use super::nodemap::NodeMap;
use super::nodemap_docket::NodeMapDocket; use super::nodemap_docket::NodeMapDocket;
use super::patch; use super::patch;
use crate::repo::Repo;
use crate::revlog::Revision; use crate::revlog::Revision;
pub enum RevlogError { pub enum RevlogError {
IoError(std::io::Error), IoError(std::io::Error),
UnsuportedVersion(u16), UnsuportedVersion(u16),
InvalidRevision, InvalidRevision,
/// Found more than one entry whose ID match the requested prefix /// Found more than one entry whose ID match the requested prefix
AmbiguousPrefix, AmbiguousPrefix,
Corrupted, Corrupted,
UnknowDataFormat(u8), UnknowDataFormat(u8),
} }
pub(super) fn mmap_open(path: &Path) -> Result<Mmap, std::io::Error> {
let file = File::open(path)?;
let mmap = unsafe { MmapOptions::new().map(&file) }?;
Ok(mmap)
}
/// Read only implementation of revlog. /// Read only implementation of revlog.
pub struct Revlog { pub struct Revlog {
/// When index and data are not interleaved: bytes of the revlog index. /// When index and data are not interleaved: bytes of the revlog index.
/// When index and data are interleaved: bytes of the revlog index and /// When index and data are interleaved: bytes of the revlog index and
/// data. /// data.
index: Index, index: Index,
/// When index and data are not interleaved: bytes of the revlog data /// When index and data are not interleaved: bytes of the revlog data
data_bytes: Option<Box<dyn Deref<Target = [u8]> + Send>>, data_bytes: Option<Box<dyn Deref<Target = [u8]> + Send>>,
/// When present on disk: the persistent nodemap for this revlog /// When present on disk: the persistent nodemap for this revlog
nodemap: Option<nodemap::NodeTree>, nodemap: Option<nodemap::NodeTree>,
} }
impl Revlog { impl Revlog {
/// Open a revlog index file. /// Open a revlog index file.
/// ///
/// 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(
index_path: &Path, repo: &Repo,
index_path: impl AsRef<Path>,
data_path: Option<&Path>, data_path: Option<&Path>,
) -> Result<Self, RevlogError> { ) -> Result<Self, RevlogError> {
let index_mmap = let index_path = index_path.as_ref();
mmap_open(&index_path).map_err(RevlogError::IoError)?; let index_mmap = repo
.store_vfs()
.mmap_open(&index_path)
.map_err(RevlogError::IoError)?;
let version = get_version(&index_mmap); let version = get_version(&index_mmap);
if version != 1 { if version != 1 {
return Err(RevlogError::UnsuportedVersion(version)); return Err(RevlogError::UnsuportedVersion(version));
} }
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]>
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
} else { } else {
let data_path = data_path.unwrap_or(&default_data_path); let data_path = data_path.unwrap_or(&default_data_path);
let data_mmap = let data_mmap = repo
mmap_open(data_path).map_err(RevlogError::IoError)?; .store_vfs()
.mmap_open(data_path)
.map_err(RevlogError::IoError)?;
Some(Box::new(data_mmap)) Some(Box::new(data_mmap))
}; };
let nodemap = NodeMapDocket::read_from_file(index_path)?.map( let nodemap = NodeMapDocket::read_from_file(repo, index_path)?.map(
|(docket, data)| { |(docket, data)| {
nodemap::NodeTree::load_bytes( nodemap::NodeTree::load_bytes(
Box::new(data), Box::new(data),
docket.data_length, docket.data_length,
) )
}, },
); );

rust/rhg/src/commands/cat.rs

use crate::commands::Command; use crate::commands::Command;
use crate::error::{CommandError, CommandErrorKind}; use crate::error::{CommandError, CommandErrorKind};
use crate::ui::utf8_to_local; use crate::ui::utf8_to_local;
use crate::ui::Ui; use crate::ui::Ui;
use hg::operations::find_root;
use hg::operations::{cat, CatRevError, CatRevErrorKind}; use hg::operations::{cat, CatRevError, CatRevErrorKind};
use hg::requirements; use hg::repo::Repo;
use hg::utils::hg_path::HgPathBuf; use hg::utils::hg_path::HgPathBuf;
use micro_timer::timed; use micro_timer::timed;
use std::convert::TryFrom; use std::convert::TryFrom;
pub const HELP_TEXT: &str = " pub const HELP_TEXT: &str = "
Output the current or given revision of files Output the current or given revision of files
"; ";
ui.write_stdout(data)?; ui.write_stdout(data)?;
Ok(()) Ok(())
} }
} }
impl<'a> Command for CatCommand<'a> { impl<'a> Command for CatCommand<'a> {
#[timed] #[timed]
fn run(&self, ui: &Ui) -> Result<(), CommandError> { fn run(&self, ui: &Ui) -> Result<(), CommandError> {
let root = find_root()?; let repo = Repo::find()?;
requirements::check(&root)?; repo.check_requirements()?;
let cwd = std::env::current_dir() let cwd = std::env::current_dir()
.or_else(|e| Err(CommandErrorKind::CurrentDirNotFound(e)))?; .or_else(|e| Err(CommandErrorKind::CurrentDirNotFound(e)))?;
let mut files = vec![]; let mut files = vec![];
for file in self.files.iter() { for file in self.files.iter() {
let normalized = cwd.join(&file); let normalized = cwd.join(&file);
let stripped = normalized let stripped = normalized
.strip_prefix(&root) .strip_prefix(&repo.working_directory_path())
.or(Err(CommandErrorKind::Abort(None)))?; .or(Err(CommandErrorKind::Abort(None)))?;
let hg_file = HgPathBuf::try_from(stripped.to_path_buf()) let hg_file = HgPathBuf::try_from(stripped.to_path_buf())
.or(Err(CommandErrorKind::Abort(None)))?; .or(Err(CommandErrorKind::Abort(None)))?;
files.push(hg_file); files.push(hg_file);
} }
match self.rev { match self.rev {
Some(rev) => { Some(rev) => {
let data = cat(&root, rev, &files) let data = cat(&repo, rev, &files)
.map_err(|e| map_rev_error(rev, e))?; .map_err(|e| map_rev_error(rev, e))?;
self.display(ui, &data) self.display(ui, &data)
} }
None => Err(CommandErrorKind::Unimplemented.into()), None => Err(CommandErrorKind::Unimplemented.into()),
} }
} }
} }

rust/rhg/src/commands/debugdata.rs

use crate::commands::Command; use crate::commands::Command;
use crate::error::{CommandError, CommandErrorKind}; use crate::error::{CommandError, CommandErrorKind};
use crate::ui::utf8_to_local; use crate::ui::utf8_to_local;
use crate::ui::Ui; use crate::ui::Ui;
use hg::operations::find_root;
use hg::operations::{ use hg::operations::{
debug_data, DebugDataError, DebugDataErrorKind, DebugDataKind, debug_data, DebugDataError, DebugDataErrorKind, DebugDataKind,
}; };
use hg::repo::Repo;
use micro_timer::timed; use micro_timer::timed;
pub const HELP_TEXT: &str = " pub const HELP_TEXT: &str = "
Dump the contents of a data file revision Dump the contents of a data file revision
"; ";
pub struct DebugDataCommand<'a> { pub struct DebugDataCommand<'a> {
rev: &'a str, rev: &'a str,
kind: DebugDataKind, kind: DebugDataKind,
} }
impl<'a> DebugDataCommand<'a> { impl<'a> DebugDataCommand<'a> {
pub fn new(rev: &'a str, kind: DebugDataKind) -> Self { pub fn new(rev: &'a str, kind: DebugDataKind) -> Self {
DebugDataCommand { rev, kind } DebugDataCommand { rev, kind }
} }
} }
impl<'a> Command for DebugDataCommand<'a> { impl<'a> Command for DebugDataCommand<'a> {
#[timed] #[timed]
fn run(&self, ui: &Ui) -> Result<(), CommandError> { fn run(&self, ui: &Ui) -> Result<(), CommandError> {
let root = find_root()?; let repo = Repo::find()?;
let data = debug_data(&root, self.rev, self.kind) let data = debug_data(&repo, self.rev, self.kind)
.map_err(|e| to_command_error(self.rev, e))?; .map_err(|e| to_command_error(self.rev, e))?;
let mut stdout = ui.stdout_buffer(); let mut stdout = ui.stdout_buffer();
stdout.write_all(&data)?; stdout.write_all(&data)?;
stdout.flush()?; stdout.flush()?;
Ok(()) Ok(())
} }

rust/rhg/src/commands/debugrequirements.rs

use crate::commands::Command; use crate::commands::Command;
use crate::error::CommandError; use crate::error::CommandError;
use crate::ui::Ui; use crate::ui::Ui;
use hg::operations::find_root; use hg::repo::Repo;
use hg::requirements; use hg::requirements;
pub const HELP_TEXT: &str = " pub const HELP_TEXT: &str = "
Print the current repo requirements. Print the current repo requirements.
"; ";
pub struct DebugRequirementsCommand {} pub struct DebugRequirementsCommand {}
impl DebugRequirementsCommand { impl DebugRequirementsCommand {
pub fn new() -> Self { pub fn new() -> Self {
DebugRequirementsCommand {} DebugRequirementsCommand {}
} }
} }
impl Command for DebugRequirementsCommand { impl Command for DebugRequirementsCommand {
fn run(&self, ui: &Ui) -> Result<(), CommandError> { fn run(&self, ui: &Ui) -> Result<(), CommandError> {
let root = find_root()?; let repo = Repo::find()?;
let mut output = String::new(); let mut output = String::new();
for req in requirements::load(&root)? { for req in requirements::load(&repo)? {
output.push_str(&req); output.push_str(&req);
output.push('\n'); output.push('\n');
} }
ui.write_stdout(output.as_bytes())?; ui.write_stdout(output.as_bytes())?;
Ok(()) Ok(())
} }
} }

rust/rhg/src/commands/files.rs

use crate::commands::Command; use crate::commands::Command;
use crate::error::{CommandError, CommandErrorKind}; use crate::error::{CommandError, CommandErrorKind};
use crate::ui::utf8_to_local; use crate::ui::utf8_to_local;
use crate::ui::Ui; use crate::ui::Ui;
use hg::operations::find_root;
use hg::operations::{ use hg::operations::{
list_rev_tracked_files, ListRevTrackedFilesError, list_rev_tracked_files, ListRevTrackedFilesError,
ListRevTrackedFilesErrorKind, ListRevTrackedFilesErrorKind,
}; };
use hg::operations::{ use hg::operations::{
Dirstate, ListDirstateTrackedFilesError, ListDirstateTrackedFilesErrorKind, Dirstate, ListDirstateTrackedFilesError, ListDirstateTrackedFilesErrorKind,
}; };
use hg::requirements; use hg::repo::Repo;
use hg::utils::files::{get_bytes_from_path, relativize_path}; use hg::utils::files::{get_bytes_from_path, relativize_path};
use hg::utils::hg_path::{HgPath, HgPathBuf}; use hg::utils::hg_path::{HgPath, HgPathBuf};
use std::path::Path;
pub const HELP_TEXT: &str = " pub const HELP_TEXT: &str = "
List tracked files. List tracked files.
Returns 0 on success. Returns 0 on success.
"; ";
pub struct FilesCommand<'a> { pub struct FilesCommand<'a> {
rev: Option<&'a str>, rev: Option<&'a str>,
} }
impl<'a> FilesCommand<'a> { impl<'a> FilesCommand<'a> {
pub fn new(rev: Option<&'a str>) -> Self { pub fn new(rev: Option<&'a str>) -> Self {
FilesCommand { rev } FilesCommand { rev }
} }
fn display_files( fn display_files(
&self, &self,
ui: &Ui, ui: &Ui,
root: &Path, repo: &Repo,
files: impl IntoIterator<Item = &'a HgPath>, files: impl IntoIterator<Item = &'a HgPath>,
) -> Result<(), CommandError> { ) -> Result<(), CommandError> {
let cwd = std::env::current_dir() let cwd = std::env::current_dir()
.or_else(|e| Err(CommandErrorKind::CurrentDirNotFound(e)))?; .or_else(|e| Err(CommandErrorKind::CurrentDirNotFound(e)))?;
let rooted_cwd = cwd let rooted_cwd = cwd
.strip_prefix(root) .strip_prefix(repo.working_directory_path())
.expect("cwd was already checked within the repository"); .expect("cwd was already checked within the repository");
let rooted_cwd = HgPathBuf::from(get_bytes_from_path(rooted_cwd)); let rooted_cwd = HgPathBuf::from(get_bytes_from_path(rooted_cwd));
let mut stdout = ui.stdout_buffer(); let mut stdout = ui.stdout_buffer();
for file in files { for file in files {
stdout.write_all(relativize_path(file, &rooted_cwd).as_ref())?; stdout.write_all(relativize_path(file, &rooted_cwd).as_ref())?;
stdout.write_all(b"\n")?; stdout.write_all(b"\n")?;
} }
stdout.flush()?; stdout.flush()?;
Ok(()) Ok(())
} }
} }
impl<'a> Command for FilesCommand<'a> { impl<'a> Command for FilesCommand<'a> {
fn run(&self, ui: &Ui) -> Result<(), CommandError> { fn run(&self, ui: &Ui) -> Result<(), CommandError> {
let root = find_root()?; let repo = Repo::find()?;
requirements::check(&root)?; repo.check_requirements()?;
if let Some(rev) = self.rev { if let Some(rev) = self.rev {
let files = list_rev_tracked_files(&root, rev) let files = list_rev_tracked_files(&repo, rev)
.map_err(|e| map_rev_error(rev, e))?; .map_err(|e| map_rev_error(rev, e))?;
self.display_files(ui, &root, files.iter()) self.display_files(ui, &repo, files.iter())
} else { } else {
let distate = Dirstate::new(&root).map_err(map_dirstate_error)?; let distate = Dirstate::new(&repo).map_err(map_dirstate_error)?;
let files = distate.tracked_files().map_err(map_dirstate_error)?; let files = distate.tracked_files().map_err(map_dirstate_error)?;
self.display_files(ui, &root, files) self.display_files(ui, &repo, files)
} }
} }
} }
/// Convert `ListRevTrackedFilesErrorKind` to `CommandError` /// Convert `ListRevTrackedFilesErrorKind` to `CommandError`
fn map_rev_error(rev: &str, err: ListRevTrackedFilesError) -> CommandError { fn map_rev_error(rev: &str, err: ListRevTrackedFilesError) -> CommandError {
CommandError { CommandError {
kind: match err.kind { kind: match err.kind {

rust/rhg/src/commands/root.rs

use crate::commands::Command; use crate::commands::Command;
use crate::error::CommandError; use crate::error::CommandError;
use crate::ui::Ui; use crate::ui::Ui;
use format_bytes::format_bytes; use format_bytes::format_bytes;
use hg::operations::find_root; use hg::repo::Repo;
use hg::utils::files::get_bytes_from_path; use hg::utils::files::get_bytes_from_path;
pub const HELP_TEXT: &str = " pub const HELP_TEXT: &str = "
Print the root directory of the current repository. Print the root directory of the current repository.
Returns 0 on success. Returns 0 on success.
"; ";
pub struct RootCommand {} pub struct RootCommand {}
impl RootCommand { impl RootCommand {
pub fn new() -> Self { pub fn new() -> Self {
RootCommand {} RootCommand {}
} }
} }
impl Command for RootCommand { impl Command for RootCommand {
fn run(&self, ui: &Ui) -> Result<(), CommandError> { fn run(&self, ui: &Ui) -> Result<(), CommandError> {
let path_buf = find_root()?; let repo = Repo::find()?;
let bytes = get_bytes_from_path(repo.working_directory_path());
let bytes = get_bytes_from_path(path_buf);
ui.write_stdout(&format_bytes!(b"{}\n", bytes.as_slice()))?; ui.write_stdout(&format_bytes!(b"{}\n", bytes.as_slice()))?;
Ok(()) Ok(())
} }
} }