mercurial: comparison mercurial/exchangev2.py

equal deleted inserted replaced

-:2372284d9457
+:687b865b95ad
 # If this is a clone and it was requested to perform a "stream clone",
 # we obtain the raw files data from the remote then fall back to an
 # incremental pull. This is somewhat hacky and is not nearly robust enough
 # for long-term usage.
 if usingrawchangelogandmanifest:
-with repo.transaction('clone'):
+with repo.transaction(b'clone'):
 _fetchrawstorefiles(repo, remote)
 repo.invalidate(clearfilecache=True)
 tr = pullop.trmanager.transaction()
 # to exchange.pull() could be different.
 narrowmatcher = narrowspec.match(
 repo.root,
 # Empty maps to nevermatcher. So always
 # set includes if missing.
-pullop.includepats or {'path:.'},
+pullop.includepats or {b'path:.'},
 pullop.excludepats,
 )
 if pullop.includepats or pullop.excludepats:
 pathfilter = {}
 # New revisions are written to the changelog. But all other updates
 # are deferred. Do those now.
 # Ensure all new changesets are draft by default. If the repo is
 # publishing, the phase will be adjusted by the loop below.
-if csetres['added']:
+if csetres[b'added']:
-phases.registernew(repo, tr, phases.draft, csetres['added'])
+phases.registernew(repo, tr, phases.draft, csetres[b'added'])
 # And adjust the phase of all changesets accordingly.
 for phase in phases.phasenames:
-if phase == b'secret' or not csetres['nodesbyphase'][phase]:
+if phase == b'secret' or not csetres[b'nodesbyphase'][phase]:
 continue
 phases.advanceboundary(
 repo,
 tr,
 phases.phasenames.index(phase),
-csetres['nodesbyphase'][phase],
+csetres[b'nodesbyphase'][phase],
 )
 # Write bookmark updates.
 bookmarks.updatefromremote(
 repo.ui,
 repo,
-csetres['bookmarks'],
+csetres[b'bookmarks'],
 remote.url(),
 pullop.gettransaction,
 explicit=pullop.explicitbookmarks,
 )
-manres = _fetchmanifests(repo, tr, remote, csetres['manifestnodes'])
+manres = _fetchmanifests(repo, tr, remote, csetres[b'manifestnodes'])
 # We don't properly support shallow changeset and manifest yet. So we apply
 # depth limiting locally.
 if pullop.depth:
 relevantcsetnodes = set()
 csetsforfiles.append(node)
 mnodesforfiles.append(mnode)
 manifestlinkrevs[mnode] = rev
 else:
-csetsforfiles = [n for n in csetres['added'] if csetrelevantfilter(n)]
+csetsforfiles = [n for n in csetres[b'added'] if csetrelevantfilter(n)]
-mnodesforfiles = manres['added']
+mnodesforfiles = manres[b'added']
-manifestlinkrevs = manres['linkrevs']
+manifestlinkrevs = manres[b'linkrevs']
 # Find all file nodes referenced by added manifests and fetch those
 # revisions.
 fnodes = _derivefilesfrommanifests(repo, narrowmatcher, mnodesforfiles)
 _fetchfilesfromcsets(
 # First object is a summary of files data that follows.
 overall = next(objs)
 progress = repo.ui.makeprogress(
-_('clone'), total=overall[b'totalsize'], unit=_('bytes')
+_(b'clone'), total=overall[b'totalsize'], unit=_(b'bytes')
 )
 with progress:
 progress.update(0)
 # Next are pairs of file metadata, data.
 # we need to remain in the context manager in order to stream data.
 return _processchangesetdata(repo, tr, objs)
 def _processchangesetdata(repo, tr, objs):
-repo.hook('prechangegroup', throw=True, **pycompat.strkwargs(tr.hookargs))
+repo.hook(b'prechangegroup', throw=True, **pycompat.strkwargs(tr.hookargs))
 urepo = repo.unfiltered()
 cl = urepo.changelog
 cl.delayupdate(tr)
 # The first emitted object is a header describing the data that
 # follows.
 meta = next(objs)
 progress = repo.ui.makeprogress(
-_('changesets'), unit=_('chunks'), total=meta.get(b'totalitems')
+_(b'changesets'), unit=_(b'chunks'), total=meta.get(b'totalitems')
 )
 manifestnodes = {}
 def linkrev(node):
-repo.ui.debug('add changeset %s\n' % short(node))
+repo.ui.debug(b'add changeset %s\n' % short(node))
 # Linkrev for changelog is always self.
 return len(cl)
 def onchangeset(cl, node):
 progress.increment()
 )
 progress.complete()
 return {
-'added': added,
+b'added': added,
-'nodesbyphase': nodesbyphase,
+b'nodesbyphase': nodesbyphase,
-'bookmarks': remotebookmarks,
+b'bookmarks': remotebookmarks,
-'manifestnodes': manifestnodes,
+b'manifestnodes': manifestnodes,
 }
 def _fetchmanifests(repo, tr, remote, manifestnodes):
 rootmanifest = repo.manifestlog.getstorage(b'')
 )
 progress.increment()
 progress = repo.ui.makeprogress(
-_('manifests'), unit=_('chunks'), total=len(fetchnodes)
+_(b'manifests'), unit=_(b'chunks'), total=len(fetchnodes)
 )
 commandmeta = remote.apidescriptor[b'commands'][b'manifestdata']
 batchsize = commandmeta.get(b'recommendedbatchsize', 10000)
 # TODO make size configurable on client?
 )
 progress.complete()
 return {
-'added': added,
+b'added': added,
-'linkrevs': linkrevs,
+b'linkrevs': linkrevs,
 }
 def _derivefilesfrommanifests(repo, matcher, manifestnodes):
 """Determine what file nodes are relevant given a set of manifest nodes.
 """
 ml = repo.manifestlog
 fnodes = collections.defaultdict(dict)
 progress = repo.ui.makeprogress(
-_('scanning manifests'), total=len(manifestnodes)
+_(b'scanning manifests'), total=len(manifestnodes)
 )
 with progress:
 for manifestnode in manifestnodes:
 m = ml.get(b'', manifestnode)
 )
 progress.increment()
 progress = repo.ui.makeprogress(
-_('files'),
+_(b'files'),
-unit=_('chunks'),
+unit=_(b'chunks'),
 total=sum(len(v) for v in fnodes.itervalues()),
 )
 # TODO make batch size configurable
 batchsize = 10000
 progress.increment()
 remaining -= 1
 progress = repo.ui.makeprogress(
-_('files'),
+_(b'files'),
-unit=_('chunks'),
+unit=_(b'chunks'),
 total=sum(len(v) for v in fnodes.itervalues()),
 )
 commandmeta = remote.apidescriptor[b'commands'][b'filesdata']
 batchsize = commandmeta.get(b'recommendedbatchsize', 50000)

changeset 43077	687b865b95ad
parent 43076	2372284d9457
child 43104	74802979dd9d