( )⚙ D4190 changegroup: track changelog to manifest revision map explicitly

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D4190

changegroup: track changelog to manifest revision map explicitly
ClosedPublic

Authored by indygreg on Aug 9 2018, 2:51 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHG40374b4a780f: changegroup: track changelog to manifest revision map explicitly
Summary

Previously, self._nextclrevtolocalrev was only populated as part
of the changelog lookup callback. But cgpacker._close() was looking
at self._nextclrevtolocalrev on every invocation.

Since self._nextclrevtolocalrev is for communicating the mapping
of changelog revisions to manifest revisions, this commit refactors
the code to make that explicit.

The changelog state now stores this mapping. And after the changelog
group is emitted, we update self._clrevtolocalrev with that dict.
self._nextclrevtolocalrev is unused and has been deleted.

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.

Revision Contents
Changeset List

PathPackages
Mmercurial/changegroup.py (12 lines)

Diff 10179

mercurial/changegroup.py

if self._repo.ui.verbose and not self._repo.ui.debugflag: if self._repo.ui.verbose and not self._repo.ui.debugflag:
self._verbosenote = self._repo.ui.note self._verbosenote = self._repo.ui.note
else: else:
self._verbosenote = lambda s: None self._verbosenote = lambda s: None
# Maps CL revs to per-revlog revisions. Cleared in close() at # Maps CL revs to per-revlog revisions. Cleared in close() at
# the end of each group. # the end of each group.
self._clrevtolocalrev = {} self._clrevtolocalrev = {}
self._nextclrevtolocalrev = {}
def _close(self): def _close(self):
# Ellipses serving mode. # Ellipses serving mode.
self._clrevtolocalrev.clear() self._clrevtolocalrev.clear()
if self._nextclrevtolocalrev is not None:
self._clrevtolocalrev = self._nextclrevtolocalrev
self._nextclrevtolocalrev = None
return closechunk() return closechunk()
def group(self, revs, store, ischangelog, lookup, units=None): def group(self, revs, store, ischangelog, lookup, units=None):
"""Calculate a delta group, yielding a sequence of changegroup chunks """Calculate a delta group, yielding a sequence of changegroup chunks
(strings). (strings).
Given a list of changeset revs, return a set of deltas and Given a list of changeset revs, return a set of deltas and
yield chunk yield chunk
self._verbosenote(_('%8.i (changelog)\n') % size) self._verbosenote(_('%8.i (changelog)\n') % size)
clrevorder = clstate['clrevorder'] clrevorder = clstate['clrevorder']
mfs = clstate['mfs'] mfs = clstate['mfs']
changedfiles = clstate['changedfiles'] changedfiles = clstate['changedfiles']
if self._ellipses:
self._clrevtolocalrev = clstate['clrevtomanifestrev']
# We need to make sure that the linkrev in the changegroup refers to # We need to make sure that the linkrev in the changegroup refers to
# the first changeset that introduced the manifest or file revision. # the first changeset that introduced the manifest or file revision.
# The fastpath is usually safer than the slowpath, because the filelogs # The fastpath is usually safer than the slowpath, because the filelogs
# are walked in revlog order. # are walked in revlog order.
# #
# When taking the slowpath with reorder=None and the manifest revlog # When taking the slowpath with reorder=None and the manifest revlog
# uses generaldelta, the manifest may be walked in the "wrong" order. # uses generaldelta, the manifest may be walked in the "wrong" order.
# Without 'clrevorder', we would get an incorrect linkrev (see fix in # Without 'clrevorder', we would get an incorrect linkrev (see fix in
chunk stream has been fully consumed. chunk stream has been fully consumed.
""" """
clrevorder = {} clrevorder = {}
mfs = {} # needed manifests mfs = {} # needed manifests
mfl = self._repo.manifestlog mfl = self._repo.manifestlog
# TODO violates storage abstraction. # TODO violates storage abstraction.
mfrevlog = mfl._revlog mfrevlog = mfl._revlog
changedfiles = set() changedfiles = set()
clrevtomanifestrev = {}
# Callback for the changelog, used to collect changed files and # Callback for the changelog, used to collect changed files and
# manifest nodes. # manifest nodes.
# Returns the linkrev node (identity in the changelog case). # Returns the linkrev node (identity in the changelog case).
def lookupcl(x): def lookupcl(x):
c = cl.read(x) c = cl.read(x)
clrevorder[x] = len(clrevorder) clrevorder[x] = len(clrevorder)
if self._ellipses: if self._ellipses:
# Only update mfs if x is going to be sent. Otherwise we # Only update mfs if x is going to be sent. Otherwise we
# end up with bogus linkrevs specified for manifests and # end up with bogus linkrevs specified for manifests and
# we skip some manifest nodes that we should otherwise # we skip some manifest nodes that we should otherwise
# have sent. # have sent.
if (x in self._fullclnodes if (x in self._fullclnodes
or cl.rev(x) in self._precomputedellipsis): or cl.rev(x) in self._precomputedellipsis):
n = c[0] n = c[0]
# Record the first changeset introducing this manifest # Record the first changeset introducing this manifest
# version. # version.
mfs.setdefault(n, x) mfs.setdefault(n, x)
# Set this narrow-specific dict so we have the lowest # Set this narrow-specific dict so we have the lowest
# manifest revnum to look up for this cl revnum. (Part of # manifest revnum to look up for this cl revnum. (Part of
# mapping changelog ellipsis parents to manifest ellipsis # mapping changelog ellipsis parents to manifest ellipsis
# parents) # parents)
self._nextclrevtolocalrev.setdefault(cl.rev(x), clrevtomanifestrev.setdefault(cl.rev(x), mfrevlog.rev(n))
mfrevlog.rev(n))
# We can't trust the changed files list in the changeset if the # We can't trust the changed files list in the changeset if the
# client requested a shallow clone. # client requested a shallow clone.
if self._isshallow: if self._isshallow:
changedfiles.update(mfl[c[0]].read().keys()) changedfiles.update(mfl[c[0]].read().keys())
else: else:
changedfiles.update(c[3]) changedfiles.update(c[3])
else: else:
# Changelog doesn't benefit from reordering revisions. So send out # Changelog doesn't benefit from reordering revisions. So send out
# revisions in store order. # revisions in store order.
revs = sorted(cl.rev(n) for n in nodes) revs = sorted(cl.rev(n) for n in nodes)
state = { state = {
'clrevorder': clrevorder, 'clrevorder': clrevorder,
'mfs': mfs, 'mfs': mfs,
'changedfiles': changedfiles, 'changedfiles': changedfiles,
'clrevtomanifestrev': clrevtomanifestrev,
} }
gen = self.group(revs, cl, True, lookupcl, units=_('changesets')) gen = self.group(revs, cl, True, lookupcl, units=_('changesets'))
return state, gen return state, gen
def generatemanifests(self, commonrevs, clrevorder, fastpathlinkrev, mfs, def generatemanifests(self, commonrevs, clrevorder, fastpathlinkrev, mfs,
fnodes, source): fnodes, source):