This is an archive of the discontinued Mercurial Phabricator instance.

Differential D4085

changegroup: make some packer attributes private
ClosedPublic

Authored by indygreg on Aug 3 2018, 5:04 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHG68e490ed640e: changegroup: make some packer attributes private
Summary

These methods and attributes are low level and should not be
called or outside outside of instances. Indicate as such through
naming.

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

indygreg created this revision.Aug 3 2018, 5:04 PM
Closed by commit rHG68e490ed640e: changegroup: make some packer attributes private (authored by indygreg). · Explain WhyAug 6 2018, 2:57 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mmercurial/changegroup.py (110 lines)

Diff 9961

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 close(self): def _close(self):
# Ellipses serving mode. # Ellipses serving mode.
getattr(self, 'clrev_to_localrev', {}).clear() getattr(self, '_clrev_to_localrev', {}).clear()
if getattr(self, 'next_clrev_to_localrev', {}): if getattr(self, '_next_clrev_to_localrev', {}):
self.clrev_to_localrev = self.next_clrev_to_localrev self._clrev_to_localrev = self._next_clrev_to_localrev
del self.next_clrev_to_localrev del self._next_clrev_to_localrev
self.changelog_done = True self._changelog_done = True
return closechunk() return closechunk()
def fileheader(self, fname): def _fileheader(self, fname):
return chunkheader(len(fname)) + fname return chunkheader(len(fname)) + fname
# Extracted both for clarity and for overriding in extensions. # Extracted both for clarity and for overriding in extensions.
def _sortgroup(self, store, nodelist, lookup): def _sortgroup(self, store, nodelist, lookup):
"""Sort nodes for change group and turn them into revnums.""" """Sort nodes for change group and turn them into revnums."""
# Ellipses serving mode. # Ellipses serving mode.
# #
# In a perfect world, we'd generate better ellipsis-ified graphs # In a perfect world, we'd generate better ellipsis-ified graphs
# for non-changelog revlogs. In practice, we haven't started doing # for non-changelog revlogs. In practice, we haven't started doing
# that yet, so the resulting DAGs for the manifestlog and filelogs # that yet, so the resulting DAGs for the manifestlog and filelogs
# are actually full of bogus parentage on all the ellipsis # are actually full of bogus parentage on all the ellipsis
# nodes. This has the side effect that, while the contents are # nodes. This has the side effect that, while the contents are
# correct, the individual DAGs might be completely out of whack in # correct, the individual DAGs might be completely out of whack in
# a case like 882681bc3166 and its ancestors (back about 10 # a case like 882681bc3166 and its ancestors (back about 10
# revisions or so) in the main hg repo. # revisions or so) in the main hg repo.
# #
# The one invariant we *know* holds is that the new (potentially # The one invariant we *know* holds is that the new (potentially
# bogus) DAG shape will be valid if we order the nodes in the # bogus) DAG shape will be valid if we order the nodes in the
# order that they're introduced in dramatis personae by the # order that they're introduced in dramatis personae by the
# changelog, so what we do is we sort the non-changelog histories # changelog, so what we do is we sort the non-changelog histories
# by the order in which they are used by the changelog. # by the order in which they are used by the changelog.
if util.safehasattr(self, 'full_nodes') and self.clnode_to_rev: if util.safehasattr(self, '_full_nodes') and self._clnode_to_rev:
key = lambda n: self.clnode_to_rev[lookup(n)] key = lambda n: self._clnode_to_rev[lookup(n)]
return [store.rev(n) for n in sorted(nodelist, key=key)] return [store.rev(n) for n in sorted(nodelist, key=key)]
# for generaldelta revlogs, we linearize the revs; this will both be # for generaldelta revlogs, we linearize the revs; this will both be
# much quicker and generate a much smaller bundle # much quicker and generate a much smaller bundle
if (store._generaldelta and self._reorder is None) or self._reorder: if (store._generaldelta and self._reorder is None) or self._reorder:
dag = dagutil.revlogdag(store) dag = dagutil.revlogdag(store)
return dag.linearize(set(store.rev(n) for n in nodelist)) return dag.linearize(set(store.rev(n) for n in nodelist))
else: else:
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(nodelist) == 0: if len(nodelist) == 0:
yield self.close() yield self._close()
return return
revs = self._sortgroup(store, nodelist, lookup) revs = self._sortgroup(store, nodelist, lookup)
# 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 = self._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))
for c in self.revchunk(store, curr, prev, linknode): for c in self._revchunk(store, curr, prev, linknode):
yield c yield c
if progress: if progress:
progress.complete() progress.complete()
yield self.close() yield self._close()
# filter any nodes that claim to be part of the known set # filter any nodes that claim to be part of the known set
def prune(self, store, missing, commonrevs): def _prune(self, store, missing, commonrevs):
# TODO this violates storage abstraction for manifests. # TODO this violates storage abstraction for manifests.
if isinstance(store, manifest.manifestrevlog): if isinstance(store, manifest.manifestrevlog):
if not self._filematcher.visitdir(store._dir[:-1] or '.'): if not self._filematcher.visitdir(store._dir[:-1] or '.'):
return [] return []
rr, rl = store.rev, store.linkrev rr, rl = store.rev, store.linkrev
return [n for n in missing if rl(rr(n)) not in commonrevs] return [n for n in missing if rl(rr(n)) not in commonrevs]
def _packmanifests(self, dir, mfnodes, lookuplinknode): def _packmanifests(self, dir, mfnodes, lookuplinknode):
"""Pack flat manifests into a changegroup stream.""" """Pack flat manifests into a changegroup stream."""
assert not dir assert not dir
for chunk in self.group(mfnodes, self._repo.manifestlog._revlog, for chunk in self.group(mfnodes, self._repo.manifestlog._revlog,
lookuplinknode, units=_('manifests')): lookuplinknode, units=_('manifests')):
yield chunk yield chunk
def _packtreemanifests(self, dir, mfnodes, lookuplinknode): def _packtreemanifests(self, dir, mfnodes, lookuplinknode):
"""Version of _packmanifests that operates on directory manifests. """Version of _packmanifests that operates on directory manifests.
Encodes the directory name in the output so multiple manifests Encodes the directory name in the output so multiple manifests
can be sent. can be sent.
""" """
assert self.version == b'03' assert self.version == b'03'
if dir: if dir:
yield self.fileheader(dir) yield self._fileheader(dir)
# TODO violates storage abstractions by assuming revlogs. # TODO violates storage abstractions by assuming revlogs.
dirlog = self._repo.manifestlog._revlog.dirlog(dir) dirlog = self._repo.manifestlog._revlog.dirlog(dir)
for chunk in self.group(mfnodes, dirlog, lookuplinknode, for chunk in self.group(mfnodes, dirlog, lookuplinknode,
units=_('manifests')): units=_('manifests')):
yield chunk yield chunk
def generate(self, commonrevs, clnodes, fastpathlinkrev, source): def generate(self, commonrevs, clnodes, fastpathlinkrev, source):
'''yield a sequence of changegroup chunks (strings)''' '''yield a sequence of changegroup chunks (strings)'''
repo = self._repo repo = self._repo
cl = repo.changelog cl = repo.changelog
clrevorder = {} clrevorder = {}
mfs = {} # needed manifests mfs = {} # needed manifests
fnodes = {} # needed file nodes fnodes = {} # needed file nodes
mfl = repo.manifestlog mfl = repo.manifestlog
# TODO violates storage abstraction. # TODO violates storage abstraction.
mfrevlog = mfl._revlog mfrevlog = mfl._revlog
changedfiles = set() changedfiles = set()
ellipsesmode = util.safehasattr(self, 'full_nodes') ellipsesmode = util.safehasattr(self, '_full_nodes')
# 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 ellipsesmode: if ellipsesmode:
# 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.full_nodes if (x in self._full_nodes
or cl.rev(x) in self.precomputed_ellipsis): or cl.rev(x) in self._precomputed_ellipsis):
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.next_clrev_to_localrev.setdefault(cl.rev(x), self._next_clrev_to_localrev.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.is_shallow: if self._is_shallow:
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:
n = c[0] n = c[0]
# record the first changeset introducing this manifest version # record the first changeset introducing this manifest version
mfs.setdefault(n, x) mfs.setdefault(n, x)
'treemanifest' not in repo.requirements) 'treemanifest' not in repo.requirements)
for chunk in self.generatemanifests(commonrevs, clrevorder, for chunk in self.generatemanifests(commonrevs, clrevorder,
fastpathlinkrev, mfs, fnodes, source): fastpathlinkrev, mfs, fnodes, source):
yield chunk yield chunk
if ellipsesmode: if ellipsesmode:
mfdicts = None mfdicts = None
if self.is_shallow: if self._is_shallow:
mfdicts = [(self._repo.manifestlog[n].read(), lr) mfdicts = [(self._repo.manifestlog[n].read(), lr)
for (n, lr) in mfs.iteritems()] for (n, lr) in mfs.iteritems()]
mfs.clear() mfs.clear()
clrevs = set(cl.rev(x) for x in clnodes) clrevs = set(cl.rev(x) for x in clnodes)
if not fastpathlinkrev: if not fastpathlinkrev:
def linknodes(unused, fname): def linknodes(unused, fname):
# signature. Instead, we pass the data to ourselves using an # signature. Instead, we pass the data to ourselves using an
# instance attribute. I'm sorry. # instance attribute. I'm sorry.
self._mfdicts = mfdicts self._mfdicts = mfdicts
for chunk in self.generatefiles(changedfiles, linknodes, commonrevs, for chunk in self.generatefiles(changedfiles, linknodes, commonrevs,
source): source):
yield chunk yield chunk
yield self.close() yield self._close()
if clnodes: if clnodes:
repo.hook('outgoing', node=hex(clnodes[0]), source=source) repo.hook('outgoing', node=hex(clnodes[0]), source=source)
def generatemanifests(self, commonrevs, clrevorder, fastpathlinkrev, mfs, def generatemanifests(self, commonrevs, clrevorder, fastpathlinkrev, mfs,
fnodes, source): fnodes, source):
"""Returns an iterator of changegroup chunks containing manifests. """Returns an iterator of changegroup chunks containing manifests.
return clnode return clnode
return lookupmflinknode return lookupmflinknode
fn = (self._packtreemanifests if self._sendtreemanifests fn = (self._packtreemanifests if self._sendtreemanifests
else self._packmanifests) else self._packmanifests)
size = 0 size = 0
while tmfnodes: while tmfnodes:
dir, nodes = tmfnodes.popitem() dir, nodes = tmfnodes.popitem()
prunednodes = self.prune(dirlog(dir), nodes, commonrevs) prunednodes = self._prune(dirlog(dir), nodes, commonrevs)
if not dir or prunednodes: if not dir or prunednodes:
for x in fn(dir, prunednodes, makelookupmflinknode(dir, nodes)): for x in fn(dir, prunednodes, makelookupmflinknode(dir, nodes)):
size += len(x) size += len(x)
yield x yield x
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, linknodes, commonrevs, source): def generatefiles(self, changedfiles, linknodes, commonrevs, source):
changedfiles = list(filter(self._filematcher, changedfiles)) changedfiles = list(filter(self._filematcher, changedfiles))
if getattr(self, 'is_shallow', False): if getattr(self, '_is_shallow', False):
# See comment in generate() for why this sadness is a thing. # See comment in generate() for why this sadness is a thing.
mfdicts = self._mfdicts mfdicts = self._mfdicts
del self._mfdicts del self._mfdicts
# In a shallow clone, the linknodes callback needs to also include # In a shallow clone, the linknodes callback needs to also include
# those file nodes that are in the manifests we sent but weren't # those file nodes that are in the manifests we sent but weren't
# introduced by those manifests. # introduced by those manifests.
commonctxs = [self._repo[c] for c in commonrevs] commonctxs = [self._repo[c] for c in commonrevs]
oldlinknodes = linknodes oldlinknodes = linknodes
clrev = self._repo.changelog.rev clrev = self._repo.changelog.rev
# Defining this function has a side-effect of overriding the # Defining this function has a side-effect of overriding the
# function of the same name that was passed in as an argument. # function of the same name that was passed in as an argument.
# TODO have caller pass in appropriate function. # TODO have caller pass in appropriate function.
def linknodes(flog, fname): def linknodes(flog, fname):
for c in commonctxs: for c in commonctxs:
try: try:
fnode = c.filenode(fname) fnode = c.filenode(fname)
self.clrev_to_localrev[c.rev()] = flog.rev(fnode) self._clrev_to_localrev[c.rev()] = flog.rev(fnode)
except error.ManifestLookupError: except error.ManifestLookupError:
pass pass
links = oldlinknodes(flog, fname) links = oldlinknodes(flog, fname)
if len(links) != len(mfdicts): if len(links) != len(mfdicts):
for mf, lr in mfdicts: for mf, lr in mfdicts:
fnode = mf.get(fname, None) fnode = mf.get(fname, None)
if fnode in links: if fnode in links:
links[fnode] = min(links[fnode], lr, key=clrev) links[fnode] = min(links[fnode], lr, key=clrev)
fname) fname)
linkrevnodes = linknodes(filerevlog, fname) linkrevnodes = linknodes(filerevlog, fname)
# Lookup for filenodes, we collected the linkrev nodes above in the # Lookup for filenodes, we collected the linkrev nodes above in the
# fastpath case and with lookupmf in the slowpath case. # fastpath case and with lookupmf in the slowpath case.
def lookupfilelog(x): def lookupfilelog(x):
return linkrevnodes[x] return linkrevnodes[x]
filenodes = self.prune(filerevlog, linkrevnodes, commonrevs) filenodes = self._prune(filerevlog, linkrevnodes, commonrevs)
if filenodes: if filenodes:
progress.update(i + 1, item=fname) progress.update(i + 1, item=fname)
h = self.fileheader(fname) h = self._fileheader(fname)
size = len(h) size = len(h)
yield h yield h
for chunk in self.group(filenodes, filerevlog, lookupfilelog): for chunk in self.group(filenodes, filerevlog, lookupfilelog):
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 deltaparent(self, store, rev, p1, p2, prev): def _deltaparent(self, store, rev, p1, p2, prev):
if self._useprevdelta: if self._useprevdelta:
if not store.candelta(prev, rev): if not store.candelta(prev, rev):
raise error.ProgrammingError( raise error.ProgrammingError(
'cg1 should not be used in this case') 'cg1 should not be used in this case')
return prev return prev
# Narrow ellipses mode. # Narrow ellipses mode.
if util.safehasattr(self, 'full_nodes'): if util.safehasattr(self, '_full_nodes'):
# TODO: send better deltas when in narrow mode. # TODO: send better deltas when in narrow mode.
# #
# changegroup.group() loops over revisions to send, # changegroup.group() loops over revisions to send,
# including revisions we'll skip. What this means is that # including revisions we'll skip. What this means is that
# `prev` will be a potentially useless delta base for all # `prev` will be a potentially useless delta base for all
# ellipsis nodes, as the client likely won't have it. In # ellipsis nodes, as the client likely won't have it. In
# the future we should do bookkeeping about which nodes # the future we should do bookkeeping about which nodes
# have been sent to the client, and try to be # have been sent to the client, and try to be
else: else:
base = dp base = dp
if base != nullrev and not store.candelta(base, rev): if base != nullrev and not store.candelta(base, rev):
base = nullrev base = nullrev
return base return base
def revchunk(self, store, rev, prev, linknode): def _revchunk(self, store, rev, prev, linknode):
if util.safehasattr(self, 'full_nodes'): if util.safehasattr(self, '_full_nodes'):
fn = self._revisiondeltanarrow fn = self._revisiondeltanarrow
else: else:
fn = self._revisiondeltanormal fn = self._revisiondeltanormal
delta = fn(store, rev, prev, linknode) delta = fn(store, rev, prev, linknode)
if not delta: if not delta:
return return
meta = self._builddeltaheader(delta) meta = self._builddeltaheader(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
def _revisiondeltanormal(self, store, rev, prev, linknode): def _revisiondeltanormal(self, store, rev, prev, linknode):
node = store.node(rev) node = store.node(rev)
p1, p2 = store.parentrevs(rev) p1, p2 = store.parentrevs(rev)
base = self.deltaparent(store, rev, p1, p2, prev) base = self._deltaparent(store, rev, p1, p2, prev)
prefix = '' prefix = ''
if store.iscensored(base) or store.iscensored(rev): if store.iscensored(base) or store.iscensored(rev):
try: try:
delta = store.revision(node, raw=True) delta = store.revision(node, raw=True)
except error.CensoredNodeError as e: except error.CensoredNodeError as e:
delta = e.tombstone delta = e.tombstone
if base == nullrev: if base == nullrev:
linknode=linknode, linknode=linknode,
flags=store.flags(rev), flags=store.flags(rev),
deltachunks=(prefix, delta), deltachunks=(prefix, delta),
) )
def _revisiondeltanarrow(self, store, rev, prev, linknode): def _revisiondeltanarrow(self, store, rev, prev, linknode):
# build up some mapping information that's useful later. See # build up some mapping information that's useful later. See
# the local() nested function below. # the local() nested function below.
if not self.changelog_done: if not self._changelog_done:
self.clnode_to_rev[linknode] = rev self._clnode_to_rev[linknode] = rev
linkrev = rev linkrev = rev
self.clrev_to_localrev[linkrev] = rev self._clrev_to_localrev[linkrev] = rev
else: else:
linkrev = self.clnode_to_rev[linknode] linkrev = self._clnode_to_rev[linknode]
self.clrev_to_localrev[linkrev] = rev self._clrev_to_localrev[linkrev] = rev
# 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.full_nodes: if linknode in self._full_nodes:
return self._revisiondeltanormal(store, rev, prev, linknode) return self._revisiondeltanormal(store, rev, prev, linknode)
# At this point, a node can either be one we should skip or an # At this point, a node can either be one we should skip or an
# ellipsis. If it's not an ellipsis, bail immediately. # ellipsis. If it's not an ellipsis, bail immediately.
if linkrev not in self.precomputed_ellipsis: if linkrev not in self._precomputed_ellipsis:
return return
linkparents = self.precomputed_ellipsis[linkrev] linkparents = self._precomputed_ellipsis[linkrev]
def local(clrev): def local(clrev):
"""Turn a changelog revnum into a local revnum. """Turn a changelog revnum into a local revnum.
The ellipsis dag is stored as revnums on the changelog, The ellipsis dag is stored as revnums on the changelog,
but when we're producing ellipsis entries for but when we're producing ellipsis entries for
non-changelog revlogs, we need to turn those numbers into non-changelog revlogs, we need to turn those numbers into
something local. This does that for us, and during the something local. This does that for us, and during the
changelog sending phase will also expand the stored changelog sending phase will also expand the stored
mappings as needed. mappings as needed.
""" """
if clrev == nullrev: if clrev == nullrev:
return nullrev return nullrev
if not self.changelog_done: if not self._changelog_done:
# If we're doing the changelog, it's possible that we # If we're doing the changelog, it's possible that we
# have a parent that is already on the client, and we # have a parent that is already on the client, and we
# need to store some extra mapping information so that # need to store some extra mapping information so that
# our contained ellipsis nodes will be able to resolve # our contained ellipsis nodes will be able to resolve
# their parents. # their parents.
if clrev not in self.clrev_to_localrev: if clrev not in self._clrev_to_localrev:
clnode = store.node(clrev) clnode = store.node(clrev)
self.clnode_to_rev[clnode] = clrev self._clnode_to_rev[clnode] = clrev
return clrev return clrev
# Walk the ellipsis-ized changelog breadth-first looking for a # Walk the ellipsis-ized changelog breadth-first looking for a
# change that has been linked from the current revlog. # change that has been linked from the current revlog.
# #
# For a flat manifest revlog only a single step should be necessary # For a flat manifest revlog only a single step should be necessary
# as all relevant changelog entries are relevant to the flat # as all relevant changelog entries are relevant to the flat
# manifest. # manifest.
# #
# For a filelog or tree manifest dirlog however not every changelog # For a filelog or tree manifest dirlog however not every changelog
# entry will have been relevant, so we need to skip some changelog # entry will have been relevant, so we need to skip some changelog
# nodes even after ellipsis-izing. # nodes even after ellipsis-izing.
walk = [clrev] walk = [clrev]
while walk: while walk:
p = walk[0] p = walk[0]
walk = walk[1:] walk = walk[1:]
if p in self.clrev_to_localrev: if p in self._clrev_to_localrev:
return self.clrev_to_localrev[p] return self._clrev_to_localrev[p]
elif p in self.full_nodes: elif p in self._full_nodes:
walk.extend([pp for pp in self._repo.changelog.parentrevs(p) walk.extend([pp for pp in self._repo.changelog.parentrevs(p)
if pp != nullrev]) if pp != nullrev])
elif p in self.precomputed_ellipsis: elif p in self._precomputed_ellipsis:
walk.extend([pp for pp in self.precomputed_ellipsis[p] walk.extend([pp for pp in self._precomputed_ellipsis[p]
if pp != nullrev]) if pp != nullrev])
else: else:
# In this case, we've got an ellipsis with parents # In this case, we've got an ellipsis with parents
# outside the current bundle (likely an # outside the current bundle (likely an
# incremental pull). We "know" that we can use the # incremental pull). We "know" that we can use the
# value of this same revlog at whatever revision # value of this same revlog at whatever revision
# is pointed to by linknode. "Know" is in scare # is pointed to by linknode. "Know" is in scare
# quotes because I haven't done enough examination # quotes because I haven't done enough examination
# set, we know we have an ellipsis node and we should defer # set, we know we have an ellipsis node and we should defer
# sending that node's data. We override close() to detect # sending that node's data. We override close() to detect
# pending ellipsis nodes and flush them. # pending ellipsis nodes and flush them.
packer = getbundler(version, repo, filematcher=match) packer = getbundler(version, repo, filematcher=match)
# Give the packer the list of nodes which should not be # Give the packer the list of nodes which should not be
# ellipsis nodes. We store this rather than the set of nodes # ellipsis nodes. We store this rather than the set of nodes
# that should be an ellipsis because for very large histories # that should be an ellipsis because for very large histories
# we expect this to be significantly smaller. # we expect this to be significantly smaller.
packer.full_nodes = relevant_nodes packer._full_nodes = relevant_nodes
# Maps ellipsis revs to their roots at the changelog level. # Maps ellipsis revs to their roots at the changelog level.
packer.precomputed_ellipsis = ellipsisroots packer._precomputed_ellipsis = ellipsisroots
# 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.
packer.clrev_to_localrev = {} packer._clrev_to_localrev = {}
packer.next_clrev_to_localrev = {} packer._next_clrev_to_localrev = {}
# Maps changelog nodes to changelog revs. Filled in once # Maps changelog nodes to changelog revs. Filled in once
# during changelog stage and then left unmodified. # during changelog stage and then left unmodified.
packer.clnode_to_rev = {} packer._clnode_to_rev = {}
packer.changelog_done = False packer._changelog_done = False
# If true, informs the packer that it is serving shallow content and might # If true, informs the packer that it is serving shallow content and might
# need to pack file contents not introduced by the changes being packed. # need to pack file contents not introduced by the changes being packed.
packer.is_shallow = depth is not None packer._is_shallow = depth is not None
return packer.generate(common, visitnodes, False, source) return packer.generate(common, visitnodes, False, source)