This is an archive of the discontinued Mercurial Phabricator instance.

Differential D6941

revlog: add a way to control sidedata changes during revlog.clone
ClosedPublic

Authored by marmoute on Oct 1 2019, 12:07 PM.

Details

Reviewers
indygreg
Group Reviewers
hg-reviewers
Commits
rHG3de4d13f22be: revlog: add a way to control sidedata changes during revlog.clone
Summary

We introduce a new argument to pass a callable dealing with the side data logic.
Since the side data are usually associated to higher level logic, the revlog
code itself is unlikely to know that to do itself. As a result the higher level
upgrade code will be responsible to decide what needs to changes. The lower
level revlog.clone just get simple instructions to apply.

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.Oct 1 2019, 12:07 PM
marmoute updated this revision to Diff 16772.Oct 2 2019, 12:08 AM
marmoute updated this revision to Diff 16945.Oct 7 2019, 8:36 PM
marmoute added a commit: rHG3de4d13f22be: revlog: add a way to control sidedata changes during revlog.clone.Oct 9 2019, 12:46 PM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHG3de4d13f22be: revlog: add a way to control sidedata changes during revlog.clone (authored by marmoute). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mmercurial/revlog.py (47 lines)

Diff 16995

mercurial/revlog.py

def clone( def clone(
self, self,
tr, tr,
destrevlog, destrevlog,
addrevisioncb=None, addrevisioncb=None,
deltareuse=DELTAREUSESAMEREVS, deltareuse=DELTAREUSESAMEREVS,
forcedeltabothparents=None, forcedeltabothparents=None,
sidedatacompanion=None,
): ):
"""Copy this revlog to another, possibly with format changes. """Copy this revlog to another, possibly with format changes.
The destination revlog will contain the same revisions and nodes. The destination revlog will contain the same revisions and nodes.
However, it may not be bit-for-bit identical due to e.g. delta encoding However, it may not be bit-for-bit identical due to e.g. delta encoding
differences. differences.
The ``deltareuse`` argument control how deltas from the existing revlog The ``deltareuse`` argument control how deltas from the existing revlog
delta could choose a better revision, it will do so. This means if you delta could choose a better revision, it will do so. This means if you
are converting a non-generaldelta revlog to a generaldelta revlog, are converting a non-generaldelta revlog to a generaldelta revlog,
deltas will be recomputed if the delta's parent isn't a parent of the deltas will be recomputed if the delta's parent isn't a parent of the
revision. revision.
In addition to the delta policy, the ``forcedeltabothparents`` In addition to the delta policy, the ``forcedeltabothparents``
argument controls whether to force compute deltas against both parents argument controls whether to force compute deltas against both parents
for merges. By default, the current default is used. for merges. By default, the current default is used.
If not None, the `sidedatacompanion` is callable that accept two
arguments:
(srcrevlog, rev)
and return a triplet that control changes to sidedata content from the
old revision to the new clone result:
(dropall, filterout, update)
* if `dropall` is True, all sidedata should be dropped
* `filterout` is a set of sidedata keys that should be dropped
* `update` is a mapping of additionnal/new key -> value
""" """
if deltareuse not in self.DELTAREUSEALL: if deltareuse not in self.DELTAREUSEALL:
raise ValueError( raise ValueError(
_(b'value for deltareuse invalid: %s') % deltareuse _(b'value for deltareuse invalid: %s') % deltareuse
) )
if len(destrevlog): if len(destrevlog):
raise ValueError(_(b'destination revlog is not empty')) raise ValueError(_(b'destination revlog is not empty'))
destrevlog._lazydelta = True destrevlog._lazydelta = True
elif deltareuse == self.DELTAREUSENEVER: elif deltareuse == self.DELTAREUSENEVER:
destrevlog._lazydeltabase = False destrevlog._lazydeltabase = False
destrevlog._lazydelta = False destrevlog._lazydelta = False
destrevlog._deltabothparents = forcedeltabothparents or oldamd destrevlog._deltabothparents = forcedeltabothparents or oldamd
self._clone( self._clone(
tr, destrevlog, addrevisioncb, deltareuse, forcedeltabothparents tr,
destrevlog,
addrevisioncb,
deltareuse,
forcedeltabothparents,
sidedatacompanion,
) )
finally: finally:
destrevlog._lazydelta = oldlazydelta destrevlog._lazydelta = oldlazydelta
destrevlog._lazydeltabase = oldlazydeltabase destrevlog._lazydeltabase = oldlazydeltabase
destrevlog._deltabothparents = oldamd destrevlog._deltabothparents = oldamd
def _clone( def _clone(
self, tr, destrevlog, addrevisioncb, deltareuse, forcedeltabothparents self,
tr,
destrevlog,
addrevisioncb,
deltareuse,
forcedeltabothparents,
sidedatacompanion,
): ):
"""perform the core duty of `revlog.clone` after parameter processing""" """perform the core duty of `revlog.clone` after parameter processing"""
deltacomputer = deltautil.deltacomputer(destrevlog) deltacomputer = deltautil.deltacomputer(destrevlog)
index = self.index index = self.index
for rev in self: for rev in self:
entry = index[rev] entry = index[rev]
# Some classes override linkrev to take filtered revs into # Some classes override linkrev to take filtered revs into
# account. Use raw entry from index. # account. Use raw entry from index.
flags = entry[0] & 0xFFFF flags = entry[0] & 0xFFFF
linkrev = entry[4] linkrev = entry[4]
p1 = index[entry[5]][7] p1 = index[entry[5]][7]
p2 = index[entry[6]][7] p2 = index[entry[6]][7]
node = entry[7] node = entry[7]
sidedataactions = (False, [], {})
if sidedatacompanion is not None:
sidedataactions = sidedatacompanion(self, rev)
# (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 any(sidedataactions) or deltareuse == self.DELTAREUSEFULLADD:
text = self.revision(rev) dropall, filterout, update = sidedataactions
text, sidedata = self._revisiondata(rev)
if dropall:
sidedata = {}
for key in filterout:
sidedata.pop(key, None)
sidedata.update(update)
if not sidedata:
sidedata = None
destrevlog.addrevision( destrevlog.addrevision(
text, text,
tr, tr,
linkrev, linkrev,
p1, p1,
p2, p2,
cachedelta=cachedelta, cachedelta=cachedelta,
node=node, node=node,
flags=flags, flags=flags,
deltacomputer=deltacomputer, deltacomputer=deltacomputer,
sidedata=sidedata,
) )
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)))
if not cachedelta: if not cachedelta: