Mercurial: mercurial/changegroup.py comparison

comparison mercurial/changegroup.py @ 43077:687b865b95ad

formatting: byteify all mercurial/ and hgext/ string literals Done with python3.7 contrib/byteify-strings.py -i $(hg files 'set:mercurial/**.py - mercurial/thirdparty/** + hgext/**.py - hgext/fsmonitor/pywatchman/** - mercurial/__init__.py') black -l 80 -t py33 -S $(hg files 'set:**.py - mercurial/thirdparty/** - "contrib/python-zstandard/**" - hgext/fsmonitor/pywatchman/**') # skip-blame mass-reformatting only Differential Revision: https://phab.mercurial-scm.org/D6972

author	Augie Fackler <augie@google.com>
date	Sun, 06 Oct 2019 09:48:39 -0400
parents	2372284d9457
children	eef9a2d67051

comparison

equal deleted inserted replaced

-:2372284d9457
+:687b865b95ad
 util,
 )
 from .interfaces import repository
-_CHANGEGROUPV1_DELTA_HEADER = struct.Struct("20s20s20s20s")
+_CHANGEGROUPV1_DELTA_HEADER = struct.Struct(b"20s20s20s20s")
-_CHANGEGROUPV2_DELTA_HEADER = struct.Struct("20s20s20s20s20s")
+_CHANGEGROUPV2_DELTA_HEADER = struct.Struct(b"20s20s20s20s20s")
-_CHANGEGROUPV3_DELTA_HEADER = struct.Struct(">20s20s20s20s20sH")
+_CHANGEGROUPV3_DELTA_HEADER = struct.Struct(b">20s20s20s20s20sH")
-LFS_REQUIREMENT = 'lfs'
+LFS_REQUIREMENT = b'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]
+l = struct.unpack(b">l", d)[0]
 if l <= 4:
 if l:
-raise error.Abort(_("invalid chunk length %d") % l)
+raise error.Abort(_(b"invalid chunk length %d") % l)
-return ""
+return b""
 return readexactly(stream, l - 4)
 def chunkheader(length):
 """return a changegroup chunk header (string)"""
-return struct.pack(">l", length + 4)
+return struct.pack(b">l", length + 4)
 def closechunk():
 """return a changegroup chunk header (string) for a zero-length chunk"""
-return struct.pack(">l", 0)
+return struct.pack(b">l", 0)
 def _fileheader(path):
 """Obtain a changegroup chunk header for a named path."""
 return chunkheader(len(path)) + path
 fh = None
 cleanup = None
 try:
 if filename:
 if vfs:
-fh = vfs.open(filename, "wb")
+fh = vfs.open(filename, b"wb")
 else:
 # Increase default buffer size because default is usually
 # small (4k is common on Linux).
-fh = open(filename, "wb", 131072)
+fh = open(filename, b"wb", 131072)
 else:
-fd, filename = pycompat.mkstemp(prefix="hg-bundle-", suffix=".hg")
+fd, filename = pycompat.mkstemp(prefix=b"hg-bundle-", suffix=b".hg")
 fh = os.fdopen(fd, r"wb")
 cleanup = filename
 for c in chunks:
 fh.write(c)
 cleanup = None
 bundlerepo and some debug commands - their use is discouraged.
 """
 deltaheader = _CHANGEGROUPV1_DELTA_HEADER
 deltaheadersize = deltaheader.size
-version = '01'
+version = b'01'
 _grouplistcount = 1  # One list of files after the manifests
 def __init__(self, fh, alg, extras=None):
 if alg is None:
-alg = 'UN'
+alg = b'UN'
 if alg not in util.compengines.supportedbundletypes:
-raise error.Abort(_('unknown stream compression type: %s') % alg)
+raise error.Abort(_(b'unknown stream compression type: %s') % alg)
-if alg == 'BZ':
+if alg == b'BZ':
-alg = '_truncatedBZ'
+alg = b'_truncatedBZ'
 compengine = util.compengines.forbundletype(alg)
 self._stream = compengine.decompressorreader(fh)
 self._type = alg
 self.extras = extras or {}
 self.callback = None
 # 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'
+return self._type is not None and self._type != b'UN'
 def read(self, l):
 return self._stream.read(l)
 def seek(self, pos):
 def close(self):
 return self._stream.close()
 def _chunklength(self):
 d = readexactly(self._stream, 4)
-l = struct.unpack(">l", d)[0]
+l = struct.unpack(b">l", d)[0]
 if l <= 4:
 if l:
-raise error.Abort(_("invalid chunk length %d") % l)
+raise error.Abort(_(b"invalid chunk length %d") % l)
 return 0
 if self.callback:
 self.callback()
 return l - 4
 """return the header of the filelogs chunk, v10 only has the filename"""
 l = self._chunklength()
 if not l:
 return {}
 fname = readexactly(self._stream, l)
-return {'filename': fname}
+return {b'filename': fname}
 def _deltaheader(self, headertuple, prevnode):
 node, p1, p2, cs = headertuple
 if prevnode is None:
 deltabase = p1
 - number of heads stays the same: 1
 """
 repo = repo.unfiltered()
 def csmap(x):
-repo.ui.debug("add changeset %s\n" % short(x))
+repo.ui.debug(b"add changeset %s\n" % short(x))
 return len(cl)
 def revmap(x):
 return cl.rev(x)
 try:
 # The transaction may already carry source information. In this
 # 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)
+srctype = tr.hookargs.setdefault(b'source', srctype)
-tr.hookargs.setdefault('url', url)
+tr.hookargs.setdefault(b'url', url)
 repo.hook(
-'prechangegroup', throw=True, **pycompat.strkwargs(tr.hookargs)
+b'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)
 oldheads = set(cl.heads())
 trp = weakref.proxy(tr)
 # pull off the changeset group
-repo.ui.status(_("adding changesets\n"))
+repo.ui.status(_(b"adding changesets\n"))
 clstart = len(cl)
 progress = repo.ui.makeprogress(
-_('changesets'), unit=_('chunks'), total=expectedtotal
+_(b'changesets'), unit=_(b'chunks'), total=expectedtotal
 )
 self.callback = progress.increment
 efiles = set()
 cgnodes = cl.addgroup(deltas, csmap, trp, addrevisioncb=onchangelog)
 efiles = len(efiles)
 if not cgnodes:
 repo.ui.develwarn(
-'applied empty changelog from changegroup',
+b'applied empty changelog from changegroup',
-config='warn-empty-changegroup',
+config=b'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"))
+repo.ui.status(_(b"adding manifests\n"))
 # We know that we'll never have more manifests than we had
 # changesets.
 progress = repo.ui.makeprogress(
-_('manifests'), unit=_('chunks'), total=changesets
+_(b'manifests'), unit=_(b'chunks'), total=changesets
 )
 self._unpackmanifests(repo, revmap, trp, progress)
 needfiles = {}
-if repo.ui.configbool('server', 'validate'):
+if repo.ui.configbool(b'server', b'validate'):
 cl = repo.changelog
 ml = repo.manifestlog
 # validate incoming csets have their manifests
 for cset in pycompat.xrange(clstart, clend):
 mfnode = cl.changelogrevision(cset).manifest
 # store file cgnodes we must see
 for f, n in mfest.iteritems():
 needfiles.setdefault(f, set()).add(n)
 # process the files
-repo.ui.status(_("adding file changes\n"))
+repo.ui.status(_(b"adding file changes\n"))
 newrevs, newfiles = _addchangegroupfiles(
 repo, self, revmap, trp, efiles, needfiles
 )
 # making sure the value exists
-tr.changes.setdefault('changegroup-count-changesets', 0)
+tr.changes.setdefault(b'changegroup-count-changesets', 0)
-tr.changes.setdefault('changegroup-count-revisions', 0)
+tr.changes.setdefault(b'changegroup-count-revisions', 0)
-tr.changes.setdefault('changegroup-count-files', 0)
+tr.changes.setdefault(b'changegroup-count-files', 0)
-tr.changes.setdefault('changegroup-count-heads', 0)
+tr.changes.setdefault(b'changegroup-count-heads', 0)
 # some code use bundle operation for internal purpose. They usually
 # set `ui.quiet` to do this outside of user sight. Size the report
 # of such operation now happens at the end of the transaction, that
 # ui.quiet has not direct effect on the output.
 # To preserve this intend use an inelegant hack, we fail to report
 # the change if `quiet` is set. We should probably move to
 # something better, but this is a good first step to allow the "end
 # of transaction report" to pass tests.
 if not repo.ui.quiet:
-tr.changes['changegroup-count-changesets'] += changesets
+tr.changes[b'changegroup-count-changesets'] += changesets
-tr.changes['changegroup-count-revisions'] += newrevs
+tr.changes[b'changegroup-count-revisions'] += newrevs
-tr.changes['changegroup-count-files'] += newfiles
+tr.changes[b'changegroup-count-files'] += newfiles
 deltaheads = 0
 if oldheads:
 heads = cl.heads()
 deltaheads += len(heads) - len(oldheads)
 if h not in oldheads and repo[h].closesbranch():
 deltaheads -= 1
 # see previous comment about checking ui.quiet
 if not repo.ui.quiet:
-tr.changes['changegroup-count-heads'] += deltaheads
+tr.changes[b'changegroup-count-heads'] += deltaheads
 repo.invalidatevolatilesets()
 if changesets > 0:
-if 'node' not in tr.hookargs:
+if b'node' not in tr.hookargs:
-tr.hookargs['node'] = hex(cl.node(clstart))
+tr.hookargs[b'node'] = hex(cl.node(clstart))
-tr.hookargs['node_last'] = hex(cl.node(clend - 1))
+tr.hookargs[b'node_last'] = hex(cl.node(clend - 1))
 hookargs = dict(tr.hookargs)
 else:
 hookargs = dict(tr.hookargs)
-hookargs['node'] = hex(cl.node(clstart))
+hookargs[b'node'] = hex(cl.node(clstart))
-hookargs['node_last'] = hex(cl.node(clend - 1))
+hookargs[b'node_last'] = hex(cl.node(clend - 1))
 repo.hook(
-'pretxnchangegroup',
+b'pretxnchangegroup',
 throw=True,
 **pycompat.strkwargs(hookargs)
 )
 added = [cl.node(r) for r in pycompat.xrange(clstart, clend)]
 phaseall = None
-if srctype in ('push', 'serve'):
+if srctype in (b'push', b'serve'):
 # Old servers can not push the boundary themselves.
 # New servers won't push the boundary if changeset already
 # exists locally as secret
 #
 # We should not use added here but the list of all change in
 # transaction closes. So it's possible for the changelog
 # to have changed since we last saw it.
 if clstart >= len(repo):
 return
-repo.hook("changegroup", **pycompat.strkwargs(hookargs))
+repo.hook(b"changegroup", **pycompat.strkwargs(hookargs))
 for n in added:
 args = hookargs.copy()
-args['node'] = hex(n)
+args[b'node'] = hex(n)
-del args['node_last']
+del args[b'node_last']
-repo.hook("incoming", **pycompat.strkwargs(args))
+repo.hook(b"incoming", **pycompat.strkwargs(args))
 newheads = [h for h in repo.heads() if h not in oldheads]
 repo.ui.log(
-"incoming",
+b"incoming",
-"%d incoming changes - new heads: %s\n",
+b"%d incoming changes - new heads: %s\n",
 len(added),
-', '.join([hex(c[:6]) for c in newheads]),
+b', '.join([hex(c[:6]) for c in newheads]),
 )
 tr.addpostclose(
-'changegroup-runhooks-%020i' % clstart,
+b'changegroup-runhooks-%020i' % clstart,
 lambda tr: repo._afterlock(runhooks),
 )
 finally:
 repo.ui.flush()
 # never return 0 here:
 remain the same.
 """
 deltaheader = _CHANGEGROUPV2_DELTA_HEADER
 deltaheadersize = deltaheader.size
-version = '02'
+version = b'02'
 def _deltaheader(self, headertuple, prevnode):
 node, p1, p2, deltabase, cs = headertuple
 flags = 0
 return node, p1, p2, deltabase, cs, flags
 separating manifests and files.
 """
 deltaheader = _CHANGEGROUPV3_DELTA_HEADER
 deltaheadersize = deltaheader.size
-version = '03'
+version = b'03'
 _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
 def _unpackmanifests(self, repo, revmap, trp, prog):
 super(cg3unpacker, self)._unpackmanifests(repo, revmap, trp, prog)
 for chunkdata in iter(self.filelogheader, {}):
 # If we get here, there are directory manifests in the changegroup
-d = chunkdata["filename"]
+d = chunkdata[b"filename"]
-repo.ui.debug("adding %s revisions\n" % d)
+repo.ui.debug(b"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"))
+raise error.Abort(_(b"received dir revlog group is empty"))
 class headerlessfixup(object):
 def __init__(self, fh, h):
 self._h = h
 if store.linkrev(i) == clrev:
 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'
+b'unable to resolve parent while packing %r %r'
-' for changeset %r' % (store.indexfile, rev, clrev)
+b' for changeset %r' % (store.indexfile, rev, clrev)
 )
 return nullrev
 if not linkparents or (store.parentrevs(rev) == (nullrev, nullrev)):
 cl = repo.changelog
 if ischangelog:
 # `hg log` shows changesets in storage order. To preserve order
 # across clones, send out changesets in storage order.
-nodesorder = 'storage'
+nodesorder = b'storage'
 elif ellipses:
 nodes = _sortnodesellipsis(store, nodes, cl, lookup)
-nodesorder = 'nodes'
+nodesorder = b'nodes'
 else:
 nodesorder = None
 # Perform ellipses filtering and revision massaging. We do this before
 # emitrevisions() because a) filtering out revisions creates less work
 # 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'), total=len(nodes)
+topic, unit=_(b'chunks'), total=len(nodes)
 )
-configtarget = repo.ui.config('devel', 'bundle.delta')
+configtarget = repo.ui.config(b'devel', b'bundle.delta')
-if configtarget not in ('', 'p1', 'full'):
+if configtarget not in (b'', b'p1', b'full'):
 msg = _("""config "devel.bundle.delta" as unknown value: %s""")
 repo.ui.warn(msg % configtarget)
 deltamode = repository.CG_DELTAMODE_STD
 if forcedeltaparentprev:
 deltamode = repository.CG_DELTAMODE_PREV
-elif configtarget == 'p1':
+elif configtarget == b'p1':
 deltamode = repository.CG_DELTAMODE_P1
-elif configtarget == 'full':
+elif configtarget == b'full':
 deltamode = repository.CG_DELTAMODE_FULL
 revisions = store.emitrevisions(
 nodes,
 nodesorder=nodesorder,
 """
 repo = self._repo
 cl = repo.changelog
-self._verbosenote(_('uncompressed size of bundle content:\n'))
+self._verbosenote(_(b'uncompressed size of bundle content:\n'))
 size = 0
 clstate, deltas = self._generatechangelog(
 cl, clnodes, generate=changelog
 )
 close = closechunk()
 size += len(close)
 yield closechunk()
-self._verbosenote(_('%8.i (changelog)\n') % size)
+self._verbosenote(_(b'%8.i (changelog)\n') % size)
-clrevorder = clstate['clrevorder']
+clrevorder = clstate[b'clrevorder']
-manifests = clstate['manifests']
+manifests = clstate[b'manifests']
-changedfiles = clstate['changedfiles']
+changedfiles = clstate[b'changedfiles']
 # We need to make sure that the linkrev in the changegroup refers to
 # the first changeset that introduced the manifest or file revision.
 # The fastpath is usually safer than the slowpath, because the filelogs
 # are walked in revlog order.
 # 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
+b'treemanifest' not in repo.requirements
 )
 fnodes = {}  # needed file nodes
 size = 0
 clrevorder,
 fastpathlinkrev,
 manifests,
 fnodes,
 source,
-clstate['clrevtomanifestrev'],
+clstate[b'clrevtomanifestrev'],
 )
 for tree, deltas in it:
 if tree:
 assert self.version == b'03'
 close = closechunk()
 size += len(close)
 yield close
-self._verbosenote(_('%8.i (manifests)\n') % size)
+self._verbosenote(_(b'%8.i (manifests)\n') % size)
 yield self._manifestsend
 mfdicts = None
 if self._ellipses and self._isshallow:
 mfdicts = [
 close = closechunk()
 size += len(close)
 yield close
-self._verbosenote(_('%8.i  %s\n') % (size, path))
+self._verbosenote(_(b'%8.i  %s\n') % (size, path))
 yield closechunk()
 if clnodes:
-repo.hook('outgoing', node=hex(clnodes[0]), source=source)
+repo.hook(b'outgoing', node=hex(clnodes[0]), source=source)
 def _generatechangelog(self, cl, nodes, generate=True):
 """Generate data for changelog chunks.
 Returns a 2-tuple of a dict containing state and an iterable of
 mfl = self._repo.manifestlog
 changedfiles = set()
 clrevtomanifestrev = {}
 state = {
-'clrevorder': clrevorder,
+b'clrevorder': clrevorder,
-'manifests': manifests,
+b'manifests': manifests,
-'changedfiles': changedfiles,
+b'changedfiles': changedfiles,
-'clrevtomanifestrev': clrevtomanifestrev,
+b'clrevtomanifestrev': clrevtomanifestrev,
 }
 if not (generate or self._ellipses):
 # sort the nodes in storage order
 nodes = sorted(nodes, key=cl.rev)
 nodes,
 True,
 lookupcl,
 self._forcedeltaparentprev,
 ellipses=self._ellipses,
-topic=_('changesets'),
+topic=_(b'changesets'),
 clrevtolocalrev={},
 fullclnodes=self._fullclnodes,
 precomputedellipsis=self._precomputedellipsis,
 )
 `source` is unused here, but is used by extensions like remotefilelog to
 change what is sent based in pulls vs pushes, etc.
 """
 repo = self._repo
 mfl = repo.manifestlog
-tmfnodes = {'': manifests}
+tmfnodes = {b'': manifests}
 # Callback for the manifest, used to collect linkrevs for filelog
 # revisions.
 # Returns the linkrev node (collected in lookupcl).
 def makelookupmflinknode(tree, nodes):
 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 == b't':  # subdirectory manifest
-subtree = tree + p + '/'
+subtree = tree + p + b'/'
 tmfclnodes = tmfnodes.setdefault(subtree, {})
 tmfclnode = tmfclnodes.setdefault(n, clnode)
 if clrevorder[clnode] < clrevorder[tmfclnode]:
 tmfclnodes[n] = clnode
 else:
 prunednodes,
 False,
 lookupfn,
 self._forcedeltaparentprev,
 ellipses=self._ellipses,
-topic=_('manifests'),
+topic=_(b'manifests'),
 clrevtolocalrev=clrevtolocalrev,
 fullclnodes=self._fullclnodes,
 precomputedellipsis=self._precomputedellipsis,
 )
 else:
 linknodes = normallinknodes
 repo = self._repo
 progress = repo.ui.makeprogress(
-_('files'), unit=_('files'), total=len(changedfiles)
+_(b'files'), unit=_(b'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") % fname
+_(b"empty or missing file data for %s") % fname
 )
 clrevtolocalrev.clear()
 linkrevnodes = linknodes(filerevlog, fname)
 fullnodes=fullnodes,
 )
 _packermap = {
-'01': (_makecg1packer, cg1unpacker),
+b'01': (_makecg1packer, cg1unpacker),
 # cg2 adds support for exchanging generaldelta
-'02': (_makecg2packer, cg2unpacker),
+b'02': (_makecg2packer, cg2unpacker),
 # cg3 adds support for exchanging revlog flags and treemanifests
-'03': (_makecg3packer, cg3unpacker),
+b'03': (_makecg3packer, cg3unpacker),
 }
 def allsupportedversions(repo):
 versions = set(_packermap.keys())
 needv03 = False
 if (
-repo.ui.configbool('experimental', 'changegroup3')
+repo.ui.configbool(b'experimental', b'changegroup3')
-or repo.ui.configbool('experimental', 'treemanifest')
+or repo.ui.configbool(b'experimental', b'treemanifest')
-or 'treemanifest' in repo.requirements
+or b'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
 #
 # (or even to push subset of history)
 needv03 = True
 if not needv03:
-versions.discard('03')
+versions.discard(b'03')
 return versions
 # Changegroup versions that can be applied to the repo
 def supportedincomingversions(repo):
 # Changegroup versions that can be created from the repo
 def supportedoutgoingversions(repo):
 versions = allsupportedversions(repo)
-if 'treemanifest' in repo.requirements:
+if b'treemanifest' in repo.requirements:
 # Versions 01 and 02 support only flat manifests and it's just too
 # expensive to convert between the flat manifest and tree manifest on
 # the fly. Since tree manifests are hashed differently, all of history
 # would have to be converted. Instead, we simply don't even pretend to
 # support versions 01 and 02.
-versions.discard('01')
+versions.discard(b'01')
-versions.discard('02')
+versions.discard(b'02')
 if repository.NARROW_REQUIREMENT in repo.requirements:
 # Versions 01 and 02 don't support revlog flags, and we need to
 # support that for stripping and unbundling to work.
-versions.discard('01')
+versions.discard(b'01')
-versions.discard('02')
+versions.discard(b'02')
 if LFS_REQUIREMENT in repo.requirements:
 # Versions 01 and 02 don't support revlog flags, and we need to
 # mark LFS entries with REVIDX_EXTSTORED.
-versions.discard('01')
+versions.discard(b'01')
-versions.discard('02')
+versions.discard(b'02')
 return versions
 def localversion(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.
 versions = supportedoutgoingversions(repo)
-if 'generaldelta' in repo.requirements:
+if b'generaldelta' in repo.requirements:
-versions.discard('01')
+versions.discard(b'01')
 assert versions
 return min(versions)
 def getbundler(
 if matcher is None:
 matcher = matchmod.always()
 if oldmatcher is None:
 oldmatcher = matchmod.never()
-if version == '01' and not matcher.always():
+if version == b'01' and not matcher.always():
 raise error.ProgrammingError(
-'version 01 changegroups do not support ' 'sparse file matchers'
+b'version 01 changegroups do not support ' b'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, '
+b'ellipsis nodes require at least cg3 on client and server, '
-'but negotiated version %s'
+b'but negotiated version %s'
 )
 % version
 )
 # Requested files could include files not in the local store. So
 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':
+if repo.ui.verbose or source == b'bundle':
-repo.ui.status(_("%d changesets found\n") % len(nodes))
+repo.ui.status(_(b"%d changesets found\n") % len(nodes))
 if repo.ui.debugflag:
-repo.ui.debug("list of changesets:\n")
+repo.ui.debug(b"list of changesets:\n")
 for node in nodes:
-repo.ui.debug("%s\n" % hex(node))
+repo.ui.debug(b"%s\n" % hex(node))
 def makechangegroup(
 repo, outgoing, version, source, fastpath=False, bundlecaps=None
 ):
 )
 return getunbundler(
 version,
 util.chunkbuffer(cgstream),
 None,
-{'clcount': len(outgoing.missing)},
+{b'clcount': len(outgoing.missing)},
 )
 def makestream(
 repo,
 heads.sort()
 fastpathlinkrev = fastpath or (
 repo.filtername is None and heads == sorted(repo.heads())
 )
-repo.hook('preoutgoing', throw=True, source=source)
+repo.hook(b'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'), total=expectedfiles
+_(b'files'), unit=_(b'files'), total=expectedfiles
 )
 for chunkdata in iter(source.filelogheader, {}):
 files += 1
-f = chunkdata["filename"]
+f = chunkdata[b"filename"]
-repo.ui.debug("adding %s revisions\n" % f)
+repo.ui.debug(b"adding %s revisions\n" % f)
 progress.increment()
 fl = repo.file(f)
 o = len(fl)
 try:
 deltas = source.deltaiter()
 if not fl.addgroup(deltas, revmap, trp):
-raise error.Abort(_("received file revlog group is empty"))
+raise error.Abort(_(b"received file revlog group is empty"))
 except error.CensoredBaseError as e:
-raise error.Abort(_("received delta base is censored: %s") % e)
+raise error.Abort(_(b"received delta base is censored: %s") % e)
 revisions += len(fl) - o
 if f in needfiles:
 needs = needfiles[f]
 for new in pycompat.xrange(o, len(fl)):
 n = fl.node(new)
 if n in needs:
 needs.remove(n)
 else:
-raise error.Abort(_("received spurious file revlog entry"))
+raise error.Abort(_(b"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')
+_(b'missing file data for %s:%s - run hg verify')
 % (f, hex(n))
 )
 return revisions, files

Mercurial > hg

comparison mercurial/changegroup.py @ 43077:687b865b95ad