( )⚙ D11252 debugupgraderepo: add fix-metaencoding-flag pass for issue6528

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11252

debugupgraderepo: add fix-metaencoding-flag pass for issue6528
Needs RevisionPublic

Authored by joerg.sonnenberger on Aug 4 2021, 9:37 AM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers

Diff Detail

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

Event Timeline

marmoute added a subscriber: marmoute.Aug 4 2021, 2:22 PM

This is similar to D11239, having this done during upgrade too seems useful, but having a simpler/more-focussed command for this seems important (and "on-fly-fix" during exchange too.

Ideally we would take D11239 first and reuse its bulding block for that diff afterward.

Alphare added a subscriber: Alphare.Aug 24 2021, 12:05 PM

@joerg.sonnenberger The rewrite utils have been committed in 5.9, this can be rebased and refactored to reuse the same logic.

Alphare requested changes to this revision.Oct 18 2021, 8:05 AM
This revision now requires changes to proceed.Oct 18 2021, 8:05 AM

Revision Contents
Changeset List

Diff 29789

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, sidedatacompanion=None,
recheckmetaencoding=False,
): ):
"""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
self._clone( self._clone(
tr, tr,
destrevlog, destrevlog,
addrevisioncb, addrevisioncb,
deltareuse, deltareuse,
forcedeltabothparents, forcedeltabothparents,
sidedatacompanion, sidedatacompanion,
recheckmetaencoding,
) )
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, self,
tr, tr,
destrevlog, destrevlog,
addrevisioncb, addrevisioncb,
deltareuse, deltareuse,
forcedeltabothparents, forcedeltabothparents,
sidedatacompanion, sidedatacompanion,
recheckmetaencoding,
): ):
"""perform the core duty of `revlog.clone` after parameter processing""" """perform the core duty of `revlog.clone` after parameter processing"""
def ismetaencoded(text, flags):
return text.startswith(b'\x01\n') and (
flags & REVIDX_ISCENSORED == 0
)
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, [], {}, 0, 0) sidedataactions = (False, [], {}, 0, 0)
if sidedatacompanion is not None: if sidedatacompanion is not None:
sidedataactions = sidedatacompanion(self, rev) 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 any(sidedataactions) or deltareuse == self.DELTAREUSEFULLADD: if (
any(sidedataactions)
or deltareuse == self.DELTAREUSEFULLADD
or recheckmetaencoding
):
dropall = sidedataactions[0] dropall = sidedataactions[0]
filterout = sidedataactions[1] filterout = sidedataactions[1]
update = sidedataactions[2] update = sidedataactions[2]
new_flags = sidedataactions[3] new_flags = sidedataactions[3]
dropped_flags = sidedataactions[4] dropped_flags = sidedataactions[4]
text, sidedata = self._revisiondata(rev) text, sidedata = self._revisiondata(rev)
if dropall: if dropall:
sidedata = {} sidedata = {}
for key in filterout: for key in filterout:
sidedata.pop(key, None) sidedata.pop(key, None)
sidedata.update(update) sidedata.update(update)
if not sidedata: if not sidedata:
sidedata = None sidedata = None
if (
recheckmetaencoding
and ismetaencoded(text, flags)
and p1 != self.nullid
and p2 == self.nullid
):
p1, p2 = p2, p1
flags |= new_flags flags |= new_flags
flags &= ~dropped_flags flags &= ~dropped_flags
destrevlog.addrevision( destrevlog.addrevision(
text, text,
tr, tr,
linkrev, linkrev,

mercurial/upgrade_utils/actions.py

b'each revision will be added as new content to the ' b'each revision will be added as new content to the '
b'internal storage; this will likely drastically slow ' b'internal storage; this will likely drastically slow '
b'down execution time, but some extensions might need ' b'down execution time, but some extensions might need '
b'it' b'it'
), ),
) )
) )
register_optimization(
improvement(
name=b'fix-metaencoding-flag',
type=OPTIMISATION,
description=_(
b'filelog entries with copy metadata may have been flagged '
b'incorrectly in Mercurial 5.8. This option will look for such '
b'revisions and fix them.'
),
upgrademessage=_(
b'revision content will be recomputed; this will likely drastically '
b'slow down execution time'
),
)
)
def findoptimizations(repo): def findoptimizations(repo):
"""Determine optimisation that could be used during upgrade""" """Determine optimisation that could be used during upgrade"""
# These are unconditionally added. There is logic later that figures out # These are unconditionally added. There is logic later that figures out
# which ones to apply. # which ones to apply.
return list(ALL_OPTIMISATIONS) return list(ALL_OPTIMISATIONS)
self.delta_reuse_mode = revlog.revlog.DELTAREUSENEVER self.delta_reuse_mode = revlog.revlog.DELTAREUSENEVER
elif b're-delta-parent' in self._upgrade_actions_names: elif b're-delta-parent' in self._upgrade_actions_names:
self.delta_reuse_mode = revlog.revlog.DELTAREUSESAMEREVS self.delta_reuse_mode = revlog.revlog.DELTAREUSESAMEREVS
elif b're-delta-multibase' in self._upgrade_actions_names: elif b're-delta-multibase' in self._upgrade_actions_names:
self.delta_reuse_mode = revlog.revlog.DELTAREUSESAMEREVS self.delta_reuse_mode = revlog.revlog.DELTAREUSESAMEREVS
elif b're-delta-fulladd' in self._upgrade_actions_names: elif b're-delta-fulladd' in self._upgrade_actions_names:
self.delta_reuse_mode = revlog.revlog.DELTAREUSEFULLADD self.delta_reuse_mode = revlog.revlog.DELTAREUSEFULLADD
# should this operation search for misordered parents of copy filelog entries
self.recheckmetaencoding = (
b'fix-metaencoding-flag' in self._upgrade_actions_names
)
# should this operation force re-delta of both parents # should this operation force re-delta of both parents
self.force_re_delta_both_parents = ( self.force_re_delta_both_parents = (
b're-delta-multibase' in self._upgrade_actions_names b're-delta-multibase' in self._upgrade_actions_names
) )
# should this operation create a backup of the store # should this operation create a backup of the store
self.backup_store = backup_store self.backup_store = backup_store

mercurial/upgrade_utils/engine.py

rl_type, rl_type,
unencoded, unencoded,
upgrade_op, upgrade_op,
sidedatacompanion, sidedatacompanion,
oncopiedrevision, oncopiedrevision,
): ):
"""returns the new revlog object created""" """returns the new revlog object created"""
newrl = None newrl = None
recheckmetaencoding = (
upgrade_op.recheckmetaencoding
and (rl_type & store.FILEFLAGS_FILELOG) != 0
)
if matchrevlog(upgrade_op.revlogs_to_process, rl_type): if matchrevlog(upgrade_op.revlogs_to_process, rl_type):
ui.note( ui.note(
_(b'cloning %d revisions from %s\n') % (len(old_revlog), unencoded) _(b'cloning %d revisions from %s\n') % (len(old_revlog), unencoded)
) )
newrl = _revlogfrompath(dstrepo, rl_type, unencoded) newrl = _revlogfrompath(dstrepo, rl_type, unencoded)
old_revlog.clone( old_revlog.clone(
tr, tr,
newrl, newrl,
addrevisioncb=oncopiedrevision, addrevisioncb=oncopiedrevision,
deltareuse=upgrade_op.delta_reuse_mode, deltareuse=upgrade_op.delta_reuse_mode,
forcedeltabothparents=upgrade_op.force_re_delta_both_parents, forcedeltabothparents=upgrade_op.force_re_delta_both_parents,
sidedatacompanion=sidedatacompanion, sidedatacompanion=sidedatacompanion,
recheckmetaencoding=recheckmetaencoding,
) )
else: else:
msg = _(b'blindly copying %s containing %i revisions\n') msg = _(b'blindly copying %s containing %i revisions\n')
ui.note(msg % (unencoded, len(old_revlog))) ui.note(msg % (unencoded, len(old_revlog)))
_copyrevlog(tr, dstrepo, old_revlog, rl_type, unencoded) _copyrevlog(tr, dstrepo, old_revlog, rl_type, unencoded)
newrl = _revlogfrompath(dstrepo, rl_type, unencoded) newrl = _revlogfrompath(dstrepo, rl_type, unencoded)
return newrl return newrl