This is an archive of the discontinued Mercurial Phabricator instance.

Differential D10783

revlog: no longer return sidedata from `_revisiondata`
ClosedPublic

Authored by marmoute on May 28 2021, 6:56 PM.

Details

Reviewers
indygreg
Alphare
Group Reviewers
hg-reviewers
Commits
rHG9d9eb22b9b69: revlog: no longer return sidedata from `_revisiondata`
Summary

All users have been migrated.

When they was introduced sidedata where grouped with the actual revision data
and unpacking one came with the other. Sidedata moved be stored "independently"
and it no longer make sense to retrieve both at the same time unconditionnaly.

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

marmoute created this revision.May 28 2021, 6:56 PM
Alphare accepted this revision as: Alphare.May 31 2021, 6:20 AM
baymax updated this revision to Diff 28296.May 31 2021, 6:37 AM

✅ refresh by Heptapod after a successful CI run (🐙 💚)

baymax updated this revision to Diff 28393.Jun 1 2021, 11:10 PM

✅ refresh by Heptapod after a successful CI run (🐙 💚)

baymax updated this revision to Diff 28442.Jun 4 2021, 9:54 AM

✅ refresh by Heptapod after a successful CI run (🐙 💚)

marmoute added a commit: rHG9d9eb22b9b69: revlog: no longer return sidedata from `_revisiondata`.Jun 7 2021, 5:22 AM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHG9d9eb22b9b69: revlog: no longer return sidedata from `_revisiondata` (authored by marmoute). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 28486

mercurial/changelog.py

- list of files - list of files
- commit message as a localstr - commit message as a localstr
- dict of extra metadata - dict of extra metadata
Unless you need to access all fields, consider calling Unless you need to access all fields, consider calling
``changelogrevision`` instead, as it is faster for partial object ``changelogrevision`` instead, as it is faster for partial object
access. access.
""" """
d = self._revisiondata(nodeorrev)[0] d = self._revisiondata(nodeorrev)
sidedata = self.sidedata(nodeorrev) sidedata = self.sidedata(nodeorrev)
copy_sd = self._copiesstorage == b'changeset-sidedata' copy_sd = self._copiesstorage == b'changeset-sidedata'
c = changelogrevision(self, d, sidedata, copy_sd) c = changelogrevision(self, d, sidedata, copy_sd)
return (c.manifest, c.user, c.date, c.files, c.description, c.extra) return (c.manifest, c.user, c.date, c.files, c.description, c.extra)
def changelogrevision(self, nodeorrev): def changelogrevision(self, nodeorrev):
"""Obtain a ``changelogrevision`` for a node or revision.""" """Obtain a ``changelogrevision`` for a node or revision."""
text = self._revisiondata(nodeorrev)[0] text = self._revisiondata(nodeorrev)
sidedata = self.sidedata(nodeorrev) sidedata = self.sidedata(nodeorrev)
return changelogrevision( return changelogrevision(
self, text, sidedata, self._copiesstorage == b'changeset-sidedata' self, text, sidedata, self._copiesstorage == b'changeset-sidedata'
) )
def readfiles(self, nodeorrev): def readfiles(self, nodeorrev):
""" """
short version of read that only returns the files modified by the cset short version of read that only returns the files modified by the cset

mercurial/revlog.py

to True when generating changegroups or in debug commands. to True when generating changegroups or in debug commands.
""" """
if raw: if raw:
msg = ( msg = (
b'revlog.revision(..., raw=True) is deprecated, ' b'revlog.revision(..., raw=True) is deprecated, '
b'use revlog.rawdata(...)' b'use revlog.rawdata(...)'
) )
util.nouideprecwarn(msg, b'5.2', stacklevel=2) util.nouideprecwarn(msg, b'5.2', stacklevel=2)
return self._revisiondata(nodeorrev, _df, raw=raw)[0] return self._revisiondata(nodeorrev, _df, raw=raw)
def sidedata(self, nodeorrev, _df=None): def sidedata(self, nodeorrev, _df=None):
"""a map of extra data related to the changeset but not part of the hash """a map of extra data related to the changeset but not part of the hash
This function currently return a dictionary. However, more advanced This function currently return a dictionary. However, more advanced
mapping object will likely be used in the future for a more mapping object will likely be used in the future for a more
efficient/lazy code. efficient/lazy code.
""" """
rev = nodeorrev rev = nodeorrev
node = self.node(rev) node = self.node(rev)
else: else:
node = nodeorrev node = nodeorrev
rev = None rev = None
# fast path the special `nullid` rev # fast path the special `nullid` rev
if node == self.nullid: if node == self.nullid:
return b"", {} return b""
# ``rawtext`` is the text as stored inside the revlog. Might be the # ``rawtext`` is the text as stored inside the revlog. Might be the
# revision or might need to be processed to retrieve the revision. # revision or might need to be processed to retrieve the revision.
rev, rawtext, validated = self._rawtext(node, rev, _df=_df) rev, rawtext, validated = self._rawtext(node, rev, _df=_df)
if self.hassidedata:
if rev is None:
rev = self.rev(node)
sidedata = self._sidedata(rev)
else:
sidedata = {}
if raw and validated: if raw and validated:
# if we don't want to process the raw text and that raw # if we don't want to process the raw text and that raw
# text is cached, we can exit early. # text is cached, we can exit early.
return rawtext, sidedata return rawtext
if rev is None: if rev is None:
rev = self.rev(node) rev = self.rev(node)
# the revlog's flag for this revision # the revlog's flag for this revision
# (usually alter its state or content) # (usually alter its state or content)
flags = self.flags(rev) flags = self.flags(rev)
if validated and flags == REVIDX_DEFAULT_FLAGS: if validated and flags == REVIDX_DEFAULT_FLAGS:
# no extra flags set, no flag processor runs, text = rawtext # no extra flags set, no flag processor runs, text = rawtext
return rawtext, sidedata return rawtext
if raw: if raw:
validatehash = flagutil.processflagsraw(self, rawtext, flags) validatehash = flagutil.processflagsraw(self, rawtext, flags)
text = rawtext text = rawtext
else: else:
r = flagutil.processflagsread(self, rawtext, flags) r = flagutil.processflagsread(self, rawtext, flags)
text, validatehash = r text, validatehash = r
if validatehash: if validatehash:
self.checkhash(text, node, rev=rev) self.checkhash(text, node, rev=rev)
if not validated: if not validated:
self._revisioncache = (node, rev, rawtext) self._revisioncache = (node, rev, rawtext)
return text, sidedata return text
def _rawtext(self, node, rev, _df=None): def _rawtext(self, node, rev, _df=None):
"""return the possibly unvalidated rawtext for a revision """return the possibly unvalidated rawtext for a revision
returns (rev, rawtext, validated) returns (rev, rawtext, validated)
""" """
# revision in the cache (could be useful to apply delta) # revision in the cache (could be useful to apply delta)
sidedata = sidedatautil.deserialize_sidedata(segment) sidedata = sidedatautil.deserialize_sidedata(segment)
return sidedata return sidedata
def rawdata(self, nodeorrev, _df=None): def rawdata(self, nodeorrev, _df=None):
"""return an uncompressed raw data of a given node or revision number. """return an uncompressed raw data of a given node or revision number.
_df - an existing file handle to read from. (internal-only) _df - an existing file handle to read from. (internal-only)
""" """
return self._revisiondata(nodeorrev, _df, raw=True)[0] return self._revisiondata(nodeorrev, _df, raw=True)
def hash(self, text, p1, p2): def hash(self, text, p1, p2):
"""Compute a node hash. """Compute a node hash.
Available as a function so that subclasses can replace the hash Available as a function so that subclasses can replace the hash
as needed. as needed.
""" """
return storageutil.hashrevisionsha1(text, p1, p2) return storageutil.hashrevisionsha1(text, p1, p2)
p2 = index[entry[6]][7] p2 = index[entry[6]][7]
node = entry[7] node = entry[7]
# (Possibly) reuse the delta from the revlog if allowed and # (Possibly) reuse the delta from the revlog if allowed and
# the revlog chunk is a delta. # the revlog chunk is a delta.
cachedelta = None cachedelta = None
rawtext = None rawtext = None
if deltareuse == self.DELTAREUSEFULLADD: if deltareuse == self.DELTAREUSEFULLADD:
text = self._revisiondata(rev)[0] text = self._revisiondata(rev)
sidedata = self.sidedata(rev) sidedata = self.sidedata(rev)
if sidedata_helpers is not None: if sidedata_helpers is not None:
(sidedata, new_flags) = sidedatautil.run_sidedata_helpers( (sidedata, new_flags) = sidedatautil.run_sidedata_helpers(
self, sidedata_helpers, sidedata, rev self, sidedata_helpers, sidedata, rev
) )
flags = flags | new_flags[0] & ~new_flags[1] flags = flags | new_flags[0] & ~new_flags[1]
else: else:
if destrevlog._lazydelta: if destrevlog._lazydelta:
dp = self.deltaparent(rev) dp = self.deltaparent(rev)
if dp != nullrev: if dp != nullrev:
cachedelta = (dp, bytes(self._chunk(rev))) cachedelta = (dp, bytes(self._chunk(rev)))
sidedata = None sidedata = None
if not cachedelta: if not cachedelta:
rawtext = self._revisiondata(rev)[0] rawtext = self._revisiondata(rev)
sidedata = self.sidedata(rev) sidedata = self.sidedata(rev)
if sidedata is None: if sidedata is None:
sidedata = self.sidedata(rev) sidedata = self.sidedata(rev)
if sidedata_helpers is not None: if sidedata_helpers is not None:
(sidedata, new_flags) = sidedatautil.run_sidedata_helpers( (sidedata, new_flags) = sidedatautil.run_sidedata_helpers(
self, sidedata_helpers, sidedata, rev self, sidedata_helpers, sidedata, rev
) )

tests/testlib/ext-sidedata.py

sd[sidedata.SD_TEST1] = struct.pack('>I', len(text)) sd[sidedata.SD_TEST1] = struct.pack('>I', len(text))
# and sha2 hashes # and sha2 hashes
sha256 = hashlib.sha256(text).digest() sha256 = hashlib.sha256(text).digest()
sd[sidedata.SD_TEST2] = struct.pack('>32s', sha256) sd[sidedata.SD_TEST2] = struct.pack('>32s', sha256)
return orig(self, text, transaction, link, p1, p2, *args, **kwargs) return orig(self, text, transaction, link, p1, p2, *args, **kwargs)
def wrap_revisiondata(orig, self, nodeorrev, *args, **kwargs): def wrap_revisiondata(orig, self, nodeorrev, *args, **kwargs):
text, sd = orig(self, nodeorrev, *args, **kwargs) text = orig(self, nodeorrev, *args, **kwargs)
sd = self.sidedata(nodeorrev)
if getattr(self, 'sidedatanocheck', False): if getattr(self, 'sidedatanocheck', False):
return text, sd return text
if self.hassidedata: if self.hassidedata:
return text, sd return text
if nodeorrev != nullrev and nodeorrev != self.nullid: if nodeorrev != nullrev and nodeorrev != self.nullid:
cat1 = sd.get(sidedata.SD_TEST1) cat1 = sd.get(sidedata.SD_TEST1)
if cat1 is not None and len(text) != struct.unpack('>I', cat1)[0]: if cat1 is not None and len(text) != struct.unpack('>I', cat1)[0]:
raise RuntimeError('text size mismatch') raise RuntimeError('text size mismatch')
expected = sd.get(sidedata.SD_TEST2) expected = sd.get(sidedata.SD_TEST2)
got = hashlib.sha256(text).digest() got = hashlib.sha256(text).digest()
if expected is not None and got != expected: if expected is not None and got != expected:
raise RuntimeError('sha256 mismatch') raise RuntimeError('sha256 mismatch')
return text, sd return text
def wrapget_sidedata_helpers(orig, srcrepo, dstrepo): def wrapget_sidedata_helpers(orig, srcrepo, dstrepo):
repo, computers, removers = orig(srcrepo, dstrepo) repo, computers, removers = orig(srcrepo, dstrepo)
assert not computers and not removers # deal with composition later assert not computers and not removers # deal with composition later
addedreqs = dstrepo.requirements - srcrepo.requirements addedreqs = dstrepo.requirements - srcrepo.requirements
if requirements.REVLOGV2_REQUIREMENT in addedreqs: if requirements.REVLOGV2_REQUIREMENT in addedreqs: