This is an archive of the discontinued Mercurial Phabricator instance.

Differential D9861

rust: Simplify error type for reading hex node IDs
ClosedPublic

Authored by SimonSapin on Jan 25 2021, 4:12 PM.

Details

Reviewers
Alphare
pulkit
Group Reviewers
hg-reviewers
Commits
rHG5893706af3de: rust: Simplify error type for reading hex node IDs
Summary

If a string is not valid hexadecimal it’s not that useful to track the precise reason.

Diff Detail

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

Event Timeline

SimonSapin created this revision.Jan 25 2021, 4:12 PM
SimonSapin updated this revision to Diff 25349.Jan 28 2021, 2:38 PM
Alphare accepted this revision.Jan 29 2021, 6:34 AM
pulkit accepted this revision.Jan 31 2021, 2:38 PM
This revision is now accepted and ready to land.Jan 31 2021, 2:38 PM
SimonSapin added a commit: rHG5893706af3de: rust: Simplify error type for reading hex node IDs.Jan 31 2021, 3:26 PM
Closed by commit rHG5893706af3de: rust: Simplify error type for reading hex node IDs (authored by SimonSapin). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 25243

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::{Node, NodeError, NodePrefix, NodePrefixRef}; pub use node::{FromHexError, Node, NodePrefix, NodePrefixRef};
pub mod changelog; pub mod changelog;
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
/// ///

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};
use std::convert::{TryFrom, TryInto}; use std::convert::{TryFrom, TryInto};
use std::fmt; use std::fmt;
/// 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
/// should use the conversion methods at the boundaries (FFI, actual /// should use the conversion methods at the boundaries (FFI, actual
/// computation of hashes and I/O) only, and only if required. /// computation of hashes and I/O) only, and only if required.
/// ///
/// All other callers outside of unit tests should just handle `Node` values /// All other callers outside of unit tests should just handle `Node` values
/// and never make any assumption on the actual length, using [`nybbles_len`] /// and never make any assumption on the actual length, using [`nybbles_len`]
/// if they need a loop boundary. /// if they need a loop boundary.
/// ///
/// All methods that create a `Node` either take a type that enforces /// All methods that create a `Node` either take a type that enforces
/// the size or fail immediately at runtime with [`ExactLengthRequired`]. /// the size or return an error at runtime.
/// ///
/// [`nybbles_len`]: #method.nybbles_len /// [`nybbles_len`]: #method.nybbles_len
/// [`ExactLengthRequired`]: struct.NodeError#variant.ExactLengthRequired
#[derive(Clone, Debug, PartialEq)] #[derive(Clone, Debug, PartialEq)]
#[repr(transparent)] #[repr(transparent)]
pub struct Node { pub struct Node {
data: NodeData, data: NodeData,
} }
/// The node value for NULL_REVISION /// The node value for NULL_REVISION
pub const NULL_NODE: Node = Node { pub const NULL_NODE: Node = Node {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
for &byte in &self.data { for &byte in &self.data {
write!(f, "{:02x}", byte)? write!(f, "{:02x}", byte)?
} }
Ok(()) Ok(())
} }
} }
#[derive(Debug, PartialEq)] #[derive(Debug)]
pub enum NodeError { pub struct FromHexError;
ExactLengthRequired(usize, String),
PrefixTooLong(String),
HexError(FromHexError, String),
}
/// Low level utility function, also for prefixes /// Low level utility function, also for prefixes
fn get_nybble(s: &[u8], i: usize) -> u8 { fn get_nybble(s: &[u8], i: usize) -> u8 {
if i % 2 == 0 { if i % 2 == 0 {
s[i / 2] >> 4 s[i / 2] >> 4
} else { } else {
s[i / 2] & 0x0f s[i / 2] & 0x0f
} }
} }
/// 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: impl AsRef<[u8]>) -> Result<Node, NodeError> { pub fn from_hex(hex: impl AsRef<[u8]>) -> Result<Node, FromHexError> {
Ok(NodeData::from_hex(hex.as_ref()) Ok(NodeData::from_hex(hex.as_ref())
.map_err(|e| NodeError::from((e, hex)))? .map_err(|_| FromHexError)?
.into()) .into())
} }
/// 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<[u8]>> From<(FromHexError, T)> for NodeError {
fn from(err_offender: (FromHexError, T)) -> Self {
let (err, offender) = err_offender;
let offender = String::from_utf8_lossy(offender.as_ref()).into_owned();
match err {
FromHexError::InvalidStringLength => {
NodeError::ExactLengthRequired(NODE_NYBBLES_LENGTH, offender)
}
_ => 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
/// or not. /// or not.
#[derive(Debug, PartialEq)] #[derive(Debug, PartialEq)]
pub struct NodePrefix { pub struct NodePrefix {
buf: Vec<u8>, buf: Vec<u8>,
is_odd: bool, is_odd: bool,
} }
impl NodePrefix { impl NodePrefix {
/// Convert from hexadecimal string representation /// Convert from hexadecimal string representation
/// ///
/// Similarly to `hex::decode`, can be used with Unicode string types /// Similarly to `hex::decode`, can be used with Unicode string types
/// (`String`, `&str`) as well as bytes. /// (`String`, `&str`) as well as bytes.
/// ///
/// 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: impl AsRef<[u8]>) -> Result<Self, NodeError> { pub fn from_hex(hex: impl AsRef<[u8]>) -> Result<Self, FromHexError> {
let hex = hex.as_ref(); let hex = hex.as_ref();
let len = hex.len(); let len = hex.len();
if len > NODE_NYBBLES_LENGTH { if len > NODE_NYBBLES_LENGTH {
return Err(NodeError::PrefixTooLong( return Err(FromHexError);
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> = let mut buf: Vec<u8> =
Vec::from_hex(&even_part).map_err(|e| (e, hex))?; Vec::from_hex(&even_part).map_err(|_| FromHexError)?;
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)? as u8;
FromHexError::InvalidHexCharacter {
c: latest_char,
index: len - 1,
},
hex,
)
})? 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 {
NodePrefixRef { NodePrefixRef {
buf: &self.buf, buf: &self.buf,
} }
fn sample_node_hex() -> String { fn sample_node_hex() -> String {
hex_pad_right("0123456789abcdeffedcba9876543210deadbeef") hex_pad_right("0123456789abcdeffedcba9876543210deadbeef")
} }
#[test] #[test]
fn test_node_from_hex() { fn test_node_from_hex() {
assert_eq!(Node::from_hex(&sample_node_hex()), Ok(sample_node())); assert_eq!(Node::from_hex(&sample_node_hex()).unwrap(), sample_node());
let mut short = hex_pad_right("0123"); let mut short = hex_pad_right("0123");
short.pop(); short.pop();
short.pop(); short.pop();
assert_eq!( assert!(Node::from_hex(&short).is_err());
Node::from_hex(&short),
Err(NodeError::ExactLengthRequired(NODE_NYBBLES_LENGTH, short)),
);
let not_hex = hex_pad_right("012... oops"); let not_hex = hex_pad_right("012... oops");
assert_eq!( assert!(Node::from_hex(&not_hex).is_err(),);
Node::from_hex(&not_hex),
Err(NodeError::HexError(
FromHexError::InvalidHexCharacter { c: '.', index: 3 },
not_hex,
)),
);
} }
#[test] #[test]
fn test_node_encode_hex() { fn test_node_encode_hex() {
assert_eq!(format!("{:x}", sample_node()), sample_node_hex()); assert_eq!(format!("{:x}", sample_node()), sample_node_hex());
} }
#[test] #[test]
fn test_prefix_from_hex() -> Result<(), NodeError> { fn test_prefix_from_hex() -> Result<(), FromHexError> {
assert_eq!( assert_eq!(
NodePrefix::from_hex("0e1")?, NodePrefix::from_hex("0e1")?,
NodePrefix { NodePrefix {
buf: vec![14, 16], buf: vec![14, 16],
is_odd: true is_odd: true
} }
); );
assert_eq!( assert_eq!(
} }
); );
Ok(()) Ok(())
} }
#[test] #[test]
fn test_prefix_from_hex_errors() { fn test_prefix_from_hex_errors() {
assert_eq!( assert!(NodePrefix::from_hex("testgr").is_err());
NodePrefix::from_hex("testgr"),
Err(NodeError::HexError(
FromHexError::InvalidHexCharacter { c: 't', index: 0 },
"testgr".to_string()
))
);
let mut long = format!("{:x}", NULL_NODE); let mut long = format!("{:x}", NULL_NODE);
long.push('c'); long.push('c');
match NodePrefix::from_hex(&long) assert!(NodePrefix::from_hex(&long).is_err())
.expect_err("should be refused as too long")
{
NodeError::PrefixTooLong(s) => assert_eq!(s, long),
err => panic!(format!("Should have been TooLong, got {:?}", err)),
}
} }
#[test] #[test]
fn test_is_prefix_of() -> Result<(), NodeError> { fn test_is_prefix_of() -> Result<(), FromHexError> {
let mut node_data = [0; NODE_BYTES_LENGTH]; let mut node_data = [0; NODE_BYTES_LENGTH];
node_data[0] = 0x12; node_data[0] = 0x12;
node_data[1] = 0xca; node_data[1] = 0xca;
let node = Node::from(node_data); let node = Node::from(node_data);
assert!(NodePrefix::from_hex("12")?.borrow().is_prefix_of(&node)); assert!(NodePrefix::from_hex("12")?.borrow().is_prefix_of(&node));
assert!(!NodePrefix::from_hex("1a")?.borrow().is_prefix_of(&node)); assert!(!NodePrefix::from_hex("1a")?.borrow().is_prefix_of(&node));
assert!(NodePrefix::from_hex("12c")?.borrow().is_prefix_of(&node)); assert!(NodePrefix::from_hex("12c")?.borrow().is_prefix_of(&node));
assert!(!NodePrefix::from_hex("12d")?.borrow().is_prefix_of(&node)); assert!(!NodePrefix::from_hex("12d")?.borrow().is_prefix_of(&node));
Ok(()) Ok(())
} }
#[test] #[test]
fn test_get_nybble() -> Result<(), NodeError> { fn test_get_nybble() -> Result<(), FromHexError> {
let prefix = NodePrefix::from_hex("dead6789cafe")?; let prefix = NodePrefix::from_hex("dead6789cafe")?;
assert_eq!(prefix.borrow().get_nybble(0), 13); assert_eq!(prefix.borrow().get_nybble(0), 13);
assert_eq!(prefix.borrow().get_nybble(7), 9); assert_eq!(prefix.borrow().get_nybble(7), 9);
Ok(()) Ok(())
} }
#[test] #[test]
fn test_first_different_nybble_even_prefix() { fn test_first_different_nybble_even_prefix() {

rust/hg-core/src/revlog/nodemap.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.
//! Indexing facilities for fast retrieval of `Revision` from `Node` //! Indexing facilities for fast retrieval of `Revision` from `Node`
//! //!
//! This provides a variation on the 16-ary radix tree that is //! This provides a variation on the 16-ary radix tree that is
//! provided as "nodetree" in revlog.c, ready for append-only persistence //! provided as "nodetree" in revlog.c, ready for append-only persistence
//! on disk. //! on disk.
//! //!
//! Following existing implicit conventions, the "nodemap" terminology //! Following existing implicit conventions, the "nodemap" terminology
//! is used in a more abstract context. //! is used in a more abstract context.
use super::{ use super::{
node::NULL_NODE, Node, NodeError, NodePrefix, NodePrefixRef, Revision, node::NULL_NODE, FromHexError, Node, NodePrefix, NodePrefixRef, Revision,
RevlogIndex, NULL_REVISION, RevlogIndex, NULL_REVISION,
}; };
use std::cmp::max; use std::cmp::max;
use std::fmt; use std::fmt;
use std::mem; use std::mem;
use std::ops::Deref; use std::ops::Deref;
use std::ops::Index; use std::ops::Index;
use std::slice; use std::slice;
#[derive(Debug, PartialEq)] #[derive(Debug, PartialEq)]
pub enum NodeMapError { pub enum NodeMapError {
MultipleResults, MultipleResults,
InvalidNodePrefix(NodeError), InvalidNodePrefix,
/// A `Revision` stored in the nodemap could not be found in the index /// A `Revision` stored in the nodemap could not be found in the index
RevisionNotInIndex(Revision), RevisionNotInIndex(Revision),
} }
impl From<NodeError> for NodeMapError { impl From<FromHexError> for NodeMapError {
fn from(err: NodeError) -> Self { fn from(_: FromHexError) -> Self {
NodeMapError::InvalidNodePrefix(err) NodeMapError::InvalidNodePrefix
} }
} }
/// Mapping system from Mercurial nodes to revision numbers. /// Mapping system from Mercurial nodes to revision numbers.
/// ///
/// ## `RevlogIndex` and `NodeMap` /// ## `RevlogIndex` and `NodeMap`
/// ///
/// One way to think about their relationship is that /// One way to think about their relationship is that

rust/hg-cpython/src/revlog.rs

buffer::{Element, PyBuffer}, buffer::{Element, PyBuffer},
exc::{IndexError, ValueError}, exc::{IndexError, ValueError},
ObjectProtocol, PyBytes, PyClone, PyDict, PyErr, PyModule, PyObject, ObjectProtocol, PyBytes, PyClone, PyDict, PyErr, PyModule, PyObject,
PyResult, PyString, PyTuple, Python, PythonObject, ToPyObject, PyResult, PyString, PyTuple, Python, PythonObject, ToPyObject,
}; };
use hg::{ use hg::{
nodemap::{Block, NodeMapError, NodeTree}, nodemap::{Block, NodeMapError, NodeTree},
revlog::{nodemap::NodeMap, RevlogIndex}, revlog::{nodemap::NodeMap, RevlogIndex},
NodeError, Revision, Revision,
}; };
use std::cell::RefCell; use std::cell::RefCell;
/// Return a Struct implementing the Graph trait /// Return a Struct implementing the Graph trait
pub(crate) fn pyindex_to_graph( pub(crate) fn pyindex_to_graph(
py: Python, py: Python,
index: PyObject, index: PyObject,
) -> PyResult<cindex::Index> { ) -> PyResult<cindex::Index> {
) )
} }
/// Standard treatment of NodeMapError /// Standard treatment of NodeMapError
fn nodemap_error(py: Python, err: NodeMapError) -> PyErr { fn nodemap_error(py: Python, err: NodeMapError) -> PyErr {
match err { match err {
NodeMapError::MultipleResults => revlog_error(py), NodeMapError::MultipleResults => revlog_error(py),
NodeMapError::RevisionNotInIndex(r) => rev_not_in_index(py, r), NodeMapError::RevisionNotInIndex(r) => rev_not_in_index(py, r),
NodeMapError::InvalidNodePrefix(s) => invalid_node_prefix(py, &s), NodeMapError::InvalidNodePrefix => {
PyErr::new::<ValueError, _>(py, "Invalid node or prefix")
} }
} }
fn invalid_node_prefix(py: Python, ne: &NodeError) -> PyErr {
PyErr::new::<ValueError, _>(
py,
format!("Invalid node or prefix: {:?}", ne),
)
} }
/// Create the module, with __package__ given from parent /// Create the module, with __package__ given from parent
pub fn init_module(py: Python, package: &str) -> PyResult<PyModule> { pub fn init_module(py: Python, package: &str) -> PyResult<PyModule> {
let dotted_name = &format!("{}.revlog", package); let dotted_name = &format!("{}.revlog", package);
let m = PyModule::new(py, dotted_name)?; let m = PyModule::new(py, dotted_name)?;
m.add(py, "__package__", package)?; m.add(py, "__package__", package)?;
m.add(py, "__doc__", "RevLog - Rust implementations")?; m.add(py, "__doc__", "RevLog - Rust implementations")?;