mercurial-scm/hg: comparison mercurial/changegroup.py

equal deleted inserted replaced

-:57875cf423c9
+:2372284d9457
 phases,
 pycompat,
 util,
 )
-from .interfaces import (
+from .interfaces import repository
-repository,
-)
 _CHANGEGROUPV1_DELTA_HEADER = struct.Struct("20s20s20s20s")
 _CHANGEGROUPV2_DELTA_HEADER = struct.Struct("20s20s20s20s20s")
 _CHANGEGROUPV3_DELTA_HEADER = struct.Struct(">20s20s20s20s20sH")
 LFS_REQUIREMENT = 'lfs'
 readexactly = util.readexactly
 def getchunk(stream):
 """return the next chunk from stream as a string"""
 d = readexactly(stream, 4)
 l = struct.unpack(">l", d)[0]
 if l:
 raise error.Abort(_("invalid chunk length %d") % l)
 return ""
 return readexactly(stream, l - 4)
 def chunkheader(length):
 """return a changegroup chunk header (string)"""
 return struct.pack(">l", length + 4)
 def closechunk():
 """return a changegroup chunk header (string) for a zero-length chunk"""
 return struct.pack(">l", 0)
 def _fileheader(path):
 """Obtain a changegroup chunk header for a named path."""
 return chunkheader(len(path)) + path
 def writechunks(ui, chunks, filename, vfs=None):
 """Write chunks to a file and return its filename.
 The stream is assumed to be a bundle file.
 if filename and vfs:
 vfs.unlink(cleanup)
 else:
 os.unlink(cleanup)
 class cg1unpacker(object):
 """Unpacker for cg1 changegroup streams.
 A changegroup unpacker handles the framing of the revision data in
 the wire format. Most consumers will want to use the apply()
 consumers should prefer apply() instead.
 A few other public methods exist. Those are used only for
 bundlerepo and some debug commands - their use is discouraged.
 """
 deltaheader = _CHANGEGROUPV1_DELTA_HEADER
 deltaheadersize = deltaheader.size
 version = '01'
-_grouplistcount = 1 # One list of files after the manifests
+_grouplistcount = 1  # One list of files after the manifests
 def __init__(self, fh, alg, extras=None):
 if alg is None:
 alg = 'UN'
 if alg not in util.compengines.supportedbundletypes:
-raise error.Abort(_('unknown stream compression type: %s')
+raise error.Abort(_('unknown stream compression type: %s') % alg)
-% alg)
 if alg == 'BZ':
 alg = '_truncatedBZ'
 compengine = util.compengines.forbundletype(alg)
 self._stream = compengine.decompressorreader(fh)
 # These methods (compressed, read, seek, tell) all appear to only
 # be used by bundlerepo, but it's a little hard to tell.
 def compressed(self):
 return self._type is not None and self._type != 'UN'
 def read(self, l):
 return self._stream.read(l)
 def seek(self, pos):
 return self._stream.seek(pos)
 def tell(self):
 return self._stream.tell()
 def close(self):
 return self._stream.close()
 def _chunklength(self):
 d = readexactly(self._stream, 4)
 break
 noentries = False
 yield chunkheader(len(chunk))
 pos = 0
 while pos < len(chunk):
-next = pos + 2**20
+next = pos + 2 ** 20
 yield chunk[pos:next]
 pos = next
 yield closechunk()
 def _unpackmanifests(self, repo, revmap, trp, prog):
 deltas = self.deltaiter()
 repo.manifestlog.getstorage(b'').addgroup(deltas, revmap, trp)
 prog.complete()
 self.callback = None
-def apply(self, repo, tr, srctype, url, targetphase=phases.draft,
+def apply(
-expectedtotal=None):
+self,
+repo,
+tr,
+srctype,
+url,
+targetphase=phases.draft,
+expectedtotal=None,
+):
 """Add the changegroup returned by source.read() to this repo.
 srctype is a string like 'push', 'pull', or 'unbundle'.  url is
 the URL of the repo where this changegroup is coming from.
 Return an integer summarizing the change to this repo:
 - more heads than before: 1+added heads (2..n)
 - fewer heads than before: -1-removed heads (-2..-n)
 - number of heads stays the same: 1
 """
 repo = repo.unfiltered()
 def csmap(x):
 repo.ui.debug("add changeset %s\n" % short(x))
 return len(cl)
 def revmap(x):
 # case we use the top level data. We overwrite the argument
 # because we need to use the top level value (if they exist)
 # in this function.
 srctype = tr.hookargs.setdefault('source', srctype)
 tr.hookargs.setdefault('url', url)
-repo.hook('prechangegroup',
+repo.hook(
-throw=True, **pycompat.strkwargs(tr.hookargs))
+'prechangegroup', throw=True, **pycompat.strkwargs(tr.hookargs)
+)
 # write changelog data to temp files so concurrent readers
 # will not see an inconsistent view
 cl = repo.changelog
 cl.delayupdate(tr)
 trp = weakref.proxy(tr)
 # pull off the changeset group
 repo.ui.status(_("adding changesets\n"))
 clstart = len(cl)
-progress = repo.ui.makeprogress(_('changesets'), unit=_('chunks'),
+progress = repo.ui.makeprogress(
-total=expectedtotal)
+_('changesets'), unit=_('chunks'), total=expectedtotal
+)
 self.callback = progress.increment
 efiles = set()
 def onchangelog(cl, node):
 efiles.update(cl.readfiles(node))
 self.changelogheader()
 deltas = self.deltaiter()
 cgnodes = cl.addgroup(deltas, csmap, trp, addrevisioncb=onchangelog)
 efiles = len(efiles)
 if not cgnodes:
-repo.ui.develwarn('applied empty changelog from changegroup',
+repo.ui.develwarn(
-config='warn-empty-changegroup')
+'applied empty changelog from changegroup',
+config='warn-empty-changegroup',
+)
 clend = len(cl)
 changesets = clend - clstart
 progress.complete()
 self.callback = None
 # pull off the manifest group
 repo.ui.status(_("adding manifests\n"))
 # We know that we'll never have more manifests than we had
 # changesets.
-progress = repo.ui.makeprogress(_('manifests'), unit=_('chunks'),
+progress = repo.ui.makeprogress(
-total=changesets)
+_('manifests'), unit=_('chunks'), total=changesets
+)
 self._unpackmanifests(repo, revmap, trp, progress)
 needfiles = {}
 if repo.ui.configbool('server', 'validate'):
 cl = repo.changelog
 needfiles.setdefault(f, set()).add(n)
 # process the files
 repo.ui.status(_("adding file changes\n"))
 newrevs, newfiles = _addchangegroupfiles(
-repo, self, revmap, trp, efiles, needfiles)
+repo, self, revmap, trp, efiles, needfiles
+)
 # making sure the value exists
 tr.changes.setdefault('changegroup-count-changesets', 0)
 tr.changes.setdefault('changegroup-count-revisions', 0)
 tr.changes.setdefault('changegroup-count-files', 0)
 hookargs = dict(tr.hookargs)
 else:
 hookargs = dict(tr.hookargs)
 hookargs['node'] = hex(cl.node(clstart))
 hookargs['node_last'] = hex(cl.node(clend - 1))
-repo.hook('pretxnchangegroup',
+repo.hook(
-throw=True, **pycompat.strkwargs(hookargs))
+'pretxnchangegroup',
+throw=True,
+**pycompat.strkwargs(hookargs)
+)
 added = [cl.node(r) for r in pycompat.xrange(clstart, clend)]
 phaseall = None
 if srctype in ('push', 'serve'):
 # Old servers can not push the boundary themselves.
 args = hookargs.copy()
 args['node'] = hex(n)
 del args['node_last']
 repo.hook("incoming", **pycompat.strkwargs(args))
-newheads = [h for h in repo.heads()
+newheads = [h for h in repo.heads() if h not in oldheads]
-if h not in oldheads]
+repo.ui.log(
-repo.ui.log("incoming",
+"incoming",
 "%d incoming changes - new heads: %s\n",
 len(added),
-', '.join([hex(c[:6]) for c in newheads]))
+', '.join([hex(c[:6]) for c in newheads]),
+)
-tr.addpostclose('changegroup-runhooks-%020i' % clstart,
-lambda tr: repo._afterlock(runhooks))
+tr.addpostclose(
+'changegroup-runhooks-%020i' % clstart,
+lambda tr: repo._afterlock(runhooks),
+)
 finally:
 repo.ui.flush()
 # never return 0 here:
 if deltaheads < 0:
 ret = deltaheads - 1
 for chunkdata in iter(lambda: self.deltachunk(chain), {}):
 # Chunkdata: (node, p1, p2, cs, deltabase, delta, flags)
 yield chunkdata
 chain = chunkdata[0]
 class cg2unpacker(cg1unpacker):
 """Unpacker for cg2 streams.
 cg2 streams add support for generaldelta, so the delta header
 format is slightly different. All other features about the data
 remain the same.
 """
 deltaheader = _CHANGEGROUPV2_DELTA_HEADER
 deltaheadersize = deltaheader.size
 version = '02'
 def _deltaheader(self, headertuple, prevnode):
 node, p1, p2, deltabase, cs = headertuple
 flags = 0
 return node, p1, p2, deltabase, cs, flags
 class cg3unpacker(cg2unpacker):
 """Unpacker for cg3 streams.
 cg3 streams add support for exchanging treemanifests and revlog
 flags. It adds the revlog flags to the delta header and an empty chunk
 separating manifests and files.
 """
 deltaheader = _CHANGEGROUPV3_DELTA_HEADER
 deltaheadersize = deltaheader.size
 version = '03'
-_grouplistcount = 2 # One list of manifests and one list of files
+_grouplistcount = 2  # One list of manifests and one list of files
 def _deltaheader(self, headertuple, prevnode):
 node, p1, p2, deltabase, cs, flags = headertuple
 return node, p1, p2, deltabase, cs, flags
 repo.ui.debug("adding %s revisions\n" % d)
 deltas = self.deltaiter()
 if not repo.manifestlog.getstorage(d).addgroup(deltas, revmap, trp):
 raise error.Abort(_("received dir revlog group is empty"))
 class headerlessfixup(object):
 def __init__(self, fh, h):
 self._h = h
 self._fh = fh
 def read(self, n):
 if self._h:
 d, self._h = self._h[:n], self._h[n:]
 if len(d) < n:
 d += readexactly(self._fh, n - len(d))
 return d
 return readexactly(self._fh, n)
 def _revisiondeltatochunks(delta, headerfn):
 """Serialize a revisiondelta to changegroup chunks."""
 # The captured revision delta may be encoded as a delta against
 # a base revision or as a full revision. The changegroup format
 elif delta.basenode == nullid:
 data = delta.revision
 prefix = mdiff.trivialdiffheader(len(data))
 else:
 data = delta.revision
-prefix = mdiff.replacediffheader(delta.baserevisionsize,
+prefix = mdiff.replacediffheader(delta.baserevisionsize, len(data))
-len(data))
 meta = headerfn(delta)
 yield chunkheader(len(meta) + len(prefix) + len(data))
 yield meta
 if prefix:
 yield prefix
 yield data
 def _sortnodesellipsis(store, nodes, cl, lookup):
 """Sort nodes for changegroup generation."""
 # Ellipses serving mode.
 #
 # changelog, so what we do is we sort the non-changelog histories
 # by the order in which they are used by the changelog.
 key = lambda n: cl.rev(lookup(n))
 return sorted(nodes, key=key)
-def _resolvenarrowrevisioninfo(cl, store, ischangelog, rev, linkrev,
-linknode, clrevtolocalrev, fullclnodes,
+def _resolvenarrowrevisioninfo(
-precomputedellipsis):
+cl,
+store,
+ischangelog,
+rev,
+linkrev,
+linknode,
+clrevtolocalrev,
+fullclnodes,
+precomputedellipsis,
+):
 linkparents = precomputedellipsis[linkrev]
 def local(clrev):
 """Turn a changelog revnum into a local revnum.
 The ellipsis dag is stored as revnums on the changelog,
 but when we're producing ellipsis entries for
 p = walk[0]
 walk = walk[1:]
 if p in clrevtolocalrev:
 return clrevtolocalrev[p]
 elif p in fullclnodes:
-walk.extend([pp for pp in cl.parentrevs(p)
+walk.extend([pp for pp in cl.parentrevs(p) if pp != nullrev])
-if pp != nullrev])
 elif p in precomputedellipsis:
-walk.extend([pp for pp in precomputedellipsis[p]
+walk.extend(
-if pp != nullrev])
+[pp for pp in precomputedellipsis[p] if pp != nullrev]
+)
 else:
 # In this case, we've got an ellipsis with parents
 # outside the current bundle (likely an
 # incremental pull). We "know" that we can use the
 # value of this same revlog at whatever revision
 return i
 # We failed to resolve a parent for this node, so
 # we crash the changegroup construction.
 raise error.Abort(
 'unable to resolve parent while packing %r %r'
-' for changeset %r' % (store.indexfile, rev, clrev))
+' for changeset %r' % (store.indexfile, rev, clrev)
+)
 return nullrev
-if not linkparents or (
+if not linkparents or (store.parentrevs(rev) == (nullrev, nullrev)):
-store.parentrevs(rev) == (nullrev, nullrev)):
 p1, p2 = nullrev, nullrev
 elif len(linkparents) == 1:
-p1, = sorted(local(p) for p in linkparents)
+(p1,) = sorted(local(p) for p in linkparents)
 p2 = nullrev
 else:
 p1, p2 = sorted(local(p) for p in linkparents)
 p1node, p2node = store.node(p1), store.node(p2)
 return p1node, p2node, linknode
-def deltagroup(repo, store, nodes, ischangelog, lookup, forcedeltaparentprev,
-topic=None,
+def deltagroup(
-ellipses=False, clrevtolocalrev=None, fullclnodes=None,
+repo,
-precomputedellipsis=None):
+store,
+nodes,
+ischangelog,
+lookup,
+forcedeltaparentprev,
+topic=None,
+ellipses=False,
+clrevtolocalrev=None,
+fullclnodes=None,
+precomputedellipsis=None,
+):
 """Calculate deltas for a set of revisions.
 Is a generator of ``revisiondelta`` instances.
 If topic is not None, progress detail will be generated using this
 else:
 # We could probably do this later and avoid the dict
 # holding state. But it likely doesn't matter.
 p1node, p2node, linknode = _resolvenarrowrevisioninfo(
-cl, store, ischangelog, rev, linkrev, linknode,
+cl,
-clrevtolocalrev, fullclnodes, precomputedellipsis)
+store,
+ischangelog,
+rev,
+linkrev,
+linknode,
+clrevtolocalrev,
+fullclnodes,
+precomputedellipsis,
+)
 adjustedparents[node] = (p1node, p2node)
 linknodes[node] = linknode
 filtered.append(node)
 # We expect the first pass to be fast, so we only engage the progress
 # meter for constructing the revision deltas.
 progress = None
 if topic is not None:
-progress = repo.ui.makeprogress(topic, unit=_('chunks'),
+progress = repo.ui.makeprogress(
-total=len(nodes))
+topic, unit=_('chunks'), total=len(nodes)
+)
 configtarget = repo.ui.config('devel', 'bundle.delta')
 if configtarget not in ('', 'p1', 'full'):
 msg = _("""config "devel.bundle.delta" as unknown value: %s""")
 repo.ui.warn(msg % configtarget)
 revisions = store.emitrevisions(
 nodes,
 nodesorder=nodesorder,
 revisiondata=True,
 assumehaveparentrevisions=not ellipses,
-deltamode=deltamode)
+deltamode=deltamode,
+)
 for i, revision in enumerate(revisions):
 if progress:
 progress.update(i + 1)
 yield revision
 if progress:
 progress.complete()
 class cgpacker(object):
-def __init__(self, repo, oldmatcher, matcher, version,
+def __init__(
-builddeltaheader, manifestsend,
+self,
-forcedeltaparentprev=False,
+repo,
-bundlecaps=None, ellipses=False,
+oldmatcher,
-shallow=False, ellipsisroots=None, fullnodes=None):
+matcher,
+version,
+builddeltaheader,
+manifestsend,
+forcedeltaparentprev=False,
+bundlecaps=None,
+ellipses=False,
+shallow=False,
+ellipsisroots=None,
+fullnodes=None,
+):
 """Given a source repo, construct a bundler.
 oldmatcher is a matcher that matches on files the client already has.
 These will not be included in the changegroup.
 if self._repo.ui.verbose and not self._repo.ui.debugflag:
 self._verbosenote = self._repo.ui.note
 else:
 self._verbosenote = lambda s: None
-def generate(self, commonrevs, clnodes, fastpathlinkrev, source,
+def generate(
-changelog=True):
+self, commonrevs, clnodes, fastpathlinkrev, source, changelog=True
+):
 """Yield a sequence of changegroup byte chunks.
 If changelog is False, changelog data won't be added to changegroup
 """
 repo = self._repo
 cl = repo.changelog
 self._verbosenote(_('uncompressed size of bundle content:\n'))
 size = 0
-clstate, deltas = self._generatechangelog(cl, clnodes,
+clstate, deltas = self._generatechangelog(
-generate=changelog)
+cl, clnodes, generate=changelog
+)
 for delta in deltas:
-for chunk in _revisiondeltatochunks(delta,
+for chunk in _revisiondeltatochunks(delta, self._builddeltaheader):
-self._builddeltaheader):
 size += len(chunk)
 yield chunk
 close = closechunk()
 size += len(close)
 # Treemanifests don't work correctly with fastpathlinkrev
 # either, because we don't discover which directory nodes to
 # send along with files. This could probably be fixed.
 fastpathlinkrev = fastpathlinkrev and (
-'treemanifest' not in repo.requirements)
+'treemanifest' not in repo.requirements
+)
 fnodes = {}  # needed file nodes
 size = 0
 it = self.generatemanifests(
-commonrevs, clrevorder, fastpathlinkrev, manifests, fnodes, source,
+commonrevs,
-clstate['clrevtomanifestrev'])
+clrevorder,
+fastpathlinkrev,
+manifests,
+fnodes,
+source,
+clstate['clrevtomanifestrev'],
+)
 for tree, deltas in it:
 if tree:
 assert self.version == b'03'
 chunk = _fileheader(tree)
 self._verbosenote(_('%8.i (manifests)\n') % size)
 yield self._manifestsend
 mfdicts = None
 if self._ellipses and self._isshallow:
-mfdicts = [(self._repo.manifestlog[n].read(), lr)
+mfdicts = [
-for (n, lr) in manifests.iteritems()]
+(self._repo.manifestlog[n].read(), lr)
+for (n, lr) in manifests.iteritems()
+]
 manifests.clear()
 clrevs = set(cl.rev(x) for x in clnodes)
-it = self.generatefiles(changedfiles, commonrevs,
+it = self.generatefiles(
-source, mfdicts, fastpathlinkrev,
+changedfiles,
-fnodes, clrevs)
+commonrevs,
+source,
+mfdicts,
+fastpathlinkrev,
+fnodes,
+clrevs,
+)
 for path, deltas in it:
 h = _fileheader(path)
 size = len(h)
 yield h
 if self._ellipses:
 # Only update manifests if x is going to be sent. Otherwise we
 # end up with bogus linkrevs specified for manifests and
 # we skip some manifest nodes that we should otherwise
 # have sent.
-if (x in self._fullclnodes
+if (
-or cl.rev(x) in self._precomputedellipsis):
+x in self._fullclnodes
+or cl.rev(x) in self._precomputedellipsis
+):
 manifestnode = c.manifest
 # Record the first changeset introducing this manifest
 # version.
 manifests.setdefault(manifestnode, x)
 # Set this narrow-specific dict so we have the lowest
 # manifest revnum to look up for this cl revnum. (Part of
 # mapping changelog ellipsis parents to manifest ellipsis
 # parents)
 clrevtomanifestrev.setdefault(
-cl.rev(x), mfl.rev(manifestnode))
+cl.rev(x), mfl.rev(manifestnode)
+)
 # We can't trust the changed files list in the changeset if the
 # client requested a shallow clone.
 if self._isshallow:
 changedfiles.update(mfl[c.manifest].read().keys())
 else:
 changedfiles.update(c.files)
 return x
 gen = deltagroup(
-self._repo, cl, nodes, True, lookupcl,
+self._repo,
+cl,
+nodes,
+True,
+lookupcl,
 self._forcedeltaparentprev,
 ellipses=self._ellipses,
 topic=_('changesets'),
 clrevtolocalrev={},
 fullclnodes=self._fullclnodes,
-precomputedellipsis=self._precomputedellipsis)
+precomputedellipsis=self._precomputedellipsis,
+)
 return state, gen
-def generatemanifests(self, commonrevs, clrevorder, fastpathlinkrev,
+def generatemanifests(
-manifests, fnodes, source, clrevtolocalrev):
+self,
+commonrevs,
+clrevorder,
+fastpathlinkrev,
+manifests,
+fnodes,
+source,
+clrevtolocalrev,
+):
 """Returns an iterator of changegroup chunks containing manifests.
 `source` is unused here, but is used by extensions like remotefilelog to
 change what is sent based in pulls vs pushes, etc.
 """
 treemanifests to send.
 """
 clnode = nodes[x]
 mdata = mfl.get(tree, x).readfast(shallow=True)
 for p, n, fl in mdata.iterentries():
-if fl == 't': # subdirectory manifest
+if fl == 't':  # subdirectory manifest
 subtree = tree + p + '/'
 tmfclnodes = tmfnodes.setdefault(subtree, {})
 tmfclnode = tmfclnodes.setdefault(n, clnode)
 if clrevorder[clnode] < clrevorder[tmfclnode]:
 tmfclnodes[n] = clnode
 fclnodes = fnodes.setdefault(f, {})
 fclnode = fclnodes.setdefault(n, clnode)
 if clrevorder[clnode] < clrevorder[fclnode]:
 fclnodes[n] = clnode
 return clnode
 return lookupmflinknode
 while tmfnodes:
 tree, nodes = tmfnodes.popitem()
 continue
 lookupfn = makelookupmflinknode(tree, nodes)
 deltas = deltagroup(
-self._repo, store, prunednodes, False, lookupfn,
+self._repo,
+store,
+prunednodes,
+False,
+lookupfn,
 self._forcedeltaparentprev,
 ellipses=self._ellipses,
 topic=_('manifests'),
 clrevtolocalrev=clrevtolocalrev,
 fullclnodes=self._fullclnodes,
-precomputedellipsis=self._precomputedellipsis)
+precomputedellipsis=self._precomputedellipsis,
+)
 if not self._oldmatcher.visitdir(store.tree[:-1]):
 yield tree, deltas
 else:
 # 'deltas' is a generator and we need to consume it even if
 # layer.
 frev, flr = store.rev, store.linkrev
 return [n for n in nodes if flr(frev(n)) not in commonrevs]
 # The 'source' parameter is useful for extensions
-def generatefiles(self, changedfiles, commonrevs, source,
+def generatefiles(
-mfdicts, fastpathlinkrev, fnodes, clrevs):
+self,
-changedfiles = [f for f in changedfiles
+changedfiles,
-if self._matcher(f) and not self._oldmatcher(f)]
+commonrevs,
+source,
+mfdicts,
+fastpathlinkrev,
+fnodes,
+clrevs,
+):
+changedfiles = [
+f
+for f in changedfiles
+if self._matcher(f) and not self._oldmatcher(f)
+]
 if not fastpathlinkrev:
 def normallinknodes(unused, fname):
 return fnodes.get(fname, {})
 else:
 cln = self._repo.changelog.node
 def normallinknodes(store, fname):
 flinkrev = store.linkrev
 fnode = store.node
 revs = ((r, flinkrev(r)) for r in store)
-return dict((fnode(r), cln(lr))
+return dict(
-for r, lr in revs if lr in clrevs)
+(fnode(r), cln(lr)) for r, lr in revs if lr in clrevs
+)
 clrevtolocalrev = {}
 if self._isshallow:
 # In a shallow clone, the linknodes callback needs to also include
 if fnode in links:
 links[fnode] = min(links[fnode], lr, key=clrev)
 elif fnode:
 links[fnode] = lr
 return links
 else:
 linknodes = normallinknodes
 repo = self._repo
-progress = repo.ui.makeprogress(_('files'), unit=_('files'),
+progress = repo.ui.makeprogress(
-total=len(changedfiles))
+_('files'), unit=_('files'), total=len(changedfiles)
+)
 for i, fname in enumerate(sorted(changedfiles)):
 filerevlog = repo.file(fname)
 if not filerevlog:
-raise error.Abort(_("empty or missing file data for %s") %
+raise error.Abort(
-fname)
+_("empty or missing file data for %s") % fname
+)
 clrevtolocalrev.clear()
 linkrevnodes = linknodes(filerevlog, fname)
 # Lookup for filenodes, we collected the linkrev nodes above in the
 frev, flr = filerevlog.rev, filerevlog.linkrev
 # Skip sending any filenode we know the client already
 # has. This avoids over-sending files relatively
 # inexpensively, so it's not a problem if we under-filter
 # here.
-filenodes = [n for n in linkrevnodes
+filenodes = [
-if flr(frev(n)) not in commonrevs]
+n for n in linkrevnodes if flr(frev(n)) not in commonrevs
+]
 if not filenodes:
 continue
 progress.update(i + 1, item=fname)
 deltas = deltagroup(
-self._repo, filerevlog, filenodes, False, lookupfilelog,
+self._repo,
+filerevlog,
+filenodes,
+False,
+lookupfilelog,
 self._forcedeltaparentprev,
 ellipses=self._ellipses,
 clrevtolocalrev=clrevtolocalrev,
 fullclnodes=self._fullclnodes,
-precomputedellipsis=self._precomputedellipsis)
+precomputedellipsis=self._precomputedellipsis,
+)
 yield fname, deltas
 progress.complete()
-def _makecg1packer(repo, oldmatcher, matcher, bundlecaps,
-ellipses=False, shallow=False, ellipsisroots=None,
+def _makecg1packer(
-fullnodes=None):
+repo,
+oldmatcher,
+matcher,
+bundlecaps,
+ellipses=False,
+shallow=False,
+ellipsisroots=None,
+fullnodes=None,
+):
 builddeltaheader = lambda d: _CHANGEGROUPV1_DELTA_HEADER.pack(
-d.node, d.p1node, d.p2node, d.linknode)
+d.node, d.p1node, d.p2node, d.linknode
+)
-return cgpacker(repo, oldmatcher, matcher, b'01',
-builddeltaheader=builddeltaheader,
+return cgpacker(
-manifestsend=b'',
+repo,
-forcedeltaparentprev=True,
+oldmatcher,
-bundlecaps=bundlecaps,
+matcher,
-ellipses=ellipses,
+b'01',
-shallow=shallow,
+builddeltaheader=builddeltaheader,
-ellipsisroots=ellipsisroots,
+manifestsend=b'',
-fullnodes=fullnodes)
+forcedeltaparentprev=True,
+bundlecaps=bundlecaps,
-def _makecg2packer(repo, oldmatcher, matcher, bundlecaps,
+ellipses=ellipses,
-ellipses=False, shallow=False, ellipsisroots=None,
+shallow=shallow,
-fullnodes=None):
+ellipsisroots=ellipsisroots,
+fullnodes=fullnodes,
+)
+def _makecg2packer(
+repo,
+oldmatcher,
+matcher,
+bundlecaps,
+ellipses=False,
+shallow=False,
+ellipsisroots=None,
+fullnodes=None,
+):
 builddeltaheader = lambda d: _CHANGEGROUPV2_DELTA_HEADER.pack(
-d.node, d.p1node, d.p2node, d.basenode, d.linknode)
+d.node, d.p1node, d.p2node, d.basenode, d.linknode
+)
-return cgpacker(repo, oldmatcher, matcher, b'02',
-builddeltaheader=builddeltaheader,
+return cgpacker(
-manifestsend=b'',
+repo,
-bundlecaps=bundlecaps,
+oldmatcher,
-ellipses=ellipses,
+matcher,
-shallow=shallow,
+b'02',
-ellipsisroots=ellipsisroots,
+builddeltaheader=builddeltaheader,
-fullnodes=fullnodes)
+manifestsend=b'',
+bundlecaps=bundlecaps,
-def _makecg3packer(repo, oldmatcher, matcher, bundlecaps,
+ellipses=ellipses,
-ellipses=False, shallow=False, ellipsisroots=None,
+shallow=shallow,
-fullnodes=None):
+ellipsisroots=ellipsisroots,
+fullnodes=fullnodes,
+)
+def _makecg3packer(
+repo,
+oldmatcher,
+matcher,
+bundlecaps,
+ellipses=False,
+shallow=False,
+ellipsisroots=None,
+fullnodes=None,
+):
 builddeltaheader = lambda d: _CHANGEGROUPV3_DELTA_HEADER.pack(
-d.node, d.p1node, d.p2node, d.basenode, d.linknode, d.flags)
+d.node, d.p1node, d.p2node, d.basenode, d.linknode, d.flags
+)
-return cgpacker(repo, oldmatcher, matcher, b'03',
-builddeltaheader=builddeltaheader,
+return cgpacker(
-manifestsend=closechunk(),
+repo,
-bundlecaps=bundlecaps,
+oldmatcher,
-ellipses=ellipses,
+matcher,
-shallow=shallow,
+b'03',
-ellipsisroots=ellipsisroots,
+builddeltaheader=builddeltaheader,
-fullnodes=fullnodes)
+manifestsend=closechunk(),
+bundlecaps=bundlecaps,
-_packermap = {'01': (_makecg1packer, cg1unpacker),
+ellipses=ellipses,
-# cg2 adds support for exchanging generaldelta
+shallow=shallow,
-'02': (_makecg2packer, cg2unpacker),
+ellipsisroots=ellipsisroots,
-# cg3 adds support for exchanging revlog flags and treemanifests
+fullnodes=fullnodes,
-'03': (_makecg3packer, cg3unpacker),
+)
+_packermap = {
+'01': (_makecg1packer, cg1unpacker),
+# cg2 adds support for exchanging generaldelta
+'02': (_makecg2packer, cg2unpacker),
+# cg3 adds support for exchanging revlog flags and treemanifests
+'03': (_makecg3packer, cg3unpacker),
 }
 def allsupportedversions(repo):
 versions = set(_packermap.keys())
 needv03 = False
-if (repo.ui.configbool('experimental', 'changegroup3') or
+if (
-repo.ui.configbool('experimental', 'treemanifest') or
+repo.ui.configbool('experimental', 'changegroup3')
-'treemanifest' in repo.requirements):
+or repo.ui.configbool('experimental', 'treemanifest')
+or 'treemanifest' in repo.requirements
+):
 # we keep version 03 because we need to to exchange treemanifest data
 #
 # we also keep vresion 01 and 02, because it is possible for repo to
 # contains both normal and tree manifest at the same time. so using
 # older version to pull data is viable
 needv03 = True
 if not needv03:
 versions.discard('03')
 return versions
 # Changegroup versions that can be applied to the repo
 def supportedincomingversions(repo):
 return allsupportedversions(repo)
 # Changegroup versions that can be created from the repo
 def supportedoutgoingversions(repo):
 versions = allsupportedversions(repo)
 if 'treemanifest' in repo.requirements:
 versions.discard('01')
 versions.discard('02')
 return versions
 def localversion(repo):
 # Finds the best version to use for bundles that are meant to be used
 # locally, such as those from strip and shelve, and temporary bundles.
 return max(supportedoutgoingversions(repo))
 def safeversion(repo):
 # Finds the smallest version that it's safe to assume clients of the repo
 # will support. For example, all hg versions that support generaldelta also
 # support changegroup 02.
 if 'generaldelta' in repo.requirements:
 versions.discard('01')
 assert versions
 return min(versions)
-def getbundler(version, repo, bundlecaps=None, oldmatcher=None,
-matcher=None, ellipses=False, shallow=False,
+def getbundler(
-ellipsisroots=None, fullnodes=None):
+version,
+repo,
+bundlecaps=None,
+oldmatcher=None,
+matcher=None,
+ellipses=False,
+shallow=False,
+ellipsisroots=None,
+fullnodes=None,
+):
 assert version in supportedoutgoingversions(repo)
 if matcher is None:
 matcher = matchmod.always()
 if oldmatcher is None:
 oldmatcher = matchmod.never()
 if version == '01' and not matcher.always():
-raise error.ProgrammingError('version 01 changegroups do not support '
+raise error.ProgrammingError(
-'sparse file matchers')
+'version 01 changegroups do not support ' 'sparse file matchers'
+)
 if ellipses and version in (b'01', b'02'):
 raise error.Abort(
-_('ellipsis nodes require at least cg3 on client and server, '
+_(
-'but negotiated version %s') % version)
+'ellipsis nodes require at least cg3 on client and server, '
+'but negotiated version %s'
+)
+% version
+)
 # Requested files could include files not in the local store. So
 # filter those out.
 matcher = repo.narrowmatch(matcher)
 fn = _packermap[version][0]
-return fn(repo, oldmatcher, matcher, bundlecaps, ellipses=ellipses,
+return fn(
-shallow=shallow, ellipsisroots=ellipsisroots,
+repo,
-fullnodes=fullnodes)
+oldmatcher,
+matcher,
+bundlecaps,
+ellipses=ellipses,
+shallow=shallow,
+ellipsisroots=ellipsisroots,
+fullnodes=fullnodes,
+)
 def getunbundler(version, fh, alg, extras=None):
 return _packermap[version][1](fh, alg, extras=extras)
 def _changegroupinfo(repo, nodes, source):
 if repo.ui.verbose or source == 'bundle':
 repo.ui.status(_("%d changesets found\n") % len(nodes))
 if repo.ui.debugflag:
 repo.ui.debug("list of changesets:\n")
 for node in nodes:
 repo.ui.debug("%s\n" % hex(node))
-def makechangegroup(repo, outgoing, version, source, fastpath=False,
-bundlecaps=None):
+def makechangegroup(
-cgstream = makestream(repo, outgoing, version, source,
+repo, outgoing, version, source, fastpath=False, bundlecaps=None
-fastpath=fastpath, bundlecaps=bundlecaps)
+):
-return getunbundler(version, util.chunkbuffer(cgstream), None,
+cgstream = makestream(
-{'clcount': len(outgoing.missing) })
+repo,
+outgoing,
-def makestream(repo, outgoing, version, source, fastpath=False,
+version,
-bundlecaps=None, matcher=None):
+source,
-bundler = getbundler(version, repo, bundlecaps=bundlecaps,
+fastpath=fastpath,
-matcher=matcher)
+bundlecaps=bundlecaps,
+)
+return getunbundler(
+version,
+util.chunkbuffer(cgstream),
+None,
+{'clcount': len(outgoing.missing)},
+)
+def makestream(
+repo,
+outgoing,
+version,
+source,
+fastpath=False,
+bundlecaps=None,
+matcher=None,
+):
+bundler = getbundler(version, repo, bundlecaps=bundlecaps, matcher=matcher)
 repo = repo.unfiltered()
 commonrevs = outgoing.common
 csets = outgoing.missing
 heads = outgoing.missingheads
 # We go through the fast path if we get told to, or if all (unfiltered
 # heads have been requested (since we then know there all linkrevs will
 # be pulled by the client).
 heads.sort()
 fastpathlinkrev = fastpath or (
-repo.filtername is None and heads == sorted(repo.heads()))
+repo.filtername is None and heads == sorted(repo.heads())
+)
 repo.hook('preoutgoing', throw=True, source=source)
 _changegroupinfo(repo, csets, source)
 return bundler.generate(commonrevs, csets, fastpathlinkrev, source)
 def _addchangegroupfiles(repo, source, revmap, trp, expectedfiles, needfiles):
 revisions = 0
 files = 0
-progress = repo.ui.makeprogress(_('files'), unit=_('files'),
+progress = repo.ui.makeprogress(
-total=expectedfiles)
+_('files'), unit=_('files'), total=expectedfiles
+)
 for chunkdata in iter(source.filelogheader, {}):
 files += 1
 f = chunkdata["filename"]
 repo.ui.debug("adding %s revisions\n" % f)
 progress.increment()
 for new in pycompat.xrange(o, len(fl)):
 n = fl.node(new)
 if n in needs:
 needs.remove(n)
 else:
-raise error.Abort(
+raise error.Abort(_("received spurious file revlog entry"))
-_("received spurious file revlog entry"))
 if not needs:
 del needfiles[f]
 progress.complete()
 for f, needs in needfiles.iteritems():
 for n in needs:
 try:
 fl.rev(n)
 except error.LookupError:
 raise error.Abort(
-_('missing file data for %s:%s - run hg verify') %
+_('missing file data for %s:%s - run hg verify')
-(f, hex(n)))
+% (f, hex(n))
+)
 return revisions, files

changeset 43076	2372284d9457
parent 43059	4bbc9569e722
child 43077	687b865b95ad