( )⚙ D4205 changegroup: pass all state into group()

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D4205

changegroup: pass all state into group()
ClosedPublic

Authored by indygreg on Aug 9 2018, 4:52 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHG8c84f1ef949e: changegroup: pass all state into group()
Summary

This will allow us to split it into a standalone function.

Diff Detail

Repository
rHG Mercurial
Lint
Lint Skipped
Unit
Unit Tests Skipped

Revision Contents
Changeset List

PathPackages
Mmercurial/changegroup.py (62 lines)

Diff 10199

mercurial/changegroup.py

self._repo = repo self._repo = repo
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
def group(self, revs, store, ischangelog, lookup, units=None, def group(self, repo, revs, store, ischangelog, lookup, deltaparentfn,
clrevtolocalrev=None): deltaheaderfn, units=None,
ellipses=False, clrevtolocalrev=None, fullclnodes=None,
precomputedellipsis=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
metadata corresponding to nodes. The first delta is metadata corresponding to nodes. The first delta is
first parent(nodelist[0]) -> nodelist[0], the receiver is first parent(nodelist[0]) -> nodelist[0], the receiver is
guaranteed to have this parent as it has all history before guaranteed to have this parent as it has all history before
these changesets. In the case firstparent is nullrev the these changesets. In the case firstparent is nullrev the
changegroup starts with a full revision. changegroup starts with a full revision.
If units is not None, progress detail will be generated, units specifies If units is not None, progress detail will be generated, units specifies
the type of revlog that is touched (changelog, manifest, etc.). the type of revlog that is touched (changelog, manifest, etc.).
""" """
# if we don't have any revisions touched by these changesets, bail # if we don't have any revisions touched by these changesets, bail
if len(revs) == 0: if len(revs) == 0:
yield closechunk() yield closechunk()
return return
cl = self._repo.changelog cl = repo.changelog
# add the parent of the first rev # add the parent of the first rev
p = store.parentrevs(revs[0])[0] p = store.parentrevs(revs[0])[0]
revs.insert(0, p) revs.insert(0, p)
# build deltas # build deltas
progress = None progress = None
if units is not None: if units is not None:
progress = self._repo.ui.makeprogress(_('bundling'), unit=units, progress = repo.ui.makeprogress(_('bundling'), unit=units,
total=(len(revs) - 1)) total=(len(revs) - 1))
for r in pycompat.xrange(len(revs) - 1): for r in pycompat.xrange(len(revs) - 1):
if progress: if progress:
progress.update(r + 1) progress.update(r + 1)
prev, curr = revs[r], revs[r + 1] prev, curr = revs[r], revs[r + 1]
linknode = lookup(store.node(curr)) linknode = lookup(store.node(curr))
if self._ellipses: if ellipses:
linkrev = cl.rev(linknode) linkrev = cl.rev(linknode)
clrevtolocalrev[linkrev] = curr clrevtolocalrev[linkrev] = curr
# This is a node to send in full, because the changeset it # This is a node to send in full, because the changeset it
# corresponds to was a full changeset. # corresponds to was a full changeset.
if linknode in self._fullclnodes: if linknode in fullclnodes:
delta = _revisiondeltanormal(store, curr, prev, linknode, delta = _revisiondeltanormal(store, curr, prev, linknode,
self._deltaparentfn) deltaparentfn)
elif linkrev not in self._precomputedellipsis: elif linkrev not in precomputedellipsis:
delta = None delta = None
else: else:
delta = _revisiondeltanarrow( delta = _revisiondeltanarrow(
cl, store, ischangelog, curr, linkrev, linknode, cl, store, ischangelog, curr, linkrev, linknode,
clrevtolocalrev, self._fullclnodes, clrevtolocalrev, fullclnodes,
self._precomputedellipsis) precomputedellipsis)
else: else:
delta = _revisiondeltanormal(store, curr, prev, linknode, delta = _revisiondeltanormal(store, curr, prev, linknode,
self._deltaparentfn) deltaparentfn)
if not delta: if not delta:
continue continue
meta = self._builddeltaheader(delta) meta = deltaheaderfn(delta)
l = len(meta) + sum(len(x) for x in delta.deltachunks) l = len(meta) + sum(len(x) for x in delta.deltachunks)
yield chunkheader(l) yield chunkheader(l)
yield meta yield meta
for x in delta.deltachunks: for x in delta.deltachunks:
yield x yield x
if progress: if progress:
progress.complete() progress.complete()
state = { state = {
'clrevorder': clrevorder, 'clrevorder': clrevorder,
'mfs': mfs, 'mfs': mfs,
'changedfiles': changedfiles, 'changedfiles': changedfiles,
'clrevtomanifestrev': clrevtomanifestrev, 'clrevtomanifestrev': clrevtomanifestrev,
} }
gen = self.group(revs, cl, True, lookupcl, units=_('changesets'), gen = self.group(self._repo, revs, cl, True, lookupcl,
clrevtolocalrev={}) self._deltaparentfn, self._builddeltaheader,
ellipses=self._ellipses,
units=_('changesets'),
clrevtolocalrev={},
fullclnodes=self._fullclnodes,
precomputedellipsis=self._precomputedellipsis)
return state, gen return state, gen
def generatemanifests(self, commonrevs, clrevorder, fastpathlinkrev, mfs, def generatemanifests(self, commonrevs, clrevorder, fastpathlinkrev, mfs,
fnodes, source, clrevtolocalrev): fnodes, source, clrevtolocalrev):
"""Returns an iterator of changegroup chunks containing manifests. """Returns an iterator of changegroup chunks containing manifests.
`source` is unused here, but is used by extensions like remotefilelog to `source` is unused here, but is used by extensions like remotefilelog to
self._reorder) self._reorder)
if dir: if dir:
assert self.version == b'03' assert self.version == b'03'
chunk = _fileheader(dir) chunk = _fileheader(dir)
size += len(chunk) size += len(chunk)
yield chunk yield chunk
for chunk in self.group(revs, store, False, lookupfn, it = self.group(
self._repo, revs, store, False, lookupfn,
self._deltaparentfn, self._builddeltaheader,
ellipses=self._ellipses,
units=_('manifests'), units=_('manifests'),
clrevtolocalrev=clrevtolocalrev): clrevtolocalrev=clrevtolocalrev,
fullclnodes=self._fullclnodes,
precomputedellipsis=self._precomputedellipsis)
for chunk in it:
size += len(chunk) size += len(chunk)
yield chunk yield chunk
self._verbosenote(_('%8.i (manifests)\n') % size) self._verbosenote(_('%8.i (manifests)\n') % size)
yield self._manifestsend yield self._manifestsend
# The 'source' parameter is useful for extensions # The 'source' parameter is useful for extensions
def generatefiles(self, changedfiles, commonrevs, source, def generatefiles(self, changedfiles, commonrevs, source,
else: else:
revs = _sortnodesnormal(filerevlog, filenodes, revs = _sortnodesnormal(filerevlog, filenodes,
self._reorder) self._reorder)
progress.update(i + 1, item=fname) progress.update(i + 1, item=fname)
h = _fileheader(fname) h = _fileheader(fname)
size = len(h) size = len(h)
yield h yield h
for chunk in self.group(revs, filerevlog, False, lookupfilelog,
clrevtolocalrev=clrevtolocalrev): it = self.group(
self._repo, revs, filerevlog, False, lookupfilelog,
self._deltaparentfn, self._builddeltaheader,
ellipses=self._ellipses,
clrevtolocalrev=clrevtolocalrev,
fullclnodes=self._fullclnodes,
precomputedellipsis=self._precomputedellipsis)
for chunk in it:
size += len(chunk) size += len(chunk)
yield chunk yield chunk
self._verbosenote(_('%8.i %s\n') % (size, fname)) self._verbosenote(_('%8.i %s\n') % (size, fname))
progress.complete() progress.complete()
def _deltaparentprev(store, rev, p1, p2, prev): def _deltaparentprev(store, rev, p1, p2, prev):
"""Resolve a delta parent to the previous revision. """Resolve a delta parent to the previous revision.