( )⚙ D11960 rhg: Add RevlogEntry::data that does delta resolution

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11960

rhg: Add RevlogEntry::data that does delta resolution
ClosedPublic

Authored by SimonSapin on Jan 6 2022, 1:56 PM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHGf2f57724d4eb: rhg: Add RevlogEntry::data that does delta resolution
Summary

This requires keeping a &Revlog reference inside the RevlogEntry struct.
This struct already had the appropriate lifetime parameter.

Diff Detail

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

Event Timeline

SimonSapin created this revision.Jan 6 2022, 1:56 PM
Alphare accepted this revision.Jan 7 2022, 4:29 AM
This revision is now accepted and ready to land.Jan 7 2022, 4:29 AM
SimonSapin added a commit: rHGf2f57724d4eb: rhg: Add RevlogEntry::data that does delta resolution.Jan 7 2022, 4:52 AM
Closed by commit rHGf2f57724d4eb: rhg: Add RevlogEntry::data that does delta resolution (authored by SimonSapin). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 31600

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

let index_file = match kind { let index_file = match kind {
DebugDataKind::Changelog => "00changelog.i", DebugDataKind::Changelog => "00changelog.i",
DebugDataKind::Manifest => "00manifest.i", DebugDataKind::Manifest => "00manifest.i",
}; };
let revlog = Revlog::open(repo, index_file, None)?; let revlog = Revlog::open(repo, index_file, None)?;
let rev = let rev =
crate::revset::resolve_rev_number_or_hex_prefix(revset, &revlog)?; crate::revset::resolve_rev_number_or_hex_prefix(revset, &revlog)?;
let data = revlog.get_rev_data(rev)?; let data = revlog.get_rev_data(rev)?;
Ok(data) Ok(data.into_owned())
} }

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

self.data_for_rev(rev) self.data_for_rev(rev)
} }
/// Return the `ChangelogEntry` of the given revision number. /// Return the `ChangelogEntry` of the given revision number.
pub fn data_for_rev( pub fn data_for_rev(
&self, &self,
rev: Revision, rev: Revision,
) -> Result<ChangelogRevisionData, RevlogError> { ) -> Result<ChangelogRevisionData, RevlogError> {
let bytes = self.revlog.get_rev_data(rev)?; let bytes = self.revlog.get_rev_data(rev)?.into_owned();
Ok(ChangelogRevisionData { bytes }) Ok(ChangelogRevisionData { bytes })
} }
pub fn node_from_rev(&self, rev: Revision) -> Option<&Node> { pub fn node_from_rev(&self, rev: Revision) -> Option<&Node> {
self.revlog.node_from_rev(rev) self.revlog.node_from_rev(rev)
} }
} }

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

} }
/// The given revision is that of the file as found in a manifest, not of a /// The given revision is that of the file as found in a manifest, not of a
/// changeset. /// changeset.
pub fn data_for_rev( pub fn data_for_rev(
&self, &self,
file_rev: Revision, file_rev: Revision,
) -> Result<FilelogRevisionData, RevlogError> { ) -> Result<FilelogRevisionData, RevlogError> {
let data: Vec<u8> = self.revlog.get_rev_data(file_rev)?; let data: Vec<u8> = self.revlog.get_rev_data(file_rev)?.into_owned();
Ok(FilelogRevisionData(data.into())) Ok(FilelogRevisionData(data.into()))
} }
} }
fn store_path(hg_path: &HgPath, suffix: &[u8]) -> PathBuf { fn store_path(hg_path: &HgPath, suffix: &[u8]) -> PathBuf {
let encoded_bytes = let encoded_bytes =
path_encode(&[b"data/", hg_path.as_bytes(), suffix].concat()); path_encode(&[b"data/", hg_path.as_bytes(), suffix].concat());
get_path_from_bytes(&encoded_bytes).into() get_path_from_bytes(&encoded_bytes).into()

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

/// Note: this is a revision number in the manifestlog, *not* of any /// Note: this is a revision number in the manifestlog, *not* of any
/// changeset. /// changeset.
/// ///
/// See also `Repo::manifest_for_rev` /// See also `Repo::manifest_for_rev`
pub fn data_for_rev( pub fn data_for_rev(
&self, &self,
rev: Revision, rev: Revision,
) -> Result<Manifest, RevlogError> { ) -> Result<Manifest, RevlogError> {
let bytes = self.revlog.get_rev_data(rev)?; let bytes = self.revlog.get_rev_data(rev)?.into_owned();
Ok(Manifest { bytes }) Ok(Manifest { bytes })
} }
} }
/// `Manifestlog` entry which knows how to interpret the `manifest` data bytes. /// `Manifestlog` entry which knows how to interpret the `manifest` data bytes.
#[derive(Debug)] #[derive(Debug)]
pub struct Manifest { pub struct Manifest {
/// Format for a manifest: flat sequence of variable-size entries, /// Format for a manifest: flat sequence of variable-size entries,

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

} }
/// Return the full data associated to a revision. /// Return the full data associated to a revision.
/// ///
/// All entries required to build the final data out of deltas will be /// 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 /// retrieved as needed, and the deltas will be applied to the inital
/// snapshot to rebuild the final data. /// snapshot to rebuild the final data.
#[timed] #[timed]
pub fn get_rev_data(&self, rev: Revision) -> Result<Vec<u8>, RevlogError> { pub fn get_rev_data(
&self,
rev: Revision,
) -> Result<Cow<[u8]>, RevlogError> {
if rev == NULL_REVISION { if rev == NULL_REVISION {
return Ok(vec![]); return Ok(Cow::Borrowed(&[]));
};
// Todo return -> Cow
let mut entry = self.get_entry(rev)?;
let mut delta_chain = vec![];
// The meaning of `base_rev_or_base_of_delta_chain` depends on
// generaldelta. See the doc on `ENTRY_DELTA_BASE` in
// `mercurial/revlogutils/constants.py` and the code in
// [_chaininfo] and in [index_deltachain].
let uses_generaldelta = self.index.uses_generaldelta();
while let Some(base_rev) = entry.base_rev_or_base_of_delta_chain {
let base_rev = if uses_generaldelta {
base_rev
} else {
entry.rev - 1
};
delta_chain.push(entry);
entry = self.get_entry_internal(base_rev)?;
}
// 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_chunk()?.into()
} else {
Revlog::build_data_from_deltas(entry, &delta_chain)?
}; };
self.get_entry(rev)?.data()
if self.check_hash(
index_entry.p1(),
index_entry.p2(),
index_entry.hash().as_bytes(),
&data,
) {
Ok(data)
} else {
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],
let start = index_entry.offset(); let start = index_entry.offset();
let end = start + index_entry.compressed_len(); let end = start + index_entry.compressed_len();
let data = if self.index.is_inline() { let data = if self.index.is_inline() {
self.index.data(start, end) self.index.data(start, end)
} else { } else {
&self.data()[start..end] &self.data()[start..end]
}; };
let entry = RevlogEntry { let entry = RevlogEntry {
revlog: self,
rev, rev,
bytes: data, bytes: data,
compressed_len: index_entry.compressed_len(), compressed_len: index_entry.compressed_len(),
uncompressed_len: index_entry.uncompressed_len(), uncompressed_len: index_entry.uncompressed_len(),
base_rev_or_base_of_delta_chain: if index_entry base_rev_or_base_of_delta_chain: if index_entry
.base_revision_or_base_of_delta_chain() .base_revision_or_base_of_delta_chain()
== rev == rev
{ {
rev: Revision, rev: Revision,
) -> Result<RevlogEntry, RevlogError> { ) -> Result<RevlogEntry, RevlogError> {
return self.get_entry(rev).map_err(|_| RevlogError::corrupted()); return self.get_entry(rev).map_err(|_| RevlogError::corrupted());
} }
} }
/// The revlog entry's bytes and the necessary informations to extract /// The revlog entry's bytes and the necessary informations to extract
/// the entry's data. /// the entry's data.
#[derive(Debug)] #[derive(Clone)]
pub struct RevlogEntry<'a> { pub struct RevlogEntry<'a> {
revlog: &'a Revlog,
rev: Revision, rev: Revision,
bytes: &'a [u8], bytes: &'a [u8],
compressed_len: usize, compressed_len: usize,
uncompressed_len: usize, uncompressed_len: usize,
base_rev_or_base_of_delta_chain: Option<Revision>, base_rev_or_base_of_delta_chain: Option<Revision>,
} }
impl<'a> RevlogEntry<'a> { impl<'a> RevlogEntry<'a> {
pub fn revision(&self) -> Revision { pub fn revision(&self) -> Revision {
self.rev self.rev
} }
/// The data for this entry, after resolving deltas if any.
pub fn data(&self) -> Result<Cow<'a, [u8]>, RevlogError> {
let mut entry = self.clone();
let mut delta_chain = vec![];
// The meaning of `base_rev_or_base_of_delta_chain` depends on
// generaldelta. See the doc on `ENTRY_DELTA_BASE` in
// `mercurial/revlogutils/constants.py` and the code in
// [_chaininfo] and in [index_deltachain].
let uses_generaldelta = self.revlog.index.uses_generaldelta();
while let Some(base_rev) = entry.base_rev_or_base_of_delta_chain {
let base_rev = if uses_generaldelta {
base_rev
} else {
entry.rev - 1
};
delta_chain.push(entry);
entry = self.revlog.get_entry_internal(base_rev)?;
}
// TODO do not look twice in the index
let index_entry = self
.revlog
.index
.get_entry(self.rev)
.ok_or(RevlogError::InvalidRevision)?;
let data = if delta_chain.is_empty() {
entry.data_chunk()?
} else {
Revlog::build_data_from_deltas(entry, &delta_chain)?.into()
};
if self.revlog.check_hash(
index_entry.p1(),
index_entry.p2(),
index_entry.hash().as_bytes(),
&data,
) {
Ok(data)
} else {
Err(RevlogError::corrupted())
}
}
/// Extract the data contained in the entry. /// Extract the data contained in the entry.
/// This may be a delta. (See `is_delta`.) /// This may be a delta. (See `is_delta`.)
fn data_chunk(&self) -> Result<Cow<'_, [u8]>, RevlogError> { fn data_chunk(&self) -> Result<Cow<'a, [u8]>, RevlogError> {
if self.bytes.is_empty() { if self.bytes.is_empty() {
return Ok(Cow::Borrowed(&[])); return Ok(Cow::Borrowed(&[]));
} }
match self.bytes[0] { match self.bytes[0] {
// Revision data is the entirety of the entry, including this // Revision data is the entirety of the entry, including this
// header. // header.
b'\0' => Ok(Cow::Borrowed(self.bytes)), b'\0' => Ok(Cow::Borrowed(self.bytes)),
// Raw revision data follows. // Raw revision data follows.