( )⚙ D11959 rhg: Rename some revlog-related types and methods

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11959

rhg: Rename some revlog-related types and methods
ClosedPublic

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

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHG20d0d896183e: rhg: Rename some revlog-related types and methods
Summary

Use "data chunck" and "data" for a revlog entry’s data before and after
resolving deltas (if any), repsectively.

The former FilelogEntry actually only contains data, rename it to
FilelogRevisionData accordingly. This leaves room to later have a
FilelogEntry type that wraps RevlogEntry.

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:27 AM
This revision is now accepted and ready to land.Jan 7 2022, 4:27 AM
SimonSapin added a commit: rHG20d0d896183e: rhg: Rename some revlog-related types and methods.Jan 7 2022, 4:52 AM
Closed by commit rHG20d0d896183e: rhg: Rename some revlog-related types and methods (authored by SimonSapin). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 31599

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

files.into_iter().map(|f| f.as_ref()), files.into_iter().map(|f| f.as_ref()),
)?; )?;
for (file_path, file_node) in found { for (file_path, file_node) in found {
found_any = true; found_any = true;
let file_log = repo.filelog(file_path)?; let file_log = repo.filelog(file_path)?;
results.push(( results.push((
file_path, file_path,
file_log.data_for_node(file_node)?.into_data()?, file_log.data_for_node(file_node)?.into_file_data()?,
)); ));
} }
Ok(CatOutput { Ok(CatOutput {
found_any, found_any,
results, results,
missing, missing,
node, node,
}) })
} }

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

let revlog = Revlog::open(repo, "00changelog.i", None)?; let revlog = Revlog::open(repo, "00changelog.i", None)?;
Ok(Self { revlog }) Ok(Self { revlog })
} }
/// Return the `ChangelogEntry` for the given node ID. /// Return the `ChangelogEntry` for the given node ID.
pub fn data_for_node( pub fn data_for_node(
&self, &self,
node: NodePrefix, node: NodePrefix,
) -> Result<ChangelogEntry, RevlogError> { ) -> Result<ChangelogRevisionData, RevlogError> {
let rev = self.revlog.rev_from_node(node)?; let rev = self.revlog.rev_from_node(node)?;
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<ChangelogEntry, RevlogError> { ) -> Result<ChangelogRevisionData, RevlogError> {
let bytes = self.revlog.get_rev_data(rev)?; let bytes = self.revlog.get_rev_data(rev)?;
Ok(ChangelogEntry { 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)
} }
} }
/// `Changelog` entry which knows how to interpret the `changelog` data bytes. /// `Changelog` entry which knows how to interpret the `changelog` data bytes.
#[derive(Debug)] #[derive(Debug)]
pub struct ChangelogEntry { pub struct ChangelogRevisionData {
/// The data bytes of the `changelog` entry. /// The data bytes of the `changelog` entry.
bytes: Vec<u8>, bytes: Vec<u8>,
} }
impl ChangelogEntry { impl ChangelogRevisionData {
/// Return an iterator over the lines of the entry. /// Return an iterator over the lines of the entry.
pub fn lines(&self) -> impl Iterator<Item = &[u8]> { pub fn lines(&self) -> impl Iterator<Item = &[u8]> {
self.bytes self.bytes
.split(|b| b == &b'\n') .split(|b| b == &b'\n')
.filter(|line| !line.is_empty()) .filter(|line| !line.is_empty())
} }
/// Return the node id of the `manifest` referenced by this `changelog` /// Return the node id of the `manifest` referenced by this `changelog`
/// entry. /// entry.
pub fn manifest_node(&self) -> Result<Node, HgError> { pub fn manifest_node(&self) -> Result<Node, HgError> {
match self.lines().next() { match self.lines().next() {
None => Ok(NULL_NODE), None => Ok(NULL_NODE),
Some(x) => Node::from_hex_for_repo(x), Some(x) => Node::from_hex_for_repo(x),
} }
} }
} }

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

Ok(Self { revlog }) Ok(Self { revlog })
} }
/// The given node ID is that of the file as found in a manifest, not of a /// The given node ID is that of the file as found in a manifest, not of a
/// changeset. /// changeset.
pub fn data_for_node( pub fn data_for_node(
&self, &self,
file_node: impl Into<NodePrefix>, file_node: impl Into<NodePrefix>,
) -> Result<FilelogEntry, RevlogError> { ) -> Result<FilelogRevisionData, RevlogError> {
let file_rev = self.revlog.rev_from_node(file_node.into())?; let file_rev = self.revlog.rev_from_node(file_node.into())?;
self.data_for_rev(file_rev) self.data_for_rev(file_rev)
} }
/// 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<FilelogEntry, 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)?;
Ok(FilelogEntry(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()
} }
pub struct FilelogEntry(Vec<u8>); /// The data for one revision in a filelog, uncompressed and delta-resolved.
pub struct FilelogRevisionData(Vec<u8>);
impl FilelogEntry { impl FilelogRevisionData {
/// Split into metadata and data /// Split into metadata and data
pub fn split(&self) -> Result<(Option<&[u8]>, &[u8]), HgError> { pub fn split(&self) -> Result<(Option<&[u8]>, &[u8]), HgError> {
const DELIMITER: &[u8; 2] = &[b'\x01', b'\n']; const DELIMITER: &[u8; 2] = &[b'\x01', b'\n'];
if let Some(rest) = self.0.drop_prefix(DELIMITER) { if let Some(rest) = self.0.drop_prefix(DELIMITER) {
if let Some((metadata, data)) = rest.split_2_by_slice(DELIMITER) { if let Some((metadata, data)) = rest.split_2_by_slice(DELIMITER) {
Ok((Some(metadata), data)) Ok((Some(metadata), data))
} else { } else {
Err(HgError::corrupted( Err(HgError::corrupted(
"Missing metadata end delimiter in filelog entry", "Missing metadata end delimiter in filelog entry",
)) ))
} }
} else { } else {
Ok((None, &self.0)) Ok((None, &self.0))
} }
} }
/// Returns the file contents at this revision, stripped of any metadata /// Returns the file contents at this revision, stripped of any metadata
pub fn data(&self) -> Result<&[u8], HgError> { pub fn file_data(&self) -> Result<&[u8], HgError> {
let (_metadata, data) = self.split()?; let (_metadata, data) = self.split()?;
Ok(data) Ok(data)
} }
/// Consume the entry, and convert it into data, discarding any metadata, /// Consume the entry, and convert it into data, discarding any metadata,
/// if present. /// if present.
pub fn into_data(self) -> Result<Vec<u8>, HgError> { pub fn into_file_data(self) -> Result<Vec<u8>, HgError> {
if let (Some(_metadata), data) = self.split()? { if let (Some(_metadata), data) = self.split()? {
Ok(data.to_owned()) Ok(data.to_owned())
} else { } else {
Ok(self.0) Ok(self.0)
} }
} }
} }

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

// TODO do not look twice in the index // TODO do not look twice in the index
let index_entry = self let index_entry = self
.index .index
.get_entry(rev) .get_entry(rev)
.ok_or(RevlogError::InvalidRevision)?; .ok_or(RevlogError::InvalidRevision)?;
let data: Vec<u8> = if delta_chain.is_empty() { let data: Vec<u8> = if delta_chain.is_empty() {
entry.data()?.into() entry.data_chunk()?.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().as_bytes(), index_entry.hash().as_bytes(),
/// 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],
) -> Result<Vec<u8>, RevlogError> { ) -> Result<Vec<u8>, RevlogError> {
let snapshot = snapshot.data()?; let snapshot = snapshot.data_chunk()?;
let deltas = deltas let deltas = deltas
.iter() .iter()
.rev() .rev()
.map(RevlogEntry::data) .map(RevlogEntry::data_chunk)
.collect::<Result<Vec<Cow<'_, [u8]>>, RevlogError>>()?; .collect::<Result<Vec<Cow<'_, [u8]>>, RevlogError>>()?;
let patches: Vec<_> = let patches: Vec<_> =
deltas.iter().map(|d| patch::PatchList::new(d)).collect(); deltas.iter().map(|d| patch::PatchList::new(d)).collect();
let patch = patch::fold_patch_lists(&patches); let patch = patch::fold_patch_lists(&patches);
Ok(patch.apply(&snapshot)) Ok(patch.apply(&snapshot))
} }
/// Return the revlog data. /// Return the revlog data.
} }
impl<'a> RevlogEntry<'a> { impl<'a> RevlogEntry<'a> {
pub fn revision(&self) -> Revision { pub fn revision(&self) -> Revision {
self.rev self.rev
} }
/// Extract the data contained in the entry. /// Extract the data contained in the entry.
pub fn data(&self) -> Result<Cow<'_, [u8]>, RevlogError> { /// This may be a delta. (See `is_delta`.)
fn data_chunk(&self) -> Result<Cow<'_, [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.

rust/rhg/src/commands/status.rs

// contents where possible. This is only valid if the revlog data does not // contents where possible. This is only valid if the revlog data does not
// contain metadata. See how Python’s `revlog.rawsize` calls // contain metadata. See how Python’s `revlog.rawsize` calls
// `storageutil.filerevisioncopied`. // `storageutil.filerevisioncopied`.
// (Maybe also check for content-modifying flags? See `revlog.size`.) // (Maybe also check for content-modifying flags? See `revlog.size`.)
let filelog_entry = let filelog_entry =
filelog.data_for_node(entry.node_id()?).map_err(|_| { filelog.data_for_node(entry.node_id()?).map_err(|_| {
HgError::corrupted("filelog missing node from manifest") HgError::corrupted("filelog missing node from manifest")
})?; })?;
let contents_in_p1 = filelog_entry.data()?; let contents_in_p1 = filelog_entry.file_data()?;
if contents_in_p1.len() as u64 != fs_len { if contents_in_p1.len() as u64 != fs_len {
// No need to read the file contents: // No need to read the file contents:
// it cannot be equal if it has a different length. // it cannot be equal if it has a different length.
return Ok(true); return Ok(true);
} }
let fs_contents = if is_symlink { let fs_contents = if is_symlink {
get_bytes_from_os_string(vfs.read_link(fs_path)?.into_os_string()) get_bytes_from_os_string(vfs.read_link(fs_path)?.into_os_string())
} else { } else {
vfs.read(fs_path)? vfs.read(fs_path)?
}; };
Ok(contents_in_p1 != &*fs_contents) Ok(contents_in_p1 != &*fs_contents)
} }