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
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.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 25415

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 bytes_cast::BytesCast; use bytes_cast::BytesCast;
use hex::{self, FromHex, FromHexError}; use hex::{self, FromHex};
use std::convert::TryFrom; use std::convert::TryFrom;
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, BytesCast)] #[derive(Clone, Debug, PartialEq, BytesCast)]
#[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 bytes_cast::{unaligned, BytesCast}; use bytes_cast::{unaligned, BytesCast};
use std::cmp::max; use std::cmp::max;
use std::fmt; use std::fmt;
use std::mem::{self, align_of, size_of}; use std::mem::{self, align_of, size_of};
use std::ops::Deref; use std::ops::Deref;
use std::ops::Index; use std::ops::Index;
#[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")?;