( )⚙ D9490 rust: use NodePrefix::from_hex instead of hex::decode directly

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
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 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 24017

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