hg-core: fix path encoding usage

1. Hash encoded path are in `.hg/store/dh` instead of `.hg/store/data`.

2. Path encoded index and data files may not have the same parent path.
   It is not just about replacing `.i` by `.d`

Differential Revision: https://phab.mercurial-scm.org/D9121

rust/hg-core/src/operations/cat.rs

@@ -1,158 +1,169 b''
 // list_tracked_files.rs
 //
 // Copyright 2020 Antoine Cezar <[e-mail]>
 //
 // This software may be used and distributed according to the terms of the
 // GNU General Public License version 2 or any later version.
 
 use std::convert::From;
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 
 use crate::revlog::changelog::Changelog;
 use crate::revlog::manifest::{Manifest, ManifestEntry};
 use crate::revlog::path_encode::path_encode;
 use crate::revlog::revlog::Revlog;
 use crate::revlog::revlog::RevlogError;
 use crate::revlog::Revision;
-use crate::utils::hg_path::HgPathBuf;
+use crate::utils::files::get_path_from_bytes;
+use crate::utils::hg_path::{HgPath, HgPathBuf};
 
 const METADATA_DELIMITER: [u8; 2] = [b'\x01', b'\n'];
 
 /// Kind of error encountered by `CatRev`
 #[derive(Debug)]
 pub enum CatRevErrorKind {
     /// Error when reading a `revlog` file.
     IoError(std::io::Error),
     /// The revision has not been found.
     InvalidRevision,
     /// A `revlog` file is corrupted.
     CorruptedRevlog,
     /// The `revlog` format version is not supported.
     UnsuportedRevlogVersion(u16),
     /// The `revlog` data format is not supported.
     UnknowRevlogDataFormat(u8),
 }
 
 /// A `CatRev` error
 #[derive(Debug)]
 pub struct CatRevError {
     /// Kind of error encountered by `CatRev`
     pub kind: CatRevErrorKind,
 }
 
 impl From<CatRevErrorKind> for CatRevError {
     fn from(kind: CatRevErrorKind) -> Self {
         CatRevError { kind }
     }
 }
 
 impl From<RevlogError> for CatRevError {
     fn from(err: RevlogError) -> Self {
         match err {
             RevlogError::IoError(err) => CatRevErrorKind::IoError(err),
             RevlogError::UnsuportedVersion(version) => {
                 CatRevErrorKind::UnsuportedRevlogVersion(version)
             }
             RevlogError::InvalidRevision => CatRevErrorKind::InvalidRevision,
             RevlogError::Corrupted => CatRevErrorKind::CorruptedRevlog,
             RevlogError::UnknowDataFormat(format) => {
                 CatRevErrorKind::UnknowRevlogDataFormat(format)
             }
         }
         .into()
     }
 }
 
 /// List files under Mercurial control at a given revision.
 pub struct CatRev<'a> {
     root: &'a PathBuf,
     /// The revision to cat the files from.
     rev: &'a str,
     /// The files to output.
     files: &'a [HgPathBuf],
     /// The changelog file
     changelog: Changelog,
     /// The manifest file
     manifest: Manifest,
     /// The manifest entry corresponding to the revision.
     ///
     /// Used to hold the owner of the returned references.
     manifest_entry: Option<ManifestEntry>,
 }
 
 impl<'a> CatRev<'a> {
     pub fn new(
         root: &'a PathBuf,
         rev: &'a str,
         files: &'a [HgPathBuf],
     ) -> Result<Self, CatRevError> {
         let changelog = Changelog::open(&root)?;
         let manifest = Manifest::open(&root)?;
         let manifest_entry = None;
 
         Ok(Self {
             root,
             rev,
             files,
             changelog,
             manifest,
             manifest_entry,
         })
     }
 
     pub fn run(&mut self) -> Result<Vec<u8>, CatRevError> {
         let changelog_entry = match self.rev.parse::<Revision>() {
             Ok(rev) => self.changelog.get_rev(rev)?,
             _ => {
                 let changelog_node = hex::decode(&self.rev)
                     .map_err(|_| CatRevErrorKind::InvalidRevision)?;
                 self.changelog.get_node(&changelog_node)?
             }
         };
         let manifest_node = hex::decode(&changelog_entry.manifest_node()?)
             .map_err(|_| CatRevErrorKind::CorruptedRevlog)?;
 
         self.manifest_entry = Some(self.manifest.get_node(&manifest_node)?);
         if let Some(ref manifest_entry) = self.manifest_entry {
             let mut bytes = vec![];
 
             for (manifest_file, node_bytes) in
                 manifest_entry.files_with_nodes()
             {
                 for cat_file in self.files.iter() {
                     if cat_file.as_bytes() == manifest_file.as_bytes() {
-                        let encoded_bytes =
-                            path_encode(manifest_file.as_bytes());
-                        let revlog_index_string = format!(
-                            ".hg/store/data/{}.i",
-                            String::from_utf8_lossy(&encoded_bytes),
-                        );
-                        let revlog_index_path =
-                            self.root.join(&revlog_index_string);
-                        let file_log = Revlog::open(&revlog_index_path)?;
+                        let index_path =
+                            store_path(self.root, manifest_file, b".i");
+                        let data_path =
+                            store_path(self.root, manifest_file, b".d");
+
+                        let file_log =
+                            Revlog::open(&index_path, Some(&data_path))?;
                         let file_node = hex::decode(&node_bytes)
                             .map_err(|_| CatRevErrorKind::CorruptedRevlog)?;
                         let file_rev = file_log.get_node_rev(&file_node)?;
                         let data = file_log.get_rev_data(file_rev)?;
                         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);
                         }
                     }
                 }
             }
 
             Ok(bytes)
         } else {
             unreachable!("manifest_entry should have been stored");
         }
     }
 }
+
+fn store_path(root: &Path, hg_path: &HgPath, suffix: &[u8]) -> PathBuf {
+    let encoded_bytes =
+        path_encode(&[b"data/", hg_path.as_bytes(), suffix].concat());
+    [
+        root,
+        &Path::new(".hg/store/"),
+        get_path_from_bytes(&encoded_bytes),
+    ]
+    .iter()
+    .collect()
+}

rust/hg-core/src/operations/debugdata.rs

@@ -1,110 +1,110 b''
 // debugdata.rs
 //
 // Copyright 2020 Antoine Cezar <[e-mail]>
 //
 // This software may be used and distributed according to the terms of the
 // GNU General Public License version 2 or any later version.
 
 use super::find_root;
 use crate::revlog::revlog::{Revlog, RevlogError};
 use crate::revlog::Revision;
 
 /// Kind of data to debug
 #[derive(Debug, Copy, Clone)]
 pub enum DebugDataKind {
     Changelog,
     Manifest,
 }
 
 /// Kind of error encountered by DebugData
 #[derive(Debug)]
 pub enum DebugDataErrorKind {
     FindRootError(find_root::FindRootError),
     /// Error when reading a `revlog` file.
     IoError(std::io::Error),
     /// The revision has not been found.
     InvalidRevision,
     /// A `revlog` file is corrupted.
     CorruptedRevlog,
     /// The `revlog` format version is not supported.
     UnsuportedRevlogVersion(u16),
     /// The `revlog` data format is not supported.
     UnknowRevlogDataFormat(u8),
 }
 
 /// A DebugData error
 #[derive(Debug)]
 pub struct DebugDataError {
     /// Kind of error encountered by DebugData
     pub kind: DebugDataErrorKind,
 }
 
 impl From<DebugDataErrorKind> for DebugDataError {
     fn from(kind: DebugDataErrorKind) -> Self {
         DebugDataError { kind }
     }
 }
 
 impl From<find_root::FindRootError> for DebugDataError {
     fn from(err: find_root::FindRootError) -> Self {
         let kind = DebugDataErrorKind::FindRootError(err);
         DebugDataError { kind }
     }
 }
 
 impl From<std::io::Error> for DebugDataError {
     fn from(err: std::io::Error) -> Self {
         let kind = DebugDataErrorKind::IoError(err);
         DebugDataError { kind }
     }
 }
 
 impl From<RevlogError> for DebugDataError {
     fn from(err: RevlogError) -> Self {
         match err {
             RevlogError::IoError(err) => DebugDataErrorKind::IoError(err),
             RevlogError::UnsuportedVersion(version) => {
                 DebugDataErrorKind::UnsuportedRevlogVersion(version)
             }
             RevlogError::InvalidRevision => {
                 DebugDataErrorKind::InvalidRevision
             }
             RevlogError::Corrupted => DebugDataErrorKind::CorruptedRevlog,
             RevlogError::UnknowDataFormat(format) => {
                 DebugDataErrorKind::UnknowRevlogDataFormat(format)
             }
         }
         .into()
     }
 }
 
 /// Dump the contents data of a revision.
 pub struct DebugData<'a> {
     /// Revision or hash of the revision.
     rev: &'a str,
     /// Kind of data to debug.
     kind: DebugDataKind,
 }
 
 impl<'a> DebugData<'a> {
     pub fn new(rev: &'a str, kind: DebugDataKind) -> Self {
         DebugData { rev, kind }
     }
 
     pub fn run(&mut self) -> Result<Vec<u8>, DebugDataError> {
         let rev = self
             .rev
             .parse::<Revision>()
             .or(Err(DebugDataErrorKind::InvalidRevision))?;
 
         let root = find_root::FindRoot::new().run()?;
         let index_file = match self.kind {
             DebugDataKind::Changelog => root.join(".hg/store/00changelog.i"),
             DebugDataKind::Manifest => root.join(".hg/store/00manifest.i"),
         };
-        let revlog = Revlog::open(&index_file)?;
+        let revlog = Revlog::open(&index_file, None)?;
         let data = revlog.get_rev_data(rev)?;
 
         Ok(data)
     }
 }

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

@@ -1,58 +1,58 b''
 use crate::revlog::revlog::{Revlog, RevlogError};
 use crate::revlog::Revision;
 use std::path::PathBuf;
 
 /// A specialized `Revlog` to work with `changelog` data format.
 pub struct Changelog {
     /// The generic `revlog` format.
     revlog: Revlog,
 }
 
 impl Changelog {
     /// Open the `changelog` of a repository given by its root.
     pub fn open(root: &PathBuf) -> Result<Self, RevlogError> {
         let index_file = root.join(".hg/store/00changelog.i");
-        let revlog = Revlog::open(&index_file)?;
+        let revlog = Revlog::open(&index_file, None)?;
         Ok(Self { revlog })
     }
 
     /// Return the `ChangelogEntry` a given node id.
     pub fn get_node(
         &self,
         node: &[u8],
     ) -> Result<ChangelogEntry, RevlogError> {
         let rev = self.revlog.get_node_rev(node)?;
         self.get_rev(rev)
     }
 
     /// Return the `ChangelogEntry` of a given node revision.
     pub fn get_rev(
         &self,
         rev: Revision,
     ) -> Result<ChangelogEntry, RevlogError> {
         let bytes = self.revlog.get_rev_data(rev)?;
         Ok(ChangelogEntry { bytes })
     }
 }
 
 /// `Changelog` entry which knows how to interpret the `changelog` data bytes.
 #[derive(Debug)]
 pub struct ChangelogEntry {
     /// The data bytes of the `changelog` entry.
     bytes: Vec<u8>,
 }
 
 impl ChangelogEntry {
     /// Return an iterator over the lines of the entry.
     pub fn lines(&self) -> impl Iterator<Item = &[u8]> {
         self.bytes
             .split(|b| b == &b'\n')
             .filter(|line| !line.is_empty())
     }
 
     /// Return the node id of the `manifest` referenced by this `changelog`
     /// entry.
     pub fn manifest_node(&self) -> Result<&[u8], RevlogError> {
         self.lines().next().ok_or(RevlogError::Corrupted)
     }
 }

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

@@ -1,73 +1,73 b''
 use crate::revlog::revlog::{Revlog, RevlogError};
 use crate::revlog::Revision;
 use crate::utils::hg_path::HgPath;
 use std::path::PathBuf;
 
 /// A specialized `Revlog` to work with `manifest` data format.
 pub struct Manifest {
     /// The generic `revlog` format.
     revlog: Revlog,
 }
 
 impl Manifest {
     /// Open the `manifest` of a repository given by its root.
     pub fn open(root: &PathBuf) -> Result<Self, RevlogError> {
         let index_file = root.join(".hg/store/00manifest.i");
-        let revlog = Revlog::open(&index_file)?;
+        let revlog = Revlog::open(&index_file, None)?;
         Ok(Self { revlog })
     }
 
     /// Return the `ManifestEntry` of a given node id.
     pub fn get_node(&self, node: &[u8]) -> Result<ManifestEntry, RevlogError> {
         let rev = self.revlog.get_node_rev(node)?;
         self.get_rev(rev)
     }
 
     /// Return the `ManifestEntry` of a given node revision.
     pub fn get_rev(
         &self,
         rev: Revision,
     ) -> Result<ManifestEntry, RevlogError> {
         let bytes = self.revlog.get_rev_data(rev)?;
         Ok(ManifestEntry { bytes })
     }
 }
 
 /// `Manifest` entry which knows how to interpret the `manifest` data bytes.
 #[derive(Debug)]
 pub struct ManifestEntry {
     bytes: Vec<u8>,
 }
 
 impl ManifestEntry {
     /// Return an iterator over the lines of the entry.
     pub fn lines(&self) -> impl Iterator<Item = &[u8]> {
         self.bytes
             .split(|b| b == &b'\n')
             .filter(|line| !line.is_empty())
     }
 
     /// Return an iterator over the files of the entry.
     pub fn files(&self) -> impl Iterator<Item = &HgPath> {
         self.lines().filter(|line| !line.is_empty()).map(|line| {
             let pos = line
                 .iter()
                 .position(|x| x == &b'\0')
                 .expect("manifest line should contain \\0");
             HgPath::new(&line[..pos])
         })
     }
 
     /// Return an iterator over the files of the entry.
     pub fn files_with_nodes(&self) -> impl Iterator<Item = (&HgPath, &[u8])> {
         self.lines().filter(|line| !line.is_empty()).map(|line| {
             let pos = line
                 .iter()
                 .position(|x| x == &b'\0')
                 .expect("manifest line should contain \\0");
             let hash_start = pos + 1;
             let hash_end = hash_start + 40;
             (HgPath::new(&line[..pos]), &line[hash_start..hash_end])
         })
     }
 }

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

@@ -1,331 +1,335 b''
 use std::borrow::Cow;
 use std::fs::File;
 use std::io::Read;
 use std::ops::Deref;
 use std::path::Path;
 
 use byteorder::{BigEndian, ByteOrder};
 use crypto::digest::Digest;
 use crypto::sha1::Sha1;
 use flate2::read::ZlibDecoder;
 use memmap::{Mmap, MmapOptions};
 use micro_timer::timed;
 use zstd;
 
 use super::index::Index;
 use super::node::{NODE_BYTES_LENGTH, NULL_NODE_ID};
 use super::patch;
 use crate::revlog::Revision;
 
 pub enum RevlogError {
     IoError(std::io::Error),
     UnsuportedVersion(u16),
     InvalidRevision,
     Corrupted,
     UnknowDataFormat(u8),
 }
 
 fn mmap_open(path: &Path) -> Result<Mmap, std::io::Error> {
     let file = File::open(path)?;
     let mmap = unsafe { MmapOptions::new().map(&file) }?;
     Ok(mmap)
 }
 
 /// Read only implementation of revlog.
 pub struct Revlog {
     /// When index and data are not interleaved: bytes of the revlog index.
     /// When index and data are interleaved: bytes of the revlog index and
     /// data.
     index: Index,
     /// When index and data are not interleaved: bytes of the revlog data
     data_bytes: Option<Box<dyn Deref<Target = [u8]> + Send>>,
 }
 
 impl Revlog {
     /// Open a revlog index file.
     ///
     /// It will also open the associated data file if index and data are not
     /// interleaved.
     #[timed]
-    pub fn open(index_path: &Path) -> Result<Self, RevlogError> {
+    pub fn open(
+        index_path: &Path,
+        data_path: Option<&Path>,
+    ) -> Result<Self, RevlogError> {
         let index_mmap =
             mmap_open(&index_path).map_err(RevlogError::IoError)?;
 
         let version = get_version(&index_mmap);
         if version != 1 {
             return Err(RevlogError::UnsuportedVersion(version));
         }
 
         let index = Index::new(Box::new(index_mmap))?;
 
-        // TODO load data only when needed //
+        let default_data_path = index_path.with_extension("d");
+
         // type annotation required
         // won't recognize Mmap as Deref<Target = [u8]>
         let data_bytes: Option<Box<dyn Deref<Target = [u8]> + Send>> =
             if index.is_inline() {
                 None
             } else {
-                let data_path = index_path.with_extension("d");
+                let data_path = data_path.unwrap_or(&default_data_path);
                 let data_mmap =
-                    mmap_open(&data_path).map_err(RevlogError::IoError)?;
+                    mmap_open(data_path).map_err(RevlogError::IoError)?;
                 Some(Box::new(data_mmap))
             };
 
         Ok(Revlog { index, data_bytes })
     }
 
     /// Return number of entries of the `Revlog`.
     pub fn len(&self) -> usize {
         self.index.len()
     }
 
     /// Returns `true` if the `Revlog` has zero `entries`.
     pub fn is_empty(&self) -> bool {
         self.index.is_empty()
     }
 
     /// Return the full data associated to a node.
     #[timed]
     pub fn get_node_rev(&self, node: &[u8]) -> Result<Revision, RevlogError> {
         // This is brute force. But it is fast enough for now.
         // Optimization will come later.
         for rev in (0..self.len() as Revision).rev() {
             let index_entry =
                 self.index.get_entry(rev).ok_or(RevlogError::Corrupted)?;
             if node == index_entry.hash() {
                 return Ok(rev);
             }
         }
         Err(RevlogError::InvalidRevision)
     }
 
     /// Return the full data associated to a revision.
     ///
     /// All entries required to build the final data out of deltas will be
     /// retrieved as needed, and the deltas will be applied to the inital
     /// snapshot to rebuild the final data.
     #[timed]
     pub fn get_rev_data(&self, rev: Revision) -> Result<Vec<u8>, RevlogError> {
         // Todo return -> Cow
         let mut entry = self.get_entry(rev)?;
         let mut delta_chain = vec![];
         while let Some(base_rev) = entry.base_rev {
             delta_chain.push(entry);
             entry =
                 self.get_entry(base_rev).or(Err(RevlogError::Corrupted))?;
         }
 
         // TODO do not look twice in the index
         let index_entry = self
             .index
             .get_entry(rev)
             .ok_or(RevlogError::InvalidRevision)?;
 
         let data: Vec<u8> = if delta_chain.is_empty() {
             entry.data()?.into()
         } else {
             Revlog::build_data_from_deltas(entry, &delta_chain)?
         };
 
         if self.check_hash(
             index_entry.p1(),
             index_entry.p2(),
             index_entry.hash(),
             &data,
         ) {
             Ok(data)
         } else {
             Err(RevlogError::Corrupted)
         }
     }
 
     /// Check the hash of some given data against the recorded hash.
     pub fn check_hash(
         &self,
         p1: Revision,
         p2: Revision,
         expected: &[u8],
         data: &[u8],
     ) -> bool {
         let e1 = self.index.get_entry(p1);
         let h1 = match e1 {
             Some(ref entry) => entry.hash(),
             None => &NULL_NODE_ID,
         };
         let e2 = self.index.get_entry(p2);
         let h2 = match e2 {
             Some(ref entry) => entry.hash(),
             None => &NULL_NODE_ID,
         };
 
         hash(data, &h1, &h2).as_slice() == expected
     }
 
     /// Build the full data of a revision out its snapshot
     /// and its deltas.
     #[timed]
     fn build_data_from_deltas(
         snapshot: RevlogEntry,
         deltas: &[RevlogEntry],
     ) -> Result<Vec<u8>, RevlogError> {
         let snapshot = snapshot.data()?;
         let deltas = deltas
             .iter()
             .rev()
             .map(RevlogEntry::data)
             .collect::<Result<Vec<Cow<'_, [u8]>>, RevlogError>>()?;
         let patches: Vec<_> =
             deltas.iter().map(|d| patch::PatchList::new(d)).collect();
         let patch = patch::fold_patch_lists(&patches);
         Ok(patch.apply(&snapshot))
     }
 
     /// Return the revlog data.
     fn data(&self) -> &[u8] {
         match self.data_bytes {
             Some(ref data_bytes) => &data_bytes,
             None => panic!(
                 "forgot to load the data or trying to access inline data"
             ),
         }
     }
 
     /// Get an entry of the revlog.
     fn get_entry(&self, rev: Revision) -> Result<RevlogEntry, RevlogError> {
         let index_entry = self
             .index
             .get_entry(rev)
             .ok_or(RevlogError::InvalidRevision)?;
         let start = index_entry.offset();
         let end = start + index_entry.compressed_len();
         let data = if self.index.is_inline() {
             self.index.data(start, end)
         } else {
             &self.data()[start..end]
         };
         let entry = RevlogEntry {
             rev,
             bytes: data,
             compressed_len: index_entry.compressed_len(),
             uncompressed_len: index_entry.uncompressed_len(),
             base_rev: if index_entry.base_revision() == rev {
                 None
             } else {
                 Some(index_entry.base_revision())
             },
         };
         Ok(entry)
     }
 }
 
 /// The revlog entry's bytes and the necessary informations to extract
 /// the entry's data.
 #[derive(Debug)]
 pub struct RevlogEntry<'a> {
     rev: Revision,
     bytes: &'a [u8],
     compressed_len: usize,
     uncompressed_len: usize,
     base_rev: Option<Revision>,
 }
 
 impl<'a> RevlogEntry<'a> {
     /// Extract the data contained in the entry.
     pub fn data(&self) -> Result<Cow<'_, [u8]>, RevlogError> {
         if self.bytes.is_empty() {
             return Ok(Cow::Borrowed(&[]));
         }
         match self.bytes[0] {
             // Revision data is the entirety of the entry, including this
             // header.
             b'\0' => Ok(Cow::Borrowed(self.bytes)),
             // Raw revision data follows.
             b'u' => Ok(Cow::Borrowed(&self.bytes[1..])),
             // zlib (RFC 1950) data.
             b'x' => Ok(Cow::Owned(self.uncompressed_zlib_data()?)),
             // zstd data.
             b'\x28' => Ok(Cow::Owned(self.uncompressed_zstd_data()?)),
             format_type => Err(RevlogError::UnknowDataFormat(format_type)),
         }
     }
 
     fn uncompressed_zlib_data(&self) -> Result<Vec<u8>, RevlogError> {
         let mut decoder = ZlibDecoder::new(self.bytes);
         if self.is_delta() {
             let mut buf = Vec::with_capacity(self.compressed_len);
             decoder
                 .read_to_end(&mut buf)
                 .or(Err(RevlogError::Corrupted))?;
             Ok(buf)
         } else {
             let mut buf = vec![0; self.uncompressed_len];
             decoder
                 .read_exact(&mut buf)
                 .or(Err(RevlogError::Corrupted))?;
             Ok(buf)
         }
     }
 
     fn uncompressed_zstd_data(&self) -> Result<Vec<u8>, RevlogError> {
         if self.is_delta() {
             let mut buf = Vec::with_capacity(self.compressed_len);
             zstd::stream::copy_decode(self.bytes, &mut buf)
                 .or(Err(RevlogError::Corrupted))?;
             Ok(buf)
         } else {
             let mut buf = vec![0; self.uncompressed_len];
             let len = zstd::block::decompress_to_buffer(self.bytes, &mut buf)
                 .or(Err(RevlogError::Corrupted))?;
             if len != self.uncompressed_len {
                 Err(RevlogError::Corrupted)
             } else {
                 Ok(buf)
             }
         }
     }
 
     /// Tell if the entry is a snapshot or a delta
     /// (influences on decompression).
     fn is_delta(&self) -> bool {
         self.base_rev.is_some()
     }
 }
 
 /// Format version of the revlog.
 pub fn get_version(index_bytes: &[u8]) -> u16 {
     BigEndian::read_u16(&index_bytes[2..=3])
 }
 
 /// Calculate the hash of a revision given its data and its parents.
 fn hash(data: &[u8], p1_hash: &[u8], p2_hash: &[u8]) -> Vec<u8> {
     let mut hasher = Sha1::new();
     let (a, b) = (p1_hash, p2_hash);
     if a > b {
         hasher.input(b);
         hasher.input(a);
     } else {
         hasher.input(a);
         hasher.input(b);
     }
     hasher.input(data);
     let mut hash = vec![0; NODE_BYTES_LENGTH];
     hasher.result(&mut hash);
     hash
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
 
     use super::super::index::IndexEntryBuilder;
 
     #[test]
     fn version_test() {
         let bytes = IndexEntryBuilder::new()
             .is_first(true)
             .with_version(1)
             .build();
 
         assert_eq!(get_version(&bytes), 1)
     }
 }