( )⚙ D11408 rust: Add a Filelog struct that wraps Revlog

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11408

rust: Add a Filelog struct that wraps Revlog
ClosedPublic

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

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHG4d2a5ca060e3: rust: Add a Filelog struct that wraps Revlog
Summary

Some filelog-specific logic is moved from code rhg cat into this struct
where it can better be reused.

Additionally, a missing end delimiter for metadata causes an error
to be returned instead of being silently ignored.

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:13 PM
Alphare accepted this revision.Sep 13 2021, 4:26 PM
Alphare added a subscriber: Alphare.
Alphare added inline comments.
rust/hg-core/src/revlog/filelog.rs
40

The more I look at get_rev the more it feels confusing to me. I'm saying this for all revlogs: having a get_rev(rev) feels weird, maybe it should be get_entry(rev) or something. This would be for another patch, of course, but I thought I'd discuss it

This revision is now accepted and ready to land.Sep 13 2021, 4:26 PM
SimonSapin added inline comments.Sep 13 2021, 4:36 PM
rust/hg-core/src/revlog/filelog.rs
40

How about get_by_rev and get_by_node? But yes, for another patch

Alphare added inline comments.Sep 14 2021, 3:47 AM
rust/hg-core/src/revlog/filelog.rs
40

Sounds good to me.

SimonSapin added a commit: rHG4d2a5ca060e3: rust: Add a Filelog struct that wraps Revlog.Sep 14 2021, 4:19 AM
Closed by commit rHG4d2a5ca060e3: rust: Add a Filelog struct that wraps Revlog (authored by SimonSapin). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 30236

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::path::PathBuf;
use crate::repo::Repo; use crate::repo::Repo;
use crate::revlog::path_encode::path_encode;
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::utils::files::get_path_from_bytes;
use crate::utils::hg_path::{HgPath, HgPathBuf}; use crate::utils::hg_path::HgPathBuf;
pub struct CatOutput { pub struct CatOutput {
/// Whether any file in the manifest matched the paths given as CLI /// Whether any file in the manifest matched the paths given as CLI
/// arguments /// arguments
pub found_any: bool, pub found_any: bool,
/// The contents of matching files, in manifest order /// The contents of matching files, in manifest order
pub concatenated: Vec<u8>, pub concatenated: Vec<u8>,
/// Which of the CLI arguments did not match any manifest file /// Which of the CLI arguments did not match any manifest file
pub missing: Vec<HgPathBuf>, pub missing: Vec<HgPathBuf>,
/// The node ID that the given revset was resolved to /// The node ID that the given revset was resolved to
pub node: Node, pub node: Node,
} }
const METADATA_DELIMITER: [u8; 2] = [b'\x01', b'\n'];
/// Output the given revision of files /// Output the given revision of files
/// ///
/// * `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<'a>( pub fn cat<'a>(
repo: &Repo, repo: &Repo,
revset: &str, revset: &str,
let mut matched = vec![false; files.len()]; let mut matched = vec![false; files.len()];
let mut found_any = false; let mut found_any = false;
for (manifest_file, node_bytes) in manifest.files_with_nodes() { for (manifest_file, node_bytes) in manifest.files_with_nodes() {
for (cat_file, is_matched) in files.iter().zip(&mut matched) { for (cat_file, is_matched) in files.iter().zip(&mut matched) {
if cat_file.as_bytes() == manifest_file.as_bytes() { if cat_file.as_bytes() == manifest_file.as_bytes() {
*is_matched = true; *is_matched = true;
found_any = true; found_any = true;
let index_path = store_path(manifest_file, b".i"); let file_log = repo.filelog(manifest_file)?;
let data_path = store_path(manifest_file, b".d");
let file_log =
Revlog::open(repo, &index_path, Some(&data_path))?;
let file_node = Node::from_hex_for_repo(node_bytes)?; let file_node = Node::from_hex_for_repo(node_bytes)?;
let file_rev = file_log.get_node_rev(file_node.into())?; let entry = file_log.get_node(file_node)?;
let data = file_log.get_rev_data(file_rev)?; bytes.extend(entry.data()?)
if data.starts_with(&METADATA_DELIMITER) {
let end_delimiter_position = data
[METADATA_DELIMITER.len()..]
.windows(METADATA_DELIMITER.len())
.position(|bytes| bytes == METADATA_DELIMITER);
if let Some(position) = end_delimiter_position {
let offset = METADATA_DELIMITER.len() * 2;
bytes.extend(data[position + offset..].iter());
}
} else {
bytes.extend(data);
}
} }
} }
} }
let missing: Vec<_> = files let missing: Vec<_> = files
.iter() .iter()
.zip(&matched) .zip(&matched)
.filter(|pair| !*pair.1) .filter(|pair| !*pair.1)
.map(|pair| pair.0.clone()) .map(|pair| pair.0.clone())
.collect(); .collect();
Ok(CatOutput { Ok(CatOutput {
found_any, found_any,
concatenated: bytes, concatenated: bytes,
missing, missing,
node, node,
}) })
} }
fn store_path(hg_path: &HgPath, suffix: &[u8]) -> PathBuf {
let encoded_bytes =
path_encode(&[b"data/", hg_path.as_bytes(), suffix].concat());
get_path_from_bytes(&encoded_bytes).into()
}

rust/hg-core/src/repo.rs

use crate::changelog::Changelog; use crate::changelog::Changelog;
use crate::config::{Config, ConfigError, ConfigParseError}; use crate::config::{Config, ConfigError, ConfigParseError};
use crate::dirstate::DirstateParents; use crate::dirstate::DirstateParents;
use crate::dirstate_tree::dirstate_map::DirstateMap; use crate::dirstate_tree::dirstate_map::DirstateMap;
use crate::dirstate_tree::owning::OwningDirstateMap; use crate::dirstate_tree::owning::OwningDirstateMap;
use crate::errors::HgError; use crate::errors::HgError;
use crate::errors::HgResultExt; use crate::errors::HgResultExt;
use crate::manifest::{Manifest, Manifestlog}; use crate::manifest::{Manifest, Manifestlog};
use crate::requirements; use crate::requirements;
use crate::revlog::filelog::Filelog;
use crate::revlog::revlog::RevlogError; use crate::revlog::revlog::RevlogError;
use crate::utils::files::get_path_from_bytes; use crate::utils::files::get_path_from_bytes;
use crate::utils::hg_path::HgPath;
use crate::utils::SliceExt; use crate::utils::SliceExt;
use crate::vfs::{is_dir, is_file, Vfs}; use crate::vfs::{is_dir, is_file, Vfs};
use crate::{exit_codes, Node}; use crate::{exit_codes, Node};
use crate::{DirstateError, Revision}; use crate::{DirstateError, Revision};
use std::cell::{Cell, Ref, RefCell, RefMut}; use std::cell::{Cell, Ref, RefCell, RefMut};
use std::collections::HashSet; use std::collections::HashSet;
use std::path::{Path, PathBuf}; use std::path::{Path, PathBuf};
) -> 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> {
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`.
struct LazyCell<T, E> { struct LazyCell<T, E> {
value: RefCell<Option<T>>, value: RefCell<Option<T>>,

rust/hg-core/src/revlog.rs

// Copyright 2018-2020 Georges Racinet <georges.racinet@octobus.net> // Copyright 2018-2020 Georges Racinet <georges.racinet@octobus.net>
// and Mercurial contributors // and Mercurial contributors
// //
// 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.
//! Mercurial concepts for handling revision history //! Mercurial concepts for handling revision history
pub mod node; pub mod node;
pub mod nodemap; pub mod nodemap;
mod nodemap_docket; mod nodemap_docket;
pub mod path_encode; pub mod path_encode;
pub use node::{FromHexError, Node, NodePrefix}; pub use node::{FromHexError, Node, NodePrefix};
pub mod changelog; pub mod changelog;
pub mod filelog;
pub mod index; pub mod index;
pub mod manifest; pub mod manifest;
pub mod patch; pub mod patch;
pub mod revlog; pub mod revlog;
/// Mercurial revision numbers /// Mercurial revision numbers
/// ///
/// As noted in revlog.c, revision numbers are actually encoded in /// As noted in revlog.c, revision numbers are actually encoded in

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

  • This file was added.
use crate::errors::HgError;
use crate::repo::Repo;
use crate::revlog::path_encode::path_encode;
use crate::revlog::revlog::{Revlog, RevlogError};
use crate::revlog::NodePrefix;
use crate::revlog::Revision;
use crate::utils::files::get_path_from_bytes;
use crate::utils::hg_path::HgPath;
use crate::utils::SliceExt;
use std::borrow::Cow;
use std::path::PathBuf;
/// A specialized `Revlog` to work with file data logs.
pub struct Filelog {
/// The generic `revlog` format.
revlog: Revlog,
}
impl Filelog {
pub fn open(repo: &Repo, file_path: &HgPath) -> Result<Self, RevlogError> {
let index_path = store_path(file_path, b".i");
let data_path = store_path(file_path, b".d");
let revlog = Revlog::open(repo, index_path, Some(&data_path))?;
Ok(Self { revlog })
}
/// The given node ID is that of the file as found in a manifest, not of a
/// changeset.
pub fn get_node(
&self,
file_node: impl Into<NodePrefix>,
) -> Result<FilelogEntry, RevlogError> {
let file_rev = self.revlog.get_node_rev(file_node.into())?;
self.get_rev(file_rev)
}
/// The given revision is that of the file as found in a manifest, not of a
/// changeset.
pub fn get_rev(
&self,
AlphareUnsubmitted
Not Done

The more I look at get_rev the more it feels confusing to me. I'm saying this for all revlogs: having a get_rev(rev) feels weird, maybe it should be get_entry(rev) or something. This would be for another patch, of course, but I thought I'd discuss it

Alphare: The more I look at `get_rev` the more it feels confusing to me. I'm saying this for all revlogs…
SimonSapinAuthorUnsubmitted
Done

How about get_by_rev and get_by_node? But yes, for another patch

SimonSapin: How about `get_by_rev` and `get_by_node`? But yes, for another patch
AlphareUnsubmitted
Not Done

Sounds good to me.

Alphare: Sounds good to me.
file_rev: Revision,
) -> Result<FilelogEntry, RevlogError> {
let data = self.revlog.get_rev_data(file_rev)?;
Ok(FilelogEntry(data.into()))
}
}
fn store_path(hg_path: &HgPath, suffix: &[u8]) -> PathBuf {
let encoded_bytes =
path_encode(&[b"data/", hg_path.as_bytes(), suffix].concat());
get_path_from_bytes(&encoded_bytes).into()
}
pub struct FilelogEntry<'filelog>(Cow<'filelog, [u8]>);
impl<'filelog> FilelogEntry<'filelog> {
/// Split into metadata and data
pub fn split(&self) -> Result<(Option<&[u8]>, &[u8]), HgError> {
const DELIMITER: &[u8; 2] = &[b'\x01', b'\n'];
if let Some(rest) = self.0.drop_prefix(DELIMITER) {
if let Some((metadata, data)) = rest.split_2_by_slice(DELIMITER) {
Ok((Some(metadata), data))
} else {
Err(HgError::corrupted(
"Missing metadata end delimiter in filelog entry",
))
}
} else {
Ok((None, &self.0))
}
}
/// Returns the file contents at this revision, stripped of any metadata
pub fn data(&self) -> Result<&[u8], HgError> {
let (_metadata, data) = self.split()?;
Ok(data)
}
}

rust/hg-core/src/utils.rs

pub trait SliceExt { pub trait SliceExt {
fn trim_end(&self) -> &Self; fn trim_end(&self) -> &Self;
fn trim_start(&self) -> &Self; fn trim_start(&self) -> &Self;
fn trim_end_matches(&self, f: impl FnMut(u8) -> bool) -> &Self; fn trim_end_matches(&self, f: impl FnMut(u8) -> bool) -> &Self;
fn trim_start_matches(&self, f: impl FnMut(u8) -> bool) -> &Self; fn trim_start_matches(&self, f: impl FnMut(u8) -> bool) -> &Self;
fn trim(&self) -> &Self; fn trim(&self) -> &Self;
fn drop_prefix(&self, needle: &Self) -> Option<&Self>; fn drop_prefix(&self, needle: &Self) -> Option<&Self>;
fn split_2(&self, separator: u8) -> Option<(&[u8], &[u8])>; fn split_2(&self, separator: u8) -> Option<(&[u8], &[u8])>;
fn split_2_by_slice(&self, separator: &[u8]) -> Option<(&[u8], &[u8])>;
} }
impl SliceExt for [u8] { impl SliceExt for [u8] {
fn trim_end(&self) -> &[u8] { fn trim_end(&self) -> &[u8] {
self.trim_end_matches(|byte| byte.is_ascii_whitespace()) self.trim_end_matches(|byte| byte.is_ascii_whitespace())
} }
fn trim_start(&self) -> &[u8] { fn trim_start(&self) -> &[u8] {
} }
fn split_2(&self, separator: u8) -> Option<(&[u8], &[u8])> { fn split_2(&self, separator: u8) -> Option<(&[u8], &[u8])> {
let mut iter = self.splitn(2, |&byte| byte == separator); let mut iter = self.splitn(2, |&byte| byte == separator);
let a = iter.next()?; let a = iter.next()?;
let b = iter.next()?; let b = iter.next()?;
Some((a, b)) Some((a, b))
} }
fn split_2_by_slice(&self, separator: &[u8]) -> Option<(&[u8], &[u8])> {
if let Some(pos) = find_slice_in_slice(self, separator) {
Some((&self[..pos], &self[pos + separator.len()..]))
} else {
None
}
}
} }
pub trait Escaped { pub trait Escaped {
/// Return bytes escaped for display to the user /// Return bytes escaped for display to the user
fn escaped_bytes(&self) -> Vec<u8>; fn escaped_bytes(&self) -> Vec<u8>;
} }
impl Escaped for u8 { impl Escaped for u8 {