This is an archive of the discontinued Mercurial Phabricator instance.

Differential D9490

rust: use NodePrefix::from_hex instead of hex::decode directly
ClosedPublic

Authored by SimonSapin on Dec 2 2020, 9:22 AM.

Details

Reviewers
pulkit
Group Reviewers
hg-reviewers
Commits
rHG88e741bf2d93: rust: use NodePrefix::from_hex instead of hex::decode directly
Summary

This adds support for prefixes with an odd number of hex digits.

Diff Detail

Repository
rHG Mercurial
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

Event Timeline

SimonSapin created this revision.Dec 2 2020, 9:22 AM
pulkit accepted this revision.Dec 4 2020, 1:27 PM
This revision is now accepted and ready to land.Dec 4 2020, 1:27 PM
baymax updated this revision to Diff 24025.Dec 4 2020, 5:39 PM

Revision Contents
Changeset List

Diff 24025

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::{Path, PathBuf};
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::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::NodePrefix;
use crate::revlog::Revision; use crate::revlog::Revision;
use crate::utils::files::get_path_from_bytes; use crate::utils::files::get_path_from_bytes;
use crate::utils::hg_path::{HgPath, HgPathBuf}; use crate::utils::hg_path::{HgPath, HgPathBuf};
const METADATA_DELIMITER: [u8; 2] = [b'\x01', b'\n']; const METADATA_DELIMITER: [u8; 2] = [b'\x01', b'\n'];
/// Kind of error encountered by `CatRev` /// Kind of error encountered by `CatRev`
#[derive(Debug)] #[derive(Debug)]
manifest_entry, manifest_entry,
}) })
} }
pub fn run(&mut self) -> Result<Vec<u8>, CatRevError> { pub fn run(&mut self) -> Result<Vec<u8>, CatRevError> {
let changelog_entry = match self.rev.parse::<Revision>() { let changelog_entry = match self.rev.parse::<Revision>() {
Ok(rev) => self.changelog.get_rev(rev)?, Ok(rev) => self.changelog.get_rev(rev)?,
_ => { _ => {
let changelog_node = hex::decode(&self.rev) let changelog_node = NodePrefix::from_hex(&self.rev)
.map_err(|_| CatRevErrorKind::InvalidRevision)?; .map_err(|_| CatRevErrorKind::InvalidRevision)?;
self.changelog.get_node(&changelog_node)? self.changelog.get_node(changelog_node.borrow())?
} }
}; };
let manifest_node = hex::decode(&changelog_entry.manifest_node()?) let manifest_node = Node::from_hex(&changelog_entry.manifest_node()?)
.map_err(|_| CatRevErrorKind::CorruptedRevlog)?; .map_err(|_| CatRevErrorKind::CorruptedRevlog)?;
self.manifest_entry = Some(self.manifest.get_node(&manifest_node)?); self.manifest_entry =
Some(self.manifest.get_node((&manifest_node).into())?);
if let Some(ref manifest_entry) = self.manifest_entry { if let Some(ref manifest_entry) = self.manifest_entry {
let mut bytes = vec![]; let mut bytes = vec![];
for (manifest_file, node_bytes) in for (manifest_file, node_bytes) in
manifest_entry.files_with_nodes() manifest_entry.files_with_nodes()
{ {
for cat_file in self.files.iter() { for cat_file in self.files.iter() {
if cat_file.as_bytes() == manifest_file.as_bytes() { if cat_file.as_bytes() == manifest_file.as_bytes() {
let index_path = let index_path =
store_path(self.root, manifest_file, b".i"); store_path(self.root, manifest_file, b".i");
let data_path = let data_path =
store_path(self.root, manifest_file, b".d"); store_path(self.root, manifest_file, b".d");
let file_log = let file_log =
Revlog::open(&index_path, Some(&data_path))?; Revlog::open(&index_path, Some(&data_path))?;
let file_node = hex::decode(&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)?; 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;

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 super::find_root; use super::find_root;
use crate::revlog::revlog::{Revlog, RevlogError}; use crate::revlog::revlog::{Revlog, RevlogError};
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,
Manifest, Manifest,
} }
DebugDataKind::Changelog => root.join(".hg/store/00changelog.i"), DebugDataKind::Changelog => root.join(".hg/store/00changelog.i"),
DebugDataKind::Manifest => root.join(".hg/store/00manifest.i"), DebugDataKind::Manifest => root.join(".hg/store/00manifest.i"),
}; };
let revlog = Revlog::open(&index_file, None)?; let revlog = Revlog::open(&index_file, None)?;
let data = match self.rev.parse::<Revision>() { let data = match self.rev.parse::<Revision>() {
Ok(rev) => revlog.get_rev_data(rev)?, Ok(rev) => revlog.get_rev_data(rev)?,
_ => { _ => {
let node = hex::decode(&self.rev) let node = NodePrefix::from_hex(&self.rev)
.map_err(|_| DebugDataErrorKind::InvalidRevision)?; .map_err(|_| DebugDataErrorKind::InvalidRevision)?;
let rev = revlog.get_node_rev(&node)?; 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::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::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::fs;
use std::path::PathBuf; use std::path::PathBuf;
} }
pub fn run( pub fn run(
&mut self, &mut self,
) -> Result<impl Iterator<Item = &HgPath>, ListRevTrackedFilesError> { ) -> Result<impl Iterator<Item = &HgPath>, ListRevTrackedFilesError> {
let changelog_entry = match self.rev.parse::<Revision>() { let changelog_entry = match self.rev.parse::<Revision>() {
Ok(rev) => self.changelog.get_rev(rev)?, Ok(rev) => self.changelog.get_rev(rev)?,
_ => { _ => {
let changelog_node = hex::decode(&self.rev) let changelog_node = NodePrefix::from_hex(&self.rev)
.or(Err(ListRevTrackedFilesErrorKind::InvalidRevision))?; .or(Err(ListRevTrackedFilesErrorKind::InvalidRevision))?;
self.changelog.get_node(&changelog_node)? self.changelog.get_node(changelog_node.borrow())?
} }
}; };
let manifest_node = hex::decode(&changelog_entry.manifest_node()?) let manifest_node = Node::from_hex(&changelog_entry.manifest_node()?)
.or(Err(ListRevTrackedFilesErrorKind::CorruptedRevlog))?; .or(Err(ListRevTrackedFilesErrorKind::CorruptedRevlog))?;
self.manifest_entry = Some(self.manifest.get_node(&manifest_node)?); self.manifest_entry =
Some(self.manifest.get_node((&manifest_node).into())?);
if let Some(ref manifest_entry) = self.manifest_entry { if let Some(ref manifest_entry) = self.manifest_entry {
Ok(manifest_entry.files()) Ok(manifest_entry.files())
} else { } else {
panic!( panic!(
"manifest entry should have been stored in self.manifest_node to ensure its lifetime since references are returned from it" "manifest entry should have been stored in self.manifest_node to ensure its lifetime since references are returned from it"
) )
} }
} }
} }

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

use crate::revlog::revlog::{Revlog, RevlogError}; use crate::revlog::revlog::{Revlog, RevlogError};
use crate::revlog::NodePrefixRef;
use crate::revlog::Revision; use crate::revlog::Revision;
use std::path::PathBuf; use std::path::PathBuf;
/// 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: &PathBuf) -> Result<Self, RevlogError> { pub fn open(root: &PathBuf) -> Result<Self, RevlogError> {
let index_file = root.join(".hg/store/00changelog.i"); let index_file = root.join(".hg/store/00changelog.i");
let revlog = Revlog::open(&index_file, 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: &[u8], node: NodePrefixRef,
) -> Result<ChangelogEntry, RevlogError> { ) -> Result<ChangelogEntry, 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)
} }
/// Return the `ChangelogEntry` of a given node revision. /// Return the `ChangelogEntry` of a given node revision.
pub fn get_rev( pub fn get_rev(
&self, &self,

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

use std::convert::TryInto;
use std::ops::Deref; use std::ops::Deref;
use byteorder::{BigEndian, ByteOrder}; use byteorder::{BigEndian, ByteOrder};
use crate::revlog::node::Node;
use crate::revlog::revlog::RevlogError; 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>,
pub fn p2(&self) -> Revision { pub fn p2(&self) -> Revision {
BigEndian::read_i32(&self.bytes[28..]) BigEndian::read_i32(&self.bytes[28..])
} }
/// Return the hash of revision's full text. /// Return the hash of revision's full text.
/// ///
/// Currently, SHA-1 is used and only the first 20 bytes of this field /// Currently, SHA-1 is used and only the first 20 bytes of this field
/// are used. /// are used.
pub fn hash(&self) -> &[u8] { pub fn hash(&self) -> &Node {
&self.bytes[32..52] (&self.bytes[32..52]).try_into().unwrap()
} }
} }
/// Value of the inline flag. /// Value of the inline flag.
pub fn is_inline(index_bytes: &[u8]) -> bool { pub fn is_inline(index_bytes: &[u8]) -> bool {
match &index_bytes[0..=1] { match &index_bytes[0..=1] {
[0, 0] | [0, 2] => false, [0, 0] | [0, 2] => false,
_ => true, _ => true,

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

use crate::revlog::revlog::{Revlog, RevlogError}; use crate::revlog::revlog::{Revlog, RevlogError};
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::PathBuf; use std::path::PathBuf;
/// 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: &PathBuf) -> Result<Self, RevlogError> { pub fn open(root: &PathBuf) -> Result<Self, RevlogError> {
let index_file = root.join(".hg/store/00manifest.i"); let index_file = root.join(".hg/store/00manifest.i");
let revlog = Revlog::open(&index_file, 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(&self, node: &[u8]) -> Result<ManifestEntry, RevlogError> { pub fn get_node(
&self,
node: NodePrefixRef,
) -> Result<ManifestEntry, 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)
} }
/// Return the `ManifestEntry` of a given node revision. /// Return the `ManifestEntry` of a given node revision.
pub fn get_rev( pub fn get_rev(
&self, &self,
rev: Revision, rev: Revision,

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

// Copyright 2019-2020 Georges Racinet <georges.racinet@octobus.net> // Copyright 2019-2020 Georges Racinet <georges.racinet@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.
//! Definitions and utilities for Revision nodes //! Definitions and utilities for Revision nodes
//! //!
//! In Mercurial code base, it is customary to call "a node" the binary SHA //! In Mercurial code base, it is customary to call "a node" the binary SHA
//! of a revision. //! of a revision.
use hex::{self, FromHex, FromHexError}; use hex::{self, FromHex, FromHexError};
use std::convert::{TryFrom, TryInto};
/// The length in bytes of a `Node` /// The length in bytes of a `Node`
/// ///
/// This constant is meant to ease refactors of this module, and /// This constant is meant to ease refactors of this module, and
/// are private so that calling code does not expect all nodes have /// are private so that calling code does not expect all nodes have
/// the same size, should we support several formats concurrently in /// the same size, should we support several formats concurrently in
/// the future. /// the future.
pub const NODE_BYTES_LENGTH: usize = 20; pub const NODE_BYTES_LENGTH: usize = 20;
}; };
impl From<NodeData> for Node { impl From<NodeData> for Node {
fn from(data: NodeData) -> Node { fn from(data: NodeData) -> Node {
Node { data } Node { data }
} }
} }
/// Return an error if the slice has an unexpected length
impl<'a> TryFrom<&'a [u8]> for &'a Node {
type Error = std::array::TryFromSliceError;
#[inline]
fn try_from(bytes: &'a [u8]) -> Result<&'a Node, Self::Error> {
let data = bytes.try_into()?;
// Safety: `#[repr(transparent)]` makes it ok to "wrap" the target
// of a reference to the type of the single field.
Ok(unsafe { std::mem::transmute::<&NodeData, &Node>(data) })
}
}
#[derive(Debug, PartialEq)] #[derive(Debug, PartialEq)]
pub enum NodeError { pub enum NodeError {
ExactLengthRequired(usize, String), ExactLengthRequired(usize, String),
PrefixTooLong(String), PrefixTooLong(String),
HexError(FromHexError, String), HexError(FromHexError, String),
} }
/// Low level utility function, also for prefixes /// Low level utility function, also for prefixes
} }
/// Convert from hexadecimal string representation /// Convert from hexadecimal string representation
/// ///
/// Exact length is required. /// Exact length is required.
/// ///
/// To be used in FFI and I/O only, in order to facilitate future /// To be used in FFI and I/O only, in order to facilitate future
/// changes of hash format. /// changes of hash format.
pub fn from_hex(hex: &str) -> Result<Node, NodeError> { pub fn from_hex(hex: impl AsRef<[u8]>) -> Result<Node, NodeError> {
Ok(NodeData::from_hex(hex) Ok(NodeData::from_hex(hex.as_ref())
.map_err(|e| NodeError::from((e, hex)))? .map_err(|e| NodeError::from((e, hex)))?
.into()) .into())
} }
/// Convert to hexadecimal string representation /// Convert to hexadecimal string representation
/// ///
/// To be used in FFI and I/O only, in order to facilitate future /// To be used in FFI and I/O only, in order to facilitate future
/// changes of hash format. /// changes of hash format.
pub fn encode_hex(&self) -> String { pub fn encode_hex(&self) -> String {
hex::encode(self.data) hex::encode(self.data)
} }
/// Provide access to binary data /// Provide access to binary data
/// ///
/// This is needed by FFI layers, for instance to return expected /// This is needed by FFI layers, for instance to return expected
/// binary values to Python. /// binary values to Python.
pub fn as_bytes(&self) -> &[u8] { pub fn as_bytes(&self) -> &[u8] {
&self.data &self.data
} }
} }
impl<T: AsRef<str>> From<(FromHexError, T)> for NodeError { impl<T: AsRef<[u8]>> From<(FromHexError, T)> for NodeError {
fn from(err_offender: (FromHexError, T)) -> Self { fn from(err_offender: (FromHexError, T)) -> Self {
let (err, offender) = err_offender; let (err, offender) = err_offender;
let offender = String::from_utf8_lossy(offender.as_ref()).into_owned();
match err { match err {
FromHexError::InvalidStringLength => { FromHexError::InvalidStringLength => {
NodeError::ExactLengthRequired( NodeError::ExactLengthRequired(NODE_NYBBLES_LENGTH, offender)
NODE_NYBBLES_LENGTH,
offender.as_ref().to_owned(),
)
} }
_ => NodeError::HexError(err, offender.as_ref().to_owned()), _ => NodeError::HexError(err, offender),
} }
} }
} }
/// The beginning of a binary revision SHA. /// The beginning of a binary revision SHA.
/// ///
/// Since it can potentially come from an hexadecimal representation with /// Since it can potentially come from an hexadecimal representation with
/// odd length, it needs to carry around whether the last 4 bits are relevant /// odd length, it needs to carry around whether the last 4 bits are relevant
if len > NODE_NYBBLES_LENGTH { if len > NODE_NYBBLES_LENGTH {
return Err(NodeError::PrefixTooLong( return Err(NodeError::PrefixTooLong(
String::from_utf8_lossy(hex).to_owned().to_string(), String::from_utf8_lossy(hex).to_owned().to_string(),
)); ));
} }
let is_odd = len % 2 == 1; let is_odd = len % 2 == 1;
let even_part = if is_odd { &hex[..len - 1] } else { hex }; let even_part = if is_odd { &hex[..len - 1] } else { hex };
let mut buf: Vec<u8> = Vec::from_hex(&even_part) let mut buf: Vec<u8> =
.map_err(|e| (e, String::from_utf8_lossy(hex)))?; Vec::from_hex(&even_part).map_err(|e| (e, hex))?;
if is_odd { if is_odd {
let latest_char = char::from(hex[len - 1]); let latest_char = char::from(hex[len - 1]);
let latest_nybble = latest_char.to_digit(16).ok_or_else(|| { let latest_nybble = latest_char.to_digit(16).ok_or_else(|| {
( (
FromHexError::InvalidHexCharacter { FromHexError::InvalidHexCharacter {
c: latest_char, c: latest_char,
index: len - 1, index: len - 1,
}, },
String::from_utf8_lossy(hex), hex,
) )
})? as u8; })? as u8;
buf.push(latest_nybble << 4); buf.push(latest_nybble << 4);
} }
Ok(NodePrefix { buf, is_odd }) Ok(NodePrefix { buf, is_odd })
} }
pub fn borrow(&self) -> NodePrefixRef { pub fn borrow(&self) -> NodePrefixRef {
fn from(node: &'a Node) -> Self { fn from(node: &'a Node) -> Self {
NodePrefixRef { NodePrefixRef {
buf: &node.data, buf: &node.data,
is_odd: false, is_odd: false,
} }
} }
} }
impl PartialEq<Node> for NodePrefixRef<'_> {
fn eq(&self, other: &Node) -> bool {
!self.is_odd && self.buf == other.data
}
}
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use super::*;
fn sample_node() -> Node { fn sample_node() -> Node {
let mut data = [0; NODE_BYTES_LENGTH]; let mut data = [0; NODE_BYTES_LENGTH];
data.copy_from_slice(&[ data.copy_from_slice(&[
0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0xfe, 0xdc, 0xba, 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0xfe, 0xdc, 0xba,
0x98, 0x76, 0x54, 0x32, 0x10, 0xde, 0xad, 0xbe, 0xef, 0x98, 0x76, 0x54, 0x32, 0x10, 0xde, 0xad, 0xbe, 0xef,
]); ]);
data.into() data.into()
} }
/// Pad an hexadecimal string to reach `NODE_NYBBLES_LENGTH` /// Pad an hexadecimal string to reach `NODE_NYBBLES_LENGTH`
/// ///check_hash
/// The padding is made with zeros /// The padding is made with zeros
pub fn hex_pad_right(hex: &str) -> String { pub fn hex_pad_right(hex: &str) -> String {
let mut res = hex.to_string(); let mut res = hex.to_string();
while res.len() < NODE_NYBBLES_LENGTH { while res.len() < NODE_NYBBLES_LENGTH {
res.push('0'); res.push('0');
} }
res res
} }

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

use std::borrow::Cow; use std::borrow::Cow;
use std::fs::File; 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 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::{NODE_BYTES_LENGTH, NULL_NODE_ID}; use super::node::{NodePrefixRef, NODE_BYTES_LENGTH, NULL_NODE};
use super::patch; use super::patch;
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
/// Returns `true` if the `Revlog` has zero `entries`. /// Returns `true` if the `Revlog` has zero `entries`.
pub fn is_empty(&self) -> bool { pub fn is_empty(&self) -> bool {
self.index.is_empty() self.index.is_empty()
} }
/// Return the full data associated to a node. /// Return the full data associated to a node.
#[timed] #[timed]
pub fn get_node_rev(&self, node: &[u8]) -> Result<Revision, RevlogError> { pub fn get_node_rev(
&self,
node: NodePrefixRef,
) -> Result<Revision, RevlogError> {
// This is brute force. But it is fast enough for now. // This is brute force. But it is fast enough for now.
// Optimization will come later. // Optimization will come later.
let mut found_by_prefix = None; let mut found_by_prefix = None;
for rev in (0..self.len() as Revision).rev() { for rev in (0..self.len() as Revision).rev() {
let index_entry = let index_entry =
self.index.get_entry(rev).ok_or(RevlogError::Corrupted)?; self.index.get_entry(rev).ok_or(RevlogError::Corrupted)?;
if index_entry.hash() == node { if node == *index_entry.hash() {
return Ok(rev); return Ok(rev);
} }
if index_entry.hash().starts_with(node) { if node.is_prefix_of(index_entry.hash()) {
if found_by_prefix.is_some() { if found_by_prefix.is_some() {
return Err(RevlogError::AmbiguousPrefix); return Err(RevlogError::AmbiguousPrefix);
} }
found_by_prefix = Some(rev) found_by_prefix = Some(rev)
} }
} }
found_by_prefix.ok_or(RevlogError::InvalidRevision) found_by_prefix.ok_or(RevlogError::InvalidRevision)
} }
entry.data()?.into() entry.data()?.into()
} else { } else {
Revlog::build_data_from_deltas(entry, &delta_chain)? Revlog::build_data_from_deltas(entry, &delta_chain)?
}; };
if self.check_hash( if self.check_hash(
index_entry.p1(), index_entry.p1(),
index_entry.p2(), index_entry.p2(),
index_entry.hash(), index_entry.hash().as_bytes(),
&data, &data,
) { ) {
Ok(data) Ok(data)
} else { } else {
Err(RevlogError::Corrupted) Err(RevlogError::Corrupted)
} }
} }
/// Check the hash of some given data against the recorded hash. /// Check the hash of some given data against the recorded hash.
pub fn check_hash( pub fn check_hash(
&self, &self,
p1: Revision, p1: Revision,
p2: Revision, p2: Revision,
expected: &[u8], expected: &[u8],
data: &[u8], data: &[u8],
) -> bool { ) -> bool {
let e1 = self.index.get_entry(p1); let e1 = self.index.get_entry(p1);
let h1 = match e1 { let h1 = match e1 {
Some(ref entry) => entry.hash(), Some(ref entry) => entry.hash(),
None => &NULL_NODE_ID, None => &NULL_NODE,
}; };
let e2 = self.index.get_entry(p2); let e2 = self.index.get_entry(p2);
let h2 = match e2 { let h2 = match e2 {
Some(ref entry) => entry.hash(), Some(ref entry) => entry.hash(),
None => &NULL_NODE_ID, None => &NULL_NODE,
}; };
hash(data, &h1, &h2).as_slice() == expected hash(data, h1.as_bytes(), h2.as_bytes()).as_slice() == expected
} }
/// Build the full data of a revision out its snapshot /// Build the full data of a revision out its snapshot
/// and its deltas. /// and its deltas.
#[timed] #[timed]
fn build_data_from_deltas( fn build_data_from_deltas(
snapshot: RevlogEntry, snapshot: RevlogEntry,
deltas: &[RevlogEntry], deltas: &[RevlogEntry],

tests/test-rhg.t

6ae9681c6d30389694d8701faf24b583cf3ccafe 6ae9681c6d30389694d8701faf24b583cf3ccafe
$ rhg files -r cf8b83 $ rhg files -r cf8b83
file-1 file-1
file-2 file-2
file-3 file-3
$ rhg cat -r cf8b83 file-2 $ rhg cat -r cf8b83 file-2
2 2
$ rhg cat -r c file-2 $ rhg cat -r c file-2
abort: invalid revision identifier c abort: ambiguous revision identifier c
[255] [255]
$ rhg cat -r d file-2
2
Cat files Cat files
$ cd $TESTTMP $ cd $TESTTMP
$ rm -rf repository $ rm -rf repository
$ hg init repository $ hg init repository
$ cd repository $ cd repository
$ echo "original content" > original $ echo "original content" > original
$ hg add original $ hg add original