This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11394

rust: Move VFS code to its own module
ClosedPublic

Authored by SimonSapin on Sep 10 2021, 11:11 AM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHG9cd35c8c6044: rust: Move VFS code to its own module
Summary

It was previously in the hg::repo module, but both repo code and vfs
will likely grow in the future.

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 10 2021, 11:11 AM
Alphare accepted this revision.Sep 13 2021, 6:11 AM
This revision is now accepted and ready to land.Sep 13 2021, 6:11 AM
SimonSapin added a commit: rHG9cd35c8c6044: rust: Move VFS code to its own module.Sep 13 2021, 10:05 AM
Closed by commit rHG9cd35c8c6044: rust: Move VFS code to its own module (authored by SimonSapin). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 30210

rust/hg-core/src/lib.rs

pub mod repo; pub mod repo;
pub mod revlog; pub mod revlog;
pub use revlog::*; pub use revlog::*;
pub mod config; pub mod config;
pub mod logging; pub mod logging;
pub mod operations; pub mod operations;
pub mod revset; pub mod revset;
pub mod utils; pub mod utils;
pub mod vfs;
use crate::utils::hg_path::{HgPathBuf, HgPathError}; use crate::utils::hg_path::{HgPathBuf, HgPathError};
pub use filepatterns::{ pub use filepatterns::{
parse_pattern_syntax, read_pattern_file, IgnorePattern, parse_pattern_syntax, read_pattern_file, IgnorePattern,
PatternFileWarning, PatternSyntax, PatternFileWarning, PatternSyntax,
}; };
use std::collections::HashMap; use std::collections::HashMap;
use std::fmt; use std::fmt;

rust/hg-core/src/logging.rs

use crate::errors::{HgError, HgResultExt, IoErrorContext, IoResultExt}; use crate::errors::{HgError, HgResultExt, IoErrorContext, IoResultExt};
use crate::repo::Vfs; use crate::vfs::Vfs;
use std::io::Write; use std::io::Write;
/// An utility to append to a log file with the given name, and optionally /// An utility to append to a log file with the given name, and optionally
/// rotate it after it reaches a certain maximum size. /// rotate it after it reaches a certain maximum size.
/// ///
/// Rotation works by renaming "example.log" to "example.log.1", after renaming /// Rotation works by renaming "example.log" to "example.log.1", after renaming
/// "example.log.1" to "example.log.2" etc up to the given maximum number of /// "example.log.1" to "example.log.2" etc up to the given maximum number of
/// files. /// files.

rust/hg-core/src/repo.rs

use crate::config::{Config, ConfigError, ConfigParseError}; use crate::config::{Config, ConfigError, ConfigParseError};
use crate::errors::{HgError, IoErrorContext, IoResultExt}; use crate::errors::HgError;
use crate::exit_codes; use crate::exit_codes;
use crate::requirements; use crate::requirements;
use crate::utils::files::get_path_from_bytes; use crate::utils::files::get_path_from_bytes;
use crate::utils::SliceExt; use crate::utils::SliceExt;
use memmap::{Mmap, MmapOptions}; use crate::vfs::{is_dir, is_file, Vfs};
use std::collections::HashSet; use std::collections::HashSet;
use std::io::ErrorKind;
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>,
fn from(error: ConfigError) -> Self { fn from(error: ConfigError) -> Self {
match error { match error {
ConfigError::Parse(error) => error.into(), ConfigError::Parse(error) => error.into(),
ConfigError::Other(error) => error.into(), ConfigError::Other(error) => error.into(),
} }
} }
} }
/// Filesystem access abstraction for the contents of a given "base" diretory
#[derive(Clone, Copy)]
pub struct Vfs<'a> {
pub(crate) base: &'a Path,
}
impl Repo { impl Repo {
/// tries to find nearest repository root in current working directory or /// tries to find nearest repository root in current working directory or
/// its ancestors /// its ancestors
pub fn find_repo_root() -> Result<PathBuf, RepoError> { pub fn find_repo_root() -> Result<PathBuf, RepoError> {
let current_directory = crate::utils::current_dir()?; let current_directory = crate::utils::current_dir()?;
// ancestors() is inclusive: it first yields `current_directory` // ancestors() is inclusive: it first yields `current_directory`
// as-is. // as-is.
for ancestor in current_directory.ancestors() { for ancestor in current_directory.ancestors() {
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()
}; };
Ok(parents) Ok(parents)
} }
} }
impl Vfs<'_> {
pub fn join(&self, relative_path: impl AsRef<Path>) -> PathBuf {
self.base.join(relative_path)
}
pub fn read(
&self,
relative_path: impl AsRef<Path>,
) -> Result<Vec<u8>, HgError> {
let path = self.join(relative_path);
std::fs::read(&path).when_reading_file(&path)
}
pub fn mmap_open(
&self,
relative_path: impl AsRef<Path>,
) -> Result<Mmap, HgError> {
let path = self.base.join(relative_path);
let file = std::fs::File::open(&path).when_reading_file(&path)?;
// TODO: what are the safety requirements here?
let mmap = unsafe { MmapOptions::new().map(&file) }
.when_reading_file(&path)?;
Ok(mmap)
}
pub fn rename(
&self,
relative_from: impl AsRef<Path>,
relative_to: impl AsRef<Path>,
) -> Result<(), HgError> {
let from = self.join(relative_from);
let to = self.join(relative_to);
std::fs::rename(&from, &to)
.with_context(|| IoErrorContext::RenamingFile { from, to })
}
}
fn fs_metadata(
path: impl AsRef<Path>,
) -> Result<Option<std::fs::Metadata>, HgError> {
let path = path.as_ref();
match std::fs::metadata(path) {
Ok(meta) => Ok(Some(meta)),
Err(error) => match error.kind() {
// TODO: when we require a Rust version where `NotADirectory` is
// stable, invert this logic and return None for it and `NotFound`
// and propagate any other error.
ErrorKind::PermissionDenied => Err(error).with_context(|| {
IoErrorContext::ReadingMetadata(path.to_owned())
}),
_ => Ok(None),
},
}
}
fn is_dir(path: impl AsRef<Path>) -> Result<bool, HgError> {
Ok(fs_metadata(path)?.map_or(false, |meta| meta.is_dir()))
}
fn is_file(path: impl AsRef<Path>) -> Result<bool, HgError> {
Ok(fs_metadata(path)?.map_or(false, |meta| meta.is_file()))
}

rust/hg-core/src/requirements.rs

use crate::errors::{HgError, HgResultExt}; use crate::errors::{HgError, HgResultExt};
use crate::repo::{Repo, Vfs}; use crate::repo::Repo;
use crate::utils::join_display; use crate::utils::join_display;
use crate::vfs::Vfs;
use std::collections::HashSet; use std::collections::HashSet;
fn parse(bytes: &[u8]) -> Result<HashSet<String>, HgError> { fn parse(bytes: &[u8]) -> Result<HashSet<String>, HgError> {
// The Python code reading this file uses `str.splitlines` // The Python code reading this file uses `str.splitlines`
// which looks for a number of line separators (even including a couple of // which looks for a number of line separators (even including a couple of
// non-ASCII ones), but Python code writing it always uses `\n`. // non-ASCII ones), but Python code writing it always uses `\n`.
let lines = bytes.split(|&byte| byte == b'\n'); let lines = bytes.split(|&byte| byte == b'\n');

rust/hg-core/src/vfs.rs

  • This file was added.
use crate::errors::{HgError, IoErrorContext, IoResultExt};
use memmap::{Mmap, MmapOptions};
use std::io::ErrorKind;
use std::path::{Path, PathBuf};
/// Filesystem access abstraction for the contents of a given "base" diretory
#[derive(Clone, Copy)]
pub struct Vfs<'a> {
pub(crate) base: &'a Path,
}
impl Vfs<'_> {
pub fn join(&self, relative_path: impl AsRef<Path>) -> PathBuf {
self.base.join(relative_path)
}
pub fn read(
&self,
relative_path: impl AsRef<Path>,
) -> Result<Vec<u8>, HgError> {
let path = self.join(relative_path);
std::fs::read(&path).when_reading_file(&path)
}
pub fn mmap_open(
&self,
relative_path: impl AsRef<Path>,
) -> Result<Mmap, HgError> {
let path = self.base.join(relative_path);
let file = std::fs::File::open(&path).when_reading_file(&path)?;
// TODO: what are the safety requirements here?
let mmap = unsafe { MmapOptions::new().map(&file) }
.when_reading_file(&path)?;
Ok(mmap)
}
pub fn rename(
&self,
relative_from: impl AsRef<Path>,
relative_to: impl AsRef<Path>,
) -> Result<(), HgError> {
let from = self.join(relative_from);
let to = self.join(relative_to);
std::fs::rename(&from, &to)
.with_context(|| IoErrorContext::RenamingFile { from, to })
}
}
fn fs_metadata(
path: impl AsRef<Path>,
) -> Result<Option<std::fs::Metadata>, HgError> {
let path = path.as_ref();
match std::fs::metadata(path) {
Ok(meta) => Ok(Some(meta)),
Err(error) => match error.kind() {
// TODO: when we require a Rust version where `NotADirectory` is
// stable, invert this logic and return None for it and `NotFound`
// and propagate any other error.
ErrorKind::PermissionDenied => Err(error).with_context(|| {
IoErrorContext::ReadingMetadata(path.to_owned())
}),
_ => Ok(None),
},
}
}
pub(crate) fn is_dir(path: impl AsRef<Path>) -> Result<bool, HgError> {
Ok(fs_metadata(path)?.map_or(false, |meta| meta.is_dir()))
}
pub(crate) fn is_file(path: impl AsRef<Path>) -> Result<bool, HgError> {
Ok(fs_metadata(path)?.map_or(false, |meta| meta.is_file()))
}