requirements: introduce new requirements related module

It was not clear where all requirements should and related APIs should be, this
patch introduces a requirements module which will have all exitsing requirements
and related APIs.

Differential Revision: https://phab.mercurial-scm.org/D8917

hgext/narrow/__init__.py

@@ -1,78 +1,78 b''
 # __init__.py - narrowhg extension
 #
 # Copyright 2017 Google, Inc.
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 '''create clones which fetch history data for subset of files (EXPERIMENTAL)'''
 
 from __future__ import absolute_import
 
 from mercurial import (
     localrepo,
     registrar,
+    requirements,
 )
 
-from mercurial.interfaces import repository
 
 from . import (
     narrowbundle2,
     narrowcommands,
     narrowrepo,
     narrowtemplates,
     narrowwirepeer,
 )
 
 # Note for extension authors: ONLY specify testedwith = 'ships-with-hg-core' for
 # extensions which SHIP WITH MERCURIAL. Non-mainline extensions should
 # be specifying the version(s) of Mercurial they are tested with, or
 # leave the attribute unspecified.
 testedwith = b'ships-with-hg-core'
 
 configtable = {}
 configitem = registrar.configitem(configtable)
 # Narrowhg *has* support for serving ellipsis nodes (which are used at
 # least by Google's internal server), but that support is pretty
 # fragile and has a lot of problems on real-world repositories that
 # have complex graph topologies. This could probably be corrected, but
 # absent someone needing the full support for ellipsis nodes in
 # repositories with merges, it's unlikely this work will get done. As
 # of this writining in late 2017, all repositories large enough for
 # ellipsis nodes to be a hard requirement also enforce strictly linear
 # history for other scaling reasons.
 configitem(
     b'experimental',
     b'narrowservebrokenellipses',
     default=False,
     alias=[(b'narrow', b'serveellipses')],
 )
 
 # Export the commands table for Mercurial to see.
 cmdtable = narrowcommands.table
 
 
 def featuresetup(ui, features):
-    features.add(repository.NARROW_REQUIREMENT)
+    features.add(requirements.NARROW_REQUIREMENT)
 
 
 def uisetup(ui):
     """Wraps user-facing mercurial commands with narrow-aware versions."""
     localrepo.featuresetupfuncs.add(featuresetup)
     narrowbundle2.setup()
     narrowcommands.setup()
     narrowwirepeer.uisetup()
 
 
 def reposetup(ui, repo):
     """Wraps local repositories with narrow repo support."""
     if not repo.local():
         return
 
     repo.ui.setconfig(b'experimental', b'narrow', True, b'narrow-ext')
-    if repository.NARROW_REQUIREMENT in repo.requirements:
+    if requirements.NARROW_REQUIREMENT in repo.requirements:
         narrowrepo.wraprepo(repo)
         narrowwirepeer.reposetup(repo)
 
 
 templatekeyword = narrowtemplates.templatekeyword
 revsetpredicate = narrowtemplates.revsetpredicate

hgext/narrow/narrowbundle2.py

@@ -1,343 +1,343 b''
 # narrowbundle2.py - bundle2 extensions for narrow repository support
 #
 # Copyright 2017 Google, Inc.
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 from __future__ import absolute_import
 
 import errno
 import struct
 
 from mercurial.i18n import _
 from mercurial.node import nullid
 from mercurial import (
     bundle2,
     changegroup,
     error,
     exchange,
     localrepo,
     narrowspec,
     repair,
+    requirements,
     scmutil,
     util,
     wireprototypes,
 )
-from mercurial.interfaces import repository
 from mercurial.utils import stringutil
 
 _NARROWACL_SECTION = b'narrowacl'
 _CHANGESPECPART = b'narrow:changespec'
 _RESSPECS = b'narrow:responsespec'
 _SPECPART = b'narrow:spec'
 _SPECPART_INCLUDE = b'include'
 _SPECPART_EXCLUDE = b'exclude'
 _KILLNODESIGNAL = b'KILL'
 _DONESIGNAL = b'DONE'
 _ELIDEDCSHEADER = b'>20s20s20sl'  # cset id, p1, p2, len(text)
 _ELIDEDMFHEADER = b'>20s20s20s20sl'  # manifest id, p1, p2, link id, len(text)
 _CSHEADERSIZE = struct.calcsize(_ELIDEDCSHEADER)
 _MFHEADERSIZE = struct.calcsize(_ELIDEDMFHEADER)
 
 # Serve a changegroup for a client with a narrow clone.
 def getbundlechangegrouppart_narrow(
     bundler,
     repo,
     source,
     bundlecaps=None,
     b2caps=None,
     heads=None,
     common=None,
     **kwargs
 ):
     assert repo.ui.configbool(b'experimental', b'narrowservebrokenellipses')
 
     cgversions = b2caps.get(b'changegroup')
     cgversions = [
         v
         for v in cgversions
         if v in changegroup.supportedoutgoingversions(repo)
     ]
     if not cgversions:
         raise ValueError(_(b'no common changegroup version'))
     version = max(cgversions)
 
     include = sorted(filter(bool, kwargs.get('includepats', [])))
     exclude = sorted(filter(bool, kwargs.get('excludepats', [])))
     generateellipsesbundle2(
         bundler,
         repo,
         include,
         exclude,
         version,
         common,
         heads,
         kwargs.get('depth', None),
     )
 
 
 def generateellipsesbundle2(
     bundler, repo, include, exclude, version, common, heads, depth,
 ):
     match = narrowspec.match(repo.root, include=include, exclude=exclude)
     if depth is not None:
         depth = int(depth)
         if depth < 1:
             raise error.Abort(_(b'depth must be positive, got %d') % depth)
 
     heads = set(heads or repo.heads())
     common = set(common or [nullid])
 
     visitnodes, relevant_nodes, ellipsisroots = exchange._computeellipsis(
         repo, common, heads, set(), match, depth=depth
     )
 
     repo.ui.debug(b'Found %d relevant revs\n' % len(relevant_nodes))
     if visitnodes:
         packer = changegroup.getbundler(
             version,
             repo,
             matcher=match,
             ellipses=True,
             shallow=depth is not None,
             ellipsisroots=ellipsisroots,
             fullnodes=relevant_nodes,
         )
         cgdata = packer.generate(common, visitnodes, False, b'narrow_widen')
 
         part = bundler.newpart(b'changegroup', data=cgdata)
         part.addparam(b'version', version)
-        if repository.TREEMANIFEST_REQUIREMENT in repo.requirements:
+        if requirements.TREEMANIFEST_REQUIREMENT in repo.requirements:
             part.addparam(b'treemanifest', b'1')
 
 
 def generate_ellipses_bundle2_for_widening(
     bundler, repo, oldmatch, newmatch, version, common, known,
 ):
     common = set(common or [nullid])
     # Steps:
     # 1. Send kill for "$known & ::common"
     #
     # 2. Send changegroup for ::common
     #
     # 3. Proceed.
     #
     # In the future, we can send kills for only the specific
     # nodes we know should go away or change shape, and then
     # send a data stream that tells the client something like this:
     #
     # a) apply this changegroup
     # b) apply nodes XXX, YYY, ZZZ that you already have
     # c) goto a
     #
     # until they've built up the full new state.
     knownrevs = {repo.changelog.rev(n) for n in known}
     # TODO: we could send only roots() of this set, and the
     # list of nodes in common, and the client could work out
     # what to strip, instead of us explicitly sending every
     # single node.
     deadrevs = knownrevs
 
     def genkills():
         for r in deadrevs:
             yield _KILLNODESIGNAL
             yield repo.changelog.node(r)
         yield _DONESIGNAL
 
     bundler.newpart(_CHANGESPECPART, data=genkills())
     newvisit, newfull, newellipsis = exchange._computeellipsis(
         repo, set(), common, knownrevs, newmatch
     )
     if newvisit:
         packer = changegroup.getbundler(
             version,
             repo,
             matcher=newmatch,
             ellipses=True,
             shallow=False,
             ellipsisroots=newellipsis,
             fullnodes=newfull,
         )
         cgdata = packer.generate(common, newvisit, False, b'narrow_widen')
 
         part = bundler.newpart(b'changegroup', data=cgdata)
         part.addparam(b'version', version)
-        if repository.TREEMANIFEST_REQUIREMENT in repo.requirements:
+        if requirements.TREEMANIFEST_REQUIREMENT in repo.requirements:
             part.addparam(b'treemanifest', b'1')
 
 
 @bundle2.parthandler(_SPECPART, (_SPECPART_INCLUDE, _SPECPART_EXCLUDE))
 def _handlechangespec_2(op, inpart):
     # XXX: This bundle2 handling is buggy and should be removed after hg5.2 is
     # released. New servers will send a mandatory bundle2 part named
     # 'Narrowspec' and will send specs as data instead of params.
     # Refer to issue5952 and 6019
     includepats = set(inpart.params.get(_SPECPART_INCLUDE, b'').splitlines())
     excludepats = set(inpart.params.get(_SPECPART_EXCLUDE, b'').splitlines())
     narrowspec.validatepatterns(includepats)
     narrowspec.validatepatterns(excludepats)
 
-    if not repository.NARROW_REQUIREMENT in op.repo.requirements:
-        op.repo.requirements.add(repository.NARROW_REQUIREMENT)
+    if not requirements.NARROW_REQUIREMENT in op.repo.requirements:
+        op.repo.requirements.add(requirements.NARROW_REQUIREMENT)
         scmutil.writereporequirements(op.repo)
     op.repo.setnarrowpats(includepats, excludepats)
     narrowspec.copytoworkingcopy(op.repo)
 
 
 @bundle2.parthandler(_RESSPECS)
 def _handlenarrowspecs(op, inpart):
     data = inpart.read()
     inc, exc = data.split(b'\0')
     includepats = set(inc.splitlines())
     excludepats = set(exc.splitlines())
     narrowspec.validatepatterns(includepats)
     narrowspec.validatepatterns(excludepats)
 
-    if repository.NARROW_REQUIREMENT not in op.repo.requirements:
-        op.repo.requirements.add(repository.NARROW_REQUIREMENT)
+    if requirements.NARROW_REQUIREMENT not in op.repo.requirements:
+        op.repo.requirements.add(requirements.NARROW_REQUIREMENT)
         scmutil.writereporequirements(op.repo)
     op.repo.setnarrowpats(includepats, excludepats)
     narrowspec.copytoworkingcopy(op.repo)
 
 
 @bundle2.parthandler(_CHANGESPECPART)
 def _handlechangespec(op, inpart):
     repo = op.repo
     cl = repo.changelog
 
     # changesets which need to be stripped entirely. either they're no longer
     # needed in the new narrow spec, or the server is sending a replacement
     # in the changegroup part.
     clkills = set()
 
     # A changespec part contains all the updates to ellipsis nodes
     # that will happen as a result of widening or narrowing a
     # repo. All the changes that this block encounters are ellipsis
     # nodes or flags to kill an existing ellipsis.
     chunksignal = changegroup.readexactly(inpart, 4)
     while chunksignal != _DONESIGNAL:
         if chunksignal == _KILLNODESIGNAL:
             # a node used to be an ellipsis but isn't anymore
             ck = changegroup.readexactly(inpart, 20)
             if cl.hasnode(ck):
                 clkills.add(ck)
         else:
             raise error.Abort(
                 _(b'unexpected changespec node chunk type: %s') % chunksignal
             )
         chunksignal = changegroup.readexactly(inpart, 4)
 
     if clkills:
         # preserve bookmarks that repair.strip() would otherwise strip
         op._bookmarksbackup = repo._bookmarks
 
         class dummybmstore(dict):
             def applychanges(self, repo, tr, changes):
                 pass
 
         localrepo.localrepository._bookmarks.set(repo, dummybmstore())
         chgrpfile = repair.strip(
             op.ui, repo, list(clkills), backup=True, topic=b'widen'
         )
         if chgrpfile:
             op._widen_uninterr = repo.ui.uninterruptible()
             op._widen_uninterr.__enter__()
             # presence of _widen_bundle attribute activates widen handler later
             op._widen_bundle = chgrpfile
     # Set the new narrowspec if we're widening. The setnewnarrowpats() method
     # will currently always be there when using the core+narrowhg server, but
     # other servers may include a changespec part even when not widening (e.g.
     # because we're deepening a shallow repo).
     if util.safehasattr(repo, 'setnewnarrowpats'):
         repo.setnewnarrowpats()
 
 
 def handlechangegroup_widen(op, inpart):
     """Changegroup exchange handler which restores temporarily-stripped nodes"""
     # We saved a bundle with stripped node data we must now restore.
     # This approach is based on mercurial/repair.py@6ee26a53c111.
     repo = op.repo
     ui = op.ui
 
     chgrpfile = op._widen_bundle
     del op._widen_bundle
     vfs = repo.vfs
 
     ui.note(_(b"adding branch\n"))
     f = vfs.open(chgrpfile, b"rb")
     try:
         gen = exchange.readbundle(ui, f, chgrpfile, vfs)
         # silence internal shuffling chatter
         override = {(b'ui', b'quiet'): True}
         if ui.verbose:
             override = {}
         with ui.configoverride(override):
             if isinstance(gen, bundle2.unbundle20):
                 with repo.transaction(b'strip') as tr:
                     bundle2.processbundle(repo, gen, lambda: tr)
             else:
                 gen.apply(
                     repo, b'strip', b'bundle:' + vfs.join(chgrpfile), True
                 )
     finally:
         f.close()
 
     # remove undo files
     for undovfs, undofile in repo.undofiles():
         try:
             undovfs.unlink(undofile)
         except OSError as e:
             if e.errno != errno.ENOENT:
                 ui.warn(
                     _(b'error removing %s: %s\n')
                     % (undovfs.join(undofile), stringutil.forcebytestr(e))
                 )
 
     # Remove partial backup only if there were no exceptions
     op._widen_uninterr.__exit__(None, None, None)
     vfs.unlink(chgrpfile)
 
 
 def setup():
     """Enable narrow repo support in bundle2-related extension points."""
     getbundleargs = wireprototypes.GETBUNDLE_ARGUMENTS
 
     getbundleargs[b'narrow'] = b'boolean'
     getbundleargs[b'depth'] = b'plain'
     getbundleargs[b'oldincludepats'] = b'csv'
     getbundleargs[b'oldexcludepats'] = b'csv'
     getbundleargs[b'known'] = b'csv'
 
     # Extend changegroup serving to handle requests from narrow clients.
     origcgfn = exchange.getbundle2partsmapping[b'changegroup']
 
     def wrappedcgfn(*args, **kwargs):
         repo = args[1]
         if repo.ui.has_section(_NARROWACL_SECTION):
             kwargs = exchange.applynarrowacl(repo, kwargs)
 
         if kwargs.get('narrow', False) and repo.ui.configbool(
             b'experimental', b'narrowservebrokenellipses'
         ):
             getbundlechangegrouppart_narrow(*args, **kwargs)
         else:
             origcgfn(*args, **kwargs)
 
     exchange.getbundle2partsmapping[b'changegroup'] = wrappedcgfn
 
     # Extend changegroup receiver so client can fixup after widen requests.
     origcghandler = bundle2.parthandlermapping[b'changegroup']
 
     def wrappedcghandler(op, inpart):
         origcghandler(op, inpart)
         if util.safehasattr(op, '_widen_bundle'):
             handlechangegroup_widen(op, inpart)
         if util.safehasattr(op, '_bookmarksbackup'):
             localrepo.localrepository._bookmarks.set(
                 op.repo, op._bookmarksbackup
             )
             del op._bookmarksbackup
 
     wrappedcghandler.params = origcghandler.params
     bundle2.parthandlermapping[b'changegroup'] = wrappedcghandler

hgext/narrow/narrowcommands.py

@@ -1,659 +1,659 b''
 # narrowcommands.py - command modifications for narrowhg extension
 #
 # Copyright 2017 Google, Inc.
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 from __future__ import absolute_import
 
 import itertools
 import os
 
 from mercurial.i18n import _
 from mercurial import (
     bundle2,
     cmdutil,
     commands,
     discovery,
     encoding,
     error,
     exchange,
     extensions,
     hg,
     narrowspec,
     node,
     pathutil,
     pycompat,
     registrar,
     repair,
     repoview,
+    requirements,
     sparse,
     util,
     wireprototypes,
 )
-from mercurial.interfaces import repository
 
 table = {}
 command = registrar.command(table)
 
 
 def setup():
     """Wraps user-facing mercurial commands with narrow-aware versions."""
 
     entry = extensions.wrapcommand(commands.table, b'clone', clonenarrowcmd)
     entry[1].append(
         (b'', b'narrow', None, _(b"create a narrow clone of select files"))
     )
     entry[1].append(
         (
             b'',
             b'depth',
             b'',
             _(b"limit the history fetched by distance from heads"),
         )
     )
     entry[1].append((b'', b'narrowspec', b'', _(b"read narrowspecs from file")))
     # TODO(durin42): unify sparse/narrow --include/--exclude logic a bit
     if b'sparse' not in extensions.enabled():
         entry[1].append(
             (b'', b'include', [], _(b"specifically fetch this file/directory"))
         )
         entry[1].append(
             (
                 b'',
                 b'exclude',
                 [],
                 _(b"do not fetch this file/directory, even if included"),
             )
         )
 
     entry = extensions.wrapcommand(commands.table, b'pull', pullnarrowcmd)
     entry[1].append(
         (
             b'',
             b'depth',
             b'',
             _(b"limit the history fetched by distance from heads"),
         )
     )
 
     extensions.wrapcommand(commands.table, b'archive', archivenarrowcmd)
 
 
 def clonenarrowcmd(orig, ui, repo, *args, **opts):
     """Wraps clone command, so 'hg clone' first wraps localrepo.clone()."""
     opts = pycompat.byteskwargs(opts)
     wrappedextraprepare = util.nullcontextmanager()
     narrowspecfile = opts[b'narrowspec']
 
     if narrowspecfile:
         filepath = os.path.join(encoding.getcwd(), narrowspecfile)
         ui.status(_(b"reading narrowspec from '%s'\n") % filepath)
         try:
             fdata = util.readfile(filepath)
         except IOError as inst:
             raise error.Abort(
                 _(b"cannot read narrowspecs from '%s': %s")
                 % (filepath, encoding.strtolocal(inst.strerror))
             )
 
         includes, excludes, profiles = sparse.parseconfig(ui, fdata, b'narrow')
         if profiles:
             raise error.Abort(
                 _(
                     b"cannot specify other files using '%include' in"
                     b" narrowspec"
                 )
             )
 
         narrowspec.validatepatterns(includes)
         narrowspec.validatepatterns(excludes)
 
         # narrowspec is passed so we should assume that user wants narrow clone
         opts[b'narrow'] = True
         opts[b'include'].extend(includes)
         opts[b'exclude'].extend(excludes)
 
     if opts[b'narrow']:
 
         def pullbundle2extraprepare_widen(orig, pullop, kwargs):
             orig(pullop, kwargs)
 
             if opts.get(b'depth'):
                 kwargs[b'depth'] = opts[b'depth']
 
         wrappedextraprepare = extensions.wrappedfunction(
             exchange, b'_pullbundle2extraprepare', pullbundle2extraprepare_widen
         )
 
     with wrappedextraprepare:
         return orig(ui, repo, *args, **pycompat.strkwargs(opts))
 
 
 def pullnarrowcmd(orig, ui, repo, *args, **opts):
     """Wraps pull command to allow modifying narrow spec."""
     wrappedextraprepare = util.nullcontextmanager()
-    if repository.NARROW_REQUIREMENT in repo.requirements:
+    if requirements.NARROW_REQUIREMENT in repo.requirements:
 
         def pullbundle2extraprepare_widen(orig, pullop, kwargs):
             orig(pullop, kwargs)
             if opts.get('depth'):
                 kwargs[b'depth'] = opts['depth']
 
         wrappedextraprepare = extensions.wrappedfunction(
             exchange, b'_pullbundle2extraprepare', pullbundle2extraprepare_widen
         )
 
     with wrappedextraprepare:
         return orig(ui, repo, *args, **opts)
 
 
 def archivenarrowcmd(orig, ui, repo, *args, **opts):
     """Wraps archive command to narrow the default includes."""
-    if repository.NARROW_REQUIREMENT in repo.requirements:
+    if requirements.NARROW_REQUIREMENT in repo.requirements:
         repo_includes, repo_excludes = repo.narrowpats
         includes = set(opts.get('include', []))
         excludes = set(opts.get('exclude', []))
         includes, excludes, unused_invalid = narrowspec.restrictpatterns(
             includes, excludes, repo_includes, repo_excludes
         )
         if includes:
             opts['include'] = includes
         if excludes:
             opts['exclude'] = excludes
     return orig(ui, repo, *args, **opts)
 
 
 def pullbundle2extraprepare(orig, pullop, kwargs):
     repo = pullop.repo
-    if repository.NARROW_REQUIREMENT not in repo.requirements:
+    if requirements.NARROW_REQUIREMENT not in repo.requirements:
         return orig(pullop, kwargs)
 
     if wireprototypes.NARROWCAP not in pullop.remote.capabilities():
         raise error.Abort(_(b"server does not support narrow clones"))
     orig(pullop, kwargs)
     kwargs[b'narrow'] = True
     include, exclude = repo.narrowpats
     kwargs[b'oldincludepats'] = include
     kwargs[b'oldexcludepats'] = exclude
     if include:
         kwargs[b'includepats'] = include
     if exclude:
         kwargs[b'excludepats'] = exclude
     # calculate known nodes only in ellipses cases because in non-ellipses cases
     # we have all the nodes
     if wireprototypes.ELLIPSESCAP1 in pullop.remote.capabilities():
         kwargs[b'known'] = [
             node.hex(ctx.node())
             for ctx in repo.set(b'::%ln', pullop.common)
             if ctx.node() != node.nullid
         ]
         if not kwargs[b'known']:
             # Mercurial serializes an empty list as '' and deserializes it as
             # [''], so delete it instead to avoid handling the empty string on
             # the server.
             del kwargs[b'known']
 
 
 extensions.wrapfunction(
     exchange, b'_pullbundle2extraprepare', pullbundle2extraprepare
 )
 
 
 def _narrow(
     ui,
     repo,
     remote,
     commoninc,
     oldincludes,
     oldexcludes,
     newincludes,
     newexcludes,
     force,
 ):
     oldmatch = narrowspec.match(repo.root, oldincludes, oldexcludes)
     newmatch = narrowspec.match(repo.root, newincludes, newexcludes)
 
     # This is essentially doing "hg outgoing" to find all local-only
     # commits. We will then check that the local-only commits don't
     # have any changes to files that will be untracked.
     unfi = repo.unfiltered()
     outgoing = discovery.findcommonoutgoing(unfi, remote, commoninc=commoninc)
     ui.status(_(b'looking for local changes to affected paths\n'))
     localnodes = []
     for n in itertools.chain(outgoing.missing, outgoing.excluded):
         if any(oldmatch(f) and not newmatch(f) for f in unfi[n].files()):
             localnodes.append(n)
     revstostrip = unfi.revs(b'descendants(%ln)', localnodes)
     hiddenrevs = repoview.filterrevs(repo, b'visible')
     visibletostrip = list(
         repo.changelog.node(r) for r in (revstostrip - hiddenrevs)
     )
     if visibletostrip:
         ui.status(
             _(
                 b'The following changeset(s) or their ancestors have '
                 b'local changes not on the remote:\n'
             )
         )
         maxnodes = 10
         if ui.verbose or len(visibletostrip) <= maxnodes:
             for n in visibletostrip:
                 ui.status(b'%s\n' % node.short(n))
         else:
             for n in visibletostrip[:maxnodes]:
                 ui.status(b'%s\n' % node.short(n))
             ui.status(
                 _(b'...and %d more, use --verbose to list all\n')
                 % (len(visibletostrip) - maxnodes)
             )
         if not force:
             raise error.Abort(
                 _(b'local changes found'),
                 hint=_(b'use --force-delete-local-changes to ignore'),
             )
 
     with ui.uninterruptible():
         if revstostrip:
             tostrip = [unfi.changelog.node(r) for r in revstostrip]
             if repo[b'.'].node() in tostrip:
                 # stripping working copy, so move to a different commit first
                 urev = max(
                     repo.revs(
                         b'(::%n) - %ln + null',
                         repo[b'.'].node(),
                         visibletostrip,
                     )
                 )
                 hg.clean(repo, urev)
             overrides = {(b'devel', b'strip-obsmarkers'): False}
             with ui.configoverride(overrides, b'narrow'):
                 repair.strip(ui, unfi, tostrip, topic=b'narrow')
 
         todelete = []
         for f, f2, size in repo.store.datafiles():
             if f.startswith(b'data/'):
                 file = f[5:-2]
                 if not newmatch(file):
                     todelete.append(f)
             elif f.startswith(b'meta/'):
                 dir = f[5:-13]
                 dirs = sorted(pathutil.dirs({dir})) + [dir]
                 include = True
                 for d in dirs:
                     visit = newmatch.visitdir(d)
                     if not visit:
                         include = False
                         break
                     if visit == b'all':
                         break
                 if not include:
                     todelete.append(f)
 
         repo.destroying()
 
         with repo.transaction(b'narrowing'):
             # Update narrowspec before removing revlogs, so repo won't be
             # corrupt in case of crash
             repo.setnarrowpats(newincludes, newexcludes)
 
             for f in todelete:
                 ui.status(_(b'deleting %s\n') % f)
                 util.unlinkpath(repo.svfs.join(f))
                 repo.store.markremoved(f)
 
             narrowspec.updateworkingcopy(repo, assumeclean=True)
             narrowspec.copytoworkingcopy(repo)
 
         repo.destroyed()
 
 
 def _widen(
     ui,
     repo,
     remote,
     commoninc,
     oldincludes,
     oldexcludes,
     newincludes,
     newexcludes,
 ):
     # for now we assume that if a server has ellipses enabled, we will be
     # exchanging ellipses nodes. In future we should add ellipses as a client
     # side requirement (maybe) to distinguish a client is shallow or not and
     # then send that information to server whether we want ellipses or not.
     # Theoretically a non-ellipses repo should be able to use narrow
     # functionality from an ellipses enabled server
     remotecap = remote.capabilities()
     ellipsesremote = any(
         cap in remotecap for cap in wireprototypes.SUPPORTED_ELLIPSESCAP
     )
 
     # check whether we are talking to a server which supports old version of
     # ellipses capabilities
     isoldellipses = (
         ellipsesremote
         and wireprototypes.ELLIPSESCAP1 in remotecap
         and wireprototypes.ELLIPSESCAP not in remotecap
     )
 
     def pullbundle2extraprepare_widen(orig, pullop, kwargs):
         orig(pullop, kwargs)
         # The old{in,ex}cludepats have already been set by orig()
         kwargs[b'includepats'] = newincludes
         kwargs[b'excludepats'] = newexcludes
 
     wrappedextraprepare = extensions.wrappedfunction(
         exchange, b'_pullbundle2extraprepare', pullbundle2extraprepare_widen
     )
 
     # define a function that narrowbundle2 can call after creating the
     # backup bundle, but before applying the bundle from the server
     def setnewnarrowpats():
         repo.setnarrowpats(newincludes, newexcludes)
 
     repo.setnewnarrowpats = setnewnarrowpats
     # silence the devel-warning of applying an empty changegroup
     overrides = {(b'devel', b'all-warnings'): False}
 
     common = commoninc[0]
     with ui.uninterruptible():
         if ellipsesremote:
             ds = repo.dirstate
             p1, p2 = ds.p1(), ds.p2()
             with ds.parentchange():
                 ds.setparents(node.nullid, node.nullid)
         if isoldellipses:
             with wrappedextraprepare:
                 exchange.pull(repo, remote, heads=common)
         else:
             known = []
             if ellipsesremote:
                 known = [
                     ctx.node()
                     for ctx in repo.set(b'::%ln', common)
                     if ctx.node() != node.nullid
                 ]
             with remote.commandexecutor() as e:
                 bundle = e.callcommand(
                     b'narrow_widen',
                     {
                         b'oldincludes': oldincludes,
                         b'oldexcludes': oldexcludes,
                         b'newincludes': newincludes,
                         b'newexcludes': newexcludes,
                         b'cgversion': b'03',
                         b'commonheads': common,
                         b'known': known,
                         b'ellipses': ellipsesremote,
                     },
                 ).result()
 
             trmanager = exchange.transactionmanager(
                 repo, b'widen', remote.url()
             )
             with trmanager, repo.ui.configoverride(overrides, b'widen'):
                 op = bundle2.bundleoperation(
                     repo, trmanager.transaction, source=b'widen'
                 )
                 # TODO: we should catch error.Abort here
                 bundle2.processbundle(repo, bundle, op=op)
 
         if ellipsesremote:
             with ds.parentchange():
                 ds.setparents(p1, p2)
 
         with repo.transaction(b'widening'):
             repo.setnewnarrowpats()
             narrowspec.updateworkingcopy(repo)
             narrowspec.copytoworkingcopy(repo)
 
 
 # TODO(rdamazio): Make new matcher format and update description
 @command(
     b'tracked',
     [
         (b'', b'addinclude', [], _(b'new paths to include')),
         (b'', b'removeinclude', [], _(b'old paths to no longer include')),
         (
             b'',
             b'auto-remove-includes',
             False,
             _(b'automatically choose unused includes to remove'),
         ),
         (b'', b'addexclude', [], _(b'new paths to exclude')),
         (b'', b'import-rules', b'', _(b'import narrowspecs from a file')),
         (b'', b'removeexclude', [], _(b'old paths to no longer exclude')),
         (
             b'',
             b'clear',
             False,
             _(b'whether to replace the existing narrowspec'),
         ),
         (
             b'',
             b'force-delete-local-changes',
             False,
             _(b'forces deletion of local changes when narrowing'),
         ),
         (
             b'',
             b'update-working-copy',
             False,
             _(b'update working copy when the store has changed'),
         ),
     ]
     + commands.remoteopts,
     _(b'[OPTIONS]... [REMOTE]'),
     inferrepo=True,
     helpcategory=command.CATEGORY_MAINTENANCE,
 )
 def trackedcmd(ui, repo, remotepath=None, *pats, **opts):
     """show or change the current narrowspec
 
     With no argument, shows the current narrowspec entries, one per line. Each
     line will be prefixed with 'I' or 'X' for included or excluded patterns,
     respectively.
 
     The narrowspec is comprised of expressions to match remote files and/or
     directories that should be pulled into your client.
     The narrowspec has *include* and *exclude* expressions, with excludes always
     trumping includes: that is, if a file matches an exclude expression, it will
     be excluded even if it also matches an include expression.
     Excluding files that were never included has no effect.
 
     Each included or excluded entry is in the format described by
     'hg help patterns'.
 
     The options allow you to add or remove included and excluded expressions.
 
     If --clear is specified, then all previous includes and excludes are DROPPED
     and replaced by the new ones specified to --addinclude and --addexclude.
     If --clear is specified without any further options, the narrowspec will be
     empty and will not match any files.
 
     If --auto-remove-includes is specified, then those includes that don't match
     any files modified by currently visible local commits (those not shared by
     the remote) will be added to the set of explicitly specified includes to
     remove.
 
     --import-rules accepts a path to a file containing rules, allowing you to
     add --addinclude, --addexclude rules in bulk. Like the other include and
     exclude switches, the changes are applied immediately.
     """
     opts = pycompat.byteskwargs(opts)
-    if repository.NARROW_REQUIREMENT not in repo.requirements:
+    if requirements.NARROW_REQUIREMENT not in repo.requirements:
         raise error.Abort(
             _(
                 b'the tracked command is only supported on '
                 b'repositories cloned with --narrow'
             )
         )
 
     # Before supporting, decide whether it "hg tracked --clear" should mean
     # tracking no paths or all paths.
     if opts[b'clear']:
         raise error.Abort(_(b'the --clear option is not yet supported'))
 
     # import rules from a file
     newrules = opts.get(b'import_rules')
     if newrules:
         try:
             filepath = os.path.join(encoding.getcwd(), newrules)
             fdata = util.readfile(filepath)
         except IOError as inst:
             raise error.Abort(
                 _(b"cannot read narrowspecs from '%s': %s")
                 % (filepath, encoding.strtolocal(inst.strerror))
             )
         includepats, excludepats, profiles = sparse.parseconfig(
             ui, fdata, b'narrow'
         )
         if profiles:
             raise error.Abort(
                 _(
                     b"including other spec files using '%include' "
                     b"is not supported in narrowspec"
                 )
             )
         opts[b'addinclude'].extend(includepats)
         opts[b'addexclude'].extend(excludepats)
 
     addedincludes = narrowspec.parsepatterns(opts[b'addinclude'])
     removedincludes = narrowspec.parsepatterns(opts[b'removeinclude'])
     addedexcludes = narrowspec.parsepatterns(opts[b'addexclude'])
     removedexcludes = narrowspec.parsepatterns(opts[b'removeexclude'])
     autoremoveincludes = opts[b'auto_remove_includes']
 
     update_working_copy = opts[b'update_working_copy']
     only_show = not (
         addedincludes
         or removedincludes
         or addedexcludes
         or removedexcludes
         or newrules
         or autoremoveincludes
         or update_working_copy
     )
 
     oldincludes, oldexcludes = repo.narrowpats
 
     # filter the user passed additions and deletions into actual additions and
     # deletions of excludes and includes
     addedincludes -= oldincludes
     removedincludes &= oldincludes
     addedexcludes -= oldexcludes
     removedexcludes &= oldexcludes
 
     widening = addedincludes or removedexcludes
     narrowing = removedincludes or addedexcludes
 
     # Only print the current narrowspec.
     if only_show:
         ui.pager(b'tracked')
         fm = ui.formatter(b'narrow', opts)
         for i in sorted(oldincludes):
             fm.startitem()
             fm.write(b'status', b'%s ', b'I', label=b'narrow.included')
             fm.write(b'pat', b'%s\n', i, label=b'narrow.included')
         for i in sorted(oldexcludes):
             fm.startitem()
             fm.write(b'status', b'%s ', b'X', label=b'narrow.excluded')
             fm.write(b'pat', b'%s\n', i, label=b'narrow.excluded')
         fm.end()
         return 0
 
     if update_working_copy:
         with repo.wlock(), repo.lock(), repo.transaction(b'narrow-wc'):
             narrowspec.updateworkingcopy(repo)
             narrowspec.copytoworkingcopy(repo)
         return 0
 
     if not (widening or narrowing or autoremoveincludes):
         ui.status(_(b"nothing to widen or narrow\n"))
         return 0
 
     with repo.wlock(), repo.lock():
         cmdutil.bailifchanged(repo)
 
         # Find the revisions we have in common with the remote. These will
         # be used for finding local-only changes for narrowing. They will
         # also define the set of revisions to update for widening.
         remotepath = ui.expandpath(remotepath or b'default')
         url, branches = hg.parseurl(remotepath)
         ui.status(_(b'comparing with %s\n') % util.hidepassword(url))
         remote = hg.peer(repo, opts, url)
 
         # check narrow support before doing anything if widening needs to be
         # performed. In future we should also abort if client is ellipses and
         # server does not support ellipses
         if widening and wireprototypes.NARROWCAP not in remote.capabilities():
             raise error.Abort(_(b"server does not support narrow clones"))
 
         commoninc = discovery.findcommonincoming(repo, remote)
 
         if autoremoveincludes:
             outgoing = discovery.findcommonoutgoing(
                 repo, remote, commoninc=commoninc
             )
             ui.status(_(b'looking for unused includes to remove\n'))
             localfiles = set()
             for n in itertools.chain(outgoing.missing, outgoing.excluded):
                 localfiles.update(repo[n].files())
             suggestedremovals = []
             for include in sorted(oldincludes):
                 match = narrowspec.match(repo.root, [include], oldexcludes)
                 if not any(match(f) for f in localfiles):
                     suggestedremovals.append(include)
             if suggestedremovals:
                 for s in suggestedremovals:
                     ui.status(b'%s\n' % s)
                 if (
                     ui.promptchoice(
                         _(
                             b'remove these unused includes (yn)?'
                             b'$$ &Yes $$ &No'
                         )
                     )
                     == 0
                 ):
                     removedincludes.update(suggestedremovals)
                     narrowing = True
             else:
                 ui.status(_(b'found no unused includes\n'))
 
         if narrowing:
             newincludes = oldincludes - removedincludes
             newexcludes = oldexcludes | addedexcludes
             _narrow(
                 ui,
                 repo,
                 remote,
                 commoninc,
                 oldincludes,
                 oldexcludes,
                 newincludes,
                 newexcludes,
                 opts[b'force_delete_local_changes'],
             )
             # _narrow() updated the narrowspec and _widen() below needs to
             # use the updated values as its base (otherwise removed includes
             # and addedexcludes will be lost in the resulting narrowspec)
             oldincludes = newincludes
             oldexcludes = newexcludes
 
         if widening:
             newincludes = oldincludes | addedincludes
             newexcludes = oldexcludes - removedexcludes
             _widen(
                 ui,
                 repo,
                 remote,
                 commoninc,
                 oldincludes,
                 oldexcludes,
                 newincludes,
                 newexcludes,
             )
 
     return 0

hgext/remotefilelog/remotefilelogserver.py

@@ -1,443 +1,443 b''
 # remotefilelogserver.py - server logic for a remotefilelog server
 #
 # Copyright 2013 Facebook, Inc.
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 from __future__ import absolute_import
 
 import errno
 import os
 import stat
 import time
 import zlib
 
 from mercurial.i18n import _
 from mercurial.node import bin, hex, nullid
 from mercurial.pycompat import open
 from mercurial import (
     changegroup,
     changelog,
     context,
     error,
     extensions,
     match,
     pycompat,
+    requirements,
     store,
     streamclone,
     util,
     wireprotoserver,
     wireprototypes,
     wireprotov1server,
 )
-from mercurial.interfaces import repository
 from . import (
     constants,
     shallowutil,
 )
 
 _sshv1server = wireprotoserver.sshv1protocolhandler
 
 
 def setupserver(ui, repo):
     """Sets up a normal Mercurial repo so it can serve files to shallow repos.
     """
     onetimesetup(ui)
 
     # don't send files to shallow clients during pulls
     def generatefiles(
         orig, self, changedfiles, linknodes, commonrevs, source, *args, **kwargs
     ):
         caps = self._bundlecaps or []
         if constants.BUNDLE2_CAPABLITY in caps:
             # only send files that don't match the specified patterns
             includepattern = None
             excludepattern = None
             for cap in self._bundlecaps or []:
                 if cap.startswith(b"includepattern="):
                     includepattern = cap[len(b"includepattern=") :].split(b'\0')
                 elif cap.startswith(b"excludepattern="):
                     excludepattern = cap[len(b"excludepattern=") :].split(b'\0')
 
             m = match.always()
             if includepattern or excludepattern:
                 m = match.match(
                     repo.root, b'', None, includepattern, excludepattern
                 )
 
             changedfiles = list([f for f in changedfiles if not m(f)])
         return orig(
             self, changedfiles, linknodes, commonrevs, source, *args, **kwargs
         )
 
     extensions.wrapfunction(
         changegroup.cgpacker, b'generatefiles', generatefiles
     )
 
 
 onetime = False
 
 
 def onetimesetup(ui):
     """Configures the wireprotocol for both clients and servers.
     """
     global onetime
     if onetime:
         return
     onetime = True
 
     # support file content requests
     wireprotov1server.wireprotocommand(
         b'x_rfl_getflogheads', b'path', permission=b'pull'
     )(getflogheads)
     wireprotov1server.wireprotocommand(
         b'x_rfl_getfiles', b'', permission=b'pull'
     )(getfiles)
     wireprotov1server.wireprotocommand(
         b'x_rfl_getfile', b'file node', permission=b'pull'
     )(getfile)
 
     class streamstate(object):
         match = None
         shallowremote = False
         noflatmf = False
 
     state = streamstate()
 
     def stream_out_shallow(repo, proto, other):
         includepattern = None
         excludepattern = None
         raw = other.get(b'includepattern')
         if raw:
             includepattern = raw.split(b'\0')
         raw = other.get(b'excludepattern')
         if raw:
             excludepattern = raw.split(b'\0')
 
         oldshallow = state.shallowremote
         oldmatch = state.match
         oldnoflatmf = state.noflatmf
         try:
             state.shallowremote = True
             state.match = match.always()
             state.noflatmf = other.get(b'noflatmanifest') == b'True'
             if includepattern or excludepattern:
                 state.match = match.match(
                     repo.root, b'', None, includepattern, excludepattern
                 )
             streamres = wireprotov1server.stream(repo, proto)
 
             # Force the first value to execute, so the file list is computed
             # within the try/finally scope
             first = next(streamres.gen)
             second = next(streamres.gen)
 
             def gen():
                 yield first
                 yield second
                 for value in streamres.gen:
                     yield value
 
             return wireprototypes.streamres(gen())
         finally:
             state.shallowremote = oldshallow
             state.match = oldmatch
             state.noflatmf = oldnoflatmf
 
     wireprotov1server.commands[b'stream_out_shallow'] = (
         stream_out_shallow,
         b'*',
     )
 
     # don't clone filelogs to shallow clients
     def _walkstreamfiles(orig, repo, matcher=None):
         if state.shallowremote:
             # if we are shallow ourselves, stream our local commits
             if shallowutil.isenabled(repo):
                 striplen = len(repo.store.path) + 1
                 readdir = repo.store.rawvfs.readdir
                 visit = [os.path.join(repo.store.path, b'data')]
                 while visit:
                     p = visit.pop()
                     for f, kind, st in readdir(p, stat=True):
                         fp = p + b'/' + f
                         if kind == stat.S_IFREG:
                             if not fp.endswith(b'.i') and not fp.endswith(
                                 b'.d'
                             ):
                                 n = util.pconvert(fp[striplen:])
                                 yield (store.decodedir(n), n, st.st_size)
                         if kind == stat.S_IFDIR:
                             visit.append(fp)
 
-            if repository.TREEMANIFEST_REQUIREMENT in repo.requirements:
+            if requirements.TREEMANIFEST_REQUIREMENT in repo.requirements:
                 for (u, e, s) in repo.store.datafiles():
                     if u.startswith(b'meta/') and (
                         u.endswith(b'.i') or u.endswith(b'.d')
                     ):
                         yield (u, e, s)
 
             # Return .d and .i files that do not match the shallow pattern
             match = state.match
             if match and not match.always():
                 for (u, e, s) in repo.store.datafiles():
                     f = u[5:-2]  # trim data/...  and .i/.d
                     if not state.match(f):
                         yield (u, e, s)
 
             for x in repo.store.topfiles():
                 if state.noflatmf and x[0][:11] == b'00manifest.':
                     continue
                 yield x
 
         elif shallowutil.isenabled(repo):
             # don't allow cloning from a shallow repo to a full repo
             # since it would require fetching every version of every
             # file in order to create the revlogs.
             raise error.Abort(
                 _(b"Cannot clone from a shallow repo to a full repo.")
             )
         else:
             for x in orig(repo, matcher):
                 yield x
 
     extensions.wrapfunction(streamclone, b'_walkstreamfiles', _walkstreamfiles)
 
     # expose remotefilelog capabilities
     def _capabilities(orig, repo, proto):
         caps = orig(repo, proto)
         if shallowutil.isenabled(repo) or ui.configbool(
             b'remotefilelog', b'server'
         ):
             if isinstance(proto, _sshv1server):
                 # legacy getfiles method which only works over ssh
                 caps.append(constants.NETWORK_CAP_LEGACY_SSH_GETFILES)
             caps.append(b'x_rfl_getflogheads')
             caps.append(b'x_rfl_getfile')
         return caps
 
     extensions.wrapfunction(wireprotov1server, b'_capabilities', _capabilities)
 
     def _adjustlinkrev(orig, self, *args, **kwargs):
         # When generating file blobs, taking the real path is too slow on large
         # repos, so force it to just return the linkrev directly.
         repo = self._repo
         if util.safehasattr(repo, b'forcelinkrev') and repo.forcelinkrev:
             return self._filelog.linkrev(self._filelog.rev(self._filenode))
         return orig(self, *args, **kwargs)
 
     extensions.wrapfunction(
         context.basefilectx, b'_adjustlinkrev', _adjustlinkrev
     )
 
     def _iscmd(orig, cmd):
         if cmd == b'x_rfl_getfiles':
             return False
         return orig(cmd)
 
     extensions.wrapfunction(wireprotoserver, b'iscmd', _iscmd)
 
 
 def _loadfileblob(repo, cachepath, path, node):
     filecachepath = os.path.join(cachepath, path, hex(node))
     if not os.path.exists(filecachepath) or os.path.getsize(filecachepath) == 0:
         filectx = repo.filectx(path, fileid=node)
         if filectx.node() == nullid:
             repo.changelog = changelog.changelog(repo.svfs)
             filectx = repo.filectx(path, fileid=node)
 
         text = createfileblob(filectx)
         # TODO configurable compression engines
         text = zlib.compress(text)
 
         # everything should be user & group read/writable
         oldumask = os.umask(0o002)
         try:
             dirname = os.path.dirname(filecachepath)
             if not os.path.exists(dirname):
                 try:
                     os.makedirs(dirname)
                 except OSError as ex:
                     if ex.errno != errno.EEXIST:
                         raise
 
             f = None
             try:
                 f = util.atomictempfile(filecachepath, b"wb")
                 f.write(text)
             except (IOError, OSError):
                 # Don't abort if the user only has permission to read,
                 # and not write.
                 pass
             finally:
                 if f:
                     f.close()
         finally:
             os.umask(oldumask)
     else:
         with open(filecachepath, b"rb") as f:
             text = f.read()
     return text
 
 
 def getflogheads(repo, proto, path):
     """A server api for requesting a filelog's heads
     """
     flog = repo.file(path)
     heads = flog.heads()
     return b'\n'.join((hex(head) for head in heads if head != nullid))
 
 
 def getfile(repo, proto, file, node):
     """A server api for requesting a particular version of a file. Can be used
     in batches to request many files at once. The return protocol is:
     <errorcode>\0<data/errormsg> where <errorcode> is 0 for success or
     non-zero for an error.
 
     data is a compressed blob with revlog flag and ancestors information. See
     createfileblob for its content.
     """
     if shallowutil.isenabled(repo):
         return b'1\0' + _(b'cannot fetch remote files from shallow repo')
     cachepath = repo.ui.config(b"remotefilelog", b"servercachepath")
     if not cachepath:
         cachepath = os.path.join(repo.path, b"remotefilelogcache")
     node = bin(node.strip())
     if node == nullid:
         return b'0\0'
     return b'0\0' + _loadfileblob(repo, cachepath, file, node)
 
 
 def getfiles(repo, proto):
     """A server api for requesting particular versions of particular files.
     """
     if shallowutil.isenabled(repo):
         raise error.Abort(_(b'cannot fetch remote files from shallow repo'))
     if not isinstance(proto, _sshv1server):
         raise error.Abort(_(b'cannot fetch remote files over non-ssh protocol'))
 
     def streamer():
         fin = proto._fin
 
         cachepath = repo.ui.config(b"remotefilelog", b"servercachepath")
         if not cachepath:
             cachepath = os.path.join(repo.path, b"remotefilelogcache")
 
         while True:
             request = fin.readline()[:-1]
             if not request:
                 break
 
             node = bin(request[:40])
             if node == nullid:
                 yield b'0\n'
                 continue
 
             path = request[40:]
 
             text = _loadfileblob(repo, cachepath, path, node)
 
             yield b'%d\n%s' % (len(text), text)
 
             # it would be better to only flush after processing a whole batch
             # but currently we don't know if there are more requests coming
             proto._fout.flush()
 
     return wireprototypes.streamres(streamer())
 
 
 def createfileblob(filectx):
     """
     format:
         v0:
             str(len(rawtext)) + '\0' + rawtext + ancestortext
         v1:
             'v1' + '\n' + metalist + '\0' + rawtext + ancestortext
             metalist := metalist + '\n' + meta | meta
             meta := sizemeta | flagmeta
             sizemeta := METAKEYSIZE + str(len(rawtext))
             flagmeta := METAKEYFLAG + str(flag)
 
             note: sizemeta must exist. METAKEYFLAG and METAKEYSIZE must have a
             length of 1.
     """
     flog = filectx.filelog()
     frev = filectx.filerev()
     revlogflags = flog._revlog.flags(frev)
     if revlogflags == 0:
         # normal files
         text = filectx.data()
     else:
         # lfs, read raw revision data
         text = flog.rawdata(frev)
 
     repo = filectx._repo
 
     ancestors = [filectx]
 
     try:
         repo.forcelinkrev = True
         ancestors.extend([f for f in filectx.ancestors()])
 
         ancestortext = b""
         for ancestorctx in ancestors:
             parents = ancestorctx.parents()
             p1 = nullid
             p2 = nullid
             if len(parents) > 0:
                 p1 = parents[0].filenode()
             if len(parents) > 1:
                 p2 = parents[1].filenode()
 
             copyname = b""
             rename = ancestorctx.renamed()
             if rename:
                 copyname = rename[0]
             linknode = ancestorctx.node()
             ancestortext += b"%s%s%s%s%s\0" % (
                 ancestorctx.filenode(),
                 p1,
                 p2,
                 linknode,
                 copyname,
             )
     finally:
         repo.forcelinkrev = False
 
     header = shallowutil.buildfileblobheader(len(text), revlogflags)
 
     return b"%s\0%s%s" % (header, text, ancestortext)
 
 
 def gcserver(ui, repo):
     if not repo.ui.configbool(b"remotefilelog", b"server"):
         return
 
     neededfiles = set()
     heads = repo.revs(b"heads(tip~25000:) - null")
 
     cachepath = repo.vfs.join(b"remotefilelogcache")
     for head in heads:
         mf = repo[head].manifest()
         for filename, filenode in pycompat.iteritems(mf):
             filecachepath = os.path.join(cachepath, filename, hex(filenode))
             neededfiles.add(filecachepath)
 
     # delete unneeded older files
     days = repo.ui.configint(b"remotefilelog", b"serverexpiration")
     expiration = time.time() - (days * 24 * 60 * 60)
 
     progress = ui.makeprogress(_(b"removing old server cache"), unit=b"files")
     progress.update(0)
     for root, dirs, files in os.walk(cachepath):
         for file in files:
             filepath = os.path.join(root, file)
             progress.increment()
             if filepath in neededfiles:
                 continue
 
             stat = os.stat(filepath)
             if stat.st_mtime < expiration:
                 os.remove(filepath)
 
     progress.complete()

hgext/sqlitestore.py

@@ -1,1295 +1,1296 b''
 # sqlitestore.py - Storage backend that uses SQLite
 #
 # Copyright 2018 Gregory Szorc <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 """store repository data in SQLite (EXPERIMENTAL)
 
 The sqlitestore extension enables the storage of repository data in SQLite.
 
 This extension is HIGHLY EXPERIMENTAL. There are NO BACKWARDS COMPATIBILITY
 GUARANTEES. This means that repositories created with this extension may
 only be usable with the exact version of this extension/Mercurial that was
 used. The extension attempts to enforce this in order to prevent repository
 corruption.
 
 In addition, several features are not yet supported or have known bugs:
 
 * Only some data is stored in SQLite. Changeset, manifest, and other repository
   data is not yet stored in SQLite.
 * Transactions are not robust. If the process is aborted at the right time
   during transaction close/rollback, the repository could be in an inconsistent
   state. This problem will diminish once all repository data is tracked by
   SQLite.
 * Bundle repositories do not work (the ability to use e.g.
   `hg -R <bundle-file> log` to automatically overlay a bundle on top of the
   existing repository).
 * Various other features don't work.
 
 This extension should work for basic clone/pull, update, and commit workflows.
 Some history rewriting operations may fail due to lack of support for bundle
 repositories.
 
 To use, activate the extension and set the ``storage.new-repo-backend`` config
 option to ``sqlite`` to enable new repositories to use SQLite for storage.
 """
 
 # To run the test suite with repos using SQLite by default, execute the
 # following:
 #
 # HGREPOFEATURES="sqlitestore" run-tests.py \
 #     --extra-config-opt extensions.sqlitestore= \
 #     --extra-config-opt storage.new-repo-backend=sqlite
 
 from __future__ import absolute_import
 
 import sqlite3
 import struct
 import threading
 import zlib
 
 from mercurial.i18n import _
 from mercurial.node import (
     nullid,
     nullrev,
     short,
 )
 from mercurial.thirdparty import attr
 from mercurial import (
     ancestor,
     dagop,
     encoding,
     error,
     extensions,
     localrepo,
     mdiff,
     pycompat,
     registrar,
+    requirements,
     util,
     verify,
 )
 from mercurial.interfaces import (
     repository,
     util as interfaceutil,
 )
 from mercurial.utils import (
     hashutil,
     storageutil,
 )
 
 try:
     from mercurial import zstd
 
     zstd.__version__
 except ImportError:
     zstd = None
 
 configtable = {}
 configitem = registrar.configitem(configtable)
 
 # experimental config: storage.sqlite.compression
 configitem(
     b'storage',
     b'sqlite.compression',
     default=b'zstd' if zstd else b'zlib',
     experimental=True,
 )
 
 # Note for extension authors: ONLY specify testedwith = 'ships-with-hg-core' for
 # extensions which SHIP WITH MERCURIAL. Non-mainline extensions should
 # be specifying the version(s) of Mercurial they are tested with, or
 # leave the attribute unspecified.
 testedwith = b'ships-with-hg-core'
 
 REQUIREMENT = b'exp-sqlite-001'
 REQUIREMENT_ZSTD = b'exp-sqlite-comp-001=zstd'
 REQUIREMENT_ZLIB = b'exp-sqlite-comp-001=zlib'
 REQUIREMENT_NONE = b'exp-sqlite-comp-001=none'
 REQUIREMENT_SHALLOW_FILES = b'exp-sqlite-shallow-files'
 
 CURRENT_SCHEMA_VERSION = 1
 
 COMPRESSION_NONE = 1
 COMPRESSION_ZSTD = 2
 COMPRESSION_ZLIB = 3
 
 FLAG_CENSORED = 1
 FLAG_MISSING_P1 = 2
 FLAG_MISSING_P2 = 4
 
 CREATE_SCHEMA = [
     # Deltas are stored as content-indexed blobs.
     # compression column holds COMPRESSION_* constant for how the
     # delta is encoded.
     'CREATE TABLE delta ('
     '    id INTEGER PRIMARY KEY, '
     '    compression INTEGER NOT NULL, '
     '    hash BLOB UNIQUE ON CONFLICT ABORT, '
     '    delta BLOB NOT NULL '
     ')',
     # Tracked paths are denormalized to integers to avoid redundant
     # storage of the path name.
     'CREATE TABLE filepath ('
     '    id INTEGER PRIMARY KEY, '
     '    path BLOB NOT NULL '
     ')',
     'CREATE UNIQUE INDEX filepath_path ON filepath (path)',
     # We have a single table for all file revision data.
     # Each file revision is uniquely described by a (path, rev) and
     # (path, node).
     #
     # Revision data is stored as a pointer to the delta producing this
     # revision and the file revision whose delta should be applied before
     # that one. One can reconstruct the delta chain by recursively following
     # the delta base revision pointers until one encounters NULL.
     #
     # flags column holds bitwise integer flags controlling storage options.
     # These flags are defined by the FLAG_* constants.
     'CREATE TABLE fileindex ('
     '    id INTEGER PRIMARY KEY, '
     '    pathid INTEGER REFERENCES filepath(id), '
     '    revnum INTEGER NOT NULL, '
     '    p1rev INTEGER NOT NULL, '
     '    p2rev INTEGER NOT NULL, '
     '    linkrev INTEGER NOT NULL, '
     '    flags INTEGER NOT NULL, '
     '    deltaid INTEGER REFERENCES delta(id), '
     '    deltabaseid INTEGER REFERENCES fileindex(id), '
     '    node BLOB NOT NULL '
     ')',
     'CREATE UNIQUE INDEX fileindex_pathrevnum '
     '    ON fileindex (pathid, revnum)',
     'CREATE UNIQUE INDEX fileindex_pathnode ON fileindex (pathid, node)',
     # Provide a view over all file data for convenience.
     'CREATE VIEW filedata AS '
     'SELECT '
     '    fileindex.id AS id, '
     '    filepath.id AS pathid, '
     '    filepath.path AS path, '
     '    fileindex.revnum AS revnum, '
     '    fileindex.node AS node, '
     '    fileindex.p1rev AS p1rev, '
     '    fileindex.p2rev AS p2rev, '
     '    fileindex.linkrev AS linkrev, '
     '    fileindex.flags AS flags, '
     '    fileindex.deltaid AS deltaid, '
     '    fileindex.deltabaseid AS deltabaseid '
     'FROM filepath, fileindex '
     'WHERE fileindex.pathid=filepath.id',
     'PRAGMA user_version=%d' % CURRENT_SCHEMA_VERSION,
 ]
 
 
 def resolvedeltachain(db, pathid, node, revisioncache, stoprids, zstddctx=None):
     """Resolve a delta chain for a file node."""
 
     # TODO the "not in ({stops})" here is possibly slowing down the query
     # because it needs to perform the lookup on every recursive invocation.
     # This could possibly be faster if we created a temporary query with
     # baseid "poisoned" to null and limited the recursive filter to
     # "is not null".
     res = db.execute(
         'WITH RECURSIVE '
         '    deltachain(deltaid, baseid) AS ('
         '        SELECT deltaid, deltabaseid FROM fileindex '
         '            WHERE pathid=? AND node=? '
         '        UNION ALL '
         '        SELECT fileindex.deltaid, deltabaseid '
         '            FROM fileindex, deltachain '
         '            WHERE '
         '                fileindex.id=deltachain.baseid '
         '                AND deltachain.baseid IS NOT NULL '
         '                AND fileindex.id NOT IN ({stops}) '
         '    ) '
         'SELECT deltachain.baseid, compression, delta '
         'FROM deltachain, delta '
         'WHERE delta.id=deltachain.deltaid'.format(
             stops=','.join(['?'] * len(stoprids))
         ),
         tuple([pathid, node] + list(stoprids.keys())),
     )
 
     deltas = []
     lastdeltabaseid = None
 
     for deltabaseid, compression, delta in res:
         lastdeltabaseid = deltabaseid
 
         if compression == COMPRESSION_ZSTD:
             delta = zstddctx.decompress(delta)
         elif compression == COMPRESSION_NONE:
             delta = delta
         elif compression == COMPRESSION_ZLIB:
             delta = zlib.decompress(delta)
         else:
             raise SQLiteStoreError(
                 b'unhandled compression type: %d' % compression
             )
 
         deltas.append(delta)
 
     if lastdeltabaseid in stoprids:
         basetext = revisioncache[stoprids[lastdeltabaseid]]
     else:
         basetext = deltas.pop()
 
     deltas.reverse()
     fulltext = mdiff.patches(basetext, deltas)
 
     # SQLite returns buffer instances for blob columns on Python 2. This
     # type can propagate through the delta application layer. Because
     # downstream callers assume revisions are bytes, cast as needed.
     if not isinstance(fulltext, bytes):
         fulltext = bytes(delta)
 
     return fulltext
 
 
 def insertdelta(db, compression, hash, delta):
     try:
         return db.execute(
             'INSERT INTO delta (compression, hash, delta) VALUES (?, ?, ?)',
             (compression, hash, delta),
         ).lastrowid
     except sqlite3.IntegrityError:
         return db.execute(
             'SELECT id FROM delta WHERE hash=?', (hash,)
         ).fetchone()[0]
 
 
 class SQLiteStoreError(error.StorageError):
     pass
 
 
 @attr.s
 class revisionentry(object):
     rid = attr.ib()
     rev = attr.ib()
     node = attr.ib()
     p1rev = attr.ib()
     p2rev = attr.ib()
     p1node = attr.ib()
     p2node = attr.ib()
     linkrev = attr.ib()
     flags = attr.ib()
 
 
 @interfaceutil.implementer(repository.irevisiondelta)
 @attr.s(slots=True)
 class sqliterevisiondelta(object):
     node = attr.ib()
     p1node = attr.ib()
     p2node = attr.ib()
     basenode = attr.ib()
     flags = attr.ib()
     baserevisionsize = attr.ib()
     revision = attr.ib()
     delta = attr.ib()
     linknode = attr.ib(default=None)
 
 
 @interfaceutil.implementer(repository.iverifyproblem)
 @attr.s(frozen=True)
 class sqliteproblem(object):
     warning = attr.ib(default=None)
     error = attr.ib(default=None)
     node = attr.ib(default=None)
 
 
 @interfaceutil.implementer(repository.ifilestorage)
 class sqlitefilestore(object):
     """Implements storage for an individual tracked path."""
 
     def __init__(self, db, path, compression):
         self._db = db
         self._path = path
 
         self._pathid = None
 
         # revnum -> node
         self._revtonode = {}
         # node -> revnum
         self._nodetorev = {}
         # node -> data structure
         self._revisions = {}
 
         self._revisioncache = util.lrucachedict(10)
 
         self._compengine = compression
 
         if compression == b'zstd':
             self._cctx = zstd.ZstdCompressor(level=3)
             self._dctx = zstd.ZstdDecompressor()
         else:
             self._cctx = None
             self._dctx = None
 
         self._refreshindex()
 
     def _refreshindex(self):
         self._revtonode = {}
         self._nodetorev = {}
         self._revisions = {}
 
         res = list(
             self._db.execute(
                 'SELECT id FROM filepath WHERE path=?', (self._path,)
             )
         )
 
         if not res:
             self._pathid = None
             return
 
         self._pathid = res[0][0]
 
         res = self._db.execute(
             'SELECT id, revnum, node, p1rev, p2rev, linkrev, flags '
             'FROM fileindex '
             'WHERE pathid=? '
             'ORDER BY revnum ASC',
             (self._pathid,),
         )
 
         for i, row in enumerate(res):
             rid, rev, node, p1rev, p2rev, linkrev, flags = row
 
             if i != rev:
                 raise SQLiteStoreError(
                     _(b'sqlite database has inconsistent revision numbers')
                 )
 
             if p1rev == nullrev:
                 p1node = nullid
             else:
                 p1node = self._revtonode[p1rev]
 
             if p2rev == nullrev:
                 p2node = nullid
             else:
                 p2node = self._revtonode[p2rev]
 
             entry = revisionentry(
                 rid=rid,
                 rev=rev,
                 node=node,
                 p1rev=p1rev,
                 p2rev=p2rev,
                 p1node=p1node,
                 p2node=p2node,
                 linkrev=linkrev,
                 flags=flags,
             )
 
             self._revtonode[rev] = node
             self._nodetorev[node] = rev
             self._revisions[node] = entry
 
     # Start of ifileindex interface.
 
     def __len__(self):
         return len(self._revisions)
 
     def __iter__(self):
         return iter(pycompat.xrange(len(self._revisions)))
 
     def hasnode(self, node):
         if node == nullid:
             return False
 
         return node in self._nodetorev
 
     def revs(self, start=0, stop=None):
         return storageutil.iterrevs(
             len(self._revisions), start=start, stop=stop
         )
 
     def parents(self, node):
         if node == nullid:
             return nullid, nullid
 
         if node not in self._revisions:
             raise error.LookupError(node, self._path, _(b'no node'))
 
         entry = self._revisions[node]
         return entry.p1node, entry.p2node
 
     def parentrevs(self, rev):
         if rev == nullrev:
             return nullrev, nullrev
 
         if rev not in self._revtonode:
             raise IndexError(rev)
 
         entry = self._revisions[self._revtonode[rev]]
         return entry.p1rev, entry.p2rev
 
     def rev(self, node):
         if node == nullid:
             return nullrev
 
         if node not in self._nodetorev:
             raise error.LookupError(node, self._path, _(b'no node'))
 
         return self._nodetorev[node]
 
     def node(self, rev):
         if rev == nullrev:
             return nullid
 
         if rev not in self._revtonode:
             raise IndexError(rev)
 
         return self._revtonode[rev]
 
     def lookup(self, node):
         return storageutil.fileidlookup(self, node, self._path)
 
     def linkrev(self, rev):
         if rev == nullrev:
             return nullrev
 
         if rev not in self._revtonode:
             raise IndexError(rev)
 
         entry = self._revisions[self._revtonode[rev]]
         return entry.linkrev
 
     def iscensored(self, rev):
         if rev == nullrev:
             return False
 
         if rev not in self._revtonode:
             raise IndexError(rev)
 
         return self._revisions[self._revtonode[rev]].flags & FLAG_CENSORED
 
     def commonancestorsheads(self, node1, node2):
         rev1 = self.rev(node1)
         rev2 = self.rev(node2)
 
         ancestors = ancestor.commonancestorsheads(self.parentrevs, rev1, rev2)
         return pycompat.maplist(self.node, ancestors)
 
     def descendants(self, revs):
         # TODO we could implement this using a recursive SQL query, which
         # might be faster.
         return dagop.descendantrevs(revs, self.revs, self.parentrevs)
 
     def heads(self, start=None, stop=None):
         if start is None and stop is None:
             if not len(self):
                 return [nullid]
 
         startrev = self.rev(start) if start is not None else nullrev
         stoprevs = {self.rev(n) for n in stop or []}
 
         revs = dagop.headrevssubset(
             self.revs, self.parentrevs, startrev=startrev, stoprevs=stoprevs
         )
 
         return [self.node(rev) for rev in revs]
 
     def children(self, node):
         rev = self.rev(node)
 
         res = self._db.execute(
             'SELECT'
             '  node '
             '  FROM filedata '
             '  WHERE path=? AND (p1rev=? OR p2rev=?) '
             '  ORDER BY revnum ASC',
             (self._path, rev, rev),
         )
 
         return [row[0] for row in res]
 
     # End of ifileindex interface.
 
     # Start of ifiledata interface.
 
     def size(self, rev):
         if rev == nullrev:
             return 0
 
         if rev not in self._revtonode:
             raise IndexError(rev)
 
         node = self._revtonode[rev]
 
         if self.renamed(node):
             return len(self.read(node))
 
         return len(self.revision(node))
 
     def revision(self, node, raw=False, _verifyhash=True):
         if node in (nullid, nullrev):
             return b''
 
         if isinstance(node, int):
             node = self.node(node)
 
         if node not in self._nodetorev:
             raise error.LookupError(node, self._path, _(b'no node'))
 
         if node in self._revisioncache:
             return self._revisioncache[node]
 
         # Because we have a fulltext revision cache, we are able to
         # short-circuit delta chain traversal and decompression as soon as
         # we encounter a revision in the cache.
 
         stoprids = {self._revisions[n].rid: n for n in self._revisioncache}
 
         if not stoprids:
             stoprids[-1] = None
 
         fulltext = resolvedeltachain(
             self._db,
             self._pathid,
             node,
             self._revisioncache,
             stoprids,
             zstddctx=self._dctx,
         )
 
         # Don't verify hashes if parent nodes were rewritten, as the hash
         # wouldn't verify.
         if self._revisions[node].flags & (FLAG_MISSING_P1 | FLAG_MISSING_P2):
             _verifyhash = False
 
         if _verifyhash:
             self._checkhash(fulltext, node)
             self._revisioncache[node] = fulltext
 
         return fulltext
 
     def rawdata(self, *args, **kwargs):
         return self.revision(*args, **kwargs)
 
     def read(self, node):
         return storageutil.filtermetadata(self.revision(node))
 
     def renamed(self, node):
         return storageutil.filerevisioncopied(self, node)
 
     def cmp(self, node, fulltext):
         return not storageutil.filedataequivalent(self, node, fulltext)
 
     def emitrevisions(
         self,
         nodes,
         nodesorder=None,
         revisiondata=False,
         assumehaveparentrevisions=False,
         deltamode=repository.CG_DELTAMODE_STD,
     ):
         if nodesorder not in (b'nodes', b'storage', b'linear', None):
             raise error.ProgrammingError(
                 b'unhandled value for nodesorder: %s' % nodesorder
             )
 
         nodes = [n for n in nodes if n != nullid]
 
         if not nodes:
             return
 
         # TODO perform in a single query.
         res = self._db.execute(
             'SELECT revnum, deltaid FROM fileindex '
             'WHERE pathid=? '
             '    AND node in (%s)' % (','.join(['?'] * len(nodes))),
             tuple([self._pathid] + nodes),
         )
 
         deltabases = {}
 
         for rev, deltaid in res:
             res = self._db.execute(
                 'SELECT revnum from fileindex WHERE pathid=? AND deltaid=?',
                 (self._pathid, deltaid),
             )
             deltabases[rev] = res.fetchone()[0]
 
         # TODO define revdifffn so we can use delta from storage.
         for delta in storageutil.emitrevisions(
             self,
             nodes,
             nodesorder,
             sqliterevisiondelta,
             deltaparentfn=deltabases.__getitem__,
             revisiondata=revisiondata,
             assumehaveparentrevisions=assumehaveparentrevisions,
             deltamode=deltamode,
         ):
 
             yield delta
 
     # End of ifiledata interface.
 
     # Start of ifilemutation interface.
 
     def add(self, filedata, meta, transaction, linkrev, p1, p2):
         if meta or filedata.startswith(b'\x01\n'):
             filedata = storageutil.packmeta(meta, filedata)
 
         return self.addrevision(filedata, transaction, linkrev, p1, p2)
 
     def addrevision(
         self,
         revisiondata,
         transaction,
         linkrev,
         p1,
         p2,
         node=None,
         flags=0,
         cachedelta=None,
     ):
         if flags:
             raise SQLiteStoreError(_(b'flags not supported on revisions'))
 
         validatehash = node is not None
         node = node or storageutil.hashrevisionsha1(revisiondata, p1, p2)
 
         if validatehash:
             self._checkhash(revisiondata, node, p1, p2)
 
         if node in self._nodetorev:
             return node
 
         node = self._addrawrevision(
             node, revisiondata, transaction, linkrev, p1, p2
         )
 
         self._revisioncache[node] = revisiondata
         return node
 
     def addgroup(
         self,
         deltas,
         linkmapper,
         transaction,
         addrevisioncb=None,
         maybemissingparents=False,
     ):
         nodes = []
 
         for node, p1, p2, linknode, deltabase, delta, wireflags in deltas:
             storeflags = 0
 
             if wireflags & repository.REVISION_FLAG_CENSORED:
                 storeflags |= FLAG_CENSORED
 
             if wireflags & ~repository.REVISION_FLAG_CENSORED:
                 raise SQLiteStoreError(b'unhandled revision flag')
 
             if maybemissingparents:
                 if p1 != nullid and not self.hasnode(p1):
                     p1 = nullid
                     storeflags |= FLAG_MISSING_P1
 
                 if p2 != nullid and not self.hasnode(p2):
                     p2 = nullid
                     storeflags |= FLAG_MISSING_P2
 
             baserev = self.rev(deltabase)
 
             # If base is censored, delta must be full replacement in a single
             # patch operation.
             if baserev != nullrev and self.iscensored(baserev):
                 hlen = struct.calcsize(b'>lll')
                 oldlen = len(self.rawdata(deltabase, _verifyhash=False))
                 newlen = len(delta) - hlen
 
                 if delta[:hlen] != mdiff.replacediffheader(oldlen, newlen):
                     raise error.CensoredBaseError(self._path, deltabase)
 
             if not (storeflags & FLAG_CENSORED) and storageutil.deltaiscensored(
                 delta, baserev, lambda x: len(self.rawdata(x))
             ):
                 storeflags |= FLAG_CENSORED
 
             linkrev = linkmapper(linknode)
 
             nodes.append(node)
 
             if node in self._revisions:
                 # Possibly reset parents to make them proper.
                 entry = self._revisions[node]
 
                 if entry.flags & FLAG_MISSING_P1 and p1 != nullid:
                     entry.p1node = p1
                     entry.p1rev = self._nodetorev[p1]
                     entry.flags &= ~FLAG_MISSING_P1
 
                     self._db.execute(
                         'UPDATE fileindex SET p1rev=?, flags=? WHERE id=?',
                         (self._nodetorev[p1], entry.flags, entry.rid),
                     )
 
                 if entry.flags & FLAG_MISSING_P2 and p2 != nullid:
                     entry.p2node = p2
                     entry.p2rev = self._nodetorev[p2]
                     entry.flags &= ~FLAG_MISSING_P2
 
                     self._db.execute(
                         'UPDATE fileindex SET p2rev=?, flags=? WHERE id=?',
                         (self._nodetorev[p1], entry.flags, entry.rid),
                     )
 
                 continue
 
             if deltabase == nullid:
                 text = mdiff.patch(b'', delta)
                 storedelta = None
             else:
                 text = None
                 storedelta = (deltabase, delta)
 
             self._addrawrevision(
                 node,
                 text,
                 transaction,
                 linkrev,
                 p1,
                 p2,
                 storedelta=storedelta,
                 flags=storeflags,
             )
 
             if addrevisioncb:
                 addrevisioncb(self, node)
 
         return nodes
 
     def censorrevision(self, tr, censornode, tombstone=b''):
         tombstone = storageutil.packmeta({b'censored': tombstone}, b'')
 
         # This restriction is cargo culted from revlogs and makes no sense for
         # SQLite, since columns can be resized at will.
         if len(tombstone) > len(self.rawdata(censornode)):
             raise error.Abort(
                 _(b'censor tombstone must be no longer than censored data')
             )
 
         # We need to replace the censored revision's data with the tombstone.
         # But replacing that data will have implications for delta chains that
         # reference it.
         #
         # While "better," more complex strategies are possible, we do something
         # simple: we find delta chain children of the censored revision and we
         # replace those incremental deltas with fulltexts of their corresponding
         # revision. Then we delete the now-unreferenced delta and original
         # revision and insert a replacement.
 
         # Find the delta to be censored.
         censoreddeltaid = self._db.execute(
             'SELECT deltaid FROM fileindex WHERE id=?',
             (self._revisions[censornode].rid,),
         ).fetchone()[0]
 
         # Find all its delta chain children.
         # TODO once we support storing deltas for !files, we'll need to look
         # for those delta chains too.
         rows = list(
             self._db.execute(
                 'SELECT id, pathid, node FROM fileindex '
                 'WHERE deltabaseid=? OR deltaid=?',
                 (censoreddeltaid, censoreddeltaid),
             )
         )
 
         for row in rows:
             rid, pathid, node = row
 
             fulltext = resolvedeltachain(
                 self._db, pathid, node, {}, {-1: None}, zstddctx=self._dctx
             )
 
             deltahash = hashutil.sha1(fulltext).digest()
 
             if self._compengine == b'zstd':
                 deltablob = self._cctx.compress(fulltext)
                 compression = COMPRESSION_ZSTD
             elif self._compengine == b'zlib':
                 deltablob = zlib.compress(fulltext)
                 compression = COMPRESSION_ZLIB
             elif self._compengine == b'none':
                 deltablob = fulltext
                 compression = COMPRESSION_NONE
             else:
                 raise error.ProgrammingError(
                     b'unhandled compression engine: %s' % self._compengine
                 )
 
             if len(deltablob) >= len(fulltext):
                 deltablob = fulltext
                 compression = COMPRESSION_NONE
 
             deltaid = insertdelta(self._db, compression, deltahash, deltablob)
 
             self._db.execute(
                 'UPDATE fileindex SET deltaid=?, deltabaseid=NULL '
                 'WHERE id=?',
                 (deltaid, rid),
             )
 
         # Now create the tombstone delta and replace the delta on the censored
         # node.
         deltahash = hashutil.sha1(tombstone).digest()
         tombstonedeltaid = insertdelta(
             self._db, COMPRESSION_NONE, deltahash, tombstone
         )
 
         flags = self._revisions[censornode].flags
         flags |= FLAG_CENSORED
 
         self._db.execute(
             'UPDATE fileindex SET flags=?, deltaid=?, deltabaseid=NULL '
             'WHERE pathid=? AND node=?',
             (flags, tombstonedeltaid, self._pathid, censornode),
         )
 
         self._db.execute('DELETE FROM delta WHERE id=?', (censoreddeltaid,))
 
         self._refreshindex()
         self._revisioncache.clear()
 
     def getstrippoint(self, minlink):
         return storageutil.resolvestripinfo(
             minlink,
             len(self) - 1,
             [self.rev(n) for n in self.heads()],
             self.linkrev,
             self.parentrevs,
         )
 
     def strip(self, minlink, transaction):
         if not len(self):
             return
 
         rev, _ignored = self.getstrippoint(minlink)
 
         if rev == len(self):
             return
 
         for rev in self.revs(rev):
             self._db.execute(
                 'DELETE FROM fileindex WHERE pathid=? AND node=?',
                 (self._pathid, self.node(rev)),
             )
 
         # TODO how should we garbage collect data in delta table?
 
         self._refreshindex()
 
     # End of ifilemutation interface.
 
     # Start of ifilestorage interface.
 
     def files(self):
         return []
 
     def storageinfo(
         self,
         exclusivefiles=False,
         sharedfiles=False,
         revisionscount=False,
         trackedsize=False,
         storedsize=False,
     ):
         d = {}
 
         if exclusivefiles:
             d[b'exclusivefiles'] = []
 
         if sharedfiles:
             # TODO list sqlite file(s) here.
             d[b'sharedfiles'] = []
 
         if revisionscount:
             d[b'revisionscount'] = len(self)
 
         if trackedsize:
             d[b'trackedsize'] = sum(
                 len(self.revision(node)) for node in self._nodetorev
             )
 
         if storedsize:
             # TODO implement this?
             d[b'storedsize'] = None
 
         return d
 
     def verifyintegrity(self, state):
         state[b'skipread'] = set()
 
         for rev in self:
             node = self.node(rev)
 
             try:
                 self.revision(node)
             except Exception as e:
                 yield sqliteproblem(
                     error=_(b'unpacking %s: %s') % (short(node), e), node=node
                 )
 
                 state[b'skipread'].add(node)
 
     # End of ifilestorage interface.
 
     def _checkhash(self, fulltext, node, p1=None, p2=None):
         if p1 is None and p2 is None:
             p1, p2 = self.parents(node)
 
         if node == storageutil.hashrevisionsha1(fulltext, p1, p2):
             return
 
         try:
             del self._revisioncache[node]
         except KeyError:
             pass
 
         if storageutil.iscensoredtext(fulltext):
             raise error.CensoredNodeError(self._path, node, fulltext)
 
         raise SQLiteStoreError(_(b'integrity check failed on %s') % self._path)
 
     def _addrawrevision(
         self,
         node,
         revisiondata,
         transaction,
         linkrev,
         p1,
         p2,
         storedelta=None,
         flags=0,
     ):
         if self._pathid is None:
             res = self._db.execute(
                 'INSERT INTO filepath (path) VALUES (?)', (self._path,)
             )
             self._pathid = res.lastrowid
 
         # For simplicity, always store a delta against p1.
         # TODO we need a lot more logic here to make behavior reasonable.
 
         if storedelta:
             deltabase, delta = storedelta
 
             if isinstance(deltabase, int):
                 deltabase = self.node(deltabase)
 
         else:
             assert revisiondata is not None
             deltabase = p1
 
             if deltabase == nullid:
                 delta = revisiondata
             else:
                 delta = mdiff.textdiff(
                     self.revision(self.rev(deltabase)), revisiondata
                 )
 
         # File index stores a pointer to its delta and the parent delta.
         # The parent delta is stored via a pointer to the fileindex PK.
         if deltabase == nullid:
             baseid = None
         else:
             baseid = self._revisions[deltabase].rid
 
         # Deltas are stored with a hash of their content. This allows
         # us to de-duplicate. The table is configured to ignore conflicts
         # and it is faster to just insert and silently noop than to look
         # first.
         deltahash = hashutil.sha1(delta).digest()
 
         if self._compengine == b'zstd':
             deltablob = self._cctx.compress(delta)
             compression = COMPRESSION_ZSTD
         elif self._compengine == b'zlib':
             deltablob = zlib.compress(delta)
             compression = COMPRESSION_ZLIB
         elif self._compengine == b'none':
             deltablob = delta
             compression = COMPRESSION_NONE
         else:
             raise error.ProgrammingError(
                 b'unhandled compression engine: %s' % self._compengine
             )
 
         # Don't store compressed data if it isn't practical.
         if len(deltablob) >= len(delta):
             deltablob = delta
             compression = COMPRESSION_NONE
 
         deltaid = insertdelta(self._db, compression, deltahash, deltablob)
 
         rev = len(self)
 
         if p1 == nullid:
             p1rev = nullrev
         else:
             p1rev = self._nodetorev[p1]
 
         if p2 == nullid:
             p2rev = nullrev
         else:
             p2rev = self._nodetorev[p2]
 
         rid = self._db.execute(
             'INSERT INTO fileindex ('
             '    pathid, revnum, node, p1rev, p2rev, linkrev, flags, '
             '    deltaid, deltabaseid) '
             '    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)',
             (
                 self._pathid,
                 rev,
                 node,
                 p1rev,
                 p2rev,
                 linkrev,
                 flags,
                 deltaid,
                 baseid,
             ),
         ).lastrowid
 
         entry = revisionentry(
             rid=rid,
             rev=rev,
             node=node,
             p1rev=p1rev,
             p2rev=p2rev,
             p1node=p1,
             p2node=p2,
             linkrev=linkrev,
             flags=flags,
         )
 
         self._nodetorev[node] = rev
         self._revtonode[rev] = node
         self._revisions[node] = entry
 
         return node
 
 
 class sqliterepository(localrepo.localrepository):
     def cancopy(self):
         return False
 
     def transaction(self, *args, **kwargs):
         current = self.currenttransaction()
 
         tr = super(sqliterepository, self).transaction(*args, **kwargs)
 
         if current:
             return tr
 
         self._dbconn.execute('BEGIN TRANSACTION')
 
         def committransaction(_):
             self._dbconn.commit()
 
         tr.addfinalize(b'sqlitestore', committransaction)
 
         return tr
 
     @property
     def _dbconn(self):
         # SQLite connections can only be used on the thread that created
         # them. In most cases, this "just works." However, hgweb uses
         # multiple threads.
         tid = threading.current_thread().ident
 
         if self._db:
             if self._db[0] == tid:
                 return self._db[1]
 
         db = makedb(self.svfs.join(b'db.sqlite'))
         self._db = (tid, db)
 
         return db
 
 
 def makedb(path):
     """Construct a database handle for a database at path."""
 
     db = sqlite3.connect(encoding.strfromlocal(path))
     db.text_factory = bytes
 
     res = db.execute('PRAGMA user_version').fetchone()[0]
 
     # New database.
     if res == 0:
         for statement in CREATE_SCHEMA:
             db.execute(statement)
 
         db.commit()
 
     elif res == CURRENT_SCHEMA_VERSION:
         pass
 
     else:
         raise error.Abort(_(b'sqlite database has unrecognized version'))
 
     db.execute('PRAGMA journal_mode=WAL')
 
     return db
 
 
 def featuresetup(ui, supported):
     supported.add(REQUIREMENT)
 
     if zstd:
         supported.add(REQUIREMENT_ZSTD)
 
     supported.add(REQUIREMENT_ZLIB)
     supported.add(REQUIREMENT_NONE)
     supported.add(REQUIREMENT_SHALLOW_FILES)
-    supported.add(repository.NARROW_REQUIREMENT)
+    supported.add(requirements.NARROW_REQUIREMENT)
 
 
 def newreporequirements(orig, ui, createopts):
     if createopts[b'backend'] != b'sqlite':
         return orig(ui, createopts)
 
     # This restriction can be lifted once we have more confidence.
     if b'sharedrepo' in createopts:
         raise error.Abort(
             _(b'shared repositories not supported with SQLite store')
         )
 
     # This filtering is out of an abundance of caution: we want to ensure
     # we honor creation options and we do that by annotating exactly the
     # creation options we recognize.
     known = {
         b'narrowfiles',
         b'backend',
         b'shallowfilestore',
     }
 
     unsupported = set(createopts) - known
     if unsupported:
         raise error.Abort(
             _(b'SQLite store does not support repo creation option: %s')
             % b', '.join(sorted(unsupported))
         )
 
     # Since we're a hybrid store that still relies on revlogs, we fall back
     # to using the revlogv1 backend's storage requirements then adding our
     # own requirement.
     createopts[b'backend'] = b'revlogv1'
     requirements = orig(ui, createopts)
     requirements.add(REQUIREMENT)
 
     compression = ui.config(b'storage', b'sqlite.compression')
 
     if compression == b'zstd' and not zstd:
         raise error.Abort(
             _(
                 b'storage.sqlite.compression set to "zstd" but '
                 b'zstandard compression not available to this '
                 b'Mercurial install'
             )
         )
 
     if compression == b'zstd':
         requirements.add(REQUIREMENT_ZSTD)
     elif compression == b'zlib':
         requirements.add(REQUIREMENT_ZLIB)
     elif compression == b'none':
         requirements.add(REQUIREMENT_NONE)
     else:
         raise error.Abort(
             _(
                 b'unknown compression engine defined in '
                 b'storage.sqlite.compression: %s'
             )
             % compression
         )
 
     if createopts.get(b'shallowfilestore'):
         requirements.add(REQUIREMENT_SHALLOW_FILES)
 
     return requirements
 
 
 @interfaceutil.implementer(repository.ilocalrepositoryfilestorage)
 class sqlitefilestorage(object):
     """Repository file storage backed by SQLite."""
 
     def file(self, path):
         if path[0] == b'/':
             path = path[1:]
 
         if REQUIREMENT_ZSTD in self.requirements:
             compression = b'zstd'
         elif REQUIREMENT_ZLIB in self.requirements:
             compression = b'zlib'
         elif REQUIREMENT_NONE in self.requirements:
             compression = b'none'
         else:
             raise error.Abort(
                 _(
                     b'unable to determine what compression engine '
                     b'to use for SQLite storage'
                 )
             )
 
         return sqlitefilestore(self._dbconn, path, compression)
 
 
 def makefilestorage(orig, requirements, features, **kwargs):
     """Produce a type conforming to ``ilocalrepositoryfilestorage``."""
     if REQUIREMENT in requirements:
         if REQUIREMENT_SHALLOW_FILES in requirements:
             features.add(repository.REPO_FEATURE_SHALLOW_FILE_STORAGE)
 
         return sqlitefilestorage
     else:
         return orig(requirements=requirements, features=features, **kwargs)
 
 
 def makemain(orig, ui, requirements, **kwargs):
     if REQUIREMENT in requirements:
         if REQUIREMENT_ZSTD in requirements and not zstd:
             raise error.Abort(
                 _(
                     b'repository uses zstandard compression, which '
                     b'is not available to this Mercurial install'
                 )
             )
 
         return sqliterepository
 
     return orig(requirements=requirements, **kwargs)
 
 
 def verifierinit(orig, self, *args, **kwargs):
     orig(self, *args, **kwargs)
 
     # We don't care that files in the store don't align with what is
     # advertised. So suppress these warnings.
     self.warnorphanstorefiles = False
 
 
 def extsetup(ui):
     localrepo.featuresetupfuncs.add(featuresetup)
     extensions.wrapfunction(
         localrepo, b'newreporequirements', newreporequirements
     )
     extensions.wrapfunction(localrepo, b'makefilestorage', makefilestorage)
     extensions.wrapfunction(localrepo, b'makemain', makemain)
     extensions.wrapfunction(verify.verifier, b'__init__', verifierinit)
 
 
 def reposetup(ui, repo):
     if isinstance(repo, sqliterepository):
         repo._db = None
 
     # TODO check for bundlerepository?

mercurial/bundle2.py

@@ -1,2585 +1,2585 b''
 # bundle2.py - generic container format to transmit arbitrary data.
 #
 # Copyright 2013 Facebook, Inc.
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 """Handling of the new bundle2 format
 
 The goal of bundle2 is to act as an atomically packet to transmit a set of
 payloads in an application agnostic way. It consist in a sequence of "parts"
 that will be handed to and processed by the application layer.
 
 
 General format architecture
 ===========================
 
 The format is architectured as follow
 
  - magic string
  - stream level parameters
  - payload parts (any number)
  - end of stream marker.
 
 the Binary format
 ============================
 
 All numbers are unsigned and big-endian.
 
 stream level parameters
 ------------------------
 
 Binary format is as follow
 
 :params size: int32
 
   The total number of Bytes used by the parameters
 
 :params value: arbitrary number of Bytes
 
   A blob of `params size` containing the serialized version of all stream level
   parameters.
 
   The blob contains a space separated list of parameters. Parameters with value
   are stored in the form `<name>=<value>`. Both name and value are urlquoted.
 
   Empty name are obviously forbidden.
 
   Name MUST start with a letter. If this first letter is lower case, the
   parameter is advisory and can be safely ignored. However when the first
   letter is capital, the parameter is mandatory and the bundling process MUST
   stop if he is not able to proceed it.
 
   Stream parameters use a simple textual format for two main reasons:
 
   - Stream level parameters should remain simple and we want to discourage any
     crazy usage.
   - Textual data allow easy human inspection of a bundle2 header in case of
     troubles.
 
   Any Applicative level options MUST go into a bundle2 part instead.
 
 Payload part
 ------------------------
 
 Binary format is as follow
 
 :header size: int32
 
   The total number of Bytes used by the part header. When the header is empty
   (size = 0) this is interpreted as the end of stream marker.
 
 :header:
 
     The header defines how to interpret the part. It contains two piece of
     data: the part type, and the part parameters.
 
     The part type is used to route an application level handler, that can
     interpret payload.
 
     Part parameters are passed to the application level handler.  They are
     meant to convey information that will help the application level object to
     interpret the part payload.
 
     The binary format of the header is has follow
 
     :typesize: (one byte)
 
     :parttype: alphanumerical part name (restricted to [a-zA-Z0-9_:-]*)
 
     :partid: A 32bits integer (unique in the bundle) that can be used to refer
              to this part.
 
     :parameters:
 
         Part's parameter may have arbitrary content, the binary structure is::
 
             <mandatory-count><advisory-count><param-sizes><param-data>
 
         :mandatory-count: 1 byte, number of mandatory parameters
 
         :advisory-count:  1 byte, number of advisory parameters
 
         :param-sizes:
 
             N couple of bytes, where N is the total number of parameters. Each
             couple contains (<size-of-key>, <size-of-value) for one parameter.
 
         :param-data:
 
             A blob of bytes from which each parameter key and value can be
             retrieved using the list of size couples stored in the previous
             field.
 
             Mandatory parameters comes first, then the advisory ones.
 
             Each parameter's key MUST be unique within the part.
 
 :payload:
 
     payload is a series of `<chunksize><chunkdata>`.
 
     `chunksize` is an int32, `chunkdata` are plain bytes (as much as
     `chunksize` says)` The payload part is concluded by a zero size chunk.
 
     The current implementation always produces either zero or one chunk.
     This is an implementation limitation that will ultimately be lifted.
 
     `chunksize` can be negative to trigger special case processing. No such
     processing is in place yet.
 
 Bundle processing
 ============================
 
 Each part is processed in order using a "part handler". Handler are registered
 for a certain part type.
 
 The matching of a part to its handler is case insensitive. The case of the
 part type is used to know if a part is mandatory or advisory. If the Part type
 contains any uppercase char it is considered mandatory. When no handler is
 known for a Mandatory part, the process is aborted and an exception is raised.
 If the part is advisory and no handler is known, the part is ignored. When the
 process is aborted, the full bundle is still read from the stream to keep the
 channel usable. But none of the part read from an abort are processed. In the
 future, dropping the stream may become an option for channel we do not care to
 preserve.
 """
 
 from __future__ import absolute_import, division
 
 import collections
 import errno
 import os
 import re
 import string
 import struct
 import sys
 
 from .i18n import _
 from . import (
     bookmarks,
     changegroup,
     encoding,
     error,
     node as nodemod,
     obsolete,
     phases,
     pushkey,
     pycompat,
+    requirements,
     scmutil,
     streamclone,
     tags,
     url,
     util,
 )
-from .interfaces import repository
 from .utils import stringutil
 
 urlerr = util.urlerr
 urlreq = util.urlreq
 
 _pack = struct.pack
 _unpack = struct.unpack
 
 _fstreamparamsize = b'>i'
 _fpartheadersize = b'>i'
 _fparttypesize = b'>B'
 _fpartid = b'>I'
 _fpayloadsize = b'>i'
 _fpartparamcount = b'>BB'
 
 preferedchunksize = 32768
 
 _parttypeforbidden = re.compile(b'[^a-zA-Z0-9_:-]')
 
 
 def outdebug(ui, message):
     """debug regarding output stream (bundling)"""
     if ui.configbool(b'devel', b'bundle2.debug'):
         ui.debug(b'bundle2-output: %s\n' % message)
 
 
 def indebug(ui, message):
     """debug on input stream (unbundling)"""
     if ui.configbool(b'devel', b'bundle2.debug'):
         ui.debug(b'bundle2-input: %s\n' % message)
 
 
 def validateparttype(parttype):
     """raise ValueError if a parttype contains invalid character"""
     if _parttypeforbidden.search(parttype):
         raise ValueError(parttype)
 
 
 def _makefpartparamsizes(nbparams):
     """return a struct format to read part parameter sizes
 
     The number parameters is variable so we need to build that format
     dynamically.
     """
     return b'>' + (b'BB' * nbparams)
 
 
 parthandlermapping = {}
 
 
 def parthandler(parttype, params=()):
     """decorator that register a function as a bundle2 part handler
 
     eg::
 
         @parthandler('myparttype', ('mandatory', 'param', 'handled'))
         def myparttypehandler(...):
             '''process a part of type "my part".'''
             ...
     """
     validateparttype(parttype)
 
     def _decorator(func):
         lparttype = parttype.lower()  # enforce lower case matching.
         assert lparttype not in parthandlermapping
         parthandlermapping[lparttype] = func
         func.params = frozenset(params)
         return func
 
     return _decorator
 
 
 class unbundlerecords(object):
     """keep record of what happens during and unbundle
 
     New records are added using `records.add('cat', obj)`. Where 'cat' is a
     category of record and obj is an arbitrary object.
 
     `records['cat']` will return all entries of this category 'cat'.
 
     Iterating on the object itself will yield `('category', obj)` tuples
     for all entries.
 
     All iterations happens in chronological order.
     """
 
     def __init__(self):
         self._categories = {}
         self._sequences = []
         self._replies = {}
 
     def add(self, category, entry, inreplyto=None):
         """add a new record of a given category.
 
         The entry can then be retrieved in the list returned by
         self['category']."""
         self._categories.setdefault(category, []).append(entry)
         self._sequences.append((category, entry))
         if inreplyto is not None:
             self.getreplies(inreplyto).add(category, entry)
 
     def getreplies(self, partid):
         """get the records that are replies to a specific part"""
         return self._replies.setdefault(partid, unbundlerecords())
 
     def __getitem__(self, cat):
         return tuple(self._categories.get(cat, ()))
 
     def __iter__(self):
         return iter(self._sequences)
 
     def __len__(self):
         return len(self._sequences)
 
     def __nonzero__(self):
         return bool(self._sequences)
 
     __bool__ = __nonzero__
 
 
 class bundleoperation(object):
     """an object that represents a single bundling process
 
     Its purpose is to carry unbundle-related objects and states.
 
     A new object should be created at the beginning of each bundle processing.
     The object is to be returned by the processing function.
 
     The object has very little content now it will ultimately contain:
     * an access to the repo the bundle is applied to,
     * a ui object,
     * a way to retrieve a transaction to add changes to the repo,
     * a way to record the result of processing each part,
     * a way to construct a bundle response when applicable.
     """
 
     def __init__(self, repo, transactiongetter, captureoutput=True, source=b''):
         self.repo = repo
         self.ui = repo.ui
         self.records = unbundlerecords()
         self.reply = None
         self.captureoutput = captureoutput
         self.hookargs = {}
         self._gettransaction = transactiongetter
         # carries value that can modify part behavior
         self.modes = {}
         self.source = source
 
     def gettransaction(self):
         transaction = self._gettransaction()
 
         if self.hookargs:
             # the ones added to the transaction supercede those added
             # to the operation.
             self.hookargs.update(transaction.hookargs)
             transaction.hookargs = self.hookargs
 
         # mark the hookargs as flushed.  further attempts to add to
         # hookargs will result in an abort.
         self.hookargs = None
 
         return transaction
 
     def addhookargs(self, hookargs):
         if self.hookargs is None:
             raise error.ProgrammingError(
                 b'attempted to add hookargs to '
                 b'operation after transaction started'
             )
         self.hookargs.update(hookargs)
 
 
 class TransactionUnavailable(RuntimeError):
     pass
 
 
 def _notransaction():
     """default method to get a transaction while processing a bundle
 
     Raise an exception to highlight the fact that no transaction was expected
     to be created"""
     raise TransactionUnavailable()
 
 
 def applybundle(repo, unbundler, tr, source, url=None, **kwargs):
     # transform me into unbundler.apply() as soon as the freeze is lifted
     if isinstance(unbundler, unbundle20):
         tr.hookargs[b'bundle2'] = b'1'
         if source is not None and b'source' not in tr.hookargs:
             tr.hookargs[b'source'] = source
         if url is not None and b'url' not in tr.hookargs:
             tr.hookargs[b'url'] = url
         return processbundle(repo, unbundler, lambda: tr, source=source)
     else:
         # the transactiongetter won't be used, but we might as well set it
         op = bundleoperation(repo, lambda: tr, source=source)
         _processchangegroup(op, unbundler, tr, source, url, **kwargs)
         return op
 
 
 class partiterator(object):
     def __init__(self, repo, op, unbundler):
         self.repo = repo
         self.op = op
         self.unbundler = unbundler
         self.iterator = None
         self.count = 0
         self.current = None
 
     def __enter__(self):
         def func():
             itr = enumerate(self.unbundler.iterparts(), 1)
             for count, p in itr:
                 self.count = count
                 self.current = p
                 yield p
                 p.consume()
                 self.current = None
 
         self.iterator = func()
         return self.iterator
 
     def __exit__(self, type, exc, tb):
         if not self.iterator:
             return
 
         # Only gracefully abort in a normal exception situation. User aborts
         # like Ctrl+C throw a KeyboardInterrupt which is not a base Exception,
         # and should not gracefully cleanup.
         if isinstance(exc, Exception):
             # Any exceptions seeking to the end of the bundle at this point are
             # almost certainly related to the underlying stream being bad.
             # And, chances are that the exception we're handling is related to
             # getting in that bad state. So, we swallow the seeking error and
             # re-raise the original error.
             seekerror = False
             try:
                 if self.current:
                     # consume the part content to not corrupt the stream.
                     self.current.consume()
 
                 for part in self.iterator:
                     # consume the bundle content
                     part.consume()
             except Exception:
                 seekerror = True
 
             # Small hack to let caller code distinguish exceptions from bundle2
             # processing from processing the old format. This is mostly needed
             # to handle different return codes to unbundle according to the type
             # of bundle. We should probably clean up or drop this return code
             # craziness in a future version.
             exc.duringunbundle2 = True
             salvaged = []
             replycaps = None
             if self.op.reply is not None:
                 salvaged = self.op.reply.salvageoutput()
                 replycaps = self.op.reply.capabilities
             exc._replycaps = replycaps
             exc._bundle2salvagedoutput = salvaged
 
             # Re-raising from a variable loses the original stack. So only use
             # that form if we need to.
             if seekerror:
                 raise exc
 
         self.repo.ui.debug(
             b'bundle2-input-bundle: %i parts total\n' % self.count
         )
 
 
 def processbundle(repo, unbundler, transactiongetter=None, op=None, source=b''):
     """This function process a bundle, apply effect to/from a repo
 
     It iterates over each part then searches for and uses the proper handling
     code to process the part. Parts are processed in order.
 
     Unknown Mandatory part will abort the process.
 
     It is temporarily possible to provide a prebuilt bundleoperation to the
     function. This is used to ensure output is properly propagated in case of
     an error during the unbundling. This output capturing part will likely be
     reworked and this ability will probably go away in the process.
     """
     if op is None:
         if transactiongetter is None:
             transactiongetter = _notransaction
         op = bundleoperation(repo, transactiongetter, source=source)
     # todo:
     # - replace this is a init function soon.
     # - exception catching
     unbundler.params
     if repo.ui.debugflag:
         msg = [b'bundle2-input-bundle:']
         if unbundler.params:
             msg.append(b' %i params' % len(unbundler.params))
         if op._gettransaction is None or op._gettransaction is _notransaction:
             msg.append(b' no-transaction')
         else:
             msg.append(b' with-transaction')
         msg.append(b'\n')
         repo.ui.debug(b''.join(msg))
 
     processparts(repo, op, unbundler)
 
     return op
 
 
 def processparts(repo, op, unbundler):
     with partiterator(repo, op, unbundler) as parts:
         for part in parts:
             _processpart(op, part)
 
 
 def _processchangegroup(op, cg, tr, source, url, **kwargs):
     ret = cg.apply(op.repo, tr, source, url, **kwargs)
     op.records.add(b'changegroup', {b'return': ret,})
     return ret
 
 
 def _gethandler(op, part):
     status = b'unknown'  # used by debug output
     try:
         handler = parthandlermapping.get(part.type)
         if handler is None:
             status = b'unsupported-type'
             raise error.BundleUnknownFeatureError(parttype=part.type)
         indebug(op.ui, b'found a handler for part %s' % part.type)
         unknownparams = part.mandatorykeys - handler.params
         if unknownparams:
             unknownparams = list(unknownparams)
             unknownparams.sort()
             status = b'unsupported-params (%s)' % b', '.join(unknownparams)
             raise error.BundleUnknownFeatureError(
                 parttype=part.type, params=unknownparams
             )
         status = b'supported'
     except error.BundleUnknownFeatureError as exc:
         if part.mandatory:  # mandatory parts
             raise
         indebug(op.ui, b'ignoring unsupported advisory part %s' % exc)
         return  # skip to part processing
     finally:
         if op.ui.debugflag:
             msg = [b'bundle2-input-part: "%s"' % part.type]
             if not part.mandatory:
                 msg.append(b' (advisory)')
             nbmp = len(part.mandatorykeys)
             nbap = len(part.params) - nbmp
             if nbmp or nbap:
                 msg.append(b' (params:')
                 if nbmp:
                     msg.append(b' %i mandatory' % nbmp)
                 if nbap:
                     msg.append(b' %i advisory' % nbmp)
                 msg.append(b')')
             msg.append(b' %s\n' % status)
             op.ui.debug(b''.join(msg))
 
     return handler
 
 
 def _processpart(op, part):
     """process a single part from a bundle
 
     The part is guaranteed to have been fully consumed when the function exits
     (even if an exception is raised)."""
     handler = _gethandler(op, part)
     if handler is None:
         return
 
     # handler is called outside the above try block so that we don't
     # risk catching KeyErrors from anything other than the
     # parthandlermapping lookup (any KeyError raised by handler()
     # itself represents a defect of a different variety).
     output = None
     if op.captureoutput and op.reply is not None:
         op.ui.pushbuffer(error=True, subproc=True)
         output = b''
     try:
         handler(op, part)
     finally:
         if output is not None:
             output = op.ui.popbuffer()
         if output:
             outpart = op.reply.newpart(b'output', data=output, mandatory=False)
             outpart.addparam(
                 b'in-reply-to', pycompat.bytestr(part.id), mandatory=False
             )
 
 
 def decodecaps(blob):
     """decode a bundle2 caps bytes blob into a dictionary
 
     The blob is a list of capabilities (one per line)
     Capabilities may have values using a line of the form::
 
         capability=value1,value2,value3
 
     The values are always a list."""
     caps = {}
     for line in blob.splitlines():
         if not line:
             continue
         if b'=' not in line:
             key, vals = line, ()
         else:
             key, vals = line.split(b'=', 1)
             vals = vals.split(b',')
         key = urlreq.unquote(key)
         vals = [urlreq.unquote(v) for v in vals]
         caps[key] = vals
     return caps
 
 
 def encodecaps(caps):
     """encode a bundle2 caps dictionary into a bytes blob"""
     chunks = []
     for ca in sorted(caps):
         vals = caps[ca]
         ca = urlreq.quote(ca)
         vals = [urlreq.quote(v) for v in vals]
         if vals:
             ca = b"%s=%s" % (ca, b','.join(vals))
         chunks.append(ca)
     return b'\n'.join(chunks)
 
 
 bundletypes = {
     b"": (b"", b'UN'),  # only when using unbundle on ssh and old http servers
     # since the unification ssh accepts a header but there
     # is no capability signaling it.
     b"HG20": (),  # special-cased below
     b"HG10UN": (b"HG10UN", b'UN'),
     b"HG10BZ": (b"HG10", b'BZ'),
     b"HG10GZ": (b"HG10GZ", b'GZ'),
 }
 
 # hgweb uses this list to communicate its preferred type
 bundlepriority = [b'HG10GZ', b'HG10BZ', b'HG10UN']
 
 
 class bundle20(object):
     """represent an outgoing bundle2 container
 
     Use the `addparam` method to add stream level parameter. and `newpart` to
     populate it. Then call `getchunks` to retrieve all the binary chunks of
     data that compose the bundle2 container."""
 
     _magicstring = b'HG20'
 
     def __init__(self, ui, capabilities=()):
         self.ui = ui
         self._params = []
         self._parts = []
         self.capabilities = dict(capabilities)
         self._compengine = util.compengines.forbundletype(b'UN')
         self._compopts = None
         # If compression is being handled by a consumer of the raw
         # data (e.g. the wire protocol), unsetting this flag tells
         # consumers that the bundle is best left uncompressed.
         self.prefercompressed = True
 
     def setcompression(self, alg, compopts=None):
         """setup core part compression to <alg>"""
         if alg in (None, b'UN'):
             return
         assert not any(n.lower() == b'compression' for n, v in self._params)
         self.addparam(b'Compression', alg)
         self._compengine = util.compengines.forbundletype(alg)
         self._compopts = compopts
 
     @property
     def nbparts(self):
         """total number of parts added to the bundler"""
         return len(self._parts)
 
     # methods used to defines the bundle2 content
     def addparam(self, name, value=None):
         """add a stream level parameter"""
         if not name:
             raise error.ProgrammingError(b'empty parameter name')
         if name[0:1] not in pycompat.bytestr(
             string.ascii_letters  # pytype: disable=wrong-arg-types
         ):
             raise error.ProgrammingError(
                 b'non letter first character: %s' % name
             )
         self._params.append((name, value))
 
     def addpart(self, part):
         """add a new part to the bundle2 container
 
         Parts contains the actual applicative payload."""
         assert part.id is None
         part.id = len(self._parts)  # very cheap counter
         self._parts.append(part)
 
     def newpart(self, typeid, *args, **kwargs):
         """create a new part and add it to the containers
 
         As the part is directly added to the containers. For now, this means
         that any failure to properly initialize the part after calling
         ``newpart`` should result in a failure of the whole bundling process.
 
         You can still fall back to manually create and add if you need better
         control."""
         part = bundlepart(typeid, *args, **kwargs)
         self.addpart(part)
         return part
 
     # methods used to generate the bundle2 stream
     def getchunks(self):
         if self.ui.debugflag:
             msg = [b'bundle2-output-bundle: "%s",' % self._magicstring]
             if self._params:
                 msg.append(b' (%i params)' % len(self._params))
             msg.append(b' %i parts total\n' % len(self._parts))
             self.ui.debug(b''.join(msg))
         outdebug(self.ui, b'start emission of %s stream' % self._magicstring)
         yield self._magicstring
         param = self._paramchunk()
         outdebug(self.ui, b'bundle parameter: %s' % param)
         yield _pack(_fstreamparamsize, len(param))
         if param:
             yield param
         for chunk in self._compengine.compressstream(
             self._getcorechunk(), self._compopts
         ):
             yield chunk
 
     def _paramchunk(self):
         """return a encoded version of all stream parameters"""
         blocks = []
         for par, value in self._params:
             par = urlreq.quote(par)
             if value is not None:
                 value = urlreq.quote(value)
                 par = b'%s=%s' % (par, value)
             blocks.append(par)
         return b' '.join(blocks)
 
     def _getcorechunk(self):
         """yield chunk for the core part of the bundle
 
         (all but headers and parameters)"""
         outdebug(self.ui, b'start of parts')
         for part in self._parts:
             outdebug(self.ui, b'bundle part: "%s"' % part.type)
             for chunk in part.getchunks(ui=self.ui):
                 yield chunk
         outdebug(self.ui, b'end of bundle')
         yield _pack(_fpartheadersize, 0)
 
     def salvageoutput(self):
         """return a list with a copy of all output parts in the bundle
 
         This is meant to be used during error handling to make sure we preserve
         server output"""
         salvaged = []
         for part in self._parts:
             if part.type.startswith(b'output'):
                 salvaged.append(part.copy())
         return salvaged
 
 
 class unpackermixin(object):
     """A mixin to extract bytes and struct data from a stream"""
 
     def __init__(self, fp):
         self._fp = fp
 
     def _unpack(self, format):
         """unpack this struct format from the stream
 
         This method is meant for internal usage by the bundle2 protocol only.
         They directly manipulate the low level stream including bundle2 level
         instruction.
 
         Do not use it to implement higher-level logic or methods."""
         data = self._readexact(struct.calcsize(format))
         return _unpack(format, data)
 
     def _readexact(self, size):
         """read exactly <size> bytes from the stream
 
         This method is meant for internal usage by the bundle2 protocol only.
         They directly manipulate the low level stream including bundle2 level
         instruction.
 
         Do not use it to implement higher-level logic or methods."""
         return changegroup.readexactly(self._fp, size)
 
 
 def getunbundler(ui, fp, magicstring=None):
     """return a valid unbundler object for a given magicstring"""
     if magicstring is None:
         magicstring = changegroup.readexactly(fp, 4)
     magic, version = magicstring[0:2], magicstring[2:4]
     if magic != b'HG':
         ui.debug(
             b"error: invalid magic: %r (version %r), should be 'HG'\n"
             % (magic, version)
         )
         raise error.Abort(_(b'not a Mercurial bundle'))
     unbundlerclass = formatmap.get(version)
     if unbundlerclass is None:
         raise error.Abort(_(b'unknown bundle version %s') % version)
     unbundler = unbundlerclass(ui, fp)
     indebug(ui, b'start processing of %s stream' % magicstring)
     return unbundler
 
 
 class unbundle20(unpackermixin):
     """interpret a bundle2 stream
 
     This class is fed with a binary stream and yields parts through its
     `iterparts` methods."""
 
     _magicstring = b'HG20'
 
     def __init__(self, ui, fp):
         """If header is specified, we do not read it out of the stream."""
         self.ui = ui
         self._compengine = util.compengines.forbundletype(b'UN')
         self._compressed = None
         super(unbundle20, self).__init__(fp)
 
     @util.propertycache
     def params(self):
         """dictionary of stream level parameters"""
         indebug(self.ui, b'reading bundle2 stream parameters')
         params = {}
         paramssize = self._unpack(_fstreamparamsize)[0]
         if paramssize < 0:
             raise error.BundleValueError(
                 b'negative bundle param size: %i' % paramssize
             )
         if paramssize:
             params = self._readexact(paramssize)
             params = self._processallparams(params)
         return params
 
     def _processallparams(self, paramsblock):
         """"""
         params = util.sortdict()
         for p in paramsblock.split(b' '):
             p = p.split(b'=', 1)
             p = [urlreq.unquote(i) for i in p]
             if len(p) < 2:
                 p.append(None)
             self._processparam(*p)
             params[p[0]] = p[1]
         return params
 
     def _processparam(self, name, value):
         """process a parameter, applying its effect if needed
 
         Parameter starting with a lower case letter are advisory and will be
         ignored when unknown.  Those starting with an upper case letter are
         mandatory and will this function will raise a KeyError when unknown.
 
         Note: no option are currently supported. Any input will be either
               ignored or failing.
         """
         if not name:
             raise ValueError('empty parameter name')
         if name[0:1] not in pycompat.bytestr(
             string.ascii_letters  # pytype: disable=wrong-arg-types
         ):
             raise ValueError('non letter first character: %s' % name)
         try:
             handler = b2streamparamsmap[name.lower()]
         except KeyError:
             if name[0:1].islower():
                 indebug(self.ui, b"ignoring unknown parameter %s" % name)
             else:
                 raise error.BundleUnknownFeatureError(params=(name,))
         else:
             handler(self, name, value)
 
     def _forwardchunks(self):
         """utility to transfer a bundle2 as binary
 
         This is made necessary by the fact the 'getbundle' command over 'ssh'
         have no way to know then the reply end, relying on the bundle to be
         interpreted to know its end. This is terrible and we are sorry, but we
         needed to move forward to get general delta enabled.
         """
         yield self._magicstring
         assert 'params' not in vars(self)
         paramssize = self._unpack(_fstreamparamsize)[0]
         if paramssize < 0:
             raise error.BundleValueError(
                 b'negative bundle param size: %i' % paramssize
             )
         if paramssize:
             params = self._readexact(paramssize)
             self._processallparams(params)
             # The payload itself is decompressed below, so drop
             # the compression parameter passed down to compensate.
             outparams = []
             for p in params.split(b' '):
                 k, v = p.split(b'=', 1)
                 if k.lower() != b'compression':
                     outparams.append(p)
             outparams = b' '.join(outparams)
             yield _pack(_fstreamparamsize, len(outparams))
             yield outparams
         else:
             yield _pack(_fstreamparamsize, paramssize)
         # From there, payload might need to be decompressed
         self._fp = self._compengine.decompressorreader(self._fp)
         emptycount = 0
         while emptycount < 2:
             # so we can brainlessly loop
             assert _fpartheadersize == _fpayloadsize
             size = self._unpack(_fpartheadersize)[0]
             yield _pack(_fpartheadersize, size)
             if size:
                 emptycount = 0
             else:
                 emptycount += 1
                 continue
             if size == flaginterrupt:
                 continue
             elif size < 0:
                 raise error.BundleValueError(b'negative chunk size: %i')
             yield self._readexact(size)
 
     def iterparts(self, seekable=False):
         """yield all parts contained in the stream"""
         cls = seekableunbundlepart if seekable else unbundlepart
         # make sure param have been loaded
         self.params
         # From there, payload need to be decompressed
         self._fp = self._compengine.decompressorreader(self._fp)
         indebug(self.ui, b'start extraction of bundle2 parts')
         headerblock = self._readpartheader()
         while headerblock is not None:
             part = cls(self.ui, headerblock, self._fp)
             yield part
             # Ensure part is fully consumed so we can start reading the next
             # part.
             part.consume()
 
             headerblock = self._readpartheader()
         indebug(self.ui, b'end of bundle2 stream')
 
     def _readpartheader(self):
         """reads a part header size and return the bytes blob
 
         returns None if empty"""
         headersize = self._unpack(_fpartheadersize)[0]
         if headersize < 0:
             raise error.BundleValueError(
                 b'negative part header size: %i' % headersize
             )
         indebug(self.ui, b'part header size: %i' % headersize)
         if headersize:
             return self._readexact(headersize)
         return None
 
     def compressed(self):
         self.params  # load params
         return self._compressed
 
     def close(self):
         """close underlying file"""
         if util.safehasattr(self._fp, 'close'):
             return self._fp.close()
 
 
 formatmap = {b'20': unbundle20}
 
 b2streamparamsmap = {}
 
 
 def b2streamparamhandler(name):
     """register a handler for a stream level parameter"""
 
     def decorator(func):
         assert name not in formatmap
         b2streamparamsmap[name] = func
         return func
 
     return decorator
 
 
 @b2streamparamhandler(b'compression')
 def processcompression(unbundler, param, value):
     """read compression parameter and install payload decompression"""
     if value not in util.compengines.supportedbundletypes:
         raise error.BundleUnknownFeatureError(params=(param,), values=(value,))
     unbundler._compengine = util.compengines.forbundletype(value)
     if value is not None:
         unbundler._compressed = True
 
 
 class bundlepart(object):
     """A bundle2 part contains application level payload
 
     The part `type` is used to route the part to the application level
     handler.
 
     The part payload is contained in ``part.data``. It could be raw bytes or a
     generator of byte chunks.
 
     You can add parameters to the part using the ``addparam`` method.
     Parameters can be either mandatory (default) or advisory. Remote side
     should be able to safely ignore the advisory ones.
 
     Both data and parameters cannot be modified after the generation has begun.
     """
 
     def __init__(
         self,
         parttype,
         mandatoryparams=(),
         advisoryparams=(),
         data=b'',
         mandatory=True,
     ):
         validateparttype(parttype)
         self.id = None
         self.type = parttype
         self._data = data
         self._mandatoryparams = list(mandatoryparams)
         self._advisoryparams = list(advisoryparams)
         # checking for duplicated entries
         self._seenparams = set()
         for pname, __ in self._mandatoryparams + self._advisoryparams:
             if pname in self._seenparams:
                 raise error.ProgrammingError(b'duplicated params: %s' % pname)
             self._seenparams.add(pname)
         # status of the part's generation:
         # - None: not started,
         # - False: currently generated,
         # - True: generation done.
         self._generated = None
         self.mandatory = mandatory
 
     def __repr__(self):
         cls = "%s.%s" % (self.__class__.__module__, self.__class__.__name__)
         return '<%s object at %x; id: %s; type: %s; mandatory: %s>' % (
             cls,
             id(self),
             self.id,
             self.type,
             self.mandatory,
         )
 
     def copy(self):
         """return a copy of the part
 
         The new part have the very same content but no partid assigned yet.
         Parts with generated data cannot be copied."""
         assert not util.safehasattr(self.data, 'next')
         return self.__class__(
             self.type,
             self._mandatoryparams,
             self._advisoryparams,
             self._data,
             self.mandatory,
         )
 
     # methods used to defines the part content
     @property
     def data(self):
         return self._data
 
     @data.setter
     def data(self, data):
         if self._generated is not None:
             raise error.ReadOnlyPartError(b'part is being generated')
         self._data = data
 
     @property
     def mandatoryparams(self):
         # make it an immutable tuple to force people through ``addparam``
         return tuple(self._mandatoryparams)
 
     @property
     def advisoryparams(self):
         # make it an immutable tuple to force people through ``addparam``
         return tuple(self._advisoryparams)
 
     def addparam(self, name, value=b'', mandatory=True):
         """add a parameter to the part
 
         If 'mandatory' is set to True, the remote handler must claim support
         for this parameter or the unbundling will be aborted.
 
         The 'name' and 'value' cannot exceed 255 bytes each.
         """
         if self._generated is not None:
             raise error.ReadOnlyPartError(b'part is being generated')
         if name in self._seenparams:
             raise ValueError(b'duplicated params: %s' % name)
         self._seenparams.add(name)
         params = self._advisoryparams
         if mandatory:
             params = self._mandatoryparams
         params.append((name, value))
 
     # methods used to generates the bundle2 stream
     def getchunks(self, ui):
         if self._generated is not None:
             raise error.ProgrammingError(b'part can only be consumed once')
         self._generated = False
 
         if ui.debugflag:
             msg = [b'bundle2-output-part: "%s"' % self.type]
             if not self.mandatory:
                 msg.append(b' (advisory)')
             nbmp = len(self.mandatoryparams)
             nbap = len(self.advisoryparams)
             if nbmp or nbap:
                 msg.append(b' (params:')
                 if nbmp:
                     msg.append(b' %i mandatory' % nbmp)
                 if nbap:
                     msg.append(b' %i advisory' % nbmp)
                 msg.append(b')')
             if not self.data:
                 msg.append(b' empty payload')
             elif util.safehasattr(self.data, 'next') or util.safehasattr(
                 self.data, b'__next__'
             ):
                 msg.append(b' streamed payload')
             else:
                 msg.append(b' %i bytes payload' % len(self.data))
             msg.append(b'\n')
             ui.debug(b''.join(msg))
 
         #### header
         if self.mandatory:
             parttype = self.type.upper()
         else:
             parttype = self.type.lower()
         outdebug(ui, b'part %s: "%s"' % (pycompat.bytestr(self.id), parttype))
         ## parttype
         header = [
             _pack(_fparttypesize, len(parttype)),
             parttype,
             _pack(_fpartid, self.id),
         ]
         ## parameters
         # count
         manpar = self.mandatoryparams
         advpar = self.advisoryparams
         header.append(_pack(_fpartparamcount, len(manpar), len(advpar)))
         # size
         parsizes = []
         for key, value in manpar:
             parsizes.append(len(key))
             parsizes.append(len(value))
         for key, value in advpar:
             parsizes.append(len(key))
             parsizes.append(len(value))
         paramsizes = _pack(_makefpartparamsizes(len(parsizes) // 2), *parsizes)
         header.append(paramsizes)
         # key, value
         for key, value in manpar:
             header.append(key)
             header.append(value)
         for key, value in advpar:
             header.append(key)
             header.append(value)
         ## finalize header
         try:
             headerchunk = b''.join(header)
         except TypeError:
             raise TypeError(
                 'Found a non-bytes trying to '
                 'build bundle part header: %r' % header
             )
         outdebug(ui, b'header chunk size: %i' % len(headerchunk))
         yield _pack(_fpartheadersize, len(headerchunk))
         yield headerchunk
         ## payload
         try:
             for chunk in self._payloadchunks():
                 outdebug(ui, b'payload chunk size: %i' % len(chunk))
                 yield _pack(_fpayloadsize, len(chunk))
                 yield chunk
         except GeneratorExit:
             # GeneratorExit means that nobody is listening for our
             # results anyway, so just bail quickly rather than trying
             # to produce an error part.
             ui.debug(b'bundle2-generatorexit\n')
             raise
         except BaseException as exc:
             bexc = stringutil.forcebytestr(exc)
             # backup exception data for later
             ui.debug(
                 b'bundle2-input-stream-interrupt: encoding exception %s' % bexc
             )
             tb = sys.exc_info()[2]
             msg = b'unexpected error: %s' % bexc
             interpart = bundlepart(
                 b'error:abort', [(b'message', msg)], mandatory=False
             )
             interpart.id = 0
             yield _pack(_fpayloadsize, -1)
             for chunk in interpart.getchunks(ui=ui):
                 yield chunk
             outdebug(ui, b'closing payload chunk')
             # abort current part payload
             yield _pack(_fpayloadsize, 0)
             pycompat.raisewithtb(exc, tb)
         # end of payload
         outdebug(ui, b'closing payload chunk')
         yield _pack(_fpayloadsize, 0)
         self._generated = True
 
     def _payloadchunks(self):
         """yield chunks of a the part payload
 
         Exists to handle the different methods to provide data to a part."""
         # we only support fixed size data now.
         # This will be improved in the future.
         if util.safehasattr(self.data, 'next') or util.safehasattr(
             self.data, b'__next__'
         ):
             buff = util.chunkbuffer(self.data)
             chunk = buff.read(preferedchunksize)
             while chunk:
                 yield chunk
                 chunk = buff.read(preferedchunksize)
         elif len(self.data):
             yield self.data
 
 
 flaginterrupt = -1
 
 
 class interrupthandler(unpackermixin):
     """read one part and process it with restricted capability
 
     This allows to transmit exception raised on the producer size during part
     iteration while the consumer is reading a part.
 
     Part processed in this manner only have access to a ui object,"""
 
     def __init__(self, ui, fp):
         super(interrupthandler, self).__init__(fp)
         self.ui = ui
 
     def _readpartheader(self):
         """reads a part header size and return the bytes blob
 
         returns None if empty"""
         headersize = self._unpack(_fpartheadersize)[0]
         if headersize < 0:
             raise error.BundleValueError(
                 b'negative part header size: %i' % headersize
             )
         indebug(self.ui, b'part header size: %i\n' % headersize)
         if headersize:
             return self._readexact(headersize)
         return None
 
     def __call__(self):
 
         self.ui.debug(
             b'bundle2-input-stream-interrupt: opening out of band context\n'
         )
         indebug(self.ui, b'bundle2 stream interruption, looking for a part.')
         headerblock = self._readpartheader()
         if headerblock is None:
             indebug(self.ui, b'no part found during interruption.')
             return
         part = unbundlepart(self.ui, headerblock, self._fp)
         op = interruptoperation(self.ui)
         hardabort = False
         try:
             _processpart(op, part)
         except (SystemExit, KeyboardInterrupt):
             hardabort = True
             raise
         finally:
             if not hardabort:
                 part.consume()
         self.ui.debug(
             b'bundle2-input-stream-interrupt: closing out of band context\n'
         )
 
 
 class interruptoperation(object):
     """A limited operation to be use by part handler during interruption
 
     It only have access to an ui object.
     """
 
     def __init__(self, ui):
         self.ui = ui
         self.reply = None
         self.captureoutput = False
 
     @property
     def repo(self):
         raise error.ProgrammingError(b'no repo access from stream interruption')
 
     def gettransaction(self):
         raise TransactionUnavailable(b'no repo access from stream interruption')
 
 
 def decodepayloadchunks(ui, fh):
     """Reads bundle2 part payload data into chunks.
 
     Part payload data consists of framed chunks. This function takes
     a file handle and emits those chunks.
     """
     dolog = ui.configbool(b'devel', b'bundle2.debug')
     debug = ui.debug
 
     headerstruct = struct.Struct(_fpayloadsize)
     headersize = headerstruct.size
     unpack = headerstruct.unpack
 
     readexactly = changegroup.readexactly
     read = fh.read
 
     chunksize = unpack(readexactly(fh, headersize))[0]
     indebug(ui, b'payload chunk size: %i' % chunksize)
 
     # changegroup.readexactly() is inlined below for performance.
     while chunksize:
         if chunksize >= 0:
             s = read(chunksize)
             if len(s) < chunksize:
                 raise error.Abort(
                     _(
                         b'stream ended unexpectedly '
                         b' (got %d bytes, expected %d)'
                     )
                     % (len(s), chunksize)
                 )
 
             yield s
         elif chunksize == flaginterrupt:
             # Interrupt "signal" detected. The regular stream is interrupted
             # and a bundle2 part follows. Consume it.
             interrupthandler(ui, fh)()
         else:
             raise error.BundleValueError(
                 b'negative payload chunk size: %s' % chunksize
             )
 
         s = read(headersize)
         if len(s) < headersize:
             raise error.Abort(
                 _(b'stream ended unexpectedly  (got %d bytes, expected %d)')
                 % (len(s), chunksize)
             )
 
         chunksize = unpack(s)[0]
 
         # indebug() inlined for performance.
         if dolog:
             debug(b'bundle2-input: payload chunk size: %i\n' % chunksize)
 
 
 class unbundlepart(unpackermixin):
     """a bundle part read from a bundle"""
 
     def __init__(self, ui, header, fp):
         super(unbundlepart, self).__init__(fp)
         self._seekable = util.safehasattr(fp, 'seek') and util.safehasattr(
             fp, b'tell'
         )
         self.ui = ui
         # unbundle state attr
         self._headerdata = header
         self._headeroffset = 0
         self._initialized = False
         self.consumed = False
         # part data
         self.id = None
         self.type = None
         self.mandatoryparams = None
         self.advisoryparams = None
         self.params = None
         self.mandatorykeys = ()
         self._readheader()
         self._mandatory = None
         self._pos = 0
 
     def _fromheader(self, size):
         """return the next <size> byte from the header"""
         offset = self._headeroffset
         data = self._headerdata[offset : (offset + size)]
         self._headeroffset = offset + size
         return data
 
     def _unpackheader(self, format):
         """read given format from header
 
         This automatically compute the size of the format to read."""
         data = self._fromheader(struct.calcsize(format))
         return _unpack(format, data)
 
     def _initparams(self, mandatoryparams, advisoryparams):
         """internal function to setup all logic related parameters"""
         # make it read only to prevent people touching it by mistake.
         self.mandatoryparams = tuple(mandatoryparams)
         self.advisoryparams = tuple(advisoryparams)
         # user friendly UI
         self.params = util.sortdict(self.mandatoryparams)
         self.params.update(self.advisoryparams)
         self.mandatorykeys = frozenset(p[0] for p in mandatoryparams)
 
     def _readheader(self):
         """read the header and setup the object"""
         typesize = self._unpackheader(_fparttypesize)[0]
         self.type = self._fromheader(typesize)
         indebug(self.ui, b'part type: "%s"' % self.type)
         self.id = self._unpackheader(_fpartid)[0]
         indebug(self.ui, b'part id: "%s"' % pycompat.bytestr(self.id))
         # extract mandatory bit from type
         self.mandatory = self.type != self.type.lower()
         self.type = self.type.lower()
         ## reading parameters
         # param count
         mancount, advcount = self._unpackheader(_fpartparamcount)
         indebug(self.ui, b'part parameters: %i' % (mancount + advcount))
         # param size
         fparamsizes = _makefpartparamsizes(mancount + advcount)
         paramsizes = self._unpackheader(fparamsizes)
         # make it a list of couple again
         paramsizes = list(zip(paramsizes[::2], paramsizes[1::2]))
         # split mandatory from advisory
         mansizes = paramsizes[:mancount]
         advsizes = paramsizes[mancount:]
         # retrieve param value
         manparams = []
         for key, value in mansizes:
             manparams.append((self._fromheader(key), self._fromheader(value)))
         advparams = []
         for key, value in advsizes:
             advparams.append((self._fromheader(key), self._fromheader(value)))
         self._initparams(manparams, advparams)
         ## part payload
         self._payloadstream = util.chunkbuffer(self._payloadchunks())
         # we read the data, tell it
         self._initialized = True
 
     def _payloadchunks(self):
         """Generator of decoded chunks in the payload."""
         return decodepayloadchunks(self.ui, self._fp)
 
     def consume(self):
         """Read the part payload until completion.
 
         By consuming the part data, the underlying stream read offset will
         be advanced to the next part (or end of stream).
         """
         if self.consumed:
             return
 
         chunk = self.read(32768)
         while chunk:
             self._pos += len(chunk)
             chunk = self.read(32768)
 
     def read(self, size=None):
         """read payload data"""
         if not self._initialized:
             self._readheader()
         if size is None:
             data = self._payloadstream.read()
         else:
             data = self._payloadstream.read(size)
         self._pos += len(data)
         if size is None or len(data) < size:
             if not self.consumed and self._pos:
                 self.ui.debug(
                     b'bundle2-input-part: total payload size %i\n' % self._pos
                 )
             self.consumed = True
         return data
 
 
 class seekableunbundlepart(unbundlepart):
     """A bundle2 part in a bundle that is seekable.
 
     Regular ``unbundlepart`` instances can only be read once. This class
     extends ``unbundlepart`` to enable bi-directional seeking within the
     part.
 
     Bundle2 part data consists of framed chunks. Offsets when seeking
     refer to the decoded data, not the offsets in the underlying bundle2
     stream.
 
     To facilitate quickly seeking within the decoded data, instances of this
     class maintain a mapping between offsets in the underlying stream and
     the decoded payload. This mapping will consume memory in proportion
     to the number of chunks within the payload (which almost certainly
     increases in proportion with the size of the part).
     """
 
     def __init__(self, ui, header, fp):
         # (payload, file) offsets for chunk starts.
         self._chunkindex = []
 
         super(seekableunbundlepart, self).__init__(ui, header, fp)
 
     def _payloadchunks(self, chunknum=0):
         '''seek to specified chunk and start yielding data'''
         if len(self._chunkindex) == 0:
             assert chunknum == 0, b'Must start with chunk 0'
             self._chunkindex.append((0, self._tellfp()))
         else:
             assert chunknum < len(self._chunkindex), (
                 b'Unknown chunk %d' % chunknum
             )
             self._seekfp(self._chunkindex[chunknum][1])
 
         pos = self._chunkindex[chunknum][0]
 
         for chunk in decodepayloadchunks(self.ui, self._fp):
             chunknum += 1
             pos += len(chunk)
             if chunknum == len(self._chunkindex):
                 self._chunkindex.append((pos, self._tellfp()))
 
             yield chunk
 
     def _findchunk(self, pos):
         '''for a given payload position, return a chunk number and offset'''
         for chunk, (ppos, fpos) in enumerate(self._chunkindex):
             if ppos == pos:
                 return chunk, 0
             elif ppos > pos:
                 return chunk - 1, pos - self._chunkindex[chunk - 1][0]
         raise ValueError(b'Unknown chunk')
 
     def tell(self):
         return self._pos
 
     def seek(self, offset, whence=os.SEEK_SET):
         if whence == os.SEEK_SET:
             newpos = offset
         elif whence == os.SEEK_CUR:
             newpos = self._pos + offset
         elif whence == os.SEEK_END:
             if not self.consumed:
                 # Can't use self.consume() here because it advances self._pos.
                 chunk = self.read(32768)
                 while chunk:
                     chunk = self.read(32768)
             newpos = self._chunkindex[-1][0] - offset
         else:
             raise ValueError(b'Unknown whence value: %r' % (whence,))
 
         if newpos > self._chunkindex[-1][0] and not self.consumed:
             # Can't use self.consume() here because it advances self._pos.
             chunk = self.read(32768)
             while chunk:
                 chunk = self.read(32668)
 
         if not 0 <= newpos <= self._chunkindex[-1][0]:
             raise ValueError(b'Offset out of range')
 
         if self._pos != newpos:
             chunk, internaloffset = self._findchunk(newpos)
             self._payloadstream = util.chunkbuffer(self._payloadchunks(chunk))
             adjust = self.read(internaloffset)
             if len(adjust) != internaloffset:
                 raise error.Abort(_(b'Seek failed\n'))
             self._pos = newpos
 
     def _seekfp(self, offset, whence=0):
         """move the underlying file pointer
 
         This method is meant for internal usage by the bundle2 protocol only.
         They directly manipulate the low level stream including bundle2 level
         instruction.
 
         Do not use it to implement higher-level logic or methods."""
         if self._seekable:
             return self._fp.seek(offset, whence)
         else:
             raise NotImplementedError(_(b'File pointer is not seekable'))
 
     def _tellfp(self):
         """return the file offset, or None if file is not seekable
 
         This method is meant for internal usage by the bundle2 protocol only.
         They directly manipulate the low level stream including bundle2 level
         instruction.
 
         Do not use it to implement higher-level logic or methods."""
         if self._seekable:
             try:
                 return self._fp.tell()
             except IOError as e:
                 if e.errno == errno.ESPIPE:
                     self._seekable = False
                 else:
                     raise
         return None
 
 
 # These are only the static capabilities.
 # Check the 'getrepocaps' function for the rest.
 capabilities = {
     b'HG20': (),
     b'bookmarks': (),
     b'error': (b'abort', b'unsupportedcontent', b'pushraced', b'pushkey'),
     b'listkeys': (),
     b'pushkey': (),
     b'digests': tuple(sorted(util.DIGESTS.keys())),
     b'remote-changegroup': (b'http', b'https'),
     b'hgtagsfnodes': (),
     b'rev-branch-cache': (),
     b'phases': (b'heads',),
     b'stream': (b'v2',),
 }
 
 
 def getrepocaps(repo, allowpushback=False, role=None):
     """return the bundle2 capabilities for a given repo
 
     Exists to allow extensions (like evolution) to mutate the capabilities.
 
     The returned value is used for servers advertising their capabilities as
     well as clients advertising their capabilities to servers as part of
     bundle2 requests. The ``role`` argument specifies which is which.
     """
     if role not in (b'client', b'server'):
         raise error.ProgrammingError(b'role argument must be client or server')
 
     caps = capabilities.copy()
     caps[b'changegroup'] = tuple(
         sorted(changegroup.supportedincomingversions(repo))
     )
     if obsolete.isenabled(repo, obsolete.exchangeopt):
         supportedformat = tuple(b'V%i' % v for v in obsolete.formats)
         caps[b'obsmarkers'] = supportedformat
     if allowpushback:
         caps[b'pushback'] = ()
     cpmode = repo.ui.config(b'server', b'concurrent-push-mode')
     if cpmode == b'check-related':
         caps[b'checkheads'] = (b'related',)
     if b'phases' in repo.ui.configlist(b'devel', b'legacy.exchange'):
         caps.pop(b'phases')
 
     # Don't advertise stream clone support in server mode if not configured.
     if role == b'server':
         streamsupported = repo.ui.configbool(
             b'server', b'uncompressed', untrusted=True
         )
         featuresupported = repo.ui.configbool(b'server', b'bundle2.stream')
 
         if not streamsupported or not featuresupported:
             caps.pop(b'stream')
     # Else always advertise support on client, because payload support
     # should always be advertised.
 
     return caps
 
 
 def bundle2caps(remote):
     """return the bundle capabilities of a peer as dict"""
     raw = remote.capable(b'bundle2')
     if not raw and raw != b'':
         return {}
     capsblob = urlreq.unquote(remote.capable(b'bundle2'))
     return decodecaps(capsblob)
 
 
 def obsmarkersversion(caps):
     """extract the list of supported obsmarkers versions from a bundle2caps dict
     """
     obscaps = caps.get(b'obsmarkers', ())
     return [int(c[1:]) for c in obscaps if c.startswith(b'V')]
 
 
 def writenewbundle(
     ui,
     repo,
     source,
     filename,
     bundletype,
     outgoing,
     opts,
     vfs=None,
     compression=None,
     compopts=None,
 ):
     if bundletype.startswith(b'HG10'):
         cg = changegroup.makechangegroup(repo, outgoing, b'01', source)
         return writebundle(
             ui,
             cg,
             filename,
             bundletype,
             vfs=vfs,
             compression=compression,
             compopts=compopts,
         )
     elif not bundletype.startswith(b'HG20'):
         raise error.ProgrammingError(b'unknown bundle type: %s' % bundletype)
 
     caps = {}
     if b'obsolescence' in opts:
         caps[b'obsmarkers'] = (b'V1',)
     bundle = bundle20(ui, caps)
     bundle.setcompression(compression, compopts)
     _addpartsfromopts(ui, repo, bundle, source, outgoing, opts)
     chunkiter = bundle.getchunks()
 
     return changegroup.writechunks(ui, chunkiter, filename, vfs=vfs)
 
 
 def _addpartsfromopts(ui, repo, bundler, source, outgoing, opts):
     # We should eventually reconcile this logic with the one behind
     # 'exchange.getbundle2partsgenerator'.
     #
     # The type of input from 'getbundle' and 'writenewbundle' are a bit
     # different right now. So we keep them separated for now for the sake of
     # simplicity.
 
     # we might not always want a changegroup in such bundle, for example in
     # stream bundles
     if opts.get(b'changegroup', True):
         cgversion = opts.get(b'cg.version')
         if cgversion is None:
             cgversion = changegroup.safeversion(repo)
         cg = changegroup.makechangegroup(repo, outgoing, cgversion, source)
         part = bundler.newpart(b'changegroup', data=cg.getchunks())
         part.addparam(b'version', cg.version)
         if b'clcount' in cg.extras:
             part.addparam(
                 b'nbchanges', b'%d' % cg.extras[b'clcount'], mandatory=False
             )
         if opts.get(b'phases') and repo.revs(
             b'%ln and secret()', outgoing.ancestorsof
         ):
             part.addparam(
                 b'targetphase', b'%d' % phases.secret, mandatory=False
             )
         if b'exp-sidedata-flag' in repo.requirements:
             part.addparam(b'exp-sidedata', b'1')
 
     if opts.get(b'streamv2', False):
         addpartbundlestream2(bundler, repo, stream=True)
 
     if opts.get(b'tagsfnodescache', True):
         addparttagsfnodescache(repo, bundler, outgoing)
 
     if opts.get(b'revbranchcache', True):
         addpartrevbranchcache(repo, bundler, outgoing)
 
     if opts.get(b'obsolescence', False):
         obsmarkers = repo.obsstore.relevantmarkers(outgoing.missing)
         buildobsmarkerspart(bundler, obsmarkers)
 
     if opts.get(b'phases', False):
         headsbyphase = phases.subsetphaseheads(repo, outgoing.missing)
         phasedata = phases.binaryencode(headsbyphase)
         bundler.newpart(b'phase-heads', data=phasedata)
 
 
 def addparttagsfnodescache(repo, bundler, outgoing):
     # we include the tags fnode cache for the bundle changeset
     # (as an optional parts)
     cache = tags.hgtagsfnodescache(repo.unfiltered())
     chunks = []
 
     # .hgtags fnodes are only relevant for head changesets. While we could
     # transfer values for all known nodes, there will likely be little to
     # no benefit.
     #
     # We don't bother using a generator to produce output data because
     # a) we only have 40 bytes per head and even esoteric numbers of heads
     # consume little memory (1M heads is 40MB) b) we don't want to send the
     # part if we don't have entries and knowing if we have entries requires
     # cache lookups.
     for node in outgoing.ancestorsof:
         # Don't compute missing, as this may slow down serving.
         fnode = cache.getfnode(node, computemissing=False)
         if fnode is not None:
             chunks.extend([node, fnode])
 
     if chunks:
         bundler.newpart(b'hgtagsfnodes', data=b''.join(chunks))
 
 
 def addpartrevbranchcache(repo, bundler, outgoing):
     # we include the rev branch cache for the bundle changeset
     # (as an optional parts)
     cache = repo.revbranchcache()
     cl = repo.unfiltered().changelog
     branchesdata = collections.defaultdict(lambda: (set(), set()))
     for node in outgoing.missing:
         branch, close = cache.branchinfo(cl.rev(node))
         branchesdata[branch][close].add(node)
 
     def generate():
         for branch, (nodes, closed) in sorted(branchesdata.items()):
             utf8branch = encoding.fromlocal(branch)
             yield rbcstruct.pack(len(utf8branch), len(nodes), len(closed))
             yield utf8branch
             for n in sorted(nodes):
                 yield n
             for n in sorted(closed):
                 yield n
 
     bundler.newpart(b'cache:rev-branch-cache', data=generate(), mandatory=False)
 
 
 def _formatrequirementsspec(requirements):
     requirements = [req for req in requirements if req != b"shared"]
     return urlreq.quote(b','.join(sorted(requirements)))
 
 
 def _formatrequirementsparams(requirements):
     requirements = _formatrequirementsspec(requirements)
     params = b"%s%s" % (urlreq.quote(b"requirements="), requirements)
     return params
 
 
 def addpartbundlestream2(bundler, repo, **kwargs):
     if not kwargs.get('stream', False):
         return
 
     if not streamclone.allowservergeneration(repo):
         raise error.Abort(
             _(
                 b'stream data requested but server does not allow '
                 b'this feature'
             ),
             hint=_(
                 b'well-behaved clients should not be '
                 b'requesting stream data from servers not '
                 b'advertising it; the client may be buggy'
             ),
         )
 
     # Stream clones don't compress well. And compression undermines a
     # goal of stream clones, which is to be fast. Communicate the desire
     # to avoid compression to consumers of the bundle.
     bundler.prefercompressed = False
 
     # get the includes and excludes
     includepats = kwargs.get('includepats')
     excludepats = kwargs.get('excludepats')
 
     narrowstream = repo.ui.configbool(
         b'experimental', b'server.stream-narrow-clones'
     )
 
     if (includepats or excludepats) and not narrowstream:
         raise error.Abort(_(b'server does not support narrow stream clones'))
 
     includeobsmarkers = False
     if repo.obsstore:
         remoteversions = obsmarkersversion(bundler.capabilities)
         if not remoteversions:
             raise error.Abort(
                 _(
                     b'server has obsolescence markers, but client '
                     b'cannot receive them via stream clone'
                 )
             )
         elif repo.obsstore._version in remoteversions:
             includeobsmarkers = True
 
     filecount, bytecount, it = streamclone.generatev2(
         repo, includepats, excludepats, includeobsmarkers
     )
     requirements = _formatrequirementsspec(repo.requirements)
     part = bundler.newpart(b'stream2', data=it)
     part.addparam(b'bytecount', b'%d' % bytecount, mandatory=True)
     part.addparam(b'filecount', b'%d' % filecount, mandatory=True)
     part.addparam(b'requirements', requirements, mandatory=True)
 
 
 def buildobsmarkerspart(bundler, markers):
     """add an obsmarker part to the bundler with <markers>
 
     No part is created if markers is empty.
     Raises ValueError if the bundler doesn't support any known obsmarker format.
     """
     if not markers:
         return None
 
     remoteversions = obsmarkersversion(bundler.capabilities)
     version = obsolete.commonversion(remoteversions)
     if version is None:
         raise ValueError(b'bundler does not support common obsmarker format')
     stream = obsolete.encodemarkers(markers, True, version=version)
     return bundler.newpart(b'obsmarkers', data=stream)
 
 
 def writebundle(
     ui, cg, filename, bundletype, vfs=None, compression=None, compopts=None
 ):
     """Write a bundle file and return its filename.
 
     Existing files will not be overwritten.
     If no filename is specified, a temporary file is created.
     bz2 compression can be turned off.
     The bundle file will be deleted in case of errors.
     """
 
     if bundletype == b"HG20":
         bundle = bundle20(ui)
         bundle.setcompression(compression, compopts)
         part = bundle.newpart(b'changegroup', data=cg.getchunks())
         part.addparam(b'version', cg.version)
         if b'clcount' in cg.extras:
             part.addparam(
                 b'nbchanges', b'%d' % cg.extras[b'clcount'], mandatory=False
             )
         chunkiter = bundle.getchunks()
     else:
         # compression argument is only for the bundle2 case
         assert compression is None
         if cg.version != b'01':
             raise error.Abort(
                 _(b'old bundle types only supports v1 changegroups')
             )
         header, comp = bundletypes[bundletype]
         if comp not in util.compengines.supportedbundletypes:
             raise error.Abort(_(b'unknown stream compression type: %s') % comp)
         compengine = util.compengines.forbundletype(comp)
 
         def chunkiter():
             yield header
             for chunk in compengine.compressstream(cg.getchunks(), compopts):
                 yield chunk
 
         chunkiter = chunkiter()
 
     # parse the changegroup data, otherwise we will block
     # in case of sshrepo because we don't know the end of the stream
     return changegroup.writechunks(ui, chunkiter, filename, vfs=vfs)
 
 
 def combinechangegroupresults(op):
     """logic to combine 0 or more addchangegroup results into one"""
     results = [r.get(b'return', 0) for r in op.records[b'changegroup']]
     changedheads = 0
     result = 1
     for ret in results:
         # If any changegroup result is 0, return 0
         if ret == 0:
             result = 0
             break
         if ret < -1:
             changedheads += ret + 1
         elif ret > 1:
             changedheads += ret - 1
     if changedheads > 0:
         result = 1 + changedheads
     elif changedheads < 0:
         result = -1 + changedheads
     return result
 
 
 @parthandler(
     b'changegroup',
     (
         b'version',
         b'nbchanges',
         b'exp-sidedata',
         b'treemanifest',
         b'targetphase',
     ),
 )
 def handlechangegroup(op, inpart):
     """apply a changegroup part on the repo
 
     This is a very early implementation that will massive rework before being
     inflicted to any end-user.
     """
     from . import localrepo
 
     tr = op.gettransaction()
     unpackerversion = inpart.params.get(b'version', b'01')
     # We should raise an appropriate exception here
     cg = changegroup.getunbundler(unpackerversion, inpart, None)
     # the source and url passed here are overwritten by the one contained in
     # the transaction.hookargs argument. So 'bundle2' is a placeholder
     nbchangesets = None
     if b'nbchanges' in inpart.params:
         nbchangesets = int(inpart.params.get(b'nbchanges'))
     if (
         b'treemanifest' in inpart.params
-        and repository.TREEMANIFEST_REQUIREMENT not in op.repo.requirements
+        and requirements.TREEMANIFEST_REQUIREMENT not in op.repo.requirements
     ):
         if len(op.repo.changelog) != 0:
             raise error.Abort(
                 _(
                     b"bundle contains tree manifests, but local repo is "
                     b"non-empty and does not use tree manifests"
                 )
             )
-        op.repo.requirements.add(repository.TREEMANIFEST_REQUIREMENT)
+        op.repo.requirements.add(requirements.TREEMANIFEST_REQUIREMENT)
         op.repo.svfs.options = localrepo.resolvestorevfsoptions(
             op.repo.ui, op.repo.requirements, op.repo.features
         )
         scmutil.writereporequirements(op.repo)
 
     bundlesidedata = bool(b'exp-sidedata' in inpart.params)
     reposidedata = bool(b'exp-sidedata-flag' in op.repo.requirements)
     if reposidedata and not bundlesidedata:
         msg = b"repository is using sidedata but the bundle source do not"
         hint = b'this is currently unsupported'
         raise error.Abort(msg, hint=hint)
 
     extrakwargs = {}
     targetphase = inpart.params.get(b'targetphase')
     if targetphase is not None:
         extrakwargs['targetphase'] = int(targetphase)
     ret = _processchangegroup(
         op,
         cg,
         tr,
         b'bundle2',
         b'bundle2',
         expectedtotal=nbchangesets,
         **extrakwargs
     )
     if op.reply is not None:
         # This is definitely not the final form of this
         # return. But one need to start somewhere.
         part = op.reply.newpart(b'reply:changegroup', mandatory=False)
         part.addparam(
             b'in-reply-to', pycompat.bytestr(inpart.id), mandatory=False
         )
         part.addparam(b'return', b'%i' % ret, mandatory=False)
     assert not inpart.read()
 
 
 _remotechangegroupparams = tuple(
     [b'url', b'size', b'digests']
     + [b'digest:%s' % k for k in util.DIGESTS.keys()]
 )
 
 
 @parthandler(b'remote-changegroup', _remotechangegroupparams)
 def handleremotechangegroup(op, inpart):
     """apply a bundle10 on the repo, given an url and validation information
 
     All the information about the remote bundle to import are given as
     parameters. The parameters include:
       - url: the url to the bundle10.
       - size: the bundle10 file size. It is used to validate what was
         retrieved by the client matches the server knowledge about the bundle.
       - digests: a space separated list of the digest types provided as
         parameters.
       - digest:<digest-type>: the hexadecimal representation of the digest with
         that name. Like the size, it is used to validate what was retrieved by
         the client matches what the server knows about the bundle.
 
     When multiple digest types are given, all of them are checked.
     """
     try:
         raw_url = inpart.params[b'url']
     except KeyError:
         raise error.Abort(_(b'remote-changegroup: missing "%s" param') % b'url')
     parsed_url = util.url(raw_url)
     if parsed_url.scheme not in capabilities[b'remote-changegroup']:
         raise error.Abort(
             _(b'remote-changegroup does not support %s urls')
             % parsed_url.scheme
         )
 
     try:
         size = int(inpart.params[b'size'])
     except ValueError:
         raise error.Abort(
             _(b'remote-changegroup: invalid value for param "%s"') % b'size'
         )
     except KeyError:
         raise error.Abort(
             _(b'remote-changegroup: missing "%s" param') % b'size'
         )
 
     digests = {}
     for typ in inpart.params.get(b'digests', b'').split():
         param = b'digest:%s' % typ
         try:
             value = inpart.params[param]
         except KeyError:
             raise error.Abort(
                 _(b'remote-changegroup: missing "%s" param') % param
             )
         digests[typ] = value
 
     real_part = util.digestchecker(url.open(op.ui, raw_url), size, digests)
 
     tr = op.gettransaction()
     from . import exchange
 
     cg = exchange.readbundle(op.repo.ui, real_part, raw_url)
     if not isinstance(cg, changegroup.cg1unpacker):
         raise error.Abort(
             _(b'%s: not a bundle version 1.0') % util.hidepassword(raw_url)
         )
     ret = _processchangegroup(op, cg, tr, b'bundle2', b'bundle2')
     if op.reply is not None:
         # This is definitely not the final form of this
         # return. But one need to start somewhere.
         part = op.reply.newpart(b'reply:changegroup')
         part.addparam(
             b'in-reply-to', pycompat.bytestr(inpart.id), mandatory=False
         )
         part.addparam(b'return', b'%i' % ret, mandatory=False)
     try:
         real_part.validate()
     except error.Abort as e:
         raise error.Abort(
             _(b'bundle at %s is corrupted:\n%s')
             % (util.hidepassword(raw_url), bytes(e))
         )
     assert not inpart.read()
 
 
 @parthandler(b'reply:changegroup', (b'return', b'in-reply-to'))
 def handlereplychangegroup(op, inpart):
     ret = int(inpart.params[b'return'])
     replyto = int(inpart.params[b'in-reply-to'])
     op.records.add(b'changegroup', {b'return': ret}, replyto)
 
 
 @parthandler(b'check:bookmarks')
 def handlecheckbookmarks(op, inpart):
     """check location of bookmarks
 
     This part is to be used to detect push race regarding bookmark, it
     contains binary encoded (bookmark, node) tuple. If the local state does
     not marks the one in the part, a PushRaced exception is raised
     """
     bookdata = bookmarks.binarydecode(inpart)
 
     msgstandard = (
         b'remote repository changed while pushing - please try again '
         b'(bookmark "%s" move from %s to %s)'
     )
     msgmissing = (
         b'remote repository changed while pushing - please try again '
         b'(bookmark "%s" is missing, expected %s)'
     )
     msgexist = (
         b'remote repository changed while pushing - please try again '
         b'(bookmark "%s" set on %s, expected missing)'
     )
     for book, node in bookdata:
         currentnode = op.repo._bookmarks.get(book)
         if currentnode != node:
             if node is None:
                 finalmsg = msgexist % (book, nodemod.short(currentnode))
             elif currentnode is None:
                 finalmsg = msgmissing % (book, nodemod.short(node))
             else:
                 finalmsg = msgstandard % (
                     book,
                     nodemod.short(node),
                     nodemod.short(currentnode),
                 )
             raise error.PushRaced(finalmsg)
 
 
 @parthandler(b'check:heads')
 def handlecheckheads(op, inpart):
     """check that head of the repo did not change
 
     This is used to detect a push race when using unbundle.
     This replaces the "heads" argument of unbundle."""
     h = inpart.read(20)
     heads = []
     while len(h) == 20:
         heads.append(h)
         h = inpart.read(20)
     assert not h
     # Trigger a transaction so that we are guaranteed to have the lock now.
     if op.ui.configbool(b'experimental', b'bundle2lazylocking'):
         op.gettransaction()
     if sorted(heads) != sorted(op.repo.heads()):
         raise error.PushRaced(
             b'remote repository changed while pushing - please try again'
         )
 
 
 @parthandler(b'check:updated-heads')
 def handlecheckupdatedheads(op, inpart):
     """check for race on the heads touched by a push
 
     This is similar to 'check:heads' but focus on the heads actually updated
     during the push. If other activities happen on unrelated heads, it is
     ignored.
 
     This allow server with high traffic to avoid push contention as long as
     unrelated parts of the graph are involved."""
     h = inpart.read(20)
     heads = []
     while len(h) == 20:
         heads.append(h)
         h = inpart.read(20)
     assert not h
     # trigger a transaction so that we are guaranteed to have the lock now.
     if op.ui.configbool(b'experimental', b'bundle2lazylocking'):
         op.gettransaction()
 
     currentheads = set()
     for ls in op.repo.branchmap().iterheads():
         currentheads.update(ls)
 
     for h in heads:
         if h not in currentheads:
             raise error.PushRaced(
                 b'remote repository changed while pushing - '
                 b'please try again'
             )
 
 
 @parthandler(b'check:phases')
 def handlecheckphases(op, inpart):
     """check that phase boundaries of the repository did not change
 
     This is used to detect a push race.
     """
     phasetonodes = phases.binarydecode(inpart)
     unfi = op.repo.unfiltered()
     cl = unfi.changelog
     phasecache = unfi._phasecache
     msg = (
         b'remote repository changed while pushing - please try again '
         b'(%s is %s expected %s)'
     )
     for expectedphase, nodes in pycompat.iteritems(phasetonodes):
         for n in nodes:
             actualphase = phasecache.phase(unfi, cl.rev(n))
             if actualphase != expectedphase:
                 finalmsg = msg % (
                     nodemod.short(n),
                     phases.phasenames[actualphase],
                     phases.phasenames[expectedphase],
                 )
                 raise error.PushRaced(finalmsg)
 
 
 @parthandler(b'output')
 def handleoutput(op, inpart):
     """forward output captured on the server to the client"""
     for line in inpart.read().splitlines():
         op.ui.status(_(b'remote: %s\n') % line)
 
 
 @parthandler(b'replycaps')
 def handlereplycaps(op, inpart):
     """Notify that a reply bundle should be created
 
     The payload contains the capabilities information for the reply"""
     caps = decodecaps(inpart.read())
     if op.reply is None:
         op.reply = bundle20(op.ui, caps)
 
 
 class AbortFromPart(error.Abort):
     """Sub-class of Abort that denotes an error from a bundle2 part."""
 
 
 @parthandler(b'error:abort', (b'message', b'hint'))
 def handleerrorabort(op, inpart):
     """Used to transmit abort error over the wire"""
     raise AbortFromPart(
         inpart.params[b'message'], hint=inpart.params.get(b'hint')
     )
 
 
 @parthandler(
     b'error:pushkey',
     (b'namespace', b'key', b'new', b'old', b'ret', b'in-reply-to'),
 )
 def handleerrorpushkey(op, inpart):
     """Used to transmit failure of a mandatory pushkey over the wire"""
     kwargs = {}
     for name in (b'namespace', b'key', b'new', b'old', b'ret'):
         value = inpart.params.get(name)
         if value is not None:
             kwargs[name] = value
     raise error.PushkeyFailed(
         inpart.params[b'in-reply-to'], **pycompat.strkwargs(kwargs)
     )
 
 
 @parthandler(b'error:unsupportedcontent', (b'parttype', b'params'))
 def handleerrorunsupportedcontent(op, inpart):
     """Used to transmit unknown content error over the wire"""
     kwargs = {}
     parttype = inpart.params.get(b'parttype')
     if parttype is not None:
         kwargs[b'parttype'] = parttype
     params = inpart.params.get(b'params')
     if params is not None:
         kwargs[b'params'] = params.split(b'\0')
 
     raise error.BundleUnknownFeatureError(**pycompat.strkwargs(kwargs))
 
 
 @parthandler(b'error:pushraced', (b'message',))
 def handleerrorpushraced(op, inpart):
     """Used to transmit push race error over the wire"""
     raise error.ResponseError(_(b'push failed:'), inpart.params[b'message'])
 
 
 @parthandler(b'listkeys', (b'namespace',))
 def handlelistkeys(op, inpart):
     """retrieve pushkey namespace content stored in a bundle2"""
     namespace = inpart.params[b'namespace']
     r = pushkey.decodekeys(inpart.read())
     op.records.add(b'listkeys', (namespace, r))
 
 
 @parthandler(b'pushkey', (b'namespace', b'key', b'old', b'new'))
 def handlepushkey(op, inpart):
     """process a pushkey request"""
     dec = pushkey.decode
     namespace = dec(inpart.params[b'namespace'])
     key = dec(inpart.params[b'key'])
     old = dec(inpart.params[b'old'])
     new = dec(inpart.params[b'new'])
     # Grab the transaction to ensure that we have the lock before performing the
     # pushkey.
     if op.ui.configbool(b'experimental', b'bundle2lazylocking'):
         op.gettransaction()
     ret = op.repo.pushkey(namespace, key, old, new)
     record = {b'namespace': namespace, b'key': key, b'old': old, b'new': new}
     op.records.add(b'pushkey', record)
     if op.reply is not None:
         rpart = op.reply.newpart(b'reply:pushkey')
         rpart.addparam(
             b'in-reply-to', pycompat.bytestr(inpart.id), mandatory=False
         )
         rpart.addparam(b'return', b'%i' % ret, mandatory=False)
     if inpart.mandatory and not ret:
         kwargs = {}
         for key in (b'namespace', b'key', b'new', b'old', b'ret'):
             if key in inpart.params:
                 kwargs[key] = inpart.params[key]
         raise error.PushkeyFailed(
             partid=b'%d' % inpart.id, **pycompat.strkwargs(kwargs)
         )
 
 
 @parthandler(b'bookmarks')
 def handlebookmark(op, inpart):
     """transmit bookmark information
 
     The part contains binary encoded bookmark information.
 
     The exact behavior of this part can be controlled by the 'bookmarks' mode
     on the bundle operation.
 
     When mode is 'apply' (the default) the bookmark information is applied as
     is to the unbundling repository. Make sure a 'check:bookmarks' part is
     issued earlier to check for push races in such update. This behavior is
     suitable for pushing.
 
     When mode is 'records', the information is recorded into the 'bookmarks'
     records of the bundle operation. This behavior is suitable for pulling.
     """
     changes = bookmarks.binarydecode(inpart)
 
     pushkeycompat = op.repo.ui.configbool(
         b'server', b'bookmarks-pushkey-compat'
     )
     bookmarksmode = op.modes.get(b'bookmarks', b'apply')
 
     if bookmarksmode == b'apply':
         tr = op.gettransaction()
         bookstore = op.repo._bookmarks
         if pushkeycompat:
             allhooks = []
             for book, node in changes:
                 hookargs = tr.hookargs.copy()
                 hookargs[b'pushkeycompat'] = b'1'
                 hookargs[b'namespace'] = b'bookmarks'
                 hookargs[b'key'] = book
                 hookargs[b'old'] = nodemod.hex(bookstore.get(book, b''))
                 hookargs[b'new'] = nodemod.hex(
                     node if node is not None else b''
                 )
                 allhooks.append(hookargs)
 
             for hookargs in allhooks:
                 op.repo.hook(
                     b'prepushkey', throw=True, **pycompat.strkwargs(hookargs)
                 )
 
         for book, node in changes:
             if bookmarks.isdivergent(book):
                 msg = _(b'cannot accept divergent bookmark %s!') % book
                 raise error.Abort(msg)
 
         bookstore.applychanges(op.repo, op.gettransaction(), changes)
 
         if pushkeycompat:
 
             def runhook(unused_success):
                 for hookargs in allhooks:
                     op.repo.hook(b'pushkey', **pycompat.strkwargs(hookargs))
 
             op.repo._afterlock(runhook)
 
     elif bookmarksmode == b'records':
         for book, node in changes:
             record = {b'bookmark': book, b'node': node}
             op.records.add(b'bookmarks', record)
     else:
         raise error.ProgrammingError(
             b'unkown bookmark mode: %s' % bookmarksmode
         )
 
 
 @parthandler(b'phase-heads')
 def handlephases(op, inpart):
     """apply phases from bundle part to repo"""
     headsbyphase = phases.binarydecode(inpart)
     phases.updatephases(op.repo.unfiltered(), op.gettransaction, headsbyphase)
 
 
 @parthandler(b'reply:pushkey', (b'return', b'in-reply-to'))
 def handlepushkeyreply(op, inpart):
     """retrieve the result of a pushkey request"""
     ret = int(inpart.params[b'return'])
     partid = int(inpart.params[b'in-reply-to'])
     op.records.add(b'pushkey', {b'return': ret}, partid)
 
 
 @parthandler(b'obsmarkers')
 def handleobsmarker(op, inpart):
     """add a stream of obsmarkers to the repo"""
     tr = op.gettransaction()
     markerdata = inpart.read()
     if op.ui.config(b'experimental', b'obsmarkers-exchange-debug'):
         op.ui.writenoi18n(
             b'obsmarker-exchange: %i bytes received\n' % len(markerdata)
         )
     # The mergemarkers call will crash if marker creation is not enabled.
     # we want to avoid this if the part is advisory.
     if not inpart.mandatory and op.repo.obsstore.readonly:
         op.repo.ui.debug(
             b'ignoring obsolescence markers, feature not enabled\n'
         )
         return
     new = op.repo.obsstore.mergemarkers(tr, markerdata)
     op.repo.invalidatevolatilesets()
     op.records.add(b'obsmarkers', {b'new': new})
     if op.reply is not None:
         rpart = op.reply.newpart(b'reply:obsmarkers')
         rpart.addparam(
             b'in-reply-to', pycompat.bytestr(inpart.id), mandatory=False
         )
         rpart.addparam(b'new', b'%i' % new, mandatory=False)
 
 
 @parthandler(b'reply:obsmarkers', (b'new', b'in-reply-to'))
 def handleobsmarkerreply(op, inpart):
     """retrieve the result of a pushkey request"""
     ret = int(inpart.params[b'new'])
     partid = int(inpart.params[b'in-reply-to'])
     op.records.add(b'obsmarkers', {b'new': ret}, partid)
 
 
 @parthandler(b'hgtagsfnodes')
 def handlehgtagsfnodes(op, inpart):
     """Applies .hgtags fnodes cache entries to the local repo.
 
     Payload is pairs of 20 byte changeset nodes and filenodes.
     """
     # Grab the transaction so we ensure that we have the lock at this point.
     if op.ui.configbool(b'experimental', b'bundle2lazylocking'):
         op.gettransaction()
     cache = tags.hgtagsfnodescache(op.repo.unfiltered())
 
     count = 0
     while True:
         node = inpart.read(20)
         fnode = inpart.read(20)
         if len(node) < 20 or len(fnode) < 20:
             op.ui.debug(b'ignoring incomplete received .hgtags fnodes data\n')
             break
         cache.setfnode(node, fnode)
         count += 1
 
     cache.write()
     op.ui.debug(b'applied %i hgtags fnodes cache entries\n' % count)
 
 
 rbcstruct = struct.Struct(b'>III')
 
 
 @parthandler(b'cache:rev-branch-cache')
 def handlerbc(op, inpart):
     """receive a rev-branch-cache payload and update the local cache
 
     The payload is a series of data related to each branch
 
     1) branch name length
     2) number of open heads
     3) number of closed heads
     4) open heads nodes
     5) closed heads nodes
     """
     total = 0
     rawheader = inpart.read(rbcstruct.size)
     cache = op.repo.revbranchcache()
     cl = op.repo.unfiltered().changelog
     while rawheader:
         header = rbcstruct.unpack(rawheader)
         total += header[1] + header[2]
         utf8branch = inpart.read(header[0])
         branch = encoding.tolocal(utf8branch)
         for x in pycompat.xrange(header[1]):
             node = inpart.read(20)
             rev = cl.rev(node)
             cache.setdata(branch, rev, node, False)
         for x in pycompat.xrange(header[2]):
             node = inpart.read(20)
             rev = cl.rev(node)
             cache.setdata(branch, rev, node, True)
         rawheader = inpart.read(rbcstruct.size)
     cache.write()
 
 
 @parthandler(b'pushvars')
 def bundle2getvars(op, part):
     '''unbundle a bundle2 containing shellvars on the server'''
     # An option to disable unbundling on server-side for security reasons
     if op.ui.configbool(b'push', b'pushvars.server'):
         hookargs = {}
         for key, value in part.advisoryparams:
             key = key.upper()
             # We want pushed variables to have USERVAR_ prepended so we know
             # they came from the --pushvar flag.
             key = b"USERVAR_" + key
             hookargs[key] = value
         op.addhookargs(hookargs)
 
 
 @parthandler(b'stream2', (b'requirements', b'filecount', b'bytecount'))
 def handlestreamv2bundle(op, part):
 
     requirements = urlreq.unquote(part.params[b'requirements']).split(b',')
     filecount = int(part.params[b'filecount'])
     bytecount = int(part.params[b'bytecount'])
 
     repo = op.repo
     if len(repo):
         msg = _(b'cannot apply stream clone to non empty repository')
         raise error.Abort(msg)
 
     repo.ui.debug(b'applying stream bundle\n')
     streamclone.applybundlev2(repo, part, filecount, bytecount, requirements)
 
 
 def widen_bundle(
     bundler, repo, oldmatcher, newmatcher, common, known, cgversion, ellipses
 ):
     """generates bundle2 for widening a narrow clone
 
     bundler is the bundle to which data should be added
     repo is the localrepository instance
     oldmatcher matches what the client already has
     newmatcher matches what the client needs (including what it already has)
     common is set of common heads between server and client
     known is a set of revs known on the client side (used in ellipses)
     cgversion is the changegroup version to send
     ellipses is boolean value telling whether to send ellipses data or not
 
     returns bundle2 of the data required for extending
     """
     commonnodes = set()
     cl = repo.changelog
     for r in repo.revs(b"::%ln", common):
         commonnodes.add(cl.node(r))
     if commonnodes:
         # XXX: we should only send the filelogs (and treemanifest). user
         # already has the changelog and manifest
         packer = changegroup.getbundler(
             cgversion,
             repo,
             oldmatcher=oldmatcher,
             matcher=newmatcher,
             fullnodes=commonnodes,
         )
         cgdata = packer.generate(
             {nodemod.nullid},
             list(commonnodes),
             False,
             b'narrow_widen',
             changelog=False,
         )
 
         part = bundler.newpart(b'changegroup', data=cgdata)
         part.addparam(b'version', cgversion)
-        if repository.TREEMANIFEST_REQUIREMENT in repo.requirements:
+        if requirements.TREEMANIFEST_REQUIREMENT in repo.requirements:
             part.addparam(b'treemanifest', b'1')
         if b'exp-sidedata-flag' in repo.requirements:
             part.addparam(b'exp-sidedata', b'1')
 
     return bundler

mercurial/changegroup.py

@@ -1,1689 +1,1690 b''
 # changegroup.py - Mercurial changegroup manipulation functions
 #
 #  Copyright 2006 Matt Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 from __future__ import absolute_import
 
 import os
 import struct
 import weakref
 
 from .i18n import _
 from .node import (
     hex,
     nullid,
     nullrev,
     short,
 )
 from .pycompat import open
 
 from . import (
     error,
     match as matchmod,
     mdiff,
     phases,
     pycompat,
+    requirements,
     util,
 )
 
 from .interfaces import repository
 
 _CHANGEGROUPV1_DELTA_HEADER = struct.Struct(b"20s20s20s20s")
 _CHANGEGROUPV2_DELTA_HEADER = struct.Struct(b"20s20s20s20s20s")
 _CHANGEGROUPV3_DELTA_HEADER = struct.Struct(b">20s20s20s20s20sH")
 
 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(b">l", d)[0]
     if l <= 4:
         if l:
             raise error.Abort(_(b"invalid chunk length %d") % l)
         return b""
     return readexactly(stream, l - 4)
 
 
 def chunkheader(length):
     """return a changegroup chunk header (string)"""
     return struct.pack(b">l", length + 4)
 
 
 def closechunk():
     """return a changegroup chunk header (string) for a zero-length chunk"""
     return struct.pack(b">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.
     Existing files will not be overwritten.
     If no filename is specified, a temporary file is created.
     """
     fh = None
     cleanup = None
     try:
         if filename:
             if vfs:
                 fh = vfs.open(filename, b"wb")
             else:
                 # Increase default buffer size because default is usually
                 # small (4k is common on Linux).
                 fh = open(filename, b"wb", 131072)
         else:
             fd, filename = pycompat.mkstemp(prefix=b"hg-bundle-", suffix=b".hg")
             fh = os.fdopen(fd, "wb")
         cleanup = filename
         for c in chunks:
             fh.write(c)
         cleanup = None
         return filename
     finally:
         if fh is not None:
             fh.close()
         if cleanup is not None:
             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()
     method to add the changes from the changegroup to a repository.
 
     If you're forwarding a changegroup unmodified to another consumer,
     use getchunks(), which returns an iterator of changegroup
     chunks. This is mostly useful for cases where you need to know the
     data stream has ended by observing the end of the changegroup.
 
     deltachunk() is useful only if you're applying delta data. Most
     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 = b'01'
     _grouplistcount = 1  # One list of files after the manifests
 
     def __init__(self, fh, alg, extras=None):
         if alg is None:
             alg = b'UN'
         if alg not in util.compengines.supportedbundletypes:
             raise error.Abort(_(b'unknown stream compression type: %s') % alg)
         if alg == b'BZ':
             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 != b'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)
         l = struct.unpack(b">l", d)[0]
         if l <= 4:
             if l:
                 raise error.Abort(_(b"invalid chunk length %d") % l)
             return 0
         if self.callback:
             self.callback()
         return l - 4
 
     def changelogheader(self):
         """v10 does not have a changelog header chunk"""
         return {}
 
     def manifestheader(self):
         """v10 does not have a manifest header chunk"""
         return {}
 
     def filelogheader(self):
         """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 {b'filename': fname}
 
     def _deltaheader(self, headertuple, prevnode):
         node, p1, p2, cs = headertuple
         if prevnode is None:
             deltabase = p1
         else:
             deltabase = prevnode
         flags = 0
         return node, p1, p2, deltabase, cs, flags
 
     def deltachunk(self, prevnode):
         l = self._chunklength()
         if not l:
             return {}
         headerdata = readexactly(self._stream, self.deltaheadersize)
         header = self.deltaheader.unpack(headerdata)
         delta = readexactly(self._stream, l - self.deltaheadersize)
         node, p1, p2, deltabase, cs, flags = self._deltaheader(header, prevnode)
         return (node, p1, p2, cs, deltabase, delta, flags)
 
     def getchunks(self):
         """returns all the chunks contains in the bundle
 
         Used when you need to forward the binary stream to a file or another
         network API. To do so, it parse the changegroup data, otherwise it will
         block in case of sshrepo because it don't know the end of the stream.
         """
         # For changegroup 1 and 2, we expect 3 parts: changelog, manifestlog,
         # and a list of filelogs. For changegroup 3, we expect 4 parts:
         # changelog, manifestlog, a list of tree manifestlogs, and a list of
         # filelogs.
         #
         # Changelog and manifestlog parts are terminated with empty chunks. The
         # tree and file parts are a list of entry sections. Each entry section
         # is a series of chunks terminating in an empty chunk. The list of these
         # entry sections is terminated in yet another empty chunk, so we know
         # we've reached the end of the tree/file list when we reach an empty
         # chunk that was proceeded by no non-empty chunks.
 
         parts = 0
         while parts < 2 + self._grouplistcount:
             noentries = True
             while True:
                 chunk = getchunk(self)
                 if not chunk:
                     # The first two empty chunks represent the end of the
                     # changelog and the manifestlog portions. The remaining
                     # empty chunks represent either A) the end of individual
                     # tree or file entries in the file list, or B) the end of
                     # the entire list. It's the end of the entire list if there
                     # were no entries (i.e. noentries is True).
                     if parts < 2:
                         parts += 1
                     elif noentries:
                         parts += 1
                     break
                 noentries = False
                 yield chunkheader(len(chunk))
                 pos = 0
                 while pos < len(chunk):
                     next = pos + 2 ** 20
                     yield chunk[pos:next]
                     pos = next
             yield closechunk()
 
     def _unpackmanifests(self, repo, revmap, trp, prog):
         self.callback = prog.increment
         # no need to check for empty manifest group here:
         # if the result of the merge of 1 and 2 is the same in 3 and 4,
         # no new manifest will be created and the manifest group will
         # be empty during the pull
         self.manifestheader()
         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,
         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:
         - nothing changed or no source: 0
         - 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(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(b'source', srctype)
             tr.hookargs.setdefault(b'url', url)
             repo.hook(
                 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(_(b"adding changesets\n"))
             clstart = len(cl)
             progress = repo.ui.makeprogress(
                 _(b'changesets'), unit=_(b'chunks'), total=expectedtotal
             )
             self.callback = progress.increment
 
             efilesset = set()
 
             def onchangelog(cl, node):
                 efilesset.update(cl.readfiles(node))
 
             self.changelogheader()
             deltas = self.deltaiter()
             cgnodes = cl.addgroup(deltas, csmap, trp, addrevisioncb=onchangelog)
             efiles = len(efilesset)
 
             if not cgnodes:
                 repo.ui.develwarn(
                     b'applied empty changelog from 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(_(b"adding manifests\n"))
             # We know that we'll never have more manifests than we had
             # changesets.
             progress = repo.ui.makeprogress(
                 _(b'manifests'), unit=_(b'chunks'), total=changesets
             )
             self._unpackmanifests(repo, revmap, trp, progress)
 
             needfiles = {}
             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
                     mfest = ml[mfnode].readdelta()
                     # store file cgnodes we must see
                     for f, n in pycompat.iteritems(mfest):
                         needfiles.setdefault(f, set()).add(n)
 
             # process the files
             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(b'changegroup-count-changesets', 0)
             tr.changes.setdefault(b'changegroup-count-revisions', 0)
             tr.changes.setdefault(b'changegroup-count-files', 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[b'changegroup-count-changesets'] += changesets
                 tr.changes[b'changegroup-count-revisions'] += newrevs
                 tr.changes[b'changegroup-count-files'] += newfiles
 
             deltaheads = 0
             if oldheads:
                 heads = cl.heads()
                 deltaheads += len(heads) - len(oldheads)
                 for h in heads:
                     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[b'changegroup-count-heads'] += deltaheads
             repo.invalidatevolatilesets()
 
             if changesets > 0:
                 if b'node' not in tr.hookargs:
                     tr.hookargs[b'node'] = hex(cl.node(clstart))
                     tr.hookargs[b'node_last'] = hex(cl.node(clend - 1))
                     hookargs = dict(tr.hookargs)
                 else:
                     hookargs = dict(tr.hookargs)
                     hookargs[b'node'] = hex(cl.node(clstart))
                     hookargs[b'node_last'] = hex(cl.node(clend - 1))
                 repo.hook(
                     b'pretxnchangegroup',
                     throw=True,
                     **pycompat.strkwargs(hookargs)
                 )
 
             added = [cl.node(r) for r in pycompat.xrange(clstart, clend)]
             phaseall = None
             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
                 # the bundle
                 if repo.publishing():
                     targetphase = phaseall = phases.public
                 else:
                     # closer target phase computation
 
                     # Those changesets have been pushed from the
                     # outside, their phases are going to be pushed
                     # alongside. Therefor `targetphase` is
                     # ignored.
                     targetphase = phaseall = phases.draft
             if added:
                 phases.registernew(repo, tr, targetphase, added)
             if phaseall is not None:
                 phases.advanceboundary(repo, tr, phaseall, cgnodes)
 
             if changesets > 0:
 
                 def runhooks(unused_success):
                     # These hooks run when the lock releases, not when the
                     # transaction closes. So it's possible for the changelog
                     # to have changed since we last saw it.
                     if clstart >= len(repo):
                         return
 
                     repo.hook(b"changegroup", **pycompat.strkwargs(hookargs))
 
                     for n in added:
                         args = hookargs.copy()
                         args[b'node'] = hex(n)
                         del args[b'node_last']
                         repo.hook(b"incoming", **pycompat.strkwargs(args))
 
                     newheads = [h for h in repo.heads() if h not in oldheads]
                     repo.ui.log(
                         b"incoming",
                         b"%d incoming changes - new heads: %s\n",
                         len(added),
                         b', '.join([hex(c[:6]) for c in newheads]),
                     )
 
                 tr.addpostclose(
                     b'changegroup-runhooks-%020i' % clstart,
                     lambda tr: repo._afterlock(runhooks),
                 )
         finally:
             repo.ui.flush()
         # never return 0 here:
         if deltaheads < 0:
             ret = deltaheads - 1
         else:
             ret = deltaheads + 1
         return ret
 
     def deltaiter(self):
         """
         returns an iterator of the deltas in this changegroup
 
         Useful for passing to the underlying storage system to be stored.
         """
         chain = None
         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 = b'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 = 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[b"filename"]
             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(_(b"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
     # requires that everything on the wire be deltas. So for full
     # revisions, we need to invent a header that says to rewrite
     # data.
 
     if delta.delta is not None:
         prefix, data = b'', delta.delta
     elif delta.basenode == nullid:
         data = delta.revision
         prefix = mdiff.trivialdiffheader(len(data))
     else:
         data = delta.revision
         prefix = mdiff.replacediffheader(delta.baserevisionsize, 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.
     #
     # In a perfect world, we'd generate better ellipsis-ified graphs
     # for non-changelog revlogs. In practice, we haven't started doing
     # that yet, so the resulting DAGs for the manifestlog and filelogs
     # are actually full of bogus parentage on all the ellipsis
     # nodes. This has the side effect that, while the contents are
     # correct, the individual DAGs might be completely out of whack in
     # a case like 882681bc3166 and its ancestors (back about 10
     # revisions or so) in the main hg repo.
     #
     # The one invariant we *know* holds is that the new (potentially
     # bogus) DAG shape will be valid if we order the nodes in the
     # order that they're introduced in dramatis personae by the
     # 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,
     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
         non-changelog revlogs, we need to turn those numbers into
         something local. This does that for us, and during the
         changelog sending phase will also expand the stored
         mappings as needed.
         """
         if clrev == nullrev:
             return nullrev
 
         if ischangelog:
             return clrev
 
         # Walk the ellipsis-ized changelog breadth-first looking for a
         # change that has been linked from the current revlog.
         #
         # For a flat manifest revlog only a single step should be necessary
         # as all relevant changelog entries are relevant to the flat
         # manifest.
         #
         # For a filelog or tree manifest dirlog however not every changelog
         # entry will have been relevant, so we need to skip some changelog
         # nodes even after ellipsis-izing.
         walk = [clrev]
         while walk:
             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) if pp != nullrev])
             elif p in precomputedellipsis:
                 walk.extend(
                     [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
                 # is pointed to by linknode. "Know" is in scare
                 # quotes because I haven't done enough examination
                 # of edge cases to convince myself this is really
                 # a fact - it works for all the (admittedly
                 # thorough) cases in our testsuite, but I would be
                 # somewhat unsurprised to find a case in the wild
                 # where this breaks down a bit. That said, I don't
                 # know if it would hurt anything.
                 for i in pycompat.xrange(rev, 0, -1):
                     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(
                     b'unable to resolve parent while packing %r %r'
                     b' for changeset %r' % (store.indexfile, rev, clrev)
                 )
 
         return nullrev
 
     if not linkparents or (store.parentrevs(rev) == (nullrev, nullrev)):
         p1, p2 = nullrev, nullrev
     elif len(linkparents) == 1:
         (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,
     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
     topic name (e.g. changesets, manifests, etc).
     """
     if not nodes:
         return
 
     cl = repo.changelog
 
     if ischangelog:
         # `hg log` shows changesets in storage order. To preserve order
         # across clones, send out changesets in storage order.
         nodesorder = b'storage'
     elif ellipses:
         nodes = _sortnodesellipsis(store, nodes, cl, lookup)
         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
     # for emitrevisions() b) dropping revisions would break emitrevisions()'s
     # assumptions about delta choices and we would possibly send a delta
     # referencing a missing base revision.
     #
     # Also, calling lookup() has side-effects with regards to populating
     # data structures. If we don't call lookup() for each node or if we call
     # lookup() after the first pass through each node, things can break -
     # possibly intermittently depending on the python hash seed! For that
     # reason, we store a mapping of all linknodes during the initial node
     # pass rather than use lookup() on the output side.
     if ellipses:
         filtered = []
         adjustedparents = {}
         linknodes = {}
 
         for node in nodes:
             rev = store.rev(node)
             linknode = lookup(node)
             linkrev = cl.rev(linknode)
             clrevtolocalrev[linkrev] = rev
 
             # If linknode is in fullclnodes, it means the corresponding
             # changeset was a full changeset and is being sent unaltered.
             if linknode in fullclnodes:
                 linknodes[node] = linknode
 
             # If the corresponding changeset wasn't in the set computed
             # as relevant to us, it should be dropped outright.
             elif linkrev not in precomputedellipsis:
                 continue
 
             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,
                     clrevtolocalrev,
                     fullclnodes,
                     precomputedellipsis,
                 )
 
                 adjustedparents[node] = (p1node, p2node)
                 linknodes[node] = linknode
 
             filtered.append(node)
 
         nodes = filtered
 
     # 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=_(b'chunks'), total=len(nodes)
         )
 
     configtarget = repo.ui.config(b'devel', b'bundle.delta')
     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 == b'p1':
         deltamode = repository.CG_DELTAMODE_P1
     elif configtarget == b'full':
         deltamode = repository.CG_DELTAMODE_FULL
 
     revisions = store.emitrevisions(
         nodes,
         nodesorder=nodesorder,
         revisiondata=True,
         assumehaveparentrevisions=not ellipses,
         deltamode=deltamode,
     )
 
     for i, revision in enumerate(revisions):
         if progress:
             progress.update(i + 1)
 
         if ellipses:
             linknode = linknodes[revision.node]
 
             if revision.node in adjustedparents:
                 p1node, p2node = adjustedparents[revision.node]
                 revision.p1node = p1node
                 revision.p2node = p2node
                 revision.flags |= repository.REVISION_FLAG_ELLIPSIS
 
         else:
             linknode = lookup(revision.node)
 
         revision.linknode = linknode
         yield revision
 
     if progress:
         progress.complete()
 
 
 class cgpacker(object):
     def __init__(
         self,
         repo,
         oldmatcher,
         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.
 
         matcher is a matcher that matches on files to include in the
         changegroup. Used to facilitate sparse changegroups.
 
         forcedeltaparentprev indicates whether delta parents must be against
         the previous revision in a delta group. This should only be used for
         compatibility with changegroup version 1.
 
         builddeltaheader is a callable that constructs the header for a group
         delta.
 
         manifestsend is a chunk to send after manifests have been fully emitted.
 
         ellipses indicates whether ellipsis serving mode is enabled.
 
         bundlecaps is optional and can be used to specify the set of
         capabilities which can be used to build the bundle. While bundlecaps is
         unused in core Mercurial, extensions rely on this feature to communicate
         capabilities to customize the changegroup packer.
 
         shallow indicates whether shallow data might be sent. The packer may
         need to pack file contents not introduced by the changes being packed.
 
         fullnodes is the set of changelog nodes which should not be ellipsis
         nodes. We store this rather than the set of nodes that should be
         ellipsis because for very large histories we expect this to be
         significantly smaller.
         """
         assert oldmatcher
         assert matcher
         self._oldmatcher = oldmatcher
         self._matcher = matcher
 
         self.version = version
         self._forcedeltaparentprev = forcedeltaparentprev
         self._builddeltaheader = builddeltaheader
         self._manifestsend = manifestsend
         self._ellipses = ellipses
 
         # Set of capabilities we can use to build the bundle.
         if bundlecaps is None:
             bundlecaps = set()
         self._bundlecaps = bundlecaps
         self._isshallow = shallow
         self._fullclnodes = fullnodes
 
         # Maps ellipsis revs to their roots at the changelog level.
         self._precomputedellipsis = ellipsisroots
 
         self._repo = repo
 
         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, 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(_(b'uncompressed size of bundle content:\n'))
         size = 0
 
         clstate, deltas = self._generatechangelog(
             cl, clnodes, generate=changelog
         )
         for delta in deltas:
             for chunk in _revisiondeltatochunks(delta, self._builddeltaheader):
                 size += len(chunk)
                 yield chunk
 
         close = closechunk()
         size += len(close)
         yield closechunk()
 
         self._verbosenote(_(b'%8.i (changelog)\n') % size)
 
         clrevorder = clstate[b'clrevorder']
         manifests = clstate[b'manifests']
         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.
         #
         # When taking the slowpath when the manifest revlog uses generaldelta,
         # the manifest may be walked in the "wrong" order. Without 'clrevorder',
         # we would get an incorrect linkrev (see fix in cc0ff93d0c0c).
         #
         # When taking the fastpath, we are only vulnerable to reordering
         # of the changelog itself. The changelog never uses generaldelta and is
         # never reordered. To handle this case, we simply take the slowpath,
         # which already has the 'clrevorder' logic. This was also fixed in
         # cc0ff93d0c0c.
 
         # 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 (
-            repository.TREEMANIFEST_REQUIREMENT not in repo.requirements
+            requirements.TREEMANIFEST_REQUIREMENT not in repo.requirements
         )
 
         fnodes = {}  # needed file nodes
 
         size = 0
         it = self.generatemanifests(
             commonrevs,
             clrevorder,
             fastpathlinkrev,
             manifests,
             fnodes,
             source,
             clstate[b'clrevtomanifestrev'],
         )
 
         for tree, deltas in it:
             if tree:
                 assert self.version == b'03'
                 chunk = _fileheader(tree)
                 size += len(chunk)
                 yield chunk
 
             for delta in deltas:
                 chunks = _revisiondeltatochunks(delta, self._builddeltaheader)
                 for chunk in chunks:
                     size += len(chunk)
                     yield chunk
 
             close = closechunk()
             size += len(close)
             yield close
 
         self._verbosenote(_(b'%8.i (manifests)\n') % size)
         yield self._manifestsend
 
         mfdicts = None
         if self._ellipses and self._isshallow:
             mfdicts = [
                 (self._repo.manifestlog[n].read(), lr)
                 for (n, lr) in pycompat.iteritems(manifests)
             ]
 
         manifests.clear()
         clrevs = {cl.rev(x) for x in clnodes}
 
         it = self.generatefiles(
             changedfiles,
             commonrevs,
             source,
             mfdicts,
             fastpathlinkrev,
             fnodes,
             clrevs,
         )
 
         for path, deltas in it:
             h = _fileheader(path)
             size = len(h)
             yield h
 
             for delta in deltas:
                 chunks = _revisiondeltatochunks(delta, self._builddeltaheader)
                 for chunk in chunks:
                     size += len(chunk)
                     yield chunk
 
             close = closechunk()
             size += len(close)
             yield close
 
             self._verbosenote(_(b'%8.i  %s\n') % (size, path))
 
         yield closechunk()
 
         if clnodes:
             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
         byte chunks. The state will not be fully populated until the
         chunk stream has been fully consumed.
 
         if generate is False, the state will be fully populated and no chunk
         stream will be yielded
         """
         clrevorder = {}
         manifests = {}
         mfl = self._repo.manifestlog
         changedfiles = set()
         clrevtomanifestrev = {}
 
         state = {
             b'clrevorder': clrevorder,
             b'manifests': manifests,
             b'changedfiles': changedfiles,
             b'clrevtomanifestrev': clrevtomanifestrev,
         }
 
         if not (generate or self._ellipses):
             # sort the nodes in storage order
             nodes = sorted(nodes, key=cl.rev)
             for node in nodes:
                 c = cl.changelogrevision(node)
                 clrevorder[node] = len(clrevorder)
                 # record the first changeset introducing this manifest version
                 manifests.setdefault(c.manifest, node)
                 # Record a complete list of potentially-changed files in
                 # this manifest.
                 changedfiles.update(c.files)
 
             return state, ()
 
         # Callback for the changelog, used to collect changed files and
         # manifest nodes.
         # Returns the linkrev node (identity in the changelog case).
         def lookupcl(x):
             c = cl.changelogrevision(x)
             clrevorder[x] = len(clrevorder)
 
             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
                     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)
                     )
                 # 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)
             else:
                 # record the first changeset introducing this manifest version
                 manifests.setdefault(c.manifest, x)
                 # Record a complete list of potentially-changed files in
                 # this manifest.
                 changedfiles.update(c.files)
 
             return x
 
         gen = deltagroup(
             self._repo,
             cl,
             nodes,
             True,
             lookupcl,
             self._forcedeltaparentprev,
             ellipses=self._ellipses,
             topic=_(b'changesets'),
             clrevtolocalrev={},
             fullclnodes=self._fullclnodes,
             precomputedellipsis=self._precomputedellipsis,
         )
 
         return state, gen
 
     def generatemanifests(
         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.
         """
         repo = self._repo
         mfl = repo.manifestlog
         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):
             if fastpathlinkrev:
                 assert not tree
                 return (
                     manifests.__getitem__
                 )  # pytype: disable=unsupported-operands
 
             def lookupmflinknode(x):
                 """Callback for looking up the linknode for manifests.
 
                 Returns the linkrev node for the specified manifest.
 
                 SIDE EFFECT:
 
                 1) fclnodes gets populated with the list of relevant
                    file nodes if we're not using fastpathlinkrev
                 2) When treemanifests are in use, collects treemanifest nodes
                    to send
 
                 Note that this means manifests must be completely sent to
                 the client before you can trust the list of files and
                 treemanifests to send.
                 """
                 clnode = nodes[x]
                 mdata = mfl.get(tree, x).readfast(shallow=True)
                 for p, n, fl in mdata.iterentries():
                     if fl == b't':  # subdirectory manifest
                         subtree = tree + p + b'/'
                         tmfclnodes = tmfnodes.setdefault(subtree, {})
                         tmfclnode = tmfclnodes.setdefault(n, clnode)
                         if clrevorder[clnode] < clrevorder[tmfclnode]:
                             tmfclnodes[n] = clnode
                     else:
                         f = tree + p
                         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()
 
             should_visit = self._matcher.visitdir(tree[:-1])
             if tree and not should_visit:
                 continue
 
             store = mfl.getstorage(tree)
 
             if not should_visit:
                 # No nodes to send because this directory is out of
                 # the client's view of the repository (probably
                 # because of narrow clones). Do this even for the root
                 # directory (tree=='')
                 prunednodes = []
             else:
                 # Avoid sending any manifest nodes we can prove the
                 # client already has by checking linkrevs. See the
                 # related comment in generatefiles().
                 prunednodes = self._prunemanifests(store, nodes, commonrevs)
 
             if tree and not prunednodes:
                 continue
 
             lookupfn = makelookupmflinknode(tree, nodes)
 
             deltas = deltagroup(
                 self._repo,
                 store,
                 prunednodes,
                 False,
                 lookupfn,
                 self._forcedeltaparentprev,
                 ellipses=self._ellipses,
                 topic=_(b'manifests'),
                 clrevtolocalrev=clrevtolocalrev,
                 fullclnodes=self._fullclnodes,
                 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
                 # we are not going to send it because a side-effect is that
                 # it updates tmdnodes (via lookupfn)
                 for d in deltas:
                     pass
                 if not tree:
                     yield tree, []
 
     def _prunemanifests(self, store, nodes, commonrevs):
         if not self._ellipses:
             # In non-ellipses case and large repositories, it is better to
             # prevent calling of store.rev and store.linkrev on a lot of
             # nodes as compared to sending some extra data
             return nodes.copy()
         # This is split out as a separate method to allow filtering
         # commonrevs in extension code.
         #
         # TODO(augie): this shouldn't be required, instead we should
         # make filtering of revisions to send delegated to the store
         # 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,
         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 {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
             # those file nodes that are in the manifests we sent but weren't
             # introduced by those manifests.
             commonctxs = [self._repo[c] for c in commonrevs]
             clrev = self._repo.changelog.rev
 
             def linknodes(flog, fname):
                 for c in commonctxs:
                     try:
                         fnode = c.filenode(fname)
                         clrevtolocalrev[c.rev()] = flog.rev(fnode)
                     except error.ManifestLookupError:
                         pass
                 links = normallinknodes(flog, fname)
                 if len(links) != len(mfdicts):
                     for mf, lr in mfdicts:
                         fnode = mf.get(fname, None)
                         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(
             _(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(
                     _(b"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
             # fastpath case and with lookupmf in the slowpath case.
             def lookupfilelog(x):
                 return linkrevnodes[x]
 
             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 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._forcedeltaparentprev,
                 ellipses=self._ellipses,
                 clrevtolocalrev=clrevtolocalrev,
                 fullclnodes=self._fullclnodes,
                 precomputedellipsis=self._precomputedellipsis,
             )
 
             yield fname, deltas
 
         progress.complete()
 
 
 def _makecg1packer(
     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
     )
 
     return cgpacker(
         repo,
         oldmatcher,
         matcher,
         b'01',
         builddeltaheader=builddeltaheader,
         manifestsend=b'',
         forcedeltaparentprev=True,
         bundlecaps=bundlecaps,
         ellipses=ellipses,
         shallow=shallow,
         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
     )
 
     return cgpacker(
         repo,
         oldmatcher,
         matcher,
         b'02',
         builddeltaheader=builddeltaheader,
         manifestsend=b'',
         bundlecaps=bundlecaps,
         ellipses=ellipses,
         shallow=shallow,
         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
     )
 
     return cgpacker(
         repo,
         oldmatcher,
         matcher,
         b'03',
         builddeltaheader=builddeltaheader,
         manifestsend=closechunk(),
         bundlecaps=bundlecaps,
         ellipses=ellipses,
         shallow=shallow,
         ellipsisroots=ellipsisroots,
         fullnodes=fullnodes,
     )
 
 
 _packermap = {
     b'01': (_makecg1packer, cg1unpacker),
     # cg2 adds support for exchanging generaldelta
     b'02': (_makecg2packer, cg2unpacker),
     # cg3 adds support for exchanging revlog flags and treemanifests
     b'03': (_makecg3packer, cg3unpacker),
 }
 
 
 def allsupportedversions(repo):
     versions = set(_packermap.keys())
     needv03 = False
     if (
         repo.ui.configbool(b'experimental', b'changegroup3')
         or repo.ui.configbool(b'experimental', b'treemanifest')
-        or repository.TREEMANIFEST_REQUIREMENT in repo.requirements
+        or requirements.TREEMANIFEST_REQUIREMENT 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 b'exp-sidedata-flag' in repo.requirements:
         needv03 = True
         # don't attempt to use 01/02 until we do sidedata cleaning
         versions.discard(b'01')
         versions.discard(b'02')
     if not needv03:
         versions.discard(b'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 repository.TREEMANIFEST_REQUIREMENT in repo.requirements:
+    if requirements.TREEMANIFEST_REQUIREMENT 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(b'01')
         versions.discard(b'02')
-    if repository.NARROW_REQUIREMENT in repo.requirements:
+    if requirements.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(b'01')
         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(b'01')
         versions.discard(b'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.
     versions = supportedoutgoingversions(repo)
     if b'generaldelta' in repo.requirements:
         versions.discard(b'01')
     assert versions
     return min(versions)
 
 
 def getbundler(
     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 == b'01' and not matcher.always():
         raise error.ProgrammingError(
             b'version 01 changegroups do not support sparse file matchers'
         )
 
     if ellipses and version in (b'01', b'02'):
         raise error.Abort(
             _(
                 b'ellipsis nodes require at least cg3 on client and server, '
                 b'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,
         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 == b'bundle':
         repo.ui.status(_(b"%d changesets found\n") % len(nodes))
     if repo.ui.debugflag:
         repo.ui.debug(b"list of changesets:\n")
         for node in nodes:
             repo.ui.debug(b"%s\n" % hex(node))
 
 
 def makechangegroup(
     repo, outgoing, version, source, fastpath=False, bundlecaps=None
 ):
     cgstream = makestream(
         repo,
         outgoing,
         version,
         source,
         fastpath=fastpath,
         bundlecaps=bundlecaps,
     )
     return getunbundler(
         version,
         util.chunkbuffer(cgstream),
         None,
         {b'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.ancestorsof
     # 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.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(
         _(b'files'), unit=_(b'files'), total=expectedfiles
     )
     for chunkdata in iter(source.filelogheader, {}):
         files += 1
         f = chunkdata[b"filename"]
         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(_(b"received file revlog group is empty"))
         except error.CensoredBaseError as 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(_(b"received spurious file revlog entry"))
             if not needs:
                 del needfiles[f]
     progress.complete()
 
     for f, needs in pycompat.iteritems(needfiles):
         fl = repo.file(f)
         for n in needs:
             try:
                 fl.rev(n)
             except error.LookupError:
                 raise error.Abort(
                     _(b'missing file data for %s:%s - run hg verify')
                     % (f, hex(n))
                 )
 
     return revisions, files

mercurial/cmdutil.py

@@ -1,4217 +1,4216 b''
 # cmdutil.py - help for command processing in mercurial
 #
 # Copyright 2005-2007 Matt Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 from __future__ import absolute_import
 
 import copy as copymod
 import errno
 import os
 import re
 
 from .i18n import _
 from .node import (
     hex,
     nullid,
     nullrev,
     short,
 )
 from .pycompat import (
     getattr,
     open,
     setattr,
 )
 from .thirdparty import attr
 
 from . import (
     bookmarks,
     changelog,
     copies,
     crecord as crecordmod,
     dirstateguard,
     encoding,
     error,
     formatter,
     logcmdutil,
     match as matchmod,
     merge as mergemod,
     mergestate as mergestatemod,
     mergeutil,
     obsolete,
     patch,
     pathutil,
     phases,
     pycompat,
     repair,
+    requirements,
     revlog,
     rewriteutil,
     scmutil,
     smartset,
     state as statemod,
     subrepoutil,
     templatekw,
     templater,
     util,
     vfs as vfsmod,
 )
 
-from .interfaces import repository
-
 from .utils import (
     dateutil,
     stringutil,
 )
 
 if pycompat.TYPE_CHECKING:
     from typing import (
         Any,
         Dict,
     )
 
     for t in (Any, Dict):
         assert t
 
 stringio = util.stringio
 
 # templates of common command options
 
 dryrunopts = [
     (b'n', b'dry-run', None, _(b'do not perform actions, just print output')),
 ]
 
 confirmopts = [
     (b'', b'confirm', None, _(b'ask before applying actions')),
 ]
 
 remoteopts = [
     (b'e', b'ssh', b'', _(b'specify ssh command to use'), _(b'CMD')),
     (
         b'',
         b'remotecmd',
         b'',
         _(b'specify hg command to run on the remote side'),
         _(b'CMD'),
     ),
     (
         b'',
         b'insecure',
         None,
         _(b'do not verify server certificate (ignoring web.cacerts config)'),
     ),
 ]
 
 walkopts = [
     (
         b'I',
         b'include',
         [],
         _(b'include names matching the given patterns'),
         _(b'PATTERN'),
     ),
     (
         b'X',
         b'exclude',
         [],
         _(b'exclude names matching the given patterns'),
         _(b'PATTERN'),
     ),
 ]
 
 commitopts = [
     (b'm', b'message', b'', _(b'use text as commit message'), _(b'TEXT')),
     (b'l', b'logfile', b'', _(b'read commit message from file'), _(b'FILE')),
 ]
 
 commitopts2 = [
     (
         b'd',
         b'date',
         b'',
         _(b'record the specified date as commit date'),
         _(b'DATE'),
     ),
     (
         b'u',
         b'user',
         b'',
         _(b'record the specified user as committer'),
         _(b'USER'),
     ),
 ]
 
 commitopts3 = [
     (b'D', b'currentdate', None, _(b'record the current date as commit date')),
     (b'U', b'currentuser', None, _(b'record the current user as committer')),
 ]
 
 formatteropts = [
     (b'T', b'template', b'', _(b'display with template'), _(b'TEMPLATE')),
 ]
 
 templateopts = [
     (
         b'',
         b'style',
         b'',
         _(b'display using template map file (DEPRECATED)'),
         _(b'STYLE'),
     ),
     (b'T', b'template', b'', _(b'display with template'), _(b'TEMPLATE')),
 ]
 
 logopts = [
     (b'p', b'patch', None, _(b'show patch')),
     (b'g', b'git', None, _(b'use git extended diff format')),
     (b'l', b'limit', b'', _(b'limit number of changes displayed'), _(b'NUM')),
     (b'M', b'no-merges', None, _(b'do not show merges')),
     (b'', b'stat', None, _(b'output diffstat-style summary of changes')),
     (b'G', b'graph', None, _(b"show the revision DAG")),
 ] + templateopts
 
 diffopts = [
     (b'a', b'text', None, _(b'treat all files as text')),
     (
         b'g',
         b'git',
         None,
         _(b'use git extended diff format (DEFAULT: diff.git)'),
     ),
     (b'', b'binary', None, _(b'generate binary diffs in git mode (default)')),
     (b'', b'nodates', None, _(b'omit dates from diff headers')),
 ]
 
 diffwsopts = [
     (
         b'w',
         b'ignore-all-space',
         None,
         _(b'ignore white space when comparing lines'),
     ),
     (
         b'b',
         b'ignore-space-change',
         None,
         _(b'ignore changes in the amount of white space'),
     ),
     (
         b'B',
         b'ignore-blank-lines',
         None,
         _(b'ignore changes whose lines are all blank'),
     ),
     (
         b'Z',
         b'ignore-space-at-eol',
         None,
         _(b'ignore changes in whitespace at EOL'),
     ),
 ]
 
 diffopts2 = (
     [
         (b'', b'noprefix', None, _(b'omit a/ and b/ prefixes from filenames')),
         (
             b'p',
             b'show-function',
             None,
             _(
                 b'show which function each change is in (DEFAULT: diff.showfunc)'
             ),
         ),
         (b'', b'reverse', None, _(b'produce a diff that undoes the changes')),
     ]
     + diffwsopts
     + [
         (
             b'U',
             b'unified',
             b'',
             _(b'number of lines of context to show'),
             _(b'NUM'),
         ),
         (b'', b'stat', None, _(b'output diffstat-style summary of changes')),
         (
             b'',
             b'root',
             b'',
             _(b'produce diffs relative to subdirectory'),
             _(b'DIR'),
         ),
     ]
 )
 
 mergetoolopts = [
     (b't', b'tool', b'', _(b'specify merge tool'), _(b'TOOL')),
 ]
 
 similarityopts = [
     (
         b's',
         b'similarity',
         b'',
         _(b'guess renamed files by similarity (0<=s<=100)'),
         _(b'SIMILARITY'),
     )
 ]
 
 subrepoopts = [(b'S', b'subrepos', None, _(b'recurse into subrepositories'))]
 
 debugrevlogopts = [
     (b'c', b'changelog', False, _(b'open changelog')),
     (b'm', b'manifest', False, _(b'open manifest')),
     (b'', b'dir', b'', _(b'open directory manifest')),
 ]
 
 # special string such that everything below this line will be ingored in the
 # editor text
 _linebelow = b"^HG: ------------------------ >8 ------------------------$"
 
 
 def check_at_most_one_arg(opts, *args):
     """abort if more than one of the arguments are in opts
 
     Returns the unique argument or None if none of them were specified.
     """
 
     def to_display(name):
         return pycompat.sysbytes(name).replace(b'_', b'-')
 
     previous = None
     for x in args:
         if opts.get(x):
             if previous:
                 raise error.Abort(
                     _(b'cannot specify both --%s and --%s')
                     % (to_display(previous), to_display(x))
                 )
             previous = x
     return previous
 
 
 def check_incompatible_arguments(opts, first, others):
     """abort if the first argument is given along with any of the others
 
     Unlike check_at_most_one_arg(), `others` are not mutually exclusive
     among themselves, and they're passed as a single collection.
     """
     for other in others:
         check_at_most_one_arg(opts, first, other)
 
 
 def resolvecommitoptions(ui, opts):
     """modify commit options dict to handle related options
 
     The return value indicates that ``rewrite.update-timestamp`` is the reason
     the ``date`` option is set.
     """
     check_at_most_one_arg(opts, b'date', b'currentdate')
     check_at_most_one_arg(opts, b'user', b'currentuser')
 
     datemaydiffer = False  # date-only change should be ignored?
 
     if opts.get(b'currentdate'):
         opts[b'date'] = b'%d %d' % dateutil.makedate()
     elif (
         not opts.get(b'date')
         and ui.configbool(b'rewrite', b'update-timestamp')
         and opts.get(b'currentdate') is None
     ):
         opts[b'date'] = b'%d %d' % dateutil.makedate()
         datemaydiffer = True
 
     if opts.get(b'currentuser'):
         opts[b'user'] = ui.username()
 
     return datemaydiffer
 
 
 def checknotesize(ui, opts):
     """ make sure note is of valid format """
 
     note = opts.get(b'note')
     if not note:
         return
 
     if len(note) > 255:
         raise error.Abort(_(b"cannot store a note of more than 255 bytes"))
     if b'\n' in note:
         raise error.Abort(_(b"note cannot contain a newline"))
 
 
 def ishunk(x):
     hunkclasses = (crecordmod.uihunk, patch.recordhunk)
     return isinstance(x, hunkclasses)
 
 
 def newandmodified(chunks, originalchunks):
     newlyaddedandmodifiedfiles = set()
     alsorestore = set()
     for chunk in chunks:
         if (
             ishunk(chunk)
             and chunk.header.isnewfile()
             and chunk not in originalchunks
         ):
             newlyaddedandmodifiedfiles.add(chunk.header.filename())
             alsorestore.update(
                 set(chunk.header.files()) - {chunk.header.filename()}
             )
     return newlyaddedandmodifiedfiles, alsorestore
 
 
 def parsealiases(cmd):
     return cmd.split(b"|")
 
 
 def setupwrapcolorwrite(ui):
     # wrap ui.write so diff output can be labeled/colorized
     def wrapwrite(orig, *args, **kw):
         label = kw.pop('label', b'')
         for chunk, l in patch.difflabel(lambda: args):
             orig(chunk, label=label + l)
 
     oldwrite = ui.write
 
     def wrap(*args, **kwargs):
         return wrapwrite(oldwrite, *args, **kwargs)
 
     setattr(ui, 'write', wrap)
     return oldwrite
 
 
 def filterchunks(ui, originalhunks, usecurses, testfile, match, operation=None):
     try:
         if usecurses:
             if testfile:
                 recordfn = crecordmod.testdecorator(
                     testfile, crecordmod.testchunkselector
                 )
             else:
                 recordfn = crecordmod.chunkselector
 
             return crecordmod.filterpatch(
                 ui, originalhunks, recordfn, operation
             )
     except crecordmod.fallbackerror as e:
         ui.warn(b'%s\n' % e)
         ui.warn(_(b'falling back to text mode\n'))
 
     return patch.filterpatch(ui, originalhunks, match, operation)
 
 
 def recordfilter(ui, originalhunks, match, operation=None):
     """ Prompts the user to filter the originalhunks and return a list of
     selected hunks.
     *operation* is used for to build ui messages to indicate the user what
     kind of filtering they are doing: reverting, committing, shelving, etc.
     (see patch.filterpatch).
     """
     usecurses = crecordmod.checkcurses(ui)
     testfile = ui.config(b'experimental', b'crecordtest')
     oldwrite = setupwrapcolorwrite(ui)
     try:
         newchunks, newopts = filterchunks(
             ui, originalhunks, usecurses, testfile, match, operation
         )
     finally:
         ui.write = oldwrite
     return newchunks, newopts
 
 
 def dorecord(
     ui, repo, commitfunc, cmdsuggest, backupall, filterfn, *pats, **opts
 ):
     opts = pycompat.byteskwargs(opts)
     if not ui.interactive():
         if cmdsuggest:
             msg = _(b'running non-interactively, use %s instead') % cmdsuggest
         else:
             msg = _(b'running non-interactively')
         raise error.Abort(msg)
 
     # make sure username is set before going interactive
     if not opts.get(b'user'):
         ui.username()  # raise exception, username not provided
 
     def recordfunc(ui, repo, message, match, opts):
         """This is generic record driver.
 
         Its job is to interactively filter local changes, and
         accordingly prepare working directory into a state in which the
         job can be delegated to a non-interactive commit command such as
         'commit' or 'qrefresh'.
 
         After the actual job is done by non-interactive command, the
         working directory is restored to its original state.
 
         In the end we'll record interesting changes, and everything else
         will be left in place, so the user can continue working.
         """
         if not opts.get(b'interactive-unshelve'):
             checkunfinished(repo, commit=True)
         wctx = repo[None]
         merge = len(wctx.parents()) > 1
         if merge:
             raise error.Abort(
                 _(
                     b'cannot partially commit a merge '
                     b'(use "hg commit" instead)'
                 )
             )
 
         def fail(f, msg):
             raise error.Abort(b'%s: %s' % (f, msg))
 
         force = opts.get(b'force')
         if not force:
             match = matchmod.badmatch(match, fail)
 
         status = repo.status(match=match)
 
         overrides = {(b'ui', b'commitsubrepos'): True}
 
         with repo.ui.configoverride(overrides, b'record'):
             # subrepoutil.precommit() modifies the status
             tmpstatus = scmutil.status(
                 copymod.copy(status.modified),
                 copymod.copy(status.added),
                 copymod.copy(status.removed),
                 copymod.copy(status.deleted),
                 copymod.copy(status.unknown),
                 copymod.copy(status.ignored),
                 copymod.copy(status.clean),  # pytype: disable=wrong-arg-count
             )
 
             # Force allows -X subrepo to skip the subrepo.
             subs, commitsubs, newstate = subrepoutil.precommit(
                 repo.ui, wctx, tmpstatus, match, force=True
             )
             for s in subs:
                 if s in commitsubs:
                     dirtyreason = wctx.sub(s).dirtyreason(True)
                     raise error.Abort(dirtyreason)
 
         if not force:
             repo.checkcommitpatterns(wctx, match, status, fail)
         diffopts = patch.difffeatureopts(
             ui,
             opts=opts,
             whitespace=True,
             section=b'commands',
             configprefix=b'commit.interactive.',
         )
         diffopts.nodates = True
         diffopts.git = True
         diffopts.showfunc = True
         originaldiff = patch.diff(repo, changes=status, opts=diffopts)
         originalchunks = patch.parsepatch(originaldiff)
         match = scmutil.match(repo[None], pats)
 
         # 1. filter patch, since we are intending to apply subset of it
         try:
             chunks, newopts = filterfn(ui, originalchunks, match)
         except error.PatchError as err:
             raise error.Abort(_(b'error parsing patch: %s') % err)
         opts.update(newopts)
 
         # We need to keep a backup of files that have been newly added and
         # modified during the recording process because there is a previous
         # version without the edit in the workdir. We also will need to restore
         # files that were the sources of renames so that the patch application
         # works.
         newlyaddedandmodifiedfiles, alsorestore = newandmodified(
             chunks, originalchunks
         )
         contenders = set()
         for h in chunks:
             try:
                 contenders.update(set(h.files()))
             except AttributeError:
                 pass
 
         changed = status.modified + status.added + status.removed
         newfiles = [f for f in changed if f in contenders]
         if not newfiles:
             ui.status(_(b'no changes to record\n'))
             return 0
 
         modified = set(status.modified)
 
         # 2. backup changed files, so we can restore them in the end
 
         if backupall:
             tobackup = changed
         else:
             tobackup = [
                 f
                 for f in newfiles
                 if f in modified or f in newlyaddedandmodifiedfiles
             ]
         backups = {}
         if tobackup:
             backupdir = repo.vfs.join(b'record-backups')
             try:
                 os.mkdir(backupdir)
             except OSError as err:
                 if err.errno != errno.EEXIST:
                     raise
         try:
             # backup continues
             for f in tobackup:
                 fd, tmpname = pycompat.mkstemp(
                     prefix=f.replace(b'/', b'_') + b'.', dir=backupdir
                 )
                 os.close(fd)
                 ui.debug(b'backup %r as %r\n' % (f, tmpname))
                 util.copyfile(repo.wjoin(f), tmpname, copystat=True)
                 backups[f] = tmpname
 
             fp = stringio()
             for c in chunks:
                 fname = c.filename()
                 if fname in backups:
                     c.write(fp)
             dopatch = fp.tell()
             fp.seek(0)
 
             # 2.5 optionally review / modify patch in text editor
             if opts.get(b'review', False):
                 patchtext = (
                     crecordmod.diffhelptext
                     + crecordmod.patchhelptext
                     + fp.read()
                 )
                 reviewedpatch = ui.edit(
                     patchtext, b"", action=b"diff", repopath=repo.path
                 )
                 fp.truncate(0)
                 fp.write(reviewedpatch)
                 fp.seek(0)
 
             [os.unlink(repo.wjoin(c)) for c in newlyaddedandmodifiedfiles]
             # 3a. apply filtered patch to clean repo  (clean)
             if backups:
                 m = scmutil.matchfiles(repo, set(backups.keys()) | alsorestore)
                 mergemod.revert_to(repo[b'.'], matcher=m)
 
             # 3b. (apply)
             if dopatch:
                 try:
                     ui.debug(b'applying patch\n')
                     ui.debug(fp.getvalue())
                     patch.internalpatch(ui, repo, fp, 1, eolmode=None)
                 except error.PatchError as err:
                     raise error.Abort(pycompat.bytestr(err))
             del fp
 
             # 4. We prepared working directory according to filtered
             #    patch. Now is the time to delegate the job to
             #    commit/qrefresh or the like!
 
             # Make all of the pathnames absolute.
             newfiles = [repo.wjoin(nf) for nf in newfiles]
             return commitfunc(ui, repo, *newfiles, **pycompat.strkwargs(opts))
         finally:
             # 5. finally restore backed-up files
             try:
                 dirstate = repo.dirstate
                 for realname, tmpname in pycompat.iteritems(backups):
                     ui.debug(b'restoring %r to %r\n' % (tmpname, realname))
 
                     if dirstate[realname] == b'n':
                         # without normallookup, restoring timestamp
                         # may cause partially committed files
                         # to be treated as unmodified
                         dirstate.normallookup(realname)
 
                     # copystat=True here and above are a hack to trick any
                     # editors that have f open that we haven't modified them.
                     #
                     # Also note that this racy as an editor could notice the
                     # file's mtime before we've finished writing it.
                     util.copyfile(tmpname, repo.wjoin(realname), copystat=True)
                     os.unlink(tmpname)
                 if tobackup:
                     os.rmdir(backupdir)
             except OSError:
                 pass
 
     def recordinwlock(ui, repo, message, match, opts):
         with repo.wlock():
             return recordfunc(ui, repo, message, match, opts)
 
     return commit(ui, repo, recordinwlock, pats, opts)
 
 
 class dirnode(object):
     """
     Represent a directory in user working copy with information required for
     the purpose of tersing its status.
 
     path is the path to the directory, without a trailing '/'
 
     statuses is a set of statuses of all files in this directory (this includes
     all the files in all the subdirectories too)
 
     files is a list of files which are direct child of this directory
 
     subdirs is a dictionary of sub-directory name as the key and it's own
     dirnode object as the value
     """
 
     def __init__(self, dirpath):
         self.path = dirpath
         self.statuses = set()
         self.files = []
         self.subdirs = {}
 
     def _addfileindir(self, filename, status):
         """Add a file in this directory as a direct child."""
         self.files.append((filename, status))
 
     def addfile(self, filename, status):
         """
         Add a file to this directory or to its direct parent directory.
 
         If the file is not direct child of this directory, we traverse to the
         directory of which this file is a direct child of and add the file
         there.
         """
 
         # the filename contains a path separator, it means it's not the direct
         # child of this directory
         if b'/' in filename:
             subdir, filep = filename.split(b'/', 1)
 
             # does the dirnode object for subdir exists
             if subdir not in self.subdirs:
                 subdirpath = pathutil.join(self.path, subdir)
                 self.subdirs[subdir] = dirnode(subdirpath)
 
             # try adding the file in subdir
             self.subdirs[subdir].addfile(filep, status)
 
         else:
             self._addfileindir(filename, status)
 
         if status not in self.statuses:
             self.statuses.add(status)
 
     def iterfilepaths(self):
         """Yield (status, path) for files directly under this directory."""
         for f, st in self.files:
             yield st, pathutil.join(self.path, f)
 
     def tersewalk(self, terseargs):
         """
         Yield (status, path) obtained by processing the status of this
         dirnode.
 
         terseargs is the string of arguments passed by the user with `--terse`
         flag.
 
         Following are the cases which can happen:
 
         1) All the files in the directory (including all the files in its
         subdirectories) share the same status and the user has asked us to terse
         that status. -> yield (status, dirpath).  dirpath will end in '/'.
 
         2) Otherwise, we do following:
 
                 a) Yield (status, filepath)  for all the files which are in this
                     directory (only the ones in this directory, not the subdirs)
 
                 b) Recurse the function on all the subdirectories of this
                    directory
         """
 
         if len(self.statuses) == 1:
             onlyst = self.statuses.pop()
 
             # Making sure we terse only when the status abbreviation is
             # passed as terse argument
             if onlyst in terseargs:
                 yield onlyst, self.path + b'/'
                 return
 
         # add the files to status list
         for st, fpath in self.iterfilepaths():
             yield st, fpath
 
         # recurse on the subdirs
         for dirobj in self.subdirs.values():
             for st, fpath in dirobj.tersewalk(terseargs):
                 yield st, fpath
 
 
 def tersedir(statuslist, terseargs):
     """
     Terse the status if all the files in a directory shares the same status.
 
     statuslist is scmutil.status() object which contains a list of files for
     each status.
     terseargs is string which is passed by the user as the argument to `--terse`
     flag.
 
     The function makes a tree of objects of dirnode class, and at each node it
     stores the information required to know whether we can terse a certain
     directory or not.
     """
     # the order matters here as that is used to produce final list
     allst = (b'm', b'a', b'r', b'd', b'u', b'i', b'c')
 
     # checking the argument validity
     for s in pycompat.bytestr(terseargs):
         if s not in allst:
             raise error.Abort(_(b"'%s' not recognized") % s)
 
     # creating a dirnode object for the root of the repo
     rootobj = dirnode(b'')
     pstatus = (
         b'modified',
         b'added',
         b'deleted',
         b'clean',
         b'unknown',
         b'ignored',
         b'removed',
     )
 
     tersedict = {}
     for attrname in pstatus:
         statuschar = attrname[0:1]
         for f in getattr(statuslist, attrname):
             rootobj.addfile(f, statuschar)
         tersedict[statuschar] = []
 
     # we won't be tersing the root dir, so add files in it
     for st, fpath in rootobj.iterfilepaths():
         tersedict[st].append(fpath)
 
     # process each sub-directory and build tersedict
     for subdir in rootobj.subdirs.values():
         for st, f in subdir.tersewalk(terseargs):
             tersedict[st].append(f)
 
     tersedlist = []
     for st in allst:
         tersedict[st].sort()
         tersedlist.append(tersedict[st])
 
     return scmutil.status(*tersedlist)
 
 
 def _commentlines(raw):
     '''Surround lineswith a comment char and a new line'''
     lines = raw.splitlines()
     commentedlines = [b'# %s' % line for line in lines]
     return b'\n'.join(commentedlines) + b'\n'
 
 
 @attr.s(frozen=True)
 class morestatus(object):
     reporoot = attr.ib()
     unfinishedop = attr.ib()
     unfinishedmsg = attr.ib()
     activemerge = attr.ib()
     unresolvedpaths = attr.ib()
     _formattedpaths = attr.ib(init=False, default=set())
     _label = b'status.morestatus'
 
     def formatfile(self, path, fm):
         self._formattedpaths.add(path)
         if self.activemerge and path in self.unresolvedpaths:
             fm.data(unresolved=True)
 
     def formatfooter(self, fm):
         if self.unfinishedop or self.unfinishedmsg:
             fm.startitem()
             fm.data(itemtype=b'morestatus')
 
         if self.unfinishedop:
             fm.data(unfinished=self.unfinishedop)
             statemsg = (
                 _(b'The repository is in an unfinished *%s* state.')
                 % self.unfinishedop
             )
             fm.plain(b'%s\n' % _commentlines(statemsg), label=self._label)
         if self.unfinishedmsg:
             fm.data(unfinishedmsg=self.unfinishedmsg)
 
         # May also start new data items.
         self._formatconflicts(fm)
 
         if self.unfinishedmsg:
             fm.plain(
                 b'%s\n' % _commentlines(self.unfinishedmsg), label=self._label
             )
 
     def _formatconflicts(self, fm):
         if not self.activemerge:
             return
 
         if self.unresolvedpaths:
             mergeliststr = b'\n'.join(
                 [
                     b'    %s'
                     % util.pathto(self.reporoot, encoding.getcwd(), path)
                     for path in self.unresolvedpaths
                 ]
             )
             msg = (
                 _(
                     '''Unresolved merge conflicts:
 
 %s
 
 To mark files as resolved:  hg resolve --mark FILE'''
                 )
                 % mergeliststr
             )
 
             # If any paths with unresolved conflicts were not previously
             # formatted, output them now.
             for f in self.unresolvedpaths:
                 if f in self._formattedpaths:
                     # Already output.
                     continue
                 fm.startitem()
                 # We can't claim to know the status of the file - it may just
                 # have been in one of the states that were not requested for
                 # display, so it could be anything.
                 fm.data(itemtype=b'file', path=f, unresolved=True)
 
         else:
             msg = _(b'No unresolved merge conflicts.')
 
         fm.plain(b'%s\n' % _commentlines(msg), label=self._label)
 
 
 def readmorestatus(repo):
     """Returns a morestatus object if the repo has unfinished state."""
     statetuple = statemod.getrepostate(repo)
     mergestate = mergestatemod.mergestate.read(repo)
     activemerge = mergestate.active()
     if not statetuple and not activemerge:
         return None
 
     unfinishedop = unfinishedmsg = unresolved = None
     if statetuple:
         unfinishedop, unfinishedmsg = statetuple
     if activemerge:
         unresolved = sorted(mergestate.unresolved())
     return morestatus(
         repo.root, unfinishedop, unfinishedmsg, activemerge, unresolved
     )
 
 
 def findpossible(cmd, table, strict=False):
     """
     Return cmd -> (aliases, command table entry)
     for each matching command.
     Return debug commands (or their aliases) only if no normal command matches.
     """
     choice = {}
     debugchoice = {}
 
     if cmd in table:
         # short-circuit exact matches, "log" alias beats "log|history"
         keys = [cmd]
     else:
         keys = table.keys()
 
     allcmds = []
     for e in keys:
         aliases = parsealiases(e)
         allcmds.extend(aliases)
         found = None
         if cmd in aliases:
             found = cmd
         elif not strict:
             for a in aliases:
                 if a.startswith(cmd):
                     found = a
                     break
         if found is not None:
             if aliases[0].startswith(b"debug") or found.startswith(b"debug"):
                 debugchoice[found] = (aliases, table[e])
             else:
                 choice[found] = (aliases, table[e])
 
     if not choice and debugchoice:
         choice = debugchoice
 
     return choice, allcmds
 
 
 def findcmd(cmd, table, strict=True):
     """Return (aliases, command table entry) for command string."""
     choice, allcmds = findpossible(cmd, table, strict)
 
     if cmd in choice:
         return choice[cmd]
 
     if len(choice) > 1:
         clist = sorted(choice)
         raise error.AmbiguousCommand(cmd, clist)
 
     if choice:
         return list(choice.values())[0]
 
     raise error.UnknownCommand(cmd, allcmds)
 
 
 def changebranch(ui, repo, revs, label, opts):
     """ Change the branch name of given revs to label """
 
     with repo.wlock(), repo.lock(), repo.transaction(b'branches'):
         # abort in case of uncommitted merge or dirty wdir
         bailifchanged(repo)
         revs = scmutil.revrange(repo, revs)
         if not revs:
             raise error.Abort(b"empty revision set")
         roots = repo.revs(b'roots(%ld)', revs)
         if len(roots) > 1:
             raise error.Abort(
                 _(b"cannot change branch of non-linear revisions")
             )
         rewriteutil.precheck(repo, revs, b'change branch of')
 
         root = repo[roots.first()]
         rpb = {parent.branch() for parent in root.parents()}
         if (
             not opts.get(b'force')
             and label not in rpb
             and label in repo.branchmap()
         ):
             raise error.Abort(_(b"a branch of the same name already exists"))
 
         if repo.revs(b'obsolete() and %ld', revs):
             raise error.Abort(
                 _(b"cannot change branch of a obsolete changeset")
             )
 
         # make sure only topological heads
         if repo.revs(b'heads(%ld) - head()', revs):
             raise error.Abort(_(b"cannot change branch in middle of a stack"))
 
         replacements = {}
         # avoid import cycle mercurial.cmdutil -> mercurial.context ->
         # mercurial.subrepo -> mercurial.cmdutil
         from . import context
 
         for rev in revs:
             ctx = repo[rev]
             oldbranch = ctx.branch()
             # check if ctx has same branch
             if oldbranch == label:
                 continue
 
             def filectxfn(repo, newctx, path):
                 try:
                     return ctx[path]
                 except error.ManifestLookupError:
                     return None
 
             ui.debug(
                 b"changing branch of '%s' from '%s' to '%s'\n"
                 % (hex(ctx.node()), oldbranch, label)
             )
             extra = ctx.extra()
             extra[b'branch_change'] = hex(ctx.node())
             # While changing branch of set of linear commits, make sure that
             # we base our commits on new parent rather than old parent which
             # was obsoleted while changing the branch
             p1 = ctx.p1().node()
             p2 = ctx.p2().node()
             if p1 in replacements:
                 p1 = replacements[p1][0]
             if p2 in replacements:
                 p2 = replacements[p2][0]
 
             mc = context.memctx(
                 repo,
                 (p1, p2),
                 ctx.description(),
                 ctx.files(),
                 filectxfn,
                 user=ctx.user(),
                 date=ctx.date(),
                 extra=extra,
                 branch=label,
             )
 
             newnode = repo.commitctx(mc)
             replacements[ctx.node()] = (newnode,)
             ui.debug(b'new node id is %s\n' % hex(newnode))
 
         # create obsmarkers and move bookmarks
         scmutil.cleanupnodes(
             repo, replacements, b'branch-change', fixphase=True
         )
 
         # move the working copy too
         wctx = repo[None]
         # in-progress merge is a bit too complex for now.
         if len(wctx.parents()) == 1:
             newid = replacements.get(wctx.p1().node())
             if newid is not None:
                 # avoid import cycle mercurial.cmdutil -> mercurial.hg ->
                 # mercurial.cmdutil
                 from . import hg
 
                 hg.update(repo, newid[0], quietempty=True)
 
         ui.status(_(b"changed branch on %d changesets\n") % len(replacements))
 
 
 def findrepo(p):
     while not os.path.isdir(os.path.join(p, b".hg")):
         oldp, p = p, os.path.dirname(p)
         if p == oldp:
             return None
 
     return p
 
 
 def bailifchanged(repo, merge=True, hint=None):
     """ enforce the precondition that working directory must be clean.
 
     'merge' can be set to false if a pending uncommitted merge should be
     ignored (such as when 'update --check' runs).
 
     'hint' is the usual hint given to Abort exception.
     """
 
     if merge and repo.dirstate.p2() != nullid:
         raise error.Abort(_(b'outstanding uncommitted merge'), hint=hint)
     st = repo.status()
     if st.modified or st.added or st.removed or st.deleted:
         raise error.Abort(_(b'uncommitted changes'), hint=hint)
     ctx = repo[None]
     for s in sorted(ctx.substate):
         ctx.sub(s).bailifchanged(hint=hint)
 
 
 def logmessage(ui, opts):
     """ get the log message according to -m and -l option """
 
     check_at_most_one_arg(opts, b'message', b'logfile')
 
     message = opts.get(b'message')
     logfile = opts.get(b'logfile')
 
     if not message and logfile:
         try:
             if isstdiofilename(logfile):
                 message = ui.fin.read()
             else:
                 message = b'\n'.join(util.readfile(logfile).splitlines())
         except IOError as inst:
             raise error.Abort(
                 _(b"can't read commit message '%s': %s")
                 % (logfile, encoding.strtolocal(inst.strerror))
             )
     return message
 
 
 def mergeeditform(ctxorbool, baseformname):
     """return appropriate editform name (referencing a committemplate)
 
     'ctxorbool' is either a ctx to be committed, or a bool indicating whether
     merging is committed.
 
     This returns baseformname with '.merge' appended if it is a merge,
     otherwise '.normal' is appended.
     """
     if isinstance(ctxorbool, bool):
         if ctxorbool:
             return baseformname + b".merge"
     elif len(ctxorbool.parents()) > 1:
         return baseformname + b".merge"
 
     return baseformname + b".normal"
 
 
 def getcommiteditor(
     edit=False, finishdesc=None, extramsg=None, editform=b'', **opts
 ):
     """get appropriate commit message editor according to '--edit' option
 
     'finishdesc' is a function to be called with edited commit message
     (= 'description' of the new changeset) just after editing, but
     before checking empty-ness. It should return actual text to be
     stored into history. This allows to change description before
     storing.
 
     'extramsg' is a extra message to be shown in the editor instead of
     'Leave message empty to abort commit' line. 'HG: ' prefix and EOL
     is automatically added.
 
     'editform' is a dot-separated list of names, to distinguish
     the purpose of commit text editing.
 
     'getcommiteditor' returns 'commitforceeditor' regardless of
     'edit', if one of 'finishdesc' or 'extramsg' is specified, because
     they are specific for usage in MQ.
     """
     if edit or finishdesc or extramsg:
         return lambda r, c, s: commitforceeditor(
             r, c, s, finishdesc=finishdesc, extramsg=extramsg, editform=editform
         )
     elif editform:
         return lambda r, c, s: commiteditor(r, c, s, editform=editform)
     else:
         return commiteditor
 
 
 def _escapecommandtemplate(tmpl):
     parts = []
     for typ, start, end in templater.scantemplate(tmpl, raw=True):
         if typ == b'string':
             parts.append(stringutil.escapestr(tmpl[start:end]))
         else:
             parts.append(tmpl[start:end])
     return b''.join(parts)
 
 
 def rendercommandtemplate(ui, tmpl, props):
     r"""Expand a literal template 'tmpl' in a way suitable for command line
 
     '\' in outermost string is not taken as an escape character because it
     is a directory separator on Windows.
 
     >>> from . import ui as uimod
     >>> ui = uimod.ui()
     >>> rendercommandtemplate(ui, b'c:\\{path}', {b'path': b'foo'})
     'c:\\foo'
     >>> rendercommandtemplate(ui, b'{"c:\\{path}"}', {'path': b'foo'})
     'c:{path}'
     """
     if not tmpl:
         return tmpl
     t = formatter.maketemplater(ui, _escapecommandtemplate(tmpl))
     return t.renderdefault(props)
 
 
 def rendertemplate(ctx, tmpl, props=None):
     """Expand a literal template 'tmpl' byte-string against one changeset
 
     Each props item must be a stringify-able value or a callable returning
     such value, i.e. no bare list nor dict should be passed.
     """
     repo = ctx.repo()
     tres = formatter.templateresources(repo.ui, repo)
     t = formatter.maketemplater(
         repo.ui, tmpl, defaults=templatekw.keywords, resources=tres
     )
     mapping = {b'ctx': ctx}
     if props:
         mapping.update(props)
     return t.renderdefault(mapping)
 
 
 def _buildfntemplate(pat, total=None, seqno=None, revwidth=None, pathname=None):
     r"""Convert old-style filename format string to template string
 
     >>> _buildfntemplate(b'foo-%b-%n.patch', seqno=0)
     'foo-{reporoot|basename}-{seqno}.patch'
     >>> _buildfntemplate(b'%R{tags % "{tag}"}%H')
     '{rev}{tags % "{tag}"}{node}'
 
     '\' in outermost strings has to be escaped because it is a directory
     separator on Windows:
 
     >>> _buildfntemplate(b'c:\\tmp\\%R\\%n.patch', seqno=0)
     'c:\\\\tmp\\\\{rev}\\\\{seqno}.patch'
     >>> _buildfntemplate(b'\\\\foo\\bar.patch')
     '\\\\\\\\foo\\\\bar.patch'
     >>> _buildfntemplate(b'\\{tags % "{tag}"}')
     '\\\\{tags % "{tag}"}'
 
     but inner strings follow the template rules (i.e. '\' is taken as an
     escape character):
 
     >>> _buildfntemplate(br'{"c:\tmp"}', seqno=0)
     '{"c:\\tmp"}'
     """
     expander = {
         b'H': b'{node}',
         b'R': b'{rev}',
         b'h': b'{node|short}',
         b'm': br'{sub(r"[^\w]", "_", desc|firstline)}',
         b'r': b'{if(revwidth, pad(rev, revwidth, "0", left=True), rev)}',
         b'%': b'%',
         b'b': b'{reporoot|basename}',
     }
     if total is not None:
         expander[b'N'] = b'{total}'
     if seqno is not None:
         expander[b'n'] = b'{seqno}'
     if total is not None and seqno is not None:
         expander[b'n'] = b'{pad(seqno, total|stringify|count, "0", left=True)}'
     if pathname is not None:
         expander[b's'] = b'{pathname|basename}'
         expander[b'd'] = b'{if(pathname|dirname, pathname|dirname, ".")}'
         expander[b'p'] = b'{pathname}'
 
     newname = []
     for typ, start, end in templater.scantemplate(pat, raw=True):
         if typ != b'string':
             newname.append(pat[start:end])
             continue
         i = start
         while i < end:
             n = pat.find(b'%', i, end)
             if n < 0:
                 newname.append(stringutil.escapestr(pat[i:end]))
                 break
             newname.append(stringutil.escapestr(pat[i:n]))
             if n + 2 > end:
                 raise error.Abort(
                     _(b"incomplete format spec in output filename")
                 )
             c = pat[n + 1 : n + 2]
             i = n + 2
             try:
                 newname.append(expander[c])
             except KeyError:
                 raise error.Abort(
                     _(b"invalid format spec '%%%s' in output filename") % c
                 )
     return b''.join(newname)
 
 
 def makefilename(ctx, pat, **props):
     if not pat:
         return pat
     tmpl = _buildfntemplate(pat, **props)
     # BUG: alias expansion shouldn't be made against template fragments
     # rewritten from %-format strings, but we have no easy way to partially
     # disable the expansion.
     return rendertemplate(ctx, tmpl, pycompat.byteskwargs(props))
 
 
 def isstdiofilename(pat):
     """True if the given pat looks like a filename denoting stdin/stdout"""
     return not pat or pat == b'-'
 
 
 class _unclosablefile(object):
     def __init__(self, fp):
         self._fp = fp
 
     def close(self):
         pass
 
     def __iter__(self):
         return iter(self._fp)
 
     def __getattr__(self, attr):
         return getattr(self._fp, attr)
 
     def __enter__(self):
         return self
 
     def __exit__(self, exc_type, exc_value, exc_tb):
         pass
 
 
 def makefileobj(ctx, pat, mode=b'wb', **props):
     writable = mode not in (b'r', b'rb')
 
     if isstdiofilename(pat):
         repo = ctx.repo()
         if writable:
             fp = repo.ui.fout
         else:
             fp = repo.ui.fin
         return _unclosablefile(fp)
     fn = makefilename(ctx, pat, **props)
     return open(fn, mode)
 
 
 def openstorage(repo, cmd, file_, opts, returnrevlog=False):
     """opens the changelog, manifest, a filelog or a given revlog"""
     cl = opts[b'changelog']
     mf = opts[b'manifest']
     dir = opts[b'dir']
     msg = None
     if cl and mf:
         msg = _(b'cannot specify --changelog and --manifest at the same time')
     elif cl and dir:
         msg = _(b'cannot specify --changelog and --dir at the same time')
     elif cl or mf or dir:
         if file_:
             msg = _(b'cannot specify filename with --changelog or --manifest')
         elif not repo:
             msg = _(
                 b'cannot specify --changelog or --manifest or --dir '
                 b'without a repository'
             )
     if msg:
         raise error.Abort(msg)
 
     r = None
     if repo:
         if cl:
             r = repo.unfiltered().changelog
         elif dir:
-            if repository.TREEMANIFEST_REQUIREMENT not in repo.requirements:
+            if requirements.TREEMANIFEST_REQUIREMENT not in repo.requirements:
                 raise error.Abort(
                     _(
                         b"--dir can only be used on repos with "
                         b"treemanifest enabled"
                     )
                 )
             if not dir.endswith(b'/'):
                 dir = dir + b'/'
             dirlog = repo.manifestlog.getstorage(dir)
             if len(dirlog):
                 r = dirlog
         elif mf:
             r = repo.manifestlog.getstorage(b'')
         elif file_:
             filelog = repo.file(file_)
             if len(filelog):
                 r = filelog
 
         # Not all storage may be revlogs. If requested, try to return an actual
         # revlog instance.
         if returnrevlog:
             if isinstance(r, revlog.revlog):
                 pass
             elif util.safehasattr(r, b'_revlog'):
                 r = r._revlog  # pytype: disable=attribute-error
             elif r is not None:
                 raise error.Abort(_(b'%r does not appear to be a revlog') % r)
 
     if not r:
         if not returnrevlog:
             raise error.Abort(_(b'cannot give path to non-revlog'))
 
         if not file_:
             raise error.CommandError(cmd, _(b'invalid arguments'))
         if not os.path.isfile(file_):
             raise error.Abort(_(b"revlog '%s' not found") % file_)
         r = revlog.revlog(
             vfsmod.vfs(encoding.getcwd(), audit=False), file_[:-2] + b".i"
         )
     return r
 
 
 def openrevlog(repo, cmd, file_, opts):
     """Obtain a revlog backing storage of an item.
 
     This is similar to ``openstorage()`` except it always returns a revlog.
 
     In most cases, a caller cares about the main storage object - not the
     revlog backing it. Therefore, this function should only be used by code
     that needs to examine low-level revlog implementation details. e.g. debug
     commands.
     """
     return openstorage(repo, cmd, file_, opts, returnrevlog=True)
 
 
 def copy(ui, repo, pats, opts, rename=False):
     check_incompatible_arguments(opts, b'forget', [b'dry_run'])
 
     # called with the repo lock held
     #
     # hgsep => pathname that uses "/" to separate directories
     # ossep => pathname that uses os.sep to separate directories
     cwd = repo.getcwd()
     targets = {}
     forget = opts.get(b"forget")
     after = opts.get(b"after")
     dryrun = opts.get(b"dry_run")
     rev = opts.get(b'at_rev')
     if rev:
         if not forget and not after:
             # TODO: Remove this restriction and make it also create the copy
             #       targets (and remove the rename source if rename==True).
             raise error.Abort(_(b'--at-rev requires --after'))
         ctx = scmutil.revsingle(repo, rev)
         if len(ctx.parents()) > 1:
             raise error.Abort(_(b'cannot mark/unmark copy in merge commit'))
     else:
         ctx = repo[None]
 
     pctx = ctx.p1()
 
     uipathfn = scmutil.getuipathfn(repo, legacyrelativevalue=True)
 
     if forget:
         if ctx.rev() is None:
             new_ctx = ctx
         else:
             if len(ctx.parents()) > 1:
                 raise error.Abort(_(b'cannot unmark copy in merge commit'))
             # avoid cycle context -> subrepo -> cmdutil
             from . import context
 
             rewriteutil.precheck(repo, [ctx.rev()], b'uncopy')
             new_ctx = context.overlayworkingctx(repo)
             new_ctx.setbase(ctx.p1())
             mergemod.graft(repo, ctx, wctx=new_ctx)
 
         match = scmutil.match(ctx, pats, opts)
 
         current_copies = ctx.p1copies()
         current_copies.update(ctx.p2copies())
 
         uipathfn = scmutil.getuipathfn(repo)
         for f in ctx.walk(match):
             if f in current_copies:
                 new_ctx[f].markcopied(None)
             elif match.exact(f):
                 ui.warn(
                     _(
                         b'%s: not unmarking as copy - file is not marked as copied\n'
                     )
                     % uipathfn(f)
                 )
 
         if ctx.rev() is not None:
             with repo.lock():
                 mem_ctx = new_ctx.tomemctx_for_amend(ctx)
                 new_node = mem_ctx.commit()
 
                 if repo.dirstate.p1() == ctx.node():
                     with repo.dirstate.parentchange():
                         scmutil.movedirstate(repo, repo[new_node])
                 replacements = {ctx.node(): [new_node]}
                 scmutil.cleanupnodes(
                     repo, replacements, b'uncopy', fixphase=True
                 )
 
         return
 
     pats = scmutil.expandpats(pats)
     if not pats:
         raise error.Abort(_(b'no source or destination specified'))
     if len(pats) == 1:
         raise error.Abort(_(b'no destination specified'))
     dest = pats.pop()
 
     def walkpat(pat):
         srcs = []
         # TODO: Inline and simplify the non-working-copy version of this code
         # since it shares very little with the working-copy version of it.
         ctx_to_walk = ctx if ctx.rev() is None else pctx
         m = scmutil.match(ctx_to_walk, [pat], opts, globbed=True)
         for abs in ctx_to_walk.walk(m):
             rel = uipathfn(abs)
             exact = m.exact(abs)
             if abs not in ctx:
                 if abs in pctx:
                     if not after:
                         if exact:
                             ui.warn(
                                 _(
                                     b'%s: not copying - file has been marked '
                                     b'for remove\n'
                                 )
                                 % rel
                             )
                         continue
                 else:
                     if exact:
                         ui.warn(
                             _(b'%s: not copying - file is not managed\n') % rel
                         )
                     continue
 
             # abs: hgsep
             # rel: ossep
             srcs.append((abs, rel, exact))
         return srcs
 
     if ctx.rev() is not None:
         rewriteutil.precheck(repo, [ctx.rev()], b'uncopy')
         absdest = pathutil.canonpath(repo.root, cwd, dest)
         if ctx.hasdir(absdest):
             raise error.Abort(
                 _(b'%s: --at-rev does not support a directory as destination')
                 % uipathfn(absdest)
             )
         if absdest not in ctx:
             raise error.Abort(
                 _(b'%s: copy destination does not exist in %s')
                 % (uipathfn(absdest), ctx)
             )
 
         # avoid cycle context -> subrepo -> cmdutil
         from . import context
 
         copylist = []
         for pat in pats:
             srcs = walkpat(pat)
             if not srcs:
                 continue
             for abs, rel, exact in srcs:
                 copylist.append(abs)
 
         if not copylist:
             raise error.Abort(_(b'no files to copy'))
         # TODO: Add support for `hg cp --at-rev . foo bar dir` and
         # `hg cp --at-rev . dir1 dir2`, preferably unifying the code with the
         # existing functions below.
         if len(copylist) != 1:
             raise error.Abort(_(b'--at-rev requires a single source'))
 
         new_ctx = context.overlayworkingctx(repo)
         new_ctx.setbase(ctx.p1())
         mergemod.graft(repo, ctx, wctx=new_ctx)
 
         new_ctx.markcopied(absdest, copylist[0])
 
         with repo.lock():
             mem_ctx = new_ctx.tomemctx_for_amend(ctx)
             new_node = mem_ctx.commit()
 
             if repo.dirstate.p1() == ctx.node():
                 with repo.dirstate.parentchange():
                     scmutil.movedirstate(repo, repo[new_node])
             replacements = {ctx.node(): [new_node]}
             scmutil.cleanupnodes(repo, replacements, b'copy', fixphase=True)
 
         return
 
     # abssrc: hgsep
     # relsrc: ossep
     # otarget: ossep
     def copyfile(abssrc, relsrc, otarget, exact):
         abstarget = pathutil.canonpath(repo.root, cwd, otarget)
         if b'/' in abstarget:
             # We cannot normalize abstarget itself, this would prevent
             # case only renames, like a => A.
             abspath, absname = abstarget.rsplit(b'/', 1)
             abstarget = repo.dirstate.normalize(abspath) + b'/' + absname
         reltarget = repo.pathto(abstarget, cwd)
         target = repo.wjoin(abstarget)
         src = repo.wjoin(abssrc)
         state = repo.dirstate[abstarget]
 
         scmutil.checkportable(ui, abstarget)
 
         # check for collisions
         prevsrc = targets.get(abstarget)
         if prevsrc is not None:
             ui.warn(
                 _(b'%s: not overwriting - %s collides with %s\n')
                 % (
                     reltarget,
                     repo.pathto(abssrc, cwd),
                     repo.pathto(prevsrc, cwd),
                 )
             )
             return True  # report a failure
 
         # check for overwrites
         exists = os.path.lexists(target)
         samefile = False
         if exists and abssrc != abstarget:
             if repo.dirstate.normalize(abssrc) == repo.dirstate.normalize(
                 abstarget
             ):
                 if not rename:
                     ui.warn(_(b"%s: can't copy - same file\n") % reltarget)
                     return True  # report a failure
                 exists = False
                 samefile = True
 
         if not after and exists or after and state in b'mn':
             if not opts[b'force']:
                 if state in b'mn':
                     msg = _(b'%s: not overwriting - file already committed\n')
                     if after:
                         flags = b'--after --force'
                     else:
                         flags = b'--force'
                     if rename:
                         hint = (
                             _(
                                 b"('hg rename %s' to replace the file by "
                                 b'recording a rename)\n'
                             )
                             % flags
                         )
                     else:
                         hint = (
                             _(
                                 b"('hg copy %s' to replace the file by "
                                 b'recording a copy)\n'
                             )
                             % flags
                         )
                 else:
                     msg = _(b'%s: not overwriting - file exists\n')
                     if rename:
                         hint = _(
                             b"('hg rename --after' to record the rename)\n"
                         )
                     else:
                         hint = _(b"('hg copy --after' to record the copy)\n")
                 ui.warn(msg % reltarget)
                 ui.warn(hint)
                 return True  # report a failure
 
         if after:
             if not exists:
                 if rename:
                     ui.warn(
                         _(b'%s: not recording move - %s does not exist\n')
                         % (relsrc, reltarget)
                     )
                 else:
                     ui.warn(
                         _(b'%s: not recording copy - %s does not exist\n')
                         % (relsrc, reltarget)
                     )
                 return True  # report a failure
         elif not dryrun:
             try:
                 if exists:
                     os.unlink(target)
                 targetdir = os.path.dirname(target) or b'.'
                 if not os.path.isdir(targetdir):
                     os.makedirs(targetdir)
                 if samefile:
                     tmp = target + b"~hgrename"
                     os.rename(src, tmp)
                     os.rename(tmp, target)
                 else:
                     # Preserve stat info on renames, not on copies; this matches
                     # Linux CLI behavior.
                     util.copyfile(src, target, copystat=rename)
                 srcexists = True
             except IOError as inst:
                 if inst.errno == errno.ENOENT:
                     ui.warn(_(b'%s: deleted in working directory\n') % relsrc)
                     srcexists = False
                 else:
                     ui.warn(
                         _(b'%s: cannot copy - %s\n')
                         % (relsrc, encoding.strtolocal(inst.strerror))
                     )
                     return True  # report a failure
 
         if ui.verbose or not exact:
             if rename:
                 ui.status(_(b'moving %s to %s\n') % (relsrc, reltarget))
             else:
                 ui.status(_(b'copying %s to %s\n') % (relsrc, reltarget))
 
         targets[abstarget] = abssrc
 
         # fix up dirstate
         scmutil.dirstatecopy(
             ui, repo, ctx, abssrc, abstarget, dryrun=dryrun, cwd=cwd
         )
         if rename and not dryrun:
             if not after and srcexists and not samefile:
                 rmdir = repo.ui.configbool(b'experimental', b'removeemptydirs')
                 repo.wvfs.unlinkpath(abssrc, rmdir=rmdir)
             ctx.forget([abssrc])
 
     # pat: ossep
     # dest ossep
     # srcs: list of (hgsep, hgsep, ossep, bool)
     # return: function that takes hgsep and returns ossep
     def targetpathfn(pat, dest, srcs):
         if os.path.isdir(pat):
             abspfx = pathutil.canonpath(repo.root, cwd, pat)
             abspfx = util.localpath(abspfx)
             if destdirexists:
                 striplen = len(os.path.split(abspfx)[0])
             else:
                 striplen = len(abspfx)
             if striplen:
                 striplen += len(pycompat.ossep)
             res = lambda p: os.path.join(dest, util.localpath(p)[striplen:])
         elif destdirexists:
             res = lambda p: os.path.join(
                 dest, os.path.basename(util.localpath(p))
             )
         else:
             res = lambda p: dest
         return res
 
     # pat: ossep
     # dest ossep
     # srcs: list of (hgsep, hgsep, ossep, bool)
     # return: function that takes hgsep and returns ossep
     def targetpathafterfn(pat, dest, srcs):
         if matchmod.patkind(pat):
             # a mercurial pattern
             res = lambda p: os.path.join(
                 dest, os.path.basename(util.localpath(p))
             )
         else:
             abspfx = pathutil.canonpath(repo.root, cwd, pat)
             if len(abspfx) < len(srcs[0][0]):
                 # A directory. Either the target path contains the last
                 # component of the source path or it does not.
                 def evalpath(striplen):
                     score = 0
                     for s in srcs:
                         t = os.path.join(dest, util.localpath(s[0])[striplen:])
                         if os.path.lexists(t):
                             score += 1
                     return score
 
                 abspfx = util.localpath(abspfx)
                 striplen = len(abspfx)
                 if striplen:
                     striplen += len(pycompat.ossep)
                 if os.path.isdir(os.path.join(dest, os.path.split(abspfx)[1])):
                     score = evalpath(striplen)
                     striplen1 = len(os.path.split(abspfx)[0])
                     if striplen1:
                         striplen1 += len(pycompat.ossep)
                     if evalpath(striplen1) > score:
                         striplen = striplen1
                 res = lambda p: os.path.join(dest, util.localpath(p)[striplen:])
             else:
                 # a file
                 if destdirexists:
                     res = lambda p: os.path.join(
                         dest, os.path.basename(util.localpath(p))
                     )
                 else:
                     res = lambda p: dest
         return res
 
     destdirexists = os.path.isdir(dest) and not os.path.islink(dest)
     if not destdirexists:
         if len(pats) > 1 or matchmod.patkind(pats[0]):
             raise error.Abort(
                 _(
                     b'with multiple sources, destination must be an '
                     b'existing directory'
                 )
             )
         if util.endswithsep(dest):
             raise error.Abort(_(b'destination %s is not a directory') % dest)
 
     tfn = targetpathfn
     if after:
         tfn = targetpathafterfn
     copylist = []
     for pat in pats:
         srcs = walkpat(pat)
         if not srcs:
             continue
         copylist.append((tfn(pat, dest, srcs), srcs))
     if not copylist:
         raise error.Abort(_(b'no files to copy'))
 
     errors = 0
     for targetpath, srcs in copylist:
         for abssrc, relsrc, exact in srcs:
             if copyfile(abssrc, relsrc, targetpath(abssrc), exact):
                 errors += 1
 
     return errors != 0
 
 
 ## facility to let extension process additional data into an import patch
 # list of identifier to be executed in order
 extrapreimport = []  # run before commit
 extrapostimport = []  # run after commit
 # mapping from identifier to actual import function
 #
 # 'preimport' are run before the commit is made and are provided the following
 # arguments:
 # - repo: the localrepository instance,
 # - patchdata: data extracted from patch header (cf m.patch.patchheadermap),
 # - extra: the future extra dictionary of the changeset, please mutate it,
 # - opts: the import options.
 # XXX ideally, we would just pass an ctx ready to be computed, that would allow
 # mutation of in memory commit and more. Feel free to rework the code to get
 # there.
 extrapreimportmap = {}
 # 'postimport' are run after the commit is made and are provided the following
 # argument:
 # - ctx: the changectx created by import.
 extrapostimportmap = {}
 
 
 def tryimportone(ui, repo, patchdata, parents, opts, msgs, updatefunc):
     """Utility function used by commands.import to import a single patch
 
     This function is explicitly defined here to help the evolve extension to
     wrap this part of the import logic.
 
     The API is currently a bit ugly because it a simple code translation from
     the import command. Feel free to make it better.
 
     :patchdata: a dictionary containing parsed patch data (such as from
                 ``patch.extract()``)
     :parents: nodes that will be parent of the created commit
     :opts: the full dict of option passed to the import command
     :msgs: list to save commit message to.
            (used in case we need to save it when failing)
     :updatefunc: a function that update a repo to a given node
                  updatefunc(<repo>, <node>)
     """
     # avoid cycle context -> subrepo -> cmdutil
     from . import context
 
     tmpname = patchdata.get(b'filename')
     message = patchdata.get(b'message')
     user = opts.get(b'user') or patchdata.get(b'user')
     date = opts.get(b'date') or patchdata.get(b'date')
     branch = patchdata.get(b'branch')
     nodeid = patchdata.get(b'nodeid')
     p1 = patchdata.get(b'p1')
     p2 = patchdata.get(b'p2')
 
     nocommit = opts.get(b'no_commit')
     importbranch = opts.get(b'import_branch')
     update = not opts.get(b'bypass')
     strip = opts[b"strip"]
     prefix = opts[b"prefix"]
     sim = float(opts.get(b'similarity') or 0)
 
     if not tmpname:
         return None, None, False
 
     rejects = False
 
     cmdline_message = logmessage(ui, opts)
     if cmdline_message:
         # pickup the cmdline msg
         message = cmdline_message
     elif message:
         # pickup the patch msg
         message = message.strip()
     else:
         # launch the editor
         message = None
     ui.debug(b'message:\n%s\n' % (message or b''))
 
     if len(parents) == 1:
         parents.append(repo[nullid])
     if opts.get(b'exact'):
         if not nodeid or not p1:
             raise error.Abort(_(b'not a Mercurial patch'))
         p1 = repo[p1]
         p2 = repo[p2 or nullid]
     elif p2:
         try:
             p1 = repo[p1]
             p2 = repo[p2]
             # Without any options, consider p2 only if the
             # patch is being applied on top of the recorded
             # first parent.
             if p1 != parents[0]:
                 p1 = parents[0]
                 p2 = repo[nullid]
         except error.RepoError:
             p1, p2 = parents
         if p2.node() == nullid:
             ui.warn(
                 _(
                     b"warning: import the patch as a normal revision\n"
                     b"(use --exact to import the patch as a merge)\n"
                 )
             )
     else:
         p1, p2 = parents
 
     n = None
     if update:
         if p1 != parents[0]:
             updatefunc(repo, p1.node())
         if p2 != parents[1]:
             repo.setparents(p1.node(), p2.node())
 
         if opts.get(b'exact') or importbranch:
             repo.dirstate.setbranch(branch or b'default')
 
         partial = opts.get(b'partial', False)
         files = set()
         try:
             patch.patch(
                 ui,
                 repo,
                 tmpname,
                 strip=strip,
                 prefix=prefix,
                 files=files,
                 eolmode=None,
                 similarity=sim / 100.0,
             )
         except error.PatchError as e:
             if not partial:
                 raise error.Abort(pycompat.bytestr(e))
             if partial:
                 rejects = True
 
         files = list(files)
         if nocommit:
             if message:
                 msgs.append(message)
         else:
             if opts.get(b'exact') or p2:
                 # If you got here, you either use --force and know what
                 # you are doing or used --exact or a merge patch while
                 # being updated to its first parent.
                 m = None
             else:
                 m = scmutil.matchfiles(repo, files or [])
             editform = mergeeditform(repo[None], b'import.normal')
             if opts.get(b'exact'):
                 editor = None
             else:
                 editor = getcommiteditor(
                     editform=editform, **pycompat.strkwargs(opts)
                 )
             extra = {}
             for idfunc in extrapreimport:
                 extrapreimportmap[idfunc](repo, patchdata, extra, opts)
             overrides = {}
             if partial:
                 overrides[(b'ui', b'allowemptycommit')] = True
             if opts.get(b'secret'):
                 overrides[(b'phases', b'new-commit')] = b'secret'
             with repo.ui.configoverride(overrides, b'import'):
                 n = repo.commit(
                     message, user, date, match=m, editor=editor, extra=extra
                 )
                 for idfunc in extrapostimport:
                     extrapostimportmap[idfunc](repo[n])
     else:
         if opts.get(b'exact') or importbranch:
             branch = branch or b'default'
         else:
             branch = p1.branch()
         store = patch.filestore()
         try:
             files = set()
             try:
                 patch.patchrepo(
                     ui,
                     repo,
                     p1,
                     store,
                     tmpname,
                     strip,
                     prefix,
                     files,
                     eolmode=None,
                 )
             except error.PatchError as e:
                 raise error.Abort(stringutil.forcebytestr(e))
             if opts.get(b'exact'):
                 editor = None
             else:
                 editor = getcommiteditor(editform=b'import.bypass')
             memctx = context.memctx(
                 repo,
                 (p1.node(), p2.node()),
                 message,
                 files=files,
                 filectxfn=store,
                 user=user,
                 date=date,
                 branch=branch,
                 editor=editor,
             )
 
             overrides = {}
             if opts.get(b'secret'):
                 overrides[(b'phases', b'new-commit')] = b'secret'
             with repo.ui.configoverride(overrides, b'import'):
                 n = memctx.commit()
         finally:
             store.close()
     if opts.get(b'exact') and nocommit:
         # --exact with --no-commit is still useful in that it does merge
         # and branch bits
         ui.warn(_(b"warning: can't check exact import with --no-commit\n"))
     elif opts.get(b'exact') and (not n or hex(n) != nodeid):
         raise error.Abort(_(b'patch is damaged or loses information'))
     msg = _(b'applied to working directory')
     if n:
         # i18n: refers to a short changeset id
         msg = _(b'created %s') % short(n)
     return msg, n, rejects
 
 
 # facility to let extensions include additional data in an exported patch
 # list of identifiers to be executed in order
 extraexport = []
 # mapping from identifier to actual export function
 # function as to return a string to be added to the header or None
 # it is given two arguments (sequencenumber, changectx)
 extraexportmap = {}
 
 
 def _exportsingle(repo, ctx, fm, match, switch_parent, seqno, diffopts):
     node = scmutil.binnode(ctx)
     parents = [p.node() for p in ctx.parents() if p]
     branch = ctx.branch()
     if switch_parent:
         parents.reverse()
 
     if parents:
         prev = parents[0]
     else:
         prev = nullid
 
     fm.context(ctx=ctx)
     fm.plain(b'# HG changeset patch\n')
     fm.write(b'user', b'# User %s\n', ctx.user())
     fm.plain(b'# Date %d %d\n' % ctx.date())
     fm.write(b'date', b'#      %s\n', fm.formatdate(ctx.date()))
     fm.condwrite(
         branch and branch != b'default', b'branch', b'# Branch %s\n', branch
     )
     fm.write(b'node', b'# Node ID %s\n', hex(node))
     fm.plain(b'# Parent  %s\n' % hex(prev))
     if len(parents) > 1:
         fm.plain(b'# Parent  %s\n' % hex(parents[1]))
     fm.data(parents=fm.formatlist(pycompat.maplist(hex, parents), name=b'node'))
 
     # TODO: redesign extraexportmap function to support formatter
     for headerid in extraexport:
         header = extraexportmap[headerid](seqno, ctx)
         if header is not None:
             fm.plain(b'# %s\n' % header)
 
     fm.write(b'desc', b'%s\n', ctx.description().rstrip())
     fm.plain(b'\n')
 
     if fm.isplain():
         chunkiter = patch.diffui(repo, prev, node, match, opts=diffopts)
         for chunk, label in chunkiter:
             fm.plain(chunk, label=label)
     else:
         chunkiter = patch.diff(repo, prev, node, match, opts=diffopts)
         # TODO: make it structured?
         fm.data(diff=b''.join(chunkiter))
 
 
 def _exportfile(repo, revs, fm, dest, switch_parent, diffopts, match):
     """Export changesets to stdout or a single file"""
     for seqno, rev in enumerate(revs, 1):
         ctx = repo[rev]
         if not dest.startswith(b'<'):
             repo.ui.note(b"%s\n" % dest)
         fm.startitem()
         _exportsingle(repo, ctx, fm, match, switch_parent, seqno, diffopts)
 
 
 def _exportfntemplate(
     repo, revs, basefm, fntemplate, switch_parent, diffopts, match
 ):
     """Export changesets to possibly multiple files"""
     total = len(revs)
     revwidth = max(len(str(rev)) for rev in revs)
     filemap = util.sortdict()  # filename: [(seqno, rev), ...]
 
     for seqno, rev in enumerate(revs, 1):
         ctx = repo[rev]
         dest = makefilename(
             ctx, fntemplate, total=total, seqno=seqno, revwidth=revwidth
         )
         filemap.setdefault(dest, []).append((seqno, rev))
 
     for dest in filemap:
         with formatter.maybereopen(basefm, dest) as fm:
             repo.ui.note(b"%s\n" % dest)
             for seqno, rev in filemap[dest]:
                 fm.startitem()
                 ctx = repo[rev]
                 _exportsingle(
                     repo, ctx, fm, match, switch_parent, seqno, diffopts
                 )
 
 
 def _prefetchchangedfiles(repo, revs, match):
     allfiles = set()
     for rev in revs:
         for file in repo[rev].files():
             if not match or match(file):
                 allfiles.add(file)
     match = scmutil.matchfiles(repo, allfiles)
     revmatches = [(rev, match) for rev in revs]
     scmutil.prefetchfiles(repo, revmatches)
 
 
 def export(
     repo,
     revs,
     basefm,
     fntemplate=b'hg-%h.patch',
     switch_parent=False,
     opts=None,
     match=None,
 ):
     '''export changesets as hg patches
 
     Args:
       repo: The repository from which we're exporting revisions.
       revs: A list of revisions to export as revision numbers.
       basefm: A formatter to which patches should be written.
       fntemplate: An optional string to use for generating patch file names.
       switch_parent: If True, show diffs against second parent when not nullid.
                      Default is false, which always shows diff against p1.
       opts: diff options to use for generating the patch.
       match: If specified, only export changes to files matching this matcher.
 
     Returns:
       Nothing.
 
     Side Effect:
       "HG Changeset Patch" data is emitted to one of the following
       destinations:
         fntemplate specified: Each rev is written to a unique file named using
                             the given template.
         Otherwise: All revs will be written to basefm.
     '''
     _prefetchchangedfiles(repo, revs, match)
 
     if not fntemplate:
         _exportfile(
             repo, revs, basefm, b'<unnamed>', switch_parent, opts, match
         )
     else:
         _exportfntemplate(
             repo, revs, basefm, fntemplate, switch_parent, opts, match
         )
 
 
 def exportfile(repo, revs, fp, switch_parent=False, opts=None, match=None):
     """Export changesets to the given file stream"""
     _prefetchchangedfiles(repo, revs, match)
 
     dest = getattr(fp, 'name', b'<unnamed>')
     with formatter.formatter(repo.ui, fp, b'export', {}) as fm:
         _exportfile(repo, revs, fm, dest, switch_parent, opts, match)
 
 
 def showmarker(fm, marker, index=None):
     """utility function to display obsolescence marker in a readable way
 
     To be used by debug function."""
     if index is not None:
         fm.write(b'index', b'%i ', index)
     fm.write(b'prednode', b'%s ', hex(marker.prednode()))
     succs = marker.succnodes()
     fm.condwrite(
         succs,
         b'succnodes',
         b'%s ',
         fm.formatlist(map(hex, succs), name=b'node'),
     )
     fm.write(b'flag', b'%X ', marker.flags())
     parents = marker.parentnodes()
     if parents is not None:
         fm.write(
             b'parentnodes',
             b'{%s} ',
             fm.formatlist(map(hex, parents), name=b'node', sep=b', '),
         )
     fm.write(b'date', b'(%s) ', fm.formatdate(marker.date()))
     meta = marker.metadata().copy()
     meta.pop(b'date', None)
     smeta = pycompat.rapply(pycompat.maybebytestr, meta)
     fm.write(
         b'metadata', b'{%s}', fm.formatdict(smeta, fmt=b'%r: %r', sep=b', ')
     )
     fm.plain(b'\n')
 
 
 def finddate(ui, repo, date):
     """Find the tipmost changeset that matches the given date spec"""
 
     df = dateutil.matchdate(date)
     m = scmutil.matchall(repo)
     results = {}
 
     def prep(ctx, fns):
         d = ctx.date()
         if df(d[0]):
             results[ctx.rev()] = d
 
     for ctx in walkchangerevs(repo, m, {b'rev': None}, prep):
         rev = ctx.rev()
         if rev in results:
             ui.status(
                 _(b"found revision %d from %s\n")
                 % (rev, dateutil.datestr(results[rev]))
             )
             return b'%d' % rev
 
     raise error.Abort(_(b"revision matching date not found"))
 
 
 def increasingwindows(windowsize=8, sizelimit=512):
     while True:
         yield windowsize
         if windowsize < sizelimit:
             windowsize *= 2
 
 
 def _walkrevs(repo, opts):
     # Default --rev value depends on --follow but --follow behavior
     # depends on revisions resolved from --rev...
     follow = opts.get(b'follow') or opts.get(b'follow_first')
     if opts.get(b'rev'):
         revs = scmutil.revrange(repo, opts[b'rev'])
     elif follow and repo.dirstate.p1() == nullid:
         revs = smartset.baseset()
     elif follow:
         revs = repo.revs(b'reverse(:.)')
     else:
         revs = smartset.spanset(repo)
         revs.reverse()
     return revs
 
 
 class FileWalkError(Exception):
     pass
 
 
 def walkfilerevs(repo, match, follow, revs, fncache):
     '''Walks the file history for the matched files.
 
     Returns the changeset revs that are involved in the file history.
 
     Throws FileWalkError if the file history can't be walked using
     filelogs alone.
     '''
     wanted = set()
     copies = []
     minrev, maxrev = min(revs), max(revs)
 
     def filerevs(filelog, last):
         """
         Only files, no patterns.  Check the history of each file.
 
         Examines filelog entries within minrev, maxrev linkrev range
         Returns an iterator yielding (linkrev, parentlinkrevs, copied)
         tuples in backwards order
         """
         cl_count = len(repo)
         revs = []
         for j in pycompat.xrange(0, last + 1):
             linkrev = filelog.linkrev(j)
             if linkrev < minrev:
                 continue
             # only yield rev for which we have the changelog, it can
             # happen while doing "hg log" during a pull or commit
             if linkrev >= cl_count:
                 break
 
             parentlinkrevs = []
             for p in filelog.parentrevs(j):
                 if p != nullrev:
                     parentlinkrevs.append(filelog.linkrev(p))
             n = filelog.node(j)
             revs.append(
                 (linkrev, parentlinkrevs, follow and filelog.renamed(n))
             )
 
         return reversed(revs)
 
     def iterfiles():
         pctx = repo[b'.']
         for filename in match.files():
             if follow:
                 if filename not in pctx:
                     raise error.Abort(
                         _(
                             b'cannot follow file not in parent '
                             b'revision: "%s"'
                         )
                         % filename
                     )
                 yield filename, pctx[filename].filenode()
             else:
                 yield filename, None
         for filename_node in copies:
             yield filename_node
 
     for file_, node in iterfiles():
         filelog = repo.file(file_)
         if not len(filelog):
             if node is None:
                 # A zero count may be a directory or deleted file, so
                 # try to find matching entries on the slow path.
                 if follow:
                     raise error.Abort(
                         _(b'cannot follow nonexistent file: "%s"') % file_
                     )
                 raise FileWalkError(b"Cannot walk via filelog")
             else:
                 continue
 
         if node is None:
             last = len(filelog) - 1
         else:
             last = filelog.rev(node)
 
         # keep track of all ancestors of the file
         ancestors = {filelog.linkrev(last)}
 
         # iterate from latest to oldest revision
         for rev, flparentlinkrevs, copied in filerevs(filelog, last):
             if not follow:
                 if rev > maxrev:
                     continue
             else:
                 # Note that last might not be the first interesting
                 # rev to us:
                 # if the file has been changed after maxrev, we'll
                 # have linkrev(last) > maxrev, and we still need
                 # to explore the file graph
                 if rev not in ancestors:
                     continue
                 # XXX insert 1327 fix here
                 if flparentlinkrevs:
                     ancestors.update(flparentlinkrevs)
 
             fncache.setdefault(rev, []).append(file_)
             wanted.add(rev)
             if copied:
                 copies.append(copied)
 
     return wanted
 
 
 class _followfilter(object):
     def __init__(self, repo, onlyfirst=False):
         self.repo = repo
         self.startrev = nullrev
         self.roots = set()
         self.onlyfirst = onlyfirst
 
     def match(self, rev):
         def realparents(rev):
             if self.onlyfirst:
                 return self.repo.changelog.parentrevs(rev)[0:1]
             else:
                 return filter(
                     lambda x: x != nullrev, self.repo.changelog.parentrevs(rev)
                 )
 
         if self.startrev == nullrev:
             self.startrev = rev
             return True
 
         if rev > self.startrev:
             # forward: all descendants
             if not self.roots:
                 self.roots.add(self.startrev)
             for parent in realparents(rev):
                 if parent in self.roots:
                     self.roots.add(rev)
                     return True
         else:
             # backwards: all parents
             if not self.roots:
                 self.roots.update(realparents(self.startrev))
             if rev in self.roots:
                 self.roots.remove(rev)
                 self.roots.update(realparents(rev))
                 return True
 
         return False
 
 
 def walkchangerevs(repo, match, opts, prepare):
     '''Iterate over files and the revs in which they changed.
 
     Callers most commonly need to iterate backwards over the history
     in which they are interested. Doing so has awful (quadratic-looking)
     performance, so we use iterators in a "windowed" way.
 
     We walk a window of revisions in the desired order.  Within the
     window, we first walk forwards to gather data, then in the desired
     order (usually backwards) to display it.
 
     This function returns an iterator yielding contexts. Before
     yielding each context, the iterator will first call the prepare
     function on each context in the window in forward order.'''
 
     allfiles = opts.get(b'all_files')
     follow = opts.get(b'follow') or opts.get(b'follow_first')
     revs = _walkrevs(repo, opts)
     if not revs:
         return []
     wanted = set()
     slowpath = match.anypats() or (not match.always() and opts.get(b'removed'))
     fncache = {}
     change = repo.__getitem__
 
     # First step is to fill wanted, the set of revisions that we want to yield.
     # When it does not induce extra cost, we also fill fncache for revisions in
     # wanted: a cache of filenames that were changed (ctx.files()) and that
     # match the file filtering conditions.
 
     if match.always() or allfiles:
         # No files, no patterns.  Display all revs.
         wanted = revs
     elif not slowpath:
         # We only have to read through the filelog to find wanted revisions
 
         try:
             wanted = walkfilerevs(repo, match, follow, revs, fncache)
         except FileWalkError:
             slowpath = True
 
             # We decided to fall back to the slowpath because at least one
             # of the paths was not a file. Check to see if at least one of them
             # existed in history, otherwise simply return
             for path in match.files():
                 if path == b'.' or path in repo.store:
                     break
             else:
                 return []
 
     if slowpath:
         # We have to read the changelog to match filenames against
         # changed files
 
         if follow:
             raise error.Abort(
                 _(b'can only follow copies/renames for explicit filenames')
             )
 
         # The slow path checks files modified in every changeset.
         # This is really slow on large repos, so compute the set lazily.
         class lazywantedset(object):
             def __init__(self):
                 self.set = set()
                 self.revs = set(revs)
 
             # No need to worry about locality here because it will be accessed
             # in the same order as the increasing window below.
             def __contains__(self, value):
                 if value in self.set:
                     return True
                 elif not value in self.revs:
                     return False
                 else:
                     self.revs.discard(value)
                     ctx = change(value)
                     if allfiles:
                         matches = list(ctx.manifest().walk(match))
                     else:
                         matches = [f for f in ctx.files() if match(f)]
                     if matches:
                         fncache[value] = matches
                         self.set.add(value)
                         return True
                     return False
 
             def discard(self, value):
                 self.revs.discard(value)
                 self.set.discard(value)
 
         wanted = lazywantedset()
 
     # it might be worthwhile to do this in the iterator if the rev range
     # is descending and the prune args are all within that range
     for rev in opts.get(b'prune', ()):
         rev = repo[rev].rev()
         ff = _followfilter(repo)
         stop = min(revs[0], revs[-1])
         for x in pycompat.xrange(rev, stop - 1, -1):
             if ff.match(x):
                 wanted = wanted - [x]
 
     # Now that wanted is correctly initialized, we can iterate over the
     # revision range, yielding only revisions in wanted.
     def iterate():
         if follow and match.always():
             ff = _followfilter(repo, onlyfirst=opts.get(b'follow_first'))
 
             def want(rev):
                 return ff.match(rev) and rev in wanted
 
         else:
 
             def want(rev):
                 return rev in wanted
 
         it = iter(revs)
         stopiteration = False
         for windowsize in increasingwindows():
             nrevs = []
             for i in pycompat.xrange(windowsize):
                 rev = next(it, None)
                 if rev is None:
                     stopiteration = True
                     break
                 elif want(rev):
                     nrevs.append(rev)
             for rev in sorted(nrevs):
                 fns = fncache.get(rev)
                 ctx = change(rev)
                 if not fns:
 
                     def fns_generator():
                         if allfiles:
 
                             def bad(f, msg):
                                 pass
 
                             for f in ctx.matches(matchmod.badmatch(match, bad)):
                                 yield f
                         else:
                             for f in ctx.files():
                                 if match(f):
                                     yield f
 
                     fns = fns_generator()
                 prepare(ctx, fns)
             for rev in nrevs:
                 yield change(rev)
 
             if stopiteration:
                 break
 
     return iterate()
 
 
 def add(ui, repo, match, prefix, uipathfn, explicitonly, **opts):
     bad = []
 
     badfn = lambda x, y: bad.append(x) or match.bad(x, y)
     names = []
     wctx = repo[None]
     cca = None
     abort, warn = scmutil.checkportabilityalert(ui)
     if abort or warn:
         cca = scmutil.casecollisionauditor(ui, abort, repo.dirstate)
 
     match = repo.narrowmatch(match, includeexact=True)
     badmatch = matchmod.badmatch(match, badfn)
     dirstate = repo.dirstate
     # We don't want to just call wctx.walk here, since it would return a lot of
     # clean files, which we aren't interested in and takes time.
     for f in sorted(
         dirstate.walk(
             badmatch,
             subrepos=sorted(wctx.substate),
             unknown=True,
             ignored=False,
             full=False,
         )
     ):
         exact = match.exact(f)
         if exact or not explicitonly and f not in wctx and repo.wvfs.lexists(f):
             if cca:
                 cca(f)
             names.append(f)
             if ui.verbose or not exact:
                 ui.status(
                     _(b'adding %s\n') % uipathfn(f), label=b'ui.addremove.added'
                 )
 
     for subpath in sorted(wctx.substate):
         sub = wctx.sub(subpath)
         try:
             submatch = matchmod.subdirmatcher(subpath, match)
             subprefix = repo.wvfs.reljoin(prefix, subpath)
             subuipathfn = scmutil.subdiruipathfn(subpath, uipathfn)
             if opts.get('subrepos'):
                 bad.extend(
                     sub.add(ui, submatch, subprefix, subuipathfn, False, **opts)
                 )
             else:
                 bad.extend(
                     sub.add(ui, submatch, subprefix, subuipathfn, True, **opts)
                 )
         except error.LookupError:
             ui.status(
                 _(b"skipping missing subrepository: %s\n") % uipathfn(subpath)
             )
 
     if not opts.get('dry_run'):
         rejected = wctx.add(names, prefix)
         bad.extend(f for f in rejected if f in match.files())
     return bad
 
 
 def addwebdirpath(repo, serverpath, webconf):
     webconf[serverpath] = repo.root
     repo.ui.debug(b'adding %s = %s\n' % (serverpath, repo.root))
 
     for r in repo.revs(b'filelog("path:.hgsub")'):
         ctx = repo[r]
         for subpath in ctx.substate:
             ctx.sub(subpath).addwebdirpath(serverpath, webconf)
 
 
 def forget(
     ui, repo, match, prefix, uipathfn, explicitonly, dryrun, interactive
 ):
     if dryrun and interactive:
         raise error.Abort(_(b"cannot specify both --dry-run and --interactive"))
     bad = []
     badfn = lambda x, y: bad.append(x) or match.bad(x, y)
     wctx = repo[None]
     forgot = []
 
     s = repo.status(match=matchmod.badmatch(match, badfn), clean=True)
     forget = sorted(s.modified + s.added + s.deleted + s.clean)
     if explicitonly:
         forget = [f for f in forget if match.exact(f)]
 
     for subpath in sorted(wctx.substate):
         sub = wctx.sub(subpath)
         submatch = matchmod.subdirmatcher(subpath, match)
         subprefix = repo.wvfs.reljoin(prefix, subpath)
         subuipathfn = scmutil.subdiruipathfn(subpath, uipathfn)
         try:
             subbad, subforgot = sub.forget(
                 submatch,
                 subprefix,
                 subuipathfn,
                 dryrun=dryrun,
                 interactive=interactive,
             )
             bad.extend([subpath + b'/' + f for f in subbad])
             forgot.extend([subpath + b'/' + f for f in subforgot])
         except error.LookupError:
             ui.status(
                 _(b"skipping missing subrepository: %s\n") % uipathfn(subpath)
             )
 
     if not explicitonly:
         for f in match.files():
             if f not in repo.dirstate and not repo.wvfs.isdir(f):
                 if f not in forgot:
                     if repo.wvfs.exists(f):
                         # Don't complain if the exact case match wasn't given.
                         # But don't do this until after checking 'forgot', so
                         # that subrepo files aren't normalized, and this op is
                         # purely from data cached by the status walk above.
                         if repo.dirstate.normalize(f) in repo.dirstate:
                             continue
                         ui.warn(
                             _(
                                 b'not removing %s: '
                                 b'file is already untracked\n'
                             )
                             % uipathfn(f)
                         )
                     bad.append(f)
 
     if interactive:
         responses = _(
             b'[Ynsa?]'
             b'$$ &Yes, forget this file'
             b'$$ &No, skip this file'
             b'$$ &Skip remaining files'
             b'$$ Include &all remaining files'
             b'$$ &? (display help)'
         )
         for filename in forget[:]:
             r = ui.promptchoice(
                 _(b'forget %s %s') % (uipathfn(filename), responses)
             )
             if r == 4:  # ?
                 while r == 4:
                     for c, t in ui.extractchoices(responses)[1]:
                         ui.write(b'%s - %s\n' % (c, encoding.lower(t)))
                     r = ui.promptchoice(
                         _(b'forget %s %s') % (uipathfn(filename), responses)
                     )
             if r == 0:  # yes
                 continue
             elif r == 1:  # no
                 forget.remove(filename)
             elif r == 2:  # Skip
                 fnindex = forget.index(filename)
                 del forget[fnindex:]
                 break
             elif r == 3:  # All
                 break
 
     for f in forget:
         if ui.verbose or not match.exact(f) or interactive:
             ui.status(
                 _(b'removing %s\n') % uipathfn(f), label=b'ui.addremove.removed'
             )
 
     if not dryrun:
         rejected = wctx.forget(forget, prefix)
         bad.extend(f for f in rejected if f in match.files())
         forgot.extend(f for f in forget if f not in rejected)
     return bad, forgot
 
 
 def files(ui, ctx, m, uipathfn, fm, fmt, subrepos):
     ret = 1
 
     needsfctx = ui.verbose or {b'size', b'flags'} & fm.datahint()
     if fm.isplain() and not needsfctx:
         # Fast path. The speed-up comes from skipping the formatter, and batching
         # calls to ui.write.
         buf = []
         for f in ctx.matches(m):
             buf.append(fmt % uipathfn(f))
             if len(buf) > 100:
                 ui.write(b''.join(buf))
                 del buf[:]
             ret = 0
         if buf:
             ui.write(b''.join(buf))
     else:
         for f in ctx.matches(m):
             fm.startitem()
             fm.context(ctx=ctx)
             if needsfctx:
                 fc = ctx[f]
                 fm.write(b'size flags', b'% 10d % 1s ', fc.size(), fc.flags())
             fm.data(path=f)
             fm.plain(fmt % uipathfn(f))
             ret = 0
 
     for subpath in sorted(ctx.substate):
         submatch = matchmod.subdirmatcher(subpath, m)
         subuipathfn = scmutil.subdiruipathfn(subpath, uipathfn)
         if subrepos or m.exact(subpath) or any(submatch.files()):
             sub = ctx.sub(subpath)
             try:
                 recurse = m.exact(subpath) or subrepos
                 if (
                     sub.printfiles(ui, submatch, subuipathfn, fm, fmt, recurse)
                     == 0
                 ):
                     ret = 0
             except error.LookupError:
                 ui.status(
                     _(b"skipping missing subrepository: %s\n")
                     % uipathfn(subpath)
                 )
 
     return ret
 
 
 def remove(
     ui, repo, m, prefix, uipathfn, after, force, subrepos, dryrun, warnings=None
 ):
     ret = 0
     s = repo.status(match=m, clean=True)
     modified, added, deleted, clean = s.modified, s.added, s.deleted, s.clean
 
     wctx = repo[None]
 
     if warnings is None:
         warnings = []
         warn = True
     else:
         warn = False
 
     subs = sorted(wctx.substate)
     progress = ui.makeprogress(
         _(b'searching'), total=len(subs), unit=_(b'subrepos')
     )
     for subpath in subs:
         submatch = matchmod.subdirmatcher(subpath, m)
         subprefix = repo.wvfs.reljoin(prefix, subpath)
         subuipathfn = scmutil.subdiruipathfn(subpath, uipathfn)
         if subrepos or m.exact(subpath) or any(submatch.files()):
             progress.increment()
             sub = wctx.sub(subpath)
             try:
                 if sub.removefiles(
                     submatch,
                     subprefix,
                     subuipathfn,
                     after,
                     force,
                     subrepos,
                     dryrun,
                     warnings,
                 ):
                     ret = 1
             except error.LookupError:
                 warnings.append(
                     _(b"skipping missing subrepository: %s\n")
                     % uipathfn(subpath)
                 )
     progress.complete()
 
     # warn about failure to delete explicit files/dirs
     deleteddirs = pathutil.dirs(deleted)
     files = m.files()
     progress = ui.makeprogress(
         _(b'deleting'), total=len(files), unit=_(b'files')
     )
     for f in files:
 
         def insubrepo():
             for subpath in wctx.substate:
                 if f.startswith(subpath + b'/'):
                     return True
             return False
 
         progress.increment()
         isdir = f in deleteddirs or wctx.hasdir(f)
         if f in repo.dirstate or isdir or f == b'.' or insubrepo() or f in subs:
             continue
 
         if repo.wvfs.exists(f):
             if repo.wvfs.isdir(f):
                 warnings.append(
                     _(b'not removing %s: no tracked files\n') % uipathfn(f)
                 )
             else:
                 warnings.append(
                     _(b'not removing %s: file is untracked\n') % uipathfn(f)
                 )
         # missing files will generate a warning elsewhere
         ret = 1
     progress.complete()
 
     if force:
         list = modified + deleted + clean + added
     elif after:
         list = deleted
         remaining = modified + added + clean
         progress = ui.makeprogress(
             _(b'skipping'), total=len(remaining), unit=_(b'files')
         )
         for f in remaining:
             progress.increment()
             if ui.verbose or (f in files):
                 warnings.append(
                     _(b'not removing %s: file still exists\n') % uipathfn(f)
                 )
             ret = 1
         progress.complete()
     else:
         list = deleted + clean
         progress = ui.makeprogress(
             _(b'skipping'), total=(len(modified) + len(added)), unit=_(b'files')
         )
         for f in modified:
             progress.increment()
             warnings.append(
                 _(
                     b'not removing %s: file is modified (use -f'
                     b' to force removal)\n'
                 )
                 % uipathfn(f)
             )
             ret = 1
         for f in added:
             progress.increment()
             warnings.append(
                 _(
                     b"not removing %s: file has been marked for add"
                     b" (use 'hg forget' to undo add)\n"
                 )
                 % uipathfn(f)
             )
             ret = 1
         progress.complete()
 
     list = sorted(list)
     progress = ui.makeprogress(
         _(b'deleting'), total=len(list), unit=_(b'files')
     )
     for f in list:
         if ui.verbose or not m.exact(f):
             progress.increment()
             ui.status(
                 _(b'removing %s\n') % uipathfn(f), label=b'ui.addremove.removed'
             )
     progress.complete()
 
     if not dryrun:
         with repo.wlock():
             if not after:
                 for f in list:
                     if f in added:
                         continue  # we never unlink added files on remove
                     rmdir = repo.ui.configbool(
                         b'experimental', b'removeemptydirs'
                     )
                     repo.wvfs.unlinkpath(f, ignoremissing=True, rmdir=rmdir)
             repo[None].forget(list)
 
     if warn:
         for warning in warnings:
             ui.warn(warning)
 
     return ret
 
 
 def _catfmtneedsdata(fm):
     return not fm.datahint() or b'data' in fm.datahint()
 
 
 def _updatecatformatter(fm, ctx, matcher, path, decode):
     """Hook for adding data to the formatter used by ``hg cat``.
 
     Extensions (e.g., lfs) can wrap this to inject keywords/data, but must call
     this method first."""
 
     # data() can be expensive to fetch (e.g. lfs), so don't fetch it if it
     # wasn't requested.
     data = b''
     if _catfmtneedsdata(fm):
         data = ctx[path].data()
         if decode:
             data = ctx.repo().wwritedata(path, data)
     fm.startitem()
     fm.context(ctx=ctx)
     fm.write(b'data', b'%s', data)
     fm.data(path=path)
 
 
 def cat(ui, repo, ctx, matcher, basefm, fntemplate, prefix, **opts):
     err = 1
     opts = pycompat.byteskwargs(opts)
 
     def write(path):
         filename = None
         if fntemplate:
             filename = makefilename(
                 ctx, fntemplate, pathname=os.path.join(prefix, path)
             )
             # attempt to create the directory if it does not already exist
             try:
                 os.makedirs(os.path.dirname(filename))
             except OSError:
                 pass
         with formatter.maybereopen(basefm, filename) as fm:
             _updatecatformatter(fm, ctx, matcher, path, opts.get(b'decode'))
 
     # Automation often uses hg cat on single files, so special case it
     # for performance to avoid the cost of parsing the manifest.
     if len(matcher.files()) == 1 and not matcher.anypats():
         file = matcher.files()[0]
         mfl = repo.manifestlog
         mfnode = ctx.manifestnode()
         try:
             if mfnode and mfl[mfnode].find(file)[0]:
                 if _catfmtneedsdata(basefm):
                     scmutil.prefetchfiles(repo, [(ctx.rev(), matcher)])
                 write(file)
                 return 0
         except KeyError:
             pass
 
     if _catfmtneedsdata(basefm):
         scmutil.prefetchfiles(repo, [(ctx.rev(), matcher)])
 
     for abs in ctx.walk(matcher):
         write(abs)
         err = 0
 
     uipathfn = scmutil.getuipathfn(repo, legacyrelativevalue=True)
     for subpath in sorted(ctx.substate):
         sub = ctx.sub(subpath)
         try:
             submatch = matchmod.subdirmatcher(subpath, matcher)
             subprefix = os.path.join(prefix, subpath)
             if not sub.cat(
                 submatch,
                 basefm,
                 fntemplate,
                 subprefix,
                 **pycompat.strkwargs(opts)
             ):
                 err = 0
         except error.RepoLookupError:
             ui.status(
                 _(b"skipping missing subrepository: %s\n") % uipathfn(subpath)
             )
 
     return err
 
 
 def commit(ui, repo, commitfunc, pats, opts):
     '''commit the specified files or all outstanding changes'''
     date = opts.get(b'date')
     if date:
         opts[b'date'] = dateutil.parsedate(date)
     message = logmessage(ui, opts)
     matcher = scmutil.match(repo[None], pats, opts)
 
     dsguard = None
     # extract addremove carefully -- this function can be called from a command
     # that doesn't support addremove
     if opts.get(b'addremove'):
         dsguard = dirstateguard.dirstateguard(repo, b'commit')
     with dsguard or util.nullcontextmanager():
         if dsguard:
             relative = scmutil.anypats(pats, opts)
             uipathfn = scmutil.getuipathfn(repo, legacyrelativevalue=relative)
             if scmutil.addremove(repo, matcher, b"", uipathfn, opts) != 0:
                 raise error.Abort(
                     _(b"failed to mark all new/missing files as added/removed")
                 )
 
         return commitfunc(ui, repo, message, matcher, opts)
 
 
 def samefile(f, ctx1, ctx2):
     if f in ctx1.manifest():
         a = ctx1.filectx(f)
         if f in ctx2.manifest():
             b = ctx2.filectx(f)
             return not a.cmp(b) and a.flags() == b.flags()
         else:
             return False
     else:
         return f not in ctx2.manifest()
 
 
 def amend(ui, repo, old, extra, pats, opts):
     # avoid cycle context -> subrepo -> cmdutil
     from . import context
 
     # amend will reuse the existing user if not specified, but the obsolete
     # marker creation requires that the current user's name is specified.
     if obsolete.isenabled(repo, obsolete.createmarkersopt):
         ui.username()  # raise exception if username not set
 
     ui.note(_(b'amending changeset %s\n') % old)
     base = old.p1()
 
     with repo.wlock(), repo.lock(), repo.transaction(b'amend'):
         # Participating changesets:
         #
         # wctx     o - workingctx that contains changes from working copy
         #          |   to go into amending commit
         #          |
         # old      o - changeset to amend
         #          |
         # base     o - first parent of the changeset to amend
         wctx = repo[None]
 
         # Copy to avoid mutating input
         extra = extra.copy()
         # Update extra dict from amended commit (e.g. to preserve graft
         # source)
         extra.update(old.extra())
 
         # Also update it from the from the wctx
         extra.update(wctx.extra())
 
         # date-only change should be ignored?
         datemaydiffer = resolvecommitoptions(ui, opts)
 
         date = old.date()
         if opts.get(b'date'):
             date = dateutil.parsedate(opts.get(b'date'))
         user = opts.get(b'user') or old.user()
 
         if len(old.parents()) > 1:
             # ctx.files() isn't reliable for merges, so fall back to the
             # slower repo.status() method
             st = base.status(old)
             files = set(st.modified) | set(st.added) | set(st.removed)
         else:
             files = set(old.files())
 
         # add/remove the files to the working copy if the "addremove" option
         # was specified.
         matcher = scmutil.match(wctx, pats, opts)
         relative = scmutil.anypats(pats, opts)
         uipathfn = scmutil.getuipathfn(repo, legacyrelativevalue=relative)
         if opts.get(b'addremove') and scmutil.addremove(
             repo, matcher, b"", uipathfn, opts
         ):
             raise error.Abort(
                 _(b"failed to mark all new/missing files as added/removed")
             )
 
         # Check subrepos. This depends on in-place wctx._status update in
         # subrepo.precommit(). To minimize the risk of this hack, we do
         # nothing if .hgsub does not exist.
         if b'.hgsub' in wctx or b'.hgsub' in old:
             subs, commitsubs, newsubstate = subrepoutil.precommit(
                 ui, wctx, wctx._status, matcher
             )
             # amend should abort if commitsubrepos is enabled
             assert not commitsubs
             if subs:
                 subrepoutil.writestate(repo, newsubstate)
 
         ms = mergestatemod.mergestate.read(repo)
         mergeutil.checkunresolved(ms)
 
         filestoamend = {f for f in wctx.files() if matcher(f)}
 
         changes = len(filestoamend) > 0
         if changes:
             # Recompute copies (avoid recording a -> b -> a)
             copied = copies.pathcopies(base, wctx, matcher)
             if old.p2:
                 copied.update(copies.pathcopies(old.p2(), wctx, matcher))
 
             # Prune files which were reverted by the updates: if old
             # introduced file X and the file was renamed in the working
             # copy, then those two files are the same and
             # we can discard X from our list of files. Likewise if X
             # was removed, it's no longer relevant. If X is missing (aka
             # deleted), old X must be preserved.
             files.update(filestoamend)
             files = [
                 f
                 for f in files
                 if (f not in filestoamend or not samefile(f, wctx, base))
             ]
 
             def filectxfn(repo, ctx_, path):
                 try:
                     # If the file being considered is not amongst the files
                     # to be amended, we should return the file context from the
                     # old changeset. This avoids issues when only some files in
                     # the working copy are being amended but there are also
                     # changes to other files from the old changeset.
                     if path not in filestoamend:
                         return old.filectx(path)
 
                     # Return None for removed files.
                     if path in wctx.removed():
                         return None
 
                     fctx = wctx[path]
                     flags = fctx.flags()
                     mctx = context.memfilectx(
                         repo,
                         ctx_,
                         fctx.path(),
                         fctx.data(),
                         islink=b'l' in flags,
                         isexec=b'x' in flags,
                         copysource=copied.get(path),
                     )
                     return mctx
                 except KeyError:
                     return None
 
         else:
             ui.note(_(b'copying changeset %s to %s\n') % (old, base))
 
             # Use version of files as in the old cset
             def filectxfn(repo, ctx_, path):
                 try:
                     return old.filectx(path)
                 except KeyError:
                     return None
 
         # See if we got a message from -m or -l, if not, open the editor with
         # the message of the changeset to amend.
         message = logmessage(ui, opts)
 
         editform = mergeeditform(old, b'commit.amend')
 
         if not message:
             message = old.description()
             # Default if message isn't provided and --edit is not passed is to
             # invoke editor, but allow --no-edit. If somehow we don't have any
             # description, let's always start the editor.
             doedit = not message or opts.get(b'edit') in [True, None]
         else:
             # Default if message is provided is to not invoke editor, but allow
             # --edit.
             doedit = opts.get(b'edit') is True
         editor = getcommiteditor(edit=doedit, editform=editform)
 
         pureextra = extra.copy()
         extra[b'amend_source'] = old.hex()
 
         new = context.memctx(
             repo,
             parents=[base.node(), old.p2().node()],
             text=message,
             files=files,
             filectxfn=filectxfn,
             user=user,
             date=date,
             extra=extra,
             editor=editor,
         )
 
         newdesc = changelog.stripdesc(new.description())
         if (
             (not changes)
             and newdesc == old.description()
             and user == old.user()
             and (date == old.date() or datemaydiffer)
             and pureextra == old.extra()
         ):
             # nothing changed. continuing here would create a new node
             # anyway because of the amend_source noise.
             #
             # This not what we expect from amend.
             return old.node()
 
         commitphase = None
         if opts.get(b'secret'):
             commitphase = phases.secret
         newid = repo.commitctx(new)
 
         # Reroute the working copy parent to the new changeset
         repo.setparents(newid, nullid)
         mapping = {old.node(): (newid,)}
         obsmetadata = None
         if opts.get(b'note'):
             obsmetadata = {b'note': encoding.fromlocal(opts[b'note'])}
         backup = ui.configbool(b'rewrite', b'backup-bundle')
         scmutil.cleanupnodes(
             repo,
             mapping,
             b'amend',
             metadata=obsmetadata,
             fixphase=True,
             targetphase=commitphase,
             backup=backup,
         )
 
         # Fixing the dirstate because localrepo.commitctx does not update
         # it. This is rather convenient because we did not need to update
         # the dirstate for all the files in the new commit which commitctx
         # could have done if it updated the dirstate. Now, we can
         # selectively update the dirstate only for the amended files.
         dirstate = repo.dirstate
 
         # Update the state of the files which were added and modified in the
         # amend to "normal" in the dirstate. We need to use "normallookup" since
         # the files may have changed since the command started; using "normal"
         # would mark them as clean but with uncommitted contents.
         normalfiles = set(wctx.modified() + wctx.added()) & filestoamend
         for f in normalfiles:
             dirstate.normallookup(f)
 
         # Update the state of files which were removed in the amend
         # to "removed" in the dirstate.
         removedfiles = set(wctx.removed()) & filestoamend
         for f in removedfiles:
             dirstate.drop(f)
 
     return newid
 
 
 def commiteditor(repo, ctx, subs, editform=b''):
     if ctx.description():
         return ctx.description()
     return commitforceeditor(
         repo, ctx, subs, editform=editform, unchangedmessagedetection=True
     )
 
 
 def commitforceeditor(
     repo,
     ctx,
     subs,
     finishdesc=None,
     extramsg=None,
     editform=b'',
     unchangedmessagedetection=False,
 ):
     if not extramsg:
         extramsg = _(b"Leave message empty to abort commit.")
 
     forms = [e for e in editform.split(b'.') if e]
     forms.insert(0, b'changeset')
     templatetext = None
     while forms:
         ref = b'.'.join(forms)
         if repo.ui.config(b'committemplate', ref):
             templatetext = committext = buildcommittemplate(
                 repo, ctx, subs, extramsg, ref
             )
             break
         forms.pop()
     else:
         committext = buildcommittext(repo, ctx, subs, extramsg)
 
     # run editor in the repository root
     olddir = encoding.getcwd()
     os.chdir(repo.root)
 
     # make in-memory changes visible to external process
     tr = repo.currenttransaction()
     repo.dirstate.write(tr)
     pending = tr and tr.writepending() and repo.root
 
     editortext = repo.ui.edit(
         committext,
         ctx.user(),
         ctx.extra(),
         editform=editform,
         pending=pending,
         repopath=repo.path,
         action=b'commit',
     )
     text = editortext
 
     # strip away anything below this special string (used for editors that want
     # to display the diff)
     stripbelow = re.search(_linebelow, text, flags=re.MULTILINE)
     if stripbelow:
         text = text[: stripbelow.start()]
 
     text = re.sub(b"(?m)^HG:.*(\n|$)", b"", text)
     os.chdir(olddir)
 
     if finishdesc:
         text = finishdesc(text)
     if not text.strip():
         raise error.Abort(_(b"empty commit message"))
     if unchangedmessagedetection and editortext == templatetext:
         raise error.Abort(_(b"commit message unchanged"))
 
     return text
 
 
 def buildcommittemplate(repo, ctx, subs, extramsg, ref):
     ui = repo.ui
     spec = formatter.reference_templatespec(ref)
     t = logcmdutil.changesettemplater(ui, repo, spec)
     t.t.cache.update(
         (k, templater.unquotestring(v))
         for k, v in repo.ui.configitems(b'committemplate')
     )
 
     if not extramsg:
         extramsg = b''  # ensure that extramsg is string
 
     ui.pushbuffer()
     t.show(ctx, extramsg=extramsg)
     return ui.popbuffer()
 
 
 def hgprefix(msg):
     return b"\n".join([b"HG: %s" % a for a in msg.split(b"\n") if a])
 
 
 def buildcommittext(repo, ctx, subs, extramsg):
     edittext = []
     modified, added, removed = ctx.modified(), ctx.added(), ctx.removed()
     if ctx.description():
         edittext.append(ctx.description())
     edittext.append(b"")
     edittext.append(b"")  # Empty line between message and comments.
     edittext.append(
         hgprefix(
             _(
                 b"Enter commit message."
                 b"  Lines beginning with 'HG:' are removed."
             )
         )
     )
     edittext.append(hgprefix(extramsg))
     edittext.append(b"HG: --")
     edittext.append(hgprefix(_(b"user: %s") % ctx.user()))
     if ctx.p2():
         edittext.append(hgprefix(_(b"branch merge")))
     if ctx.branch():
         edittext.append(hgprefix(_(b"branch '%s'") % ctx.branch()))
     if bookmarks.isactivewdirparent(repo):
         edittext.append(hgprefix(_(b"bookmark '%s'") % repo._activebookmark))
     edittext.extend([hgprefix(_(b"subrepo %s") % s) for s in subs])
     edittext.extend([hgprefix(_(b"added %s") % f) for f in added])
     edittext.extend([hgprefix(_(b"changed %s") % f) for f in modified])
     edittext.extend([hgprefix(_(b"removed %s") % f) for f in removed])
     if not added and not modified and not removed:
         edittext.append(hgprefix(_(b"no files changed")))
     edittext.append(b"")
 
     return b"\n".join(edittext)
 
 
 def commitstatus(repo, node, branch, bheads=None, opts=None):
     if opts is None:
         opts = {}
     ctx = repo[node]
     parents = ctx.parents()
 
     if (
         not opts.get(b'amend')
         and bheads
         and node not in bheads
         and not any(
             p.node() in bheads and p.branch() == branch for p in parents
         )
     ):
         repo.ui.status(_(b'created new head\n'))
         # The message is not printed for initial roots. For the other
         # changesets, it is printed in the following situations:
         #
         # Par column: for the 2 parents with ...
         #   N: null or no parent
         #   B: parent is on another named branch
         #   C: parent is a regular non head changeset
         #   H: parent was a branch head of the current branch
         # Msg column: whether we print "created new head" message
         # In the following, it is assumed that there already exists some
         # initial branch heads of the current branch, otherwise nothing is
         # printed anyway.
         #
         # Par Msg Comment
         # N N  y  additional topo root
         #
         # B N  y  additional branch root
         # C N  y  additional topo head
         # H N  n  usual case
         #
         # B B  y  weird additional branch root
         # C B  y  branch merge
         # H B  n  merge with named branch
         #
         # C C  y  additional head from merge
         # C H  n  merge with a head
         #
         # H H  n  head merge: head count decreases
 
     if not opts.get(b'close_branch'):
         for r in parents:
             if r.closesbranch() and r.branch() == branch:
                 repo.ui.status(
                     _(b'reopening closed branch head %d\n') % r.rev()
                 )
 
     if repo.ui.debugflag:
         repo.ui.write(
             _(b'committed changeset %d:%s\n') % (ctx.rev(), ctx.hex())
         )
     elif repo.ui.verbose:
         repo.ui.write(_(b'committed changeset %d:%s\n') % (ctx.rev(), ctx))
 
 
 def postcommitstatus(repo, pats, opts):
     return repo.status(match=scmutil.match(repo[None], pats, opts))
 
 
 def revert(ui, repo, ctx, parents, *pats, **opts):
     opts = pycompat.byteskwargs(opts)
     parent, p2 = parents
     node = ctx.node()
 
     mf = ctx.manifest()
     if node == p2:
         parent = p2
 
     # need all matching names in dirstate and manifest of target rev,
     # so have to walk both. do not print errors if files exist in one
     # but not other. in both cases, filesets should be evaluated against
     # workingctx to get consistent result (issue4497). this means 'set:**'
     # cannot be used to select missing files from target rev.
 
     # `names` is a mapping for all elements in working copy and target revision
     # The mapping is in the form:
     #   <abs path in repo> -> (<path from CWD>, <exactly specified by matcher?>)
     names = {}
     uipathfn = scmutil.getuipathfn(repo, legacyrelativevalue=True)
 
     with repo.wlock():
         ## filling of the `names` mapping
         # walk dirstate to fill `names`
 
         interactive = opts.get(b'interactive', False)
         wctx = repo[None]
         m = scmutil.match(wctx, pats, opts)
 
         # we'll need this later
         targetsubs = sorted(s for s in wctx.substate if m(s))
 
         if not m.always():
             matcher = matchmod.badmatch(m, lambda x, y: False)
             for abs in wctx.walk(matcher):
                 names[abs] = m.exact(abs)
 
             # walk target manifest to fill `names`
 
             def badfn(path, msg):
                 if path in names:
                     return
                 if path in ctx.substate:
                     return
                 path_ = path + b'/'
                 for f in names:
                     if f.startswith(path_):
                         return
                 ui.warn(b"%s: %s\n" % (uipathfn(path), msg))
 
             for abs in ctx.walk(matchmod.badmatch(m, badfn)):
                 if abs not in names:
                     names[abs] = m.exact(abs)
 
             # Find status of all file in `names`.
             m = scmutil.matchfiles(repo, names)
 
             changes = repo.status(
                 node1=node, match=m, unknown=True, ignored=True, clean=True
             )
         else:
             changes = repo.status(node1=node, match=m)
             for kind in changes:
                 for abs in kind:
                     names[abs] = m.exact(abs)
 
             m = scmutil.matchfiles(repo, names)
 
         modified = set(changes.modified)
         added = set(changes.added)
         removed = set(changes.removed)
         _deleted = set(changes.deleted)
         unknown = set(changes.unknown)
         unknown.update(changes.ignored)
         clean = set(changes.clean)
         modadded = set()
 
         # We need to account for the state of the file in the dirstate,
         # even when we revert against something else than parent. This will
         # slightly alter the behavior of revert (doing back up or not, delete
         # or just forget etc).
         if parent == node:
             dsmodified = modified
             dsadded = added
             dsremoved = removed
             # store all local modifications, useful later for rename detection
             localchanges = dsmodified | dsadded
             modified, added, removed = set(), set(), set()
         else:
             changes = repo.status(node1=parent, match=m)
             dsmodified = set(changes.modified)
             dsadded = set(changes.added)
             dsremoved = set(changes.removed)
             # store all local modifications, useful later for rename detection
             localchanges = dsmodified | dsadded
 
             # only take into account for removes between wc and target
             clean |= dsremoved - removed
             dsremoved &= removed
             # distinct between dirstate remove and other
             removed -= dsremoved
 
             modadded = added & dsmodified
             added -= modadded
 
             # tell newly modified apart.
             dsmodified &= modified
             dsmodified |= modified & dsadded  # dirstate added may need backup
             modified -= dsmodified
 
             # We need to wait for some post-processing to update this set
             # before making the distinction. The dirstate will be used for
             # that purpose.
             dsadded = added
 
         # in case of merge, files that are actually added can be reported as
         # modified, we need to post process the result
         if p2 != nullid:
             mergeadd = set(dsmodified)
             for path in dsmodified:
                 if path in mf:
                     mergeadd.remove(path)
             dsadded |= mergeadd
             dsmodified -= mergeadd
 
         # if f is a rename, update `names` to also revert the source
         for f in localchanges:
             src = repo.dirstate.copied(f)
             # XXX should we check for rename down to target node?
             if src and src not in names and repo.dirstate[src] == b'r':
                 dsremoved.add(src)
                 names[src] = True
 
         # determine the exact nature of the deleted changesets
         deladded = set(_deleted)
         for path in _deleted:
             if path in mf:
                 deladded.remove(path)
         deleted = _deleted - deladded
 
         # distinguish between file to forget and the other
         added = set()
         for abs in dsadded:
             if repo.dirstate[abs] != b'a':
                 added.add(abs)
         dsadded -= added
 
         for abs in deladded:
             if repo.dirstate[abs] == b'a':
                 dsadded.add(abs)
         deladded -= dsadded
 
         # For files marked as removed, we check if an unknown file is present at
         # the same path. If a such file exists it may need to be backed up.
         # Making the distinction at this stage helps have simpler backup
         # logic.
         removunk = set()
         for abs in removed:
             target = repo.wjoin(abs)
             if os.path.lexists(target):
                 removunk.add(abs)
         removed -= removunk
 
         dsremovunk = set()
         for abs in dsremoved:
             target = repo.wjoin(abs)
             if os.path.lexists(target):
                 dsremovunk.add(abs)
         dsremoved -= dsremovunk
 
         # action to be actually performed by revert
         # (<list of file>, message>) tuple
         actions = {
             b'revert': ([], _(b'reverting %s\n')),
             b'add': ([], _(b'adding %s\n')),
             b'remove': ([], _(b'removing %s\n')),
             b'drop': ([], _(b'removing %s\n')),
             b'forget': ([], _(b'forgetting %s\n')),
             b'undelete': ([], _(b'undeleting %s\n')),
             b'noop': (None, _(b'no changes needed to %s\n')),
             b'unknown': (None, _(b'file not managed: %s\n')),
         }
 
         # "constant" that convey the backup strategy.
         # All set to `discard` if `no-backup` is set do avoid checking
         # no_backup lower in the code.
         # These values are ordered for comparison purposes
         backupinteractive = 3  # do backup if interactively modified
         backup = 2  # unconditionally do backup
         check = 1  # check if the existing file differs from target
         discard = 0  # never do backup
         if opts.get(b'no_backup'):
             backupinteractive = backup = check = discard
         if interactive:
             dsmodifiedbackup = backupinteractive
         else:
             dsmodifiedbackup = backup
         tobackup = set()
 
         backupanddel = actions[b'remove']
         if not opts.get(b'no_backup'):
             backupanddel = actions[b'drop']
 
         disptable = (
             # dispatch table:
             #   file state
             #   action
             #   make backup
             ## Sets that results that will change file on disk
             # Modified compared to target, no local change
             (modified, actions[b'revert'], discard),
             # Modified compared to target, but local file is deleted
             (deleted, actions[b'revert'], discard),
             # Modified compared to target, local change
             (dsmodified, actions[b'revert'], dsmodifiedbackup),
             # Added since target
             (added, actions[b'remove'], discard),
             # Added in working directory
             (dsadded, actions[b'forget'], discard),
             # Added since target, have local modification
             (modadded, backupanddel, backup),
             # Added since target but file is missing in working directory
             (deladded, actions[b'drop'], discard),
             # Removed since  target, before working copy parent
             (removed, actions[b'add'], discard),
             # Same as `removed` but an unknown file exists at the same path
             (removunk, actions[b'add'], check),
             # Removed since targe, marked as such in working copy parent
             (dsremoved, actions[b'undelete'], discard),
             # Same as `dsremoved` but an unknown file exists at the same path
             (dsremovunk, actions[b'undelete'], check),
             ## the following sets does not result in any file changes
             # File with no modification
             (clean, actions[b'noop'], discard),
             # Existing file, not tracked anywhere
             (unknown, actions[b'unknown'], discard),
         )
 
         for abs, exact in sorted(names.items()):
             # target file to be touch on disk (relative to cwd)
             target = repo.wjoin(abs)
             # search the entry in the dispatch table.
             # if the file is in any of these sets, it was touched in the working
             # directory parent and we are sure it needs to be reverted.
             for table, (xlist, msg), dobackup in disptable:
                 if abs not in table:
                     continue
                 if xlist is not None:
                     xlist.append(abs)
                     if dobackup:
                         # If in interactive mode, don't automatically create
                         # .orig files (issue4793)
                         if dobackup == backupinteractive:
                             tobackup.add(abs)
                         elif backup <= dobackup or wctx[abs].cmp(ctx[abs]):
                             absbakname = scmutil.backuppath(ui, repo, abs)
                             bakname = os.path.relpath(
                                 absbakname, start=repo.root
                             )
                             ui.note(
                                 _(b'saving current version of %s as %s\n')
                                 % (uipathfn(abs), uipathfn(bakname))
                             )
                             if not opts.get(b'dry_run'):
                                 if interactive:
                                     util.copyfile(target, absbakname)
                                 else:
                                     util.rename(target, absbakname)
                     if opts.get(b'dry_run'):
                         if ui.verbose or not exact:
                             ui.status(msg % uipathfn(abs))
                 elif exact:
                     ui.warn(msg % uipathfn(abs))
                 break
 
         if not opts.get(b'dry_run'):
             needdata = (b'revert', b'add', b'undelete')
             oplist = [actions[name][0] for name in needdata]
             prefetch = scmutil.prefetchfiles
             matchfiles = scmutil.matchfiles(
                 repo, [f for sublist in oplist for f in sublist]
             )
             prefetch(
                 repo, [(ctx.rev(), matchfiles)],
             )
             match = scmutil.match(repo[None], pats)
             _performrevert(
                 repo,
                 parents,
                 ctx,
                 names,
                 uipathfn,
                 actions,
                 match,
                 interactive,
                 tobackup,
             )
 
         if targetsubs:
             # Revert the subrepos on the revert list
             for sub in targetsubs:
                 try:
                     wctx.sub(sub).revert(
                         ctx.substate[sub], *pats, **pycompat.strkwargs(opts)
                     )
                 except KeyError:
                     raise error.Abort(
                         b"subrepository '%s' does not exist in %s!"
                         % (sub, short(ctx.node()))
                     )
 
 
 def _performrevert(
     repo,
     parents,
     ctx,
     names,
     uipathfn,
     actions,
     match,
     interactive=False,
     tobackup=None,
 ):
     """function that actually perform all the actions computed for revert
 
     This is an independent function to let extension to plug in and react to
     the imminent revert.
 
     Make sure you have the working directory locked when calling this function.
     """
     parent, p2 = parents
     node = ctx.node()
     excluded_files = []
 
     def checkout(f):
         fc = ctx[f]
         repo.wwrite(f, fc.data(), fc.flags())
 
     def doremove(f):
         try:
             rmdir = repo.ui.configbool(b'experimental', b'removeemptydirs')
             repo.wvfs.unlinkpath(f, rmdir=rmdir)
         except OSError:
             pass
         repo.dirstate.remove(f)
 
     def prntstatusmsg(action, f):
         exact = names[f]
         if repo.ui.verbose or not exact:
             repo.ui.status(actions[action][1] % uipathfn(f))
 
     audit_path = pathutil.pathauditor(repo.root, cached=True)
     for f in actions[b'forget'][0]:
         if interactive:
             choice = repo.ui.promptchoice(
                 _(b"forget added file %s (Yn)?$$ &Yes $$ &No") % uipathfn(f)
             )
             if choice == 0:
                 prntstatusmsg(b'forget', f)
                 repo.dirstate.drop(f)
             else:
                 excluded_files.append(f)
         else:
             prntstatusmsg(b'forget', f)
             repo.dirstate.drop(f)
     for f in actions[b'remove'][0]:
         audit_path(f)
         if interactive:
             choice = repo.ui.promptchoice(
                 _(b"remove added file %s (Yn)?$$ &Yes $$ &No") % uipathfn(f)
             )
             if choice == 0:
                 prntstatusmsg(b'remove', f)
                 doremove(f)
             else:
                 excluded_files.append(f)
         else:
             prntstatusmsg(b'remove', f)
             doremove(f)
     for f in actions[b'drop'][0]:
         audit_path(f)
         prntstatusmsg(b'drop', f)
         repo.dirstate.remove(f)
 
     normal = None
     if node == parent:
         # We're reverting to our parent. If possible, we'd like status
         # to report the file as clean. We have to use normallookup for
         # merges to avoid losing information about merged/dirty files.
         if p2 != nullid:
             normal = repo.dirstate.normallookup
         else:
             normal = repo.dirstate.normal
 
     newlyaddedandmodifiedfiles = set()
     if interactive:
         # Prompt the user for changes to revert
         torevert = [f for f in actions[b'revert'][0] if f not in excluded_files]
         m = scmutil.matchfiles(repo, torevert)
         diffopts = patch.difffeatureopts(
             repo.ui,
             whitespace=True,
             section=b'commands',
             configprefix=b'revert.interactive.',
         )
         diffopts.nodates = True
         diffopts.git = True
         operation = b'apply'
         if node == parent:
             if repo.ui.configbool(
                 b'experimental', b'revert.interactive.select-to-keep'
             ):
                 operation = b'keep'
             else:
                 operation = b'discard'
 
         if operation == b'apply':
             diff = patch.diff(repo, None, ctx.node(), m, opts=diffopts)
         else:
             diff = patch.diff(repo, ctx.node(), None, m, opts=diffopts)
         originalchunks = patch.parsepatch(diff)
 
         try:
 
             chunks, opts = recordfilter(
                 repo.ui, originalchunks, match, operation=operation
             )
             if operation == b'discard':
                 chunks = patch.reversehunks(chunks)
 
         except error.PatchError as err:
             raise error.Abort(_(b'error parsing patch: %s') % err)
 
         # FIXME: when doing an interactive revert of a copy, there's no way of
         # performing a partial revert of the added file, the only option is
         # "remove added file <name> (Yn)?", so we don't need to worry about the
         # alsorestore value. Ideally we'd be able to partially revert
         # copied/renamed files.
         newlyaddedandmodifiedfiles, unusedalsorestore = newandmodified(
             chunks, originalchunks
         )
         if tobackup is None:
             tobackup = set()
         # Apply changes
         fp = stringio()
         # chunks are serialized per file, but files aren't sorted
         for f in sorted({c.header.filename() for c in chunks if ishunk(c)}):
             prntstatusmsg(b'revert', f)
         files = set()
         for c in chunks:
             if ishunk(c):
                 abs = c.header.filename()
                 # Create a backup file only if this hunk should be backed up
                 if c.header.filename() in tobackup:
                     target = repo.wjoin(abs)
                     bakname = scmutil.backuppath(repo.ui, repo, abs)
                     util.copyfile(target, bakname)
                     tobackup.remove(abs)
                 if abs not in files:
                     files.add(abs)
                     if operation == b'keep':
                         checkout(abs)
             c.write(fp)
         dopatch = fp.tell()
         fp.seek(0)
         if dopatch:
             try:
                 patch.internalpatch(repo.ui, repo, fp, 1, eolmode=None)
             except error.PatchError as err:
                 raise error.Abort(pycompat.bytestr(err))
         del fp
     else:
         for f in actions[b'revert'][0]:
             prntstatusmsg(b'revert', f)
             checkout(f)
             if normal:
                 normal(f)
 
     for f in actions[b'add'][0]:
         # Don't checkout modified files, they are already created by the diff
         if f not in newlyaddedandmodifiedfiles:
             prntstatusmsg(b'add', f)
             checkout(f)
             repo.dirstate.add(f)
 
     normal = repo.dirstate.normallookup
     if node == parent and p2 == nullid:
         normal = repo.dirstate.normal
     for f in actions[b'undelete'][0]:
         if interactive:
             choice = repo.ui.promptchoice(
                 _(b"add back removed file %s (Yn)?$$ &Yes $$ &No") % f
             )
             if choice == 0:
                 prntstatusmsg(b'undelete', f)
                 checkout(f)
                 normal(f)
             else:
                 excluded_files.append(f)
         else:
             prntstatusmsg(b'undelete', f)
             checkout(f)
             normal(f)
 
     copied = copies.pathcopies(repo[parent], ctx)
 
     for f in (
         actions[b'add'][0] + actions[b'undelete'][0] + actions[b'revert'][0]
     ):
         if f in copied:
             repo.dirstate.copy(copied[f], f)
 
 
 # a list of (ui, repo, otherpeer, opts, missing) functions called by
 # commands.outgoing.  "missing" is "missing" of the result of
 # "findcommonoutgoing()"
 outgoinghooks = util.hooks()
 
 # a list of (ui, repo) functions called by commands.summary
 summaryhooks = util.hooks()
 
 # a list of (ui, repo, opts, changes) functions called by commands.summary.
 #
 # functions should return tuple of booleans below, if 'changes' is None:
 #  (whether-incomings-are-needed, whether-outgoings-are-needed)
 #
 # otherwise, 'changes' is a tuple of tuples below:
 #  - (sourceurl, sourcebranch, sourcepeer, incoming)
 #  - (desturl,   destbranch,   destpeer,   outgoing)
 summaryremotehooks = util.hooks()
 
 
 def checkunfinished(repo, commit=False, skipmerge=False):
     '''Look for an unfinished multistep operation, like graft, and abort
     if found. It's probably good to check this right before
     bailifchanged().
     '''
     # Check for non-clearable states first, so things like rebase will take
     # precedence over update.
     for state in statemod._unfinishedstates:
         if (
             state._clearable
             or (commit and state._allowcommit)
             or state._reportonly
         ):
             continue
         if state.isunfinished(repo):
             raise error.Abort(state.msg(), hint=state.hint())
 
     for s in statemod._unfinishedstates:
         if (
             not s._clearable
             or (commit and s._allowcommit)
             or (s._opname == b'merge' and skipmerge)
             or s._reportonly
         ):
             continue
         if s.isunfinished(repo):
             raise error.Abort(s.msg(), hint=s.hint())
 
 
 def clearunfinished(repo):
     '''Check for unfinished operations (as above), and clear the ones
     that are clearable.
     '''
     for state in statemod._unfinishedstates:
         if state._reportonly:
             continue
         if not state._clearable and state.isunfinished(repo):
             raise error.Abort(state.msg(), hint=state.hint())
 
     for s in statemod._unfinishedstates:
         if s._opname == b'merge' or state._reportonly:
             continue
         if s._clearable and s.isunfinished(repo):
             util.unlink(repo.vfs.join(s._fname))
 
 
 def getunfinishedstate(repo):
     ''' Checks for unfinished operations and returns statecheck object
         for it'''
     for state in statemod._unfinishedstates:
         if state.isunfinished(repo):
             return state
     return None
 
 
 def howtocontinue(repo):
     '''Check for an unfinished operation and return the command to finish
     it.
 
     statemod._unfinishedstates list is checked for an unfinished operation
     and the corresponding message to finish it is generated if a method to
     continue is supported by the operation.
 
     Returns a (msg, warning) tuple. 'msg' is a string and 'warning' is
     a boolean.
     '''
     contmsg = _(b"continue: %s")
     for state in statemod._unfinishedstates:
         if not state._continueflag:
             continue
         if state.isunfinished(repo):
             return contmsg % state.continuemsg(), True
     if repo[None].dirty(missing=True, merge=False, branch=False):
         return contmsg % _(b"hg commit"), False
     return None, None
 
 
 def checkafterresolved(repo):
     '''Inform the user about the next action after completing hg resolve
 
     If there's a an unfinished operation that supports continue flag,
     howtocontinue will yield repo.ui.warn as the reporter.
 
     Otherwise, it will yield repo.ui.note.
     '''
     msg, warning = howtocontinue(repo)
     if msg is not None:
         if warning:
             repo.ui.warn(b"%s\n" % msg)
         else:
             repo.ui.note(b"%s\n" % msg)
 
 
 def wrongtooltocontinue(repo, task):
     '''Raise an abort suggesting how to properly continue if there is an
     active task.
 
     Uses howtocontinue() to find the active task.
 
     If there's no task (repo.ui.note for 'hg commit'), it does not offer
     a hint.
     '''
     after = howtocontinue(repo)
     hint = None
     if after[1]:
         hint = after[0]
     raise error.Abort(_(b'no %s in progress') % task, hint=hint)
 
 
 def abortgraft(ui, repo, graftstate):
     """abort the interrupted graft and rollbacks to the state before interrupted
     graft"""
     if not graftstate.exists():
         raise error.Abort(_(b"no interrupted graft to abort"))
     statedata = readgraftstate(repo, graftstate)
     newnodes = statedata.get(b'newnodes')
     if newnodes is None:
         # and old graft state which does not have all the data required to abort
         # the graft
         raise error.Abort(_(b"cannot abort using an old graftstate"))
 
     # changeset from which graft operation was started
     if len(newnodes) > 0:
         startctx = repo[newnodes[0]].p1()
     else:
         startctx = repo[b'.']
     # whether to strip or not
     cleanup = False
     from . import hg
 
     if newnodes:
         newnodes = [repo[r].rev() for r in newnodes]
         cleanup = True
         # checking that none of the newnodes turned public or is public
         immutable = [c for c in newnodes if not repo[c].mutable()]
         if immutable:
             repo.ui.warn(
                 _(b"cannot clean up public changesets %s\n")
                 % b', '.join(bytes(repo[r]) for r in immutable),
                 hint=_(b"see 'hg help phases' for details"),
             )
             cleanup = False
 
         # checking that no new nodes are created on top of grafted revs
         desc = set(repo.changelog.descendants(newnodes))
         if desc - set(newnodes):
             repo.ui.warn(
                 _(
                     b"new changesets detected on destination "
                     b"branch, can't strip\n"
                 )
             )
             cleanup = False
 
         if cleanup:
             with repo.wlock(), repo.lock():
                 hg.updaterepo(repo, startctx.node(), overwrite=True)
                 # stripping the new nodes created
                 strippoints = [
                     c.node() for c in repo.set(b"roots(%ld)", newnodes)
                 ]
                 repair.strip(repo.ui, repo, strippoints, backup=False)
 
     if not cleanup:
         # we don't update to the startnode if we can't strip
         startctx = repo[b'.']
         hg.updaterepo(repo, startctx.node(), overwrite=True)
 
     ui.status(_(b"graft aborted\n"))
     ui.status(_(b"working directory is now at %s\n") % startctx.hex()[:12])
     graftstate.delete()
     return 0
 
 
 def readgraftstate(repo, graftstate):
     # type: (Any, statemod.cmdstate) -> Dict[bytes, Any]
     """read the graft state file and return a dict of the data stored in it"""
     try:
         return graftstate.read()
     except error.CorruptedState:
         nodes = repo.vfs.read(b'graftstate').splitlines()
         return {b'nodes': nodes}
 
 
 def hgabortgraft(ui, repo):
     """ abort logic for aborting graft using 'hg abort'"""
     with repo.wlock():
         graftstate = statemod.cmdstate(repo, b'graftstate')
         return abortgraft(ui, repo, graftstate)

mercurial/exchange.py

@@ -1,3157 +1,3157 b''
 # exchange.py - utility to exchange data between repos.
 #
 # Copyright 2005-2007 Matt Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 from __future__ import absolute_import
 
 import collections
 import weakref
 
 from .i18n import _
 from .node import (
     hex,
     nullid,
     nullrev,
 )
 from .thirdparty import attr
 from . import (
     bookmarks as bookmod,
     bundle2,
     changegroup,
     discovery,
     error,
     exchangev2,
     lock as lockmod,
     logexchange,
     narrowspec,
     obsolete,
     obsutil,
     phases,
     pushkey,
     pycompat,
+    requirements,
     scmutil,
     sslutil,
     streamclone,
     url as urlmod,
     util,
     wireprototypes,
 )
-from .interfaces import repository
 from .utils import (
     hashutil,
     stringutil,
 )
 
 urlerr = util.urlerr
 urlreq = util.urlreq
 
 _NARROWACL_SECTION = b'narrowacl'
 
 # Maps bundle version human names to changegroup versions.
 _bundlespeccgversions = {
     b'v1': b'01',
     b'v2': b'02',
     b'packed1': b's1',
     b'bundle2': b'02',  # legacy
 }
 
 # Maps bundle version with content opts to choose which part to bundle
 _bundlespeccontentopts = {
     b'v1': {
         b'changegroup': True,
         b'cg.version': b'01',
         b'obsolescence': False,
         b'phases': False,
         b'tagsfnodescache': False,
         b'revbranchcache': False,
     },
     b'v2': {
         b'changegroup': True,
         b'cg.version': b'02',
         b'obsolescence': False,
         b'phases': False,
         b'tagsfnodescache': True,
         b'revbranchcache': True,
     },
     b'packed1': {b'cg.version': b's1'},
 }
 _bundlespeccontentopts[b'bundle2'] = _bundlespeccontentopts[b'v2']
 
 _bundlespecvariants = {
     b"streamv2": {
         b"changegroup": False,
         b"streamv2": True,
         b"tagsfnodescache": False,
         b"revbranchcache": False,
     }
 }
 
 # Compression engines allowed in version 1. THIS SHOULD NEVER CHANGE.
 _bundlespecv1compengines = {b'gzip', b'bzip2', b'none'}
 
 
 @attr.s
 class bundlespec(object):
     compression = attr.ib()
     wirecompression = attr.ib()
     version = attr.ib()
     wireversion = attr.ib()
     params = attr.ib()
     contentopts = attr.ib()
 
 
 def parsebundlespec(repo, spec, strict=True):
     """Parse a bundle string specification into parts.
 
     Bundle specifications denote a well-defined bundle/exchange format.
     The content of a given specification should not change over time in
     order to ensure that bundles produced by a newer version of Mercurial are
     readable from an older version.
 
     The string currently has the form:
 
        <compression>-<type>[;<parameter0>[;<parameter1>]]
 
     Where <compression> is one of the supported compression formats
     and <type> is (currently) a version string. A ";" can follow the type and
     all text afterwards is interpreted as URI encoded, ";" delimited key=value
     pairs.
 
     If ``strict`` is True (the default) <compression> is required. Otherwise,
     it is optional.
 
     Returns a bundlespec object of (compression, version, parameters).
     Compression will be ``None`` if not in strict mode and a compression isn't
     defined.
 
     An ``InvalidBundleSpecification`` is raised when the specification is
     not syntactically well formed.
 
     An ``UnsupportedBundleSpecification`` is raised when the compression or
     bundle type/version is not recognized.
 
     Note: this function will likely eventually return a more complex data
     structure, including bundle2 part information.
     """
 
     def parseparams(s):
         if b';' not in s:
             return s, {}
 
         params = {}
         version, paramstr = s.split(b';', 1)
 
         for p in paramstr.split(b';'):
             if b'=' not in p:
                 raise error.InvalidBundleSpecification(
                     _(
                         b'invalid bundle specification: '
                         b'missing "=" in parameter: %s'
                     )
                     % p
                 )
 
             key, value = p.split(b'=', 1)
             key = urlreq.unquote(key)
             value = urlreq.unquote(value)
             params[key] = value
 
         return version, params
 
     if strict and b'-' not in spec:
         raise error.InvalidBundleSpecification(
             _(
                 b'invalid bundle specification; '
                 b'must be prefixed with compression: %s'
             )
             % spec
         )
 
     if b'-' in spec:
         compression, version = spec.split(b'-', 1)
 
         if compression not in util.compengines.supportedbundlenames:
             raise error.UnsupportedBundleSpecification(
                 _(b'%s compression is not supported') % compression
             )
 
         version, params = parseparams(version)
 
         if version not in _bundlespeccgversions:
             raise error.UnsupportedBundleSpecification(
                 _(b'%s is not a recognized bundle version') % version
             )
     else:
         # Value could be just the compression or just the version, in which
         # case some defaults are assumed (but only when not in strict mode).
         assert not strict
 
         spec, params = parseparams(spec)
 
         if spec in util.compengines.supportedbundlenames:
             compression = spec
             version = b'v1'
             # Generaldelta repos require v2.
             if b'generaldelta' in repo.requirements:
                 version = b'v2'
             # Modern compression engines require v2.
             if compression not in _bundlespecv1compengines:
                 version = b'v2'
         elif spec in _bundlespeccgversions:
             if spec == b'packed1':
                 compression = b'none'
             else:
                 compression = b'bzip2'
             version = spec
         else:
             raise error.UnsupportedBundleSpecification(
                 _(b'%s is not a recognized bundle specification') % spec
             )
 
     # Bundle version 1 only supports a known set of compression engines.
     if version == b'v1' and compression not in _bundlespecv1compengines:
         raise error.UnsupportedBundleSpecification(
             _(b'compression engine %s is not supported on v1 bundles')
             % compression
         )
 
     # The specification for packed1 can optionally declare the data formats
     # required to apply it. If we see this metadata, compare against what the
     # repo supports and error if the bundle isn't compatible.
     if version == b'packed1' and b'requirements' in params:
         requirements = set(params[b'requirements'].split(b','))
         missingreqs = requirements - repo.supportedformats
         if missingreqs:
             raise error.UnsupportedBundleSpecification(
                 _(b'missing support for repository features: %s')
                 % b', '.join(sorted(missingreqs))
             )
 
     # Compute contentopts based on the version
     contentopts = _bundlespeccontentopts.get(version, {}).copy()
 
     # Process the variants
     if b"stream" in params and params[b"stream"] == b"v2":
         variant = _bundlespecvariants[b"streamv2"]
         contentopts.update(variant)
 
     engine = util.compengines.forbundlename(compression)
     compression, wirecompression = engine.bundletype()
     wireversion = _bundlespeccgversions[version]
 
     return bundlespec(
         compression, wirecompression, version, wireversion, params, contentopts
     )
 
 
 def readbundle(ui, fh, fname, vfs=None):
     header = changegroup.readexactly(fh, 4)
 
     alg = None
     if not fname:
         fname = b"stream"
         if not header.startswith(b'HG') and header.startswith(b'\0'):
             fh = changegroup.headerlessfixup(fh, header)
             header = b"HG10"
             alg = b'UN'
     elif vfs:
         fname = vfs.join(fname)
 
     magic, version = header[0:2], header[2:4]
 
     if magic != b'HG':
         raise error.Abort(_(b'%s: not a Mercurial bundle') % fname)
     if version == b'10':
         if alg is None:
             alg = changegroup.readexactly(fh, 2)
         return changegroup.cg1unpacker(fh, alg)
     elif version.startswith(b'2'):
         return bundle2.getunbundler(ui, fh, magicstring=magic + version)
     elif version == b'S1':
         return streamclone.streamcloneapplier(fh)
     else:
         raise error.Abort(
             _(b'%s: unknown bundle version %s') % (fname, version)
         )
 
 
 def getbundlespec(ui, fh):
     """Infer the bundlespec from a bundle file handle.
 
     The input file handle is seeked and the original seek position is not
     restored.
     """
 
     def speccompression(alg):
         try:
             return util.compengines.forbundletype(alg).bundletype()[0]
         except KeyError:
             return None
 
     b = readbundle(ui, fh, None)
     if isinstance(b, changegroup.cg1unpacker):
         alg = b._type
         if alg == b'_truncatedBZ':
             alg = b'BZ'
         comp = speccompression(alg)
         if not comp:
             raise error.Abort(_(b'unknown compression algorithm: %s') % alg)
         return b'%s-v1' % comp
     elif isinstance(b, bundle2.unbundle20):
         if b'Compression' in b.params:
             comp = speccompression(b.params[b'Compression'])
             if not comp:
                 raise error.Abort(
                     _(b'unknown compression algorithm: %s') % comp
                 )
         else:
             comp = b'none'
 
         version = None
         for part in b.iterparts():
             if part.type == b'changegroup':
                 version = part.params[b'version']
                 if version in (b'01', b'02'):
                     version = b'v2'
                 else:
                     raise error.Abort(
                         _(
                             b'changegroup version %s does not have '
                             b'a known bundlespec'
                         )
                         % version,
                         hint=_(b'try upgrading your Mercurial client'),
                     )
             elif part.type == b'stream2' and version is None:
                 # A stream2 part requires to be part of a v2 bundle
                 requirements = urlreq.unquote(part.params[b'requirements'])
                 splitted = requirements.split()
                 params = bundle2._formatrequirementsparams(splitted)
                 return b'none-v2;stream=v2;%s' % params
 
         if not version:
             raise error.Abort(
                 _(b'could not identify changegroup version in bundle')
             )
 
         return b'%s-%s' % (comp, version)
     elif isinstance(b, streamclone.streamcloneapplier):
         requirements = streamclone.readbundle1header(fh)[2]
         formatted = bundle2._formatrequirementsparams(requirements)
         return b'none-packed1;%s' % formatted
     else:
         raise error.Abort(_(b'unknown bundle type: %s') % b)
 
 
 def _computeoutgoing(repo, heads, common):
     """Computes which revs are outgoing given a set of common
     and a set of heads.
 
     This is a separate function so extensions can have access to
     the logic.
 
     Returns a discovery.outgoing object.
     """
     cl = repo.changelog
     if common:
         hasnode = cl.hasnode
         common = [n for n in common if hasnode(n)]
     else:
         common = [nullid]
     if not heads:
         heads = cl.heads()
     return discovery.outgoing(repo, common, heads)
 
 
 def _checkpublish(pushop):
     repo = pushop.repo
     ui = repo.ui
     behavior = ui.config(b'experimental', b'auto-publish')
     if pushop.publish or behavior not in (b'warn', b'confirm', b'abort'):
         return
     remotephases = listkeys(pushop.remote, b'phases')
     if not remotephases.get(b'publishing', False):
         return
 
     if pushop.revs is None:
         published = repo.filtered(b'served').revs(b'not public()')
     else:
         published = repo.revs(b'::%ln - public()', pushop.revs)
     if published:
         if behavior == b'warn':
             ui.warn(
                 _(b'%i changesets about to be published\n') % len(published)
             )
         elif behavior == b'confirm':
             if ui.promptchoice(
                 _(b'push and publish %i changesets (yn)?$$ &Yes $$ &No')
                 % len(published)
             ):
                 raise error.Abort(_(b'user quit'))
         elif behavior == b'abort':
             msg = _(b'push would publish %i changesets') % len(published)
             hint = _(
                 b"use --publish or adjust 'experimental.auto-publish'"
                 b" config"
             )
             raise error.Abort(msg, hint=hint)
 
 
 def _forcebundle1(op):
     """return true if a pull/push must use bundle1
 
     This function is used to allow testing of the older bundle version"""
     ui = op.repo.ui
     # The goal is this config is to allow developer to choose the bundle
     # version used during exchanged. This is especially handy during test.
     # Value is a list of bundle version to be picked from, highest version
     # should be used.
     #
     # developer config: devel.legacy.exchange
     exchange = ui.configlist(b'devel', b'legacy.exchange')
     forcebundle1 = b'bundle2' not in exchange and b'bundle1' in exchange
     return forcebundle1 or not op.remote.capable(b'bundle2')
 
 
 class pushoperation(object):
     """A object that represent a single push operation
 
     Its purpose is to carry push related state and very common operations.
 
     A new pushoperation should be created at the beginning of each push and
     discarded afterward.
     """
 
     def __init__(
         self,
         repo,
         remote,
         force=False,
         revs=None,
         newbranch=False,
         bookmarks=(),
         publish=False,
         pushvars=None,
     ):
         # repo we push from
         self.repo = repo
         self.ui = repo.ui
         # repo we push to
         self.remote = remote
         # force option provided
         self.force = force
         # revs to be pushed (None is "all")
         self.revs = revs
         # bookmark explicitly pushed
         self.bookmarks = bookmarks
         # allow push of new branch
         self.newbranch = newbranch
         # step already performed
         # (used to check what steps have been already performed through bundle2)
         self.stepsdone = set()
         # Integer version of the changegroup push result
         # - None means nothing to push
         # - 0 means HTTP error
         # - 1 means we pushed and remote head count is unchanged *or*
         #   we have outgoing changesets but refused to push
         # - other values as described by addchangegroup()
         self.cgresult = None
         # Boolean value for the bookmark push
         self.bkresult = None
         # discover.outgoing object (contains common and outgoing data)
         self.outgoing = None
         # all remote topological heads before the push
         self.remoteheads = None
         # Details of the remote branch pre and post push
         #
         # mapping: {'branch': ([remoteheads],
         #                      [newheads],
         #                      [unsyncedheads],
         #                      [discardedheads])}
         # - branch: the branch name
         # - remoteheads: the list of remote heads known locally
         #                None if the branch is new
         # - newheads: the new remote heads (known locally) with outgoing pushed
         # - unsyncedheads: the list of remote heads unknown locally.
         # - discardedheads: the list of remote heads made obsolete by the push
         self.pushbranchmap = None
         # testable as a boolean indicating if any nodes are missing locally.
         self.incoming = None
         # summary of the remote phase situation
         self.remotephases = None
         # phases changes that must be pushed along side the changesets
         self.outdatedphases = None
         # phases changes that must be pushed if changeset push fails
         self.fallbackoutdatedphases = None
         # outgoing obsmarkers
         self.outobsmarkers = set()
         # outgoing bookmarks, list of (bm, oldnode | '', newnode | '')
         self.outbookmarks = []
         # transaction manager
         self.trmanager = None
         # map { pushkey partid -> callback handling failure}
         # used to handle exception from mandatory pushkey part failure
         self.pkfailcb = {}
         # an iterable of pushvars or None
         self.pushvars = pushvars
         # publish pushed changesets
         self.publish = publish
 
     @util.propertycache
     def futureheads(self):
         """future remote heads if the changeset push succeeds"""
         return self.outgoing.ancestorsof
 
     @util.propertycache
     def fallbackheads(self):
         """future remote heads if the changeset push fails"""
         if self.revs is None:
             # not target to push, all common are relevant
             return self.outgoing.commonheads
         unfi = self.repo.unfiltered()
         # I want cheads = heads(::ancestorsof and ::commonheads)
         # (ancestorsof is revs with secret changeset filtered out)
         #
         # This can be expressed as:
         #     cheads = ( (ancestorsof and ::commonheads)
         #              + (commonheads and ::ancestorsof))"
         #              )
         #
         # while trying to push we already computed the following:
         #     common = (::commonheads)
         #     missing = ((commonheads::ancestorsof) - commonheads)
         #
         # We can pick:
         # * ancestorsof part of common (::commonheads)
         common = self.outgoing.common
         rev = self.repo.changelog.index.rev
         cheads = [node for node in self.revs if rev(node) in common]
         # and
         # * commonheads parents on missing
         revset = unfi.set(
             b'%ln and parents(roots(%ln))',
             self.outgoing.commonheads,
             self.outgoing.missing,
         )
         cheads.extend(c.node() for c in revset)
         return cheads
 
     @property
     def commonheads(self):
         """set of all common heads after changeset bundle push"""
         if self.cgresult:
             return self.futureheads
         else:
             return self.fallbackheads
 
 
 # mapping of message used when pushing bookmark
 bookmsgmap = {
     b'update': (
         _(b"updating bookmark %s\n"),
         _(b'updating bookmark %s failed!\n'),
     ),
     b'export': (
         _(b"exporting bookmark %s\n"),
         _(b'exporting bookmark %s failed!\n'),
     ),
     b'delete': (
         _(b"deleting remote bookmark %s\n"),
         _(b'deleting remote bookmark %s failed!\n'),
     ),
 }
 
 
 def push(
     repo,
     remote,
     force=False,
     revs=None,
     newbranch=False,
     bookmarks=(),
     publish=False,
     opargs=None,
 ):
     '''Push outgoing changesets (limited by revs) from a local
     repository to remote. Return an integer:
       - None means nothing to push
       - 0 means HTTP error
       - 1 means we pushed and remote head count is unchanged *or*
         we have outgoing changesets but refused to push
       - other values as described by addchangegroup()
     '''
     if opargs is None:
         opargs = {}
     pushop = pushoperation(
         repo,
         remote,
         force,
         revs,
         newbranch,
         bookmarks,
         publish,
         **pycompat.strkwargs(opargs)
     )
     if pushop.remote.local():
         missing = (
             set(pushop.repo.requirements) - pushop.remote.local().supported
         )
         if missing:
             msg = _(
                 b"required features are not"
                 b" supported in the destination:"
                 b" %s"
             ) % (b', '.join(sorted(missing)))
             raise error.Abort(msg)
 
     if not pushop.remote.canpush():
         raise error.Abort(_(b"destination does not support push"))
 
     if not pushop.remote.capable(b'unbundle'):
         raise error.Abort(
             _(
                 b'cannot push: destination does not support the '
                 b'unbundle wire protocol command'
             )
         )
 
     # get lock as we might write phase data
     wlock = lock = None
     try:
         # bundle2 push may receive a reply bundle touching bookmarks
         # requiring the wlock. Take it now to ensure proper ordering.
         maypushback = pushop.ui.configbool(b'experimental', b'bundle2.pushback')
         if (
             (not _forcebundle1(pushop))
             and maypushback
             and not bookmod.bookmarksinstore(repo)
         ):
             wlock = pushop.repo.wlock()
         lock = pushop.repo.lock()
         pushop.trmanager = transactionmanager(
             pushop.repo, b'push-response', pushop.remote.url()
         )
     except error.LockUnavailable as err:
         # source repo cannot be locked.
         # We do not abort the push, but just disable the local phase
         # synchronisation.
         msg = b'cannot lock source repository: %s\n' % stringutil.forcebytestr(
             err
         )
         pushop.ui.debug(msg)
 
     with wlock or util.nullcontextmanager():
         with lock or util.nullcontextmanager():
             with pushop.trmanager or util.nullcontextmanager():
                 pushop.repo.checkpush(pushop)
                 _checkpublish(pushop)
                 _pushdiscovery(pushop)
                 if not pushop.force:
                     _checksubrepostate(pushop)
                 if not _forcebundle1(pushop):
                     _pushbundle2(pushop)
                 _pushchangeset(pushop)
                 _pushsyncphase(pushop)
                 _pushobsolete(pushop)
                 _pushbookmark(pushop)
 
     if repo.ui.configbool(b'experimental', b'remotenames'):
         logexchange.pullremotenames(repo, remote)
 
     return pushop
 
 
 # list of steps to perform discovery before push
 pushdiscoveryorder = []
 
 # Mapping between step name and function
 #
 # This exists to help extensions wrap steps if necessary
 pushdiscoverymapping = {}
 
 
 def pushdiscovery(stepname):
     """decorator for function performing discovery before push
 
     The function is added to the step -> function mapping and appended to the
     list of steps.  Beware that decorated function will be added in order (this
     may matter).
 
     You can only use this decorator for a new step, if you want to wrap a step
     from an extension, change the pushdiscovery dictionary directly."""
 
     def dec(func):
         assert stepname not in pushdiscoverymapping
         pushdiscoverymapping[stepname] = func
         pushdiscoveryorder.append(stepname)
         return func
 
     return dec
 
 
 def _pushdiscovery(pushop):
     """Run all discovery steps"""
     for stepname in pushdiscoveryorder:
         step = pushdiscoverymapping[stepname]
         step(pushop)
 
 
 def _checksubrepostate(pushop):
     """Ensure all outgoing referenced subrepo revisions are present locally"""
     for n in pushop.outgoing.missing:
         ctx = pushop.repo[n]
 
         if b'.hgsub' in ctx.manifest() and b'.hgsubstate' in ctx.files():
             for subpath in sorted(ctx.substate):
                 sub = ctx.sub(subpath)
                 sub.verify(onpush=True)
 
 
 @pushdiscovery(b'changeset')
 def _pushdiscoverychangeset(pushop):
     """discover the changeset that need to be pushed"""
     fci = discovery.findcommonincoming
     if pushop.revs:
         commoninc = fci(
             pushop.repo,
             pushop.remote,
             force=pushop.force,
             ancestorsof=pushop.revs,
         )
     else:
         commoninc = fci(pushop.repo, pushop.remote, force=pushop.force)
     common, inc, remoteheads = commoninc
     fco = discovery.findcommonoutgoing
     outgoing = fco(
         pushop.repo,
         pushop.remote,
         onlyheads=pushop.revs,
         commoninc=commoninc,
         force=pushop.force,
     )
     pushop.outgoing = outgoing
     pushop.remoteheads = remoteheads
     pushop.incoming = inc
 
 
 @pushdiscovery(b'phase')
 def _pushdiscoveryphase(pushop):
     """discover the phase that needs to be pushed
 
     (computed for both success and failure case for changesets push)"""
     outgoing = pushop.outgoing
     unfi = pushop.repo.unfiltered()
     remotephases = listkeys(pushop.remote, b'phases')
 
     if (
         pushop.ui.configbool(b'ui', b'_usedassubrepo')
         and remotephases  # server supports phases
         and not pushop.outgoing.missing  # no changesets to be pushed
         and remotephases.get(b'publishing', False)
     ):
         # When:
         # - this is a subrepo push
         # - and remote support phase
         # - and no changeset are to be pushed
         # - and remote is publishing
         # We may be in issue 3781 case!
         # We drop the possible phase synchronisation done by
         # courtesy to publish changesets possibly locally draft
         # on the remote.
         pushop.outdatedphases = []
         pushop.fallbackoutdatedphases = []
         return
 
     pushop.remotephases = phases.remotephasessummary(
         pushop.repo, pushop.fallbackheads, remotephases
     )
     droots = pushop.remotephases.draftroots
 
     extracond = b''
     if not pushop.remotephases.publishing:
         extracond = b' and public()'
     revset = b'heads((%%ln::%%ln) %s)' % extracond
     # Get the list of all revs draft on remote by public here.
     # XXX Beware that revset break if droots is not strictly
     # XXX root we may want to ensure it is but it is costly
     fallback = list(unfi.set(revset, droots, pushop.fallbackheads))
     if not pushop.remotephases.publishing and pushop.publish:
         future = list(
             unfi.set(
                 b'%ln and (not public() or %ln::)', pushop.futureheads, droots
             )
         )
     elif not outgoing.missing:
         future = fallback
     else:
         # adds changeset we are going to push as draft
         #
         # should not be necessary for publishing server, but because of an
         # issue fixed in xxxxx we have to do it anyway.
         fdroots = list(
             unfi.set(b'roots(%ln  + %ln::)', outgoing.missing, droots)
         )
         fdroots = [f.node() for f in fdroots]
         future = list(unfi.set(revset, fdroots, pushop.futureheads))
     pushop.outdatedphases = future
     pushop.fallbackoutdatedphases = fallback
 
 
 @pushdiscovery(b'obsmarker')
 def _pushdiscoveryobsmarkers(pushop):
     if not obsolete.isenabled(pushop.repo, obsolete.exchangeopt):
         return
 
     if not pushop.repo.obsstore:
         return
 
     if b'obsolete' not in listkeys(pushop.remote, b'namespaces'):
         return
 
     repo = pushop.repo
     # very naive computation, that can be quite expensive on big repo.
     # However: evolution is currently slow on them anyway.
     nodes = (c.node() for c in repo.set(b'::%ln', pushop.futureheads))
     pushop.outobsmarkers = pushop.repo.obsstore.relevantmarkers(nodes)
 
 
 @pushdiscovery(b'bookmarks')
 def _pushdiscoverybookmarks(pushop):
     ui = pushop.ui
     repo = pushop.repo.unfiltered()
     remote = pushop.remote
     ui.debug(b"checking for updated bookmarks\n")
     ancestors = ()
     if pushop.revs:
         revnums = pycompat.maplist(repo.changelog.rev, pushop.revs)
         ancestors = repo.changelog.ancestors(revnums, inclusive=True)
 
     remotebookmark = bookmod.unhexlifybookmarks(listkeys(remote, b'bookmarks'))
 
     explicit = {
         repo._bookmarks.expandname(bookmark) for bookmark in pushop.bookmarks
     }
 
     comp = bookmod.comparebookmarks(repo, repo._bookmarks, remotebookmark)
     return _processcompared(pushop, ancestors, explicit, remotebookmark, comp)
 
 
 def _processcompared(pushop, pushed, explicit, remotebms, comp):
     """take decision on bookmarks to push to the remote repo
 
     Exists to help extensions alter this behavior.
     """
     addsrc, adddst, advsrc, advdst, diverge, differ, invalid, same = comp
 
     repo = pushop.repo
 
     for b, scid, dcid in advsrc:
         if b in explicit:
             explicit.remove(b)
         if not pushed or repo[scid].rev() in pushed:
             pushop.outbookmarks.append((b, dcid, scid))
     # search added bookmark
     for b, scid, dcid in addsrc:
         if b in explicit:
             explicit.remove(b)
             if bookmod.isdivergent(b):
                 pushop.ui.warn(_(b'cannot push divergent bookmark %s!\n') % b)
                 pushop.bkresult = 2
             else:
                 pushop.outbookmarks.append((b, b'', scid))
     # search for overwritten bookmark
     for b, scid, dcid in list(advdst) + list(diverge) + list(differ):
         if b in explicit:
             explicit.remove(b)
             pushop.outbookmarks.append((b, dcid, scid))
     # search for bookmark to delete
     for b, scid, dcid in adddst:
         if b in explicit:
             explicit.remove(b)
             # treat as "deleted locally"
             pushop.outbookmarks.append((b, dcid, b''))
     # identical bookmarks shouldn't get reported
     for b, scid, dcid in same:
         if b in explicit:
             explicit.remove(b)
 
     if explicit:
         explicit = sorted(explicit)
         # we should probably list all of them
         pushop.ui.warn(
             _(
                 b'bookmark %s does not exist on the local '
                 b'or remote repository!\n'
             )
             % explicit[0]
         )
         pushop.bkresult = 2
 
     pushop.outbookmarks.sort()
 
 
 def _pushcheckoutgoing(pushop):
     outgoing = pushop.outgoing
     unfi = pushop.repo.unfiltered()
     if not outgoing.missing:
         # nothing to push
         scmutil.nochangesfound(unfi.ui, unfi, outgoing.excluded)
         return False
     # something to push
     if not pushop.force:
         # if repo.obsstore == False --> no obsolete
         # then, save the iteration
         if unfi.obsstore:
             # this message are here for 80 char limit reason
             mso = _(b"push includes obsolete changeset: %s!")
             mspd = _(b"push includes phase-divergent changeset: %s!")
             mscd = _(b"push includes content-divergent changeset: %s!")
             mst = {
                 b"orphan": _(b"push includes orphan changeset: %s!"),
                 b"phase-divergent": mspd,
                 b"content-divergent": mscd,
             }
             # If we are to push if there is at least one
             # obsolete or unstable changeset in missing, at
             # least one of the missinghead will be obsolete or
             # unstable. So checking heads only is ok
             for node in outgoing.ancestorsof:
                 ctx = unfi[node]
                 if ctx.obsolete():
                     raise error.Abort(mso % ctx)
                 elif ctx.isunstable():
                     # TODO print more than one instability in the abort
                     # message
                     raise error.Abort(mst[ctx.instabilities()[0]] % ctx)
 
         discovery.checkheads(pushop)
     return True
 
 
 # List of names of steps to perform for an outgoing bundle2, order matters.
 b2partsgenorder = []
 
 # Mapping between step name and function
 #
 # This exists to help extensions wrap steps if necessary
 b2partsgenmapping = {}
 
 
 def b2partsgenerator(stepname, idx=None):
     """decorator for function generating bundle2 part
 
     The function is added to the step -> function mapping and appended to the
     list of steps.  Beware that decorated functions will be added in order
     (this may matter).
 
     You can only use this decorator for new steps, if you want to wrap a step
     from an extension, attack the b2partsgenmapping dictionary directly."""
 
     def dec(func):
         assert stepname not in b2partsgenmapping
         b2partsgenmapping[stepname] = func
         if idx is None:
             b2partsgenorder.append(stepname)
         else:
             b2partsgenorder.insert(idx, stepname)
         return func
 
     return dec
 
 
 def _pushb2ctxcheckheads(pushop, bundler):
     """Generate race condition checking parts
 
     Exists as an independent function to aid extensions
     """
     # * 'force' do not check for push race,
     # * if we don't push anything, there are nothing to check.
     if not pushop.force and pushop.outgoing.ancestorsof:
         allowunrelated = b'related' in bundler.capabilities.get(
             b'checkheads', ()
         )
         emptyremote = pushop.pushbranchmap is None
         if not allowunrelated or emptyremote:
             bundler.newpart(b'check:heads', data=iter(pushop.remoteheads))
         else:
             affected = set()
             for branch, heads in pycompat.iteritems(pushop.pushbranchmap):
                 remoteheads, newheads, unsyncedheads, discardedheads = heads
                 if remoteheads is not None:
                     remote = set(remoteheads)
                     affected |= set(discardedheads) & remote
                     affected |= remote - set(newheads)
             if affected:
                 data = iter(sorted(affected))
                 bundler.newpart(b'check:updated-heads', data=data)
 
 
 def _pushing(pushop):
     """return True if we are pushing anything"""
     return bool(
         pushop.outgoing.missing
         or pushop.outdatedphases
         or pushop.outobsmarkers
         or pushop.outbookmarks
     )
 
 
 @b2partsgenerator(b'check-bookmarks')
 def _pushb2checkbookmarks(pushop, bundler):
     """insert bookmark move checking"""
     if not _pushing(pushop) or pushop.force:
         return
     b2caps = bundle2.bundle2caps(pushop.remote)
     hasbookmarkcheck = b'bookmarks' in b2caps
     if not (pushop.outbookmarks and hasbookmarkcheck):
         return
     data = []
     for book, old, new in pushop.outbookmarks:
         data.append((book, old))
     checkdata = bookmod.binaryencode(data)
     bundler.newpart(b'check:bookmarks', data=checkdata)
 
 
 @b2partsgenerator(b'check-phases')
 def _pushb2checkphases(pushop, bundler):
     """insert phase move checking"""
     if not _pushing(pushop) or pushop.force:
         return
     b2caps = bundle2.bundle2caps(pushop.remote)
     hasphaseheads = b'heads' in b2caps.get(b'phases', ())
     if pushop.remotephases is not None and hasphaseheads:
         # check that the remote phase has not changed
         checks = {p: [] for p in phases.allphases}
         checks[phases.public].extend(pushop.remotephases.publicheads)
         checks[phases.draft].extend(pushop.remotephases.draftroots)
         if any(pycompat.itervalues(checks)):
             for phase in checks:
                 checks[phase].sort()
             checkdata = phases.binaryencode(checks)
             bundler.newpart(b'check:phases', data=checkdata)
 
 
 @b2partsgenerator(b'changeset')
 def _pushb2ctx(pushop, bundler):
     """handle changegroup push through bundle2
 
     addchangegroup result is stored in the ``pushop.cgresult`` attribute.
     """
     if b'changesets' in pushop.stepsdone:
         return
     pushop.stepsdone.add(b'changesets')
     # Send known heads to the server for race detection.
     if not _pushcheckoutgoing(pushop):
         return
     pushop.repo.prepushoutgoinghooks(pushop)
 
     _pushb2ctxcheckheads(pushop, bundler)
 
     b2caps = bundle2.bundle2caps(pushop.remote)
     version = b'01'
     cgversions = b2caps.get(b'changegroup')
     if cgversions:  # 3.1 and 3.2 ship with an empty value
         cgversions = [
             v
             for v in cgversions
             if v in changegroup.supportedoutgoingversions(pushop.repo)
         ]
         if not cgversions:
             raise error.Abort(_(b'no common changegroup version'))
         version = max(cgversions)
     cgstream = changegroup.makestream(
         pushop.repo, pushop.outgoing, version, b'push'
     )
     cgpart = bundler.newpart(b'changegroup', data=cgstream)
     if cgversions:
         cgpart.addparam(b'version', version)
-    if repository.TREEMANIFEST_REQUIREMENT in pushop.repo.requirements:
+    if requirements.TREEMANIFEST_REQUIREMENT in pushop.repo.requirements:
         cgpart.addparam(b'treemanifest', b'1')
     if b'exp-sidedata-flag' in pushop.repo.requirements:
         cgpart.addparam(b'exp-sidedata', b'1')
 
     def handlereply(op):
         """extract addchangegroup returns from server reply"""
         cgreplies = op.records.getreplies(cgpart.id)
         assert len(cgreplies[b'changegroup']) == 1
         pushop.cgresult = cgreplies[b'changegroup'][0][b'return']
 
     return handlereply
 
 
 @b2partsgenerator(b'phase')
 def _pushb2phases(pushop, bundler):
     """handle phase push through bundle2"""
     if b'phases' in pushop.stepsdone:
         return
     b2caps = bundle2.bundle2caps(pushop.remote)
     ui = pushop.repo.ui
 
     legacyphase = b'phases' in ui.configlist(b'devel', b'legacy.exchange')
     haspushkey = b'pushkey' in b2caps
     hasphaseheads = b'heads' in b2caps.get(b'phases', ())
 
     if hasphaseheads and not legacyphase:
         return _pushb2phaseheads(pushop, bundler)
     elif haspushkey:
         return _pushb2phasespushkey(pushop, bundler)
 
 
 def _pushb2phaseheads(pushop, bundler):
     """push phase information through a bundle2 - binary part"""
     pushop.stepsdone.add(b'phases')
     if pushop.outdatedphases:
         updates = {p: [] for p in phases.allphases}
         updates[0].extend(h.node() for h in pushop.outdatedphases)
         phasedata = phases.binaryencode(updates)
         bundler.newpart(b'phase-heads', data=phasedata)
 
 
 def _pushb2phasespushkey(pushop, bundler):
     """push phase information through a bundle2 - pushkey part"""
     pushop.stepsdone.add(b'phases')
     part2node = []
 
     def handlefailure(pushop, exc):
         targetid = int(exc.partid)
         for partid, node in part2node:
             if partid == targetid:
                 raise error.Abort(_(b'updating %s to public failed') % node)
 
     enc = pushkey.encode
     for newremotehead in pushop.outdatedphases:
         part = bundler.newpart(b'pushkey')
         part.addparam(b'namespace', enc(b'phases'))
         part.addparam(b'key', enc(newremotehead.hex()))
         part.addparam(b'old', enc(b'%d' % phases.draft))
         part.addparam(b'new', enc(b'%d' % phases.public))
         part2node.append((part.id, newremotehead))
         pushop.pkfailcb[part.id] = handlefailure
 
     def handlereply(op):
         for partid, node in part2node:
             partrep = op.records.getreplies(partid)
             results = partrep[b'pushkey']
             assert len(results) <= 1
             msg = None
             if not results:
                 msg = _(b'server ignored update of %s to public!\n') % node
             elif not int(results[0][b'return']):
                 msg = _(b'updating %s to public failed!\n') % node
             if msg is not None:
                 pushop.ui.warn(msg)
 
     return handlereply
 
 
 @b2partsgenerator(b'obsmarkers')
 def _pushb2obsmarkers(pushop, bundler):
     if b'obsmarkers' in pushop.stepsdone:
         return
     remoteversions = bundle2.obsmarkersversion(bundler.capabilities)
     if obsolete.commonversion(remoteversions) is None:
         return
     pushop.stepsdone.add(b'obsmarkers')
     if pushop.outobsmarkers:
         markers = obsutil.sortedmarkers(pushop.outobsmarkers)
         bundle2.buildobsmarkerspart(bundler, markers)
 
 
 @b2partsgenerator(b'bookmarks')
 def _pushb2bookmarks(pushop, bundler):
     """handle bookmark push through bundle2"""
     if b'bookmarks' in pushop.stepsdone:
         return
     b2caps = bundle2.bundle2caps(pushop.remote)
 
     legacy = pushop.repo.ui.configlist(b'devel', b'legacy.exchange')
     legacybooks = b'bookmarks' in legacy
 
     if not legacybooks and b'bookmarks' in b2caps:
         return _pushb2bookmarkspart(pushop, bundler)
     elif b'pushkey' in b2caps:
         return _pushb2bookmarkspushkey(pushop, bundler)
 
 
 def _bmaction(old, new):
     """small utility for bookmark pushing"""
     if not old:
         return b'export'
     elif not new:
         return b'delete'
     return b'update'
 
 
 def _abortonsecretctx(pushop, node, b):
     """abort if a given bookmark points to a secret changeset"""
     if node and pushop.repo[node].phase() == phases.secret:
         raise error.Abort(
             _(b'cannot push bookmark %s as it points to a secret changeset') % b
         )
 
 
 def _pushb2bookmarkspart(pushop, bundler):
     pushop.stepsdone.add(b'bookmarks')
     if not pushop.outbookmarks:
         return
 
     allactions = []
     data = []
     for book, old, new in pushop.outbookmarks:
         _abortonsecretctx(pushop, new, book)
         data.append((book, new))
         allactions.append((book, _bmaction(old, new)))
     checkdata = bookmod.binaryencode(data)
     bundler.newpart(b'bookmarks', data=checkdata)
 
     def handlereply(op):
         ui = pushop.ui
         # if success
         for book, action in allactions:
             ui.status(bookmsgmap[action][0] % book)
 
     return handlereply
 
 
 def _pushb2bookmarkspushkey(pushop, bundler):
     pushop.stepsdone.add(b'bookmarks')
     part2book = []
     enc = pushkey.encode
 
     def handlefailure(pushop, exc):
         targetid = int(exc.partid)
         for partid, book, action in part2book:
             if partid == targetid:
                 raise error.Abort(bookmsgmap[action][1].rstrip() % book)
         # we should not be called for part we did not generated
         assert False
 
     for book, old, new in pushop.outbookmarks:
         _abortonsecretctx(pushop, new, book)
         part = bundler.newpart(b'pushkey')
         part.addparam(b'namespace', enc(b'bookmarks'))
         part.addparam(b'key', enc(book))
         part.addparam(b'old', enc(hex(old)))
         part.addparam(b'new', enc(hex(new)))
         action = b'update'
         if not old:
             action = b'export'
         elif not new:
             action = b'delete'
         part2book.append((part.id, book, action))
         pushop.pkfailcb[part.id] = handlefailure
 
     def handlereply(op):
         ui = pushop.ui
         for partid, book, action in part2book:
             partrep = op.records.getreplies(partid)
             results = partrep[b'pushkey']
             assert len(results) <= 1
             if not results:
                 pushop.ui.warn(_(b'server ignored bookmark %s update\n') % book)
             else:
                 ret = int(results[0][b'return'])
                 if ret:
                     ui.status(bookmsgmap[action][0] % book)
                 else:
                     ui.warn(bookmsgmap[action][1] % book)
                     if pushop.bkresult is not None:
                         pushop.bkresult = 1
 
     return handlereply
 
 
 @b2partsgenerator(b'pushvars', idx=0)
 def _getbundlesendvars(pushop, bundler):
     '''send shellvars via bundle2'''
     pushvars = pushop.pushvars
     if pushvars:
         shellvars = {}
         for raw in pushvars:
             if b'=' not in raw:
                 msg = (
                     b"unable to parse variable '%s', should follow "
                     b"'KEY=VALUE' or 'KEY=' format"
                 )
                 raise error.Abort(msg % raw)
             k, v = raw.split(b'=', 1)
             shellvars[k] = v
 
         part = bundler.newpart(b'pushvars')
 
         for key, value in pycompat.iteritems(shellvars):
             part.addparam(key, value, mandatory=False)
 
 
 def _pushbundle2(pushop):
     """push data to the remote using bundle2
 
     The only currently supported type of data is changegroup but this will
     evolve in the future."""
     bundler = bundle2.bundle20(pushop.ui, bundle2.bundle2caps(pushop.remote))
     pushback = pushop.trmanager and pushop.ui.configbool(
         b'experimental', b'bundle2.pushback'
     )
 
     # create reply capability
     capsblob = bundle2.encodecaps(
         bundle2.getrepocaps(pushop.repo, allowpushback=pushback, role=b'client')
     )
     bundler.newpart(b'replycaps', data=capsblob)
     replyhandlers = []
     for partgenname in b2partsgenorder:
         partgen = b2partsgenmapping[partgenname]
         ret = partgen(pushop, bundler)
         if callable(ret):
             replyhandlers.append(ret)
     # do not push if nothing to push
     if bundler.nbparts <= 1:
         return
     stream = util.chunkbuffer(bundler.getchunks())
     try:
         try:
             with pushop.remote.commandexecutor() as e:
                 reply = e.callcommand(
                     b'unbundle',
                     {
                         b'bundle': stream,
                         b'heads': [b'force'],
                         b'url': pushop.remote.url(),
                     },
                 ).result()
         except error.BundleValueError as exc:
             raise error.Abort(_(b'missing support for %s') % exc)
         try:
             trgetter = None
             if pushback:
                 trgetter = pushop.trmanager.transaction
             op = bundle2.processbundle(pushop.repo, reply, trgetter)
         except error.BundleValueError as exc:
             raise error.Abort(_(b'missing support for %s') % exc)
         except bundle2.AbortFromPart as exc:
             pushop.ui.status(_(b'remote: %s\n') % exc)
             if exc.hint is not None:
                 pushop.ui.status(_(b'remote: %s\n') % (b'(%s)' % exc.hint))
             raise error.Abort(_(b'push failed on remote'))
     except error.PushkeyFailed as exc:
         partid = int(exc.partid)
         if partid not in pushop.pkfailcb:
             raise
         pushop.pkfailcb[partid](pushop, exc)
     for rephand in replyhandlers:
         rephand(op)
 
 
 def _pushchangeset(pushop):
     """Make the actual push of changeset bundle to remote repo"""
     if b'changesets' in pushop.stepsdone:
         return
     pushop.stepsdone.add(b'changesets')
     if not _pushcheckoutgoing(pushop):
         return
 
     # Should have verified this in push().
     assert pushop.remote.capable(b'unbundle')
 
     pushop.repo.prepushoutgoinghooks(pushop)
     outgoing = pushop.outgoing
     # TODO: get bundlecaps from remote
     bundlecaps = None
     # create a changegroup from local
     if pushop.revs is None and not (
         outgoing.excluded or pushop.repo.changelog.filteredrevs
     ):
         # push everything,
         # use the fast path, no race possible on push
         cg = changegroup.makechangegroup(
             pushop.repo,
             outgoing,
             b'01',
             b'push',
             fastpath=True,
             bundlecaps=bundlecaps,
         )
     else:
         cg = changegroup.makechangegroup(
             pushop.repo, outgoing, b'01', b'push', bundlecaps=bundlecaps
         )
 
     # apply changegroup to remote
     # local repo finds heads on server, finds out what
     # revs it must push. once revs transferred, if server
     # finds it has different heads (someone else won
     # commit/push race), server aborts.
     if pushop.force:
         remoteheads = [b'force']
     else:
         remoteheads = pushop.remoteheads
     # ssh: return remote's addchangegroup()
     # http: return remote's addchangegroup() or 0 for error
     pushop.cgresult = pushop.remote.unbundle(cg, remoteheads, pushop.repo.url())
 
 
 def _pushsyncphase(pushop):
     """synchronise phase information locally and remotely"""
     cheads = pushop.commonheads
     # even when we don't push, exchanging phase data is useful
     remotephases = listkeys(pushop.remote, b'phases')
     if (
         pushop.ui.configbool(b'ui', b'_usedassubrepo')
         and remotephases  # server supports phases
         and pushop.cgresult is None  # nothing was pushed
         and remotephases.get(b'publishing', False)
     ):
         # When:
         # - this is a subrepo push
         # - and remote support phase
         # - and no changeset was pushed
         # - and remote is publishing
         # We may be in issue 3871 case!
         # We drop the possible phase synchronisation done by
         # courtesy to publish changesets possibly locally draft
         # on the remote.
         remotephases = {b'publishing': b'True'}
     if not remotephases:  # old server or public only reply from non-publishing
         _localphasemove(pushop, cheads)
         # don't push any phase data as there is nothing to push
     else:
         ana = phases.analyzeremotephases(pushop.repo, cheads, remotephases)
         pheads, droots = ana
         ### Apply remote phase on local
         if remotephases.get(b'publishing', False):
             _localphasemove(pushop, cheads)
         else:  # publish = False
             _localphasemove(pushop, pheads)
             _localphasemove(pushop, cheads, phases.draft)
         ### Apply local phase on remote
 
         if pushop.cgresult:
             if b'phases' in pushop.stepsdone:
                 # phases already pushed though bundle2
                 return
             outdated = pushop.outdatedphases
         else:
             outdated = pushop.fallbackoutdatedphases
 
         pushop.stepsdone.add(b'phases')
 
         # filter heads already turned public by the push
         outdated = [c for c in outdated if c.node() not in pheads]
         # fallback to independent pushkey command
         for newremotehead in outdated:
             with pushop.remote.commandexecutor() as e:
                 r = e.callcommand(
                     b'pushkey',
                     {
                         b'namespace': b'phases',
                         b'key': newremotehead.hex(),
                         b'old': b'%d' % phases.draft,
                         b'new': b'%d' % phases.public,
                     },
                 ).result()
 
             if not r:
                 pushop.ui.warn(
                     _(b'updating %s to public failed!\n') % newremotehead
                 )
 
 
 def _localphasemove(pushop, nodes, phase=phases.public):
     """move <nodes> to <phase> in the local source repo"""
     if pushop.trmanager:
         phases.advanceboundary(
             pushop.repo, pushop.trmanager.transaction(), phase, nodes
         )
     else:
         # repo is not locked, do not change any phases!
         # Informs the user that phases should have been moved when
         # applicable.
         actualmoves = [n for n in nodes if phase < pushop.repo[n].phase()]
         phasestr = phases.phasenames[phase]
         if actualmoves:
             pushop.ui.status(
                 _(
                     b'cannot lock source repo, skipping '
                     b'local %s phase update\n'
                 )
                 % phasestr
             )
 
 
 def _pushobsolete(pushop):
     """utility function to push obsolete markers to a remote"""
     if b'obsmarkers' in pushop.stepsdone:
         return
     repo = pushop.repo
     remote = pushop.remote
     pushop.stepsdone.add(b'obsmarkers')
     if pushop.outobsmarkers:
         pushop.ui.debug(b'try to push obsolete markers to remote\n')
         rslts = []
         markers = obsutil.sortedmarkers(pushop.outobsmarkers)
         remotedata = obsolete._pushkeyescape(markers)
         for key in sorted(remotedata, reverse=True):
             # reverse sort to ensure we end with dump0
             data = remotedata[key]
             rslts.append(remote.pushkey(b'obsolete', key, b'', data))
         if [r for r in rslts if not r]:
             msg = _(b'failed to push some obsolete markers!\n')
             repo.ui.warn(msg)
 
 
 def _pushbookmark(pushop):
     """Update bookmark position on remote"""
     if pushop.cgresult == 0 or b'bookmarks' in pushop.stepsdone:
         return
     pushop.stepsdone.add(b'bookmarks')
     ui = pushop.ui
     remote = pushop.remote
 
     for b, old, new in pushop.outbookmarks:
         action = b'update'
         if not old:
             action = b'export'
         elif not new:
             action = b'delete'
 
         with remote.commandexecutor() as e:
             r = e.callcommand(
                 b'pushkey',
                 {
                     b'namespace': b'bookmarks',
                     b'key': b,
                     b'old': hex(old),
                     b'new': hex(new),
                 },
             ).result()
 
         if r:
             ui.status(bookmsgmap[action][0] % b)
         else:
             ui.warn(bookmsgmap[action][1] % b)
             # discovery can have set the value form invalid entry
             if pushop.bkresult is not None:
                 pushop.bkresult = 1
 
 
 class pulloperation(object):
     """A object that represent a single pull operation
 
     It purpose is to carry pull related state and very common operation.
 
     A new should be created at the beginning of each pull and discarded
     afterward.
     """
 
     def __init__(
         self,
         repo,
         remote,
         heads=None,
         force=False,
         bookmarks=(),
         remotebookmarks=None,
         streamclonerequested=None,
         includepats=None,
         excludepats=None,
         depth=None,
     ):
         # repo we pull into
         self.repo = repo
         # repo we pull from
         self.remote = remote
         # revision we try to pull (None is "all")
         self.heads = heads
         # bookmark pulled explicitly
         self.explicitbookmarks = [
             repo._bookmarks.expandname(bookmark) for bookmark in bookmarks
         ]
         # do we force pull?
         self.force = force
         # whether a streaming clone was requested
         self.streamclonerequested = streamclonerequested
         # transaction manager
         self.trmanager = None
         # set of common changeset between local and remote before pull
         self.common = None
         # set of pulled head
         self.rheads = None
         # list of missing changeset to fetch remotely
         self.fetch = None
         # remote bookmarks data
         self.remotebookmarks = remotebookmarks
         # result of changegroup pulling (used as return code by pull)
         self.cgresult = None
         # list of step already done
         self.stepsdone = set()
         # Whether we attempted a clone from pre-generated bundles.
         self.clonebundleattempted = False
         # Set of file patterns to include.
         self.includepats = includepats
         # Set of file patterns to exclude.
         self.excludepats = excludepats
         # Number of ancestor changesets to pull from each pulled head.
         self.depth = depth
 
     @util.propertycache
     def pulledsubset(self):
         """heads of the set of changeset target by the pull"""
         # compute target subset
         if self.heads is None:
             # We pulled every thing possible
             # sync on everything common
             c = set(self.common)
             ret = list(self.common)
             for n in self.rheads:
                 if n not in c:
                     ret.append(n)
             return ret
         else:
             # We pulled a specific subset
             # sync on this subset
             return self.heads
 
     @util.propertycache
     def canusebundle2(self):
         return not _forcebundle1(self)
 
     @util.propertycache
     def remotebundle2caps(self):
         return bundle2.bundle2caps(self.remote)
 
     def gettransaction(self):
         # deprecated; talk to trmanager directly
         return self.trmanager.transaction()
 
 
 class transactionmanager(util.transactional):
     """An object to manage the life cycle of a transaction
 
     It creates the transaction on demand and calls the appropriate hooks when
     closing the transaction."""
 
     def __init__(self, repo, source, url):
         self.repo = repo
         self.source = source
         self.url = url
         self._tr = None
 
     def transaction(self):
         """Return an open transaction object, constructing if necessary"""
         if not self._tr:
             trname = b'%s\n%s' % (self.source, util.hidepassword(self.url))
             self._tr = self.repo.transaction(trname)
             self._tr.hookargs[b'source'] = self.source
             self._tr.hookargs[b'url'] = self.url
         return self._tr
 
     def close(self):
         """close transaction if created"""
         if self._tr is not None:
             self._tr.close()
 
     def release(self):
         """release transaction if created"""
         if self._tr is not None:
             self._tr.release()
 
 
 def listkeys(remote, namespace):
     with remote.commandexecutor() as e:
         return e.callcommand(b'listkeys', {b'namespace': namespace}).result()
 
 
 def _fullpullbundle2(repo, pullop):
     # The server may send a partial reply, i.e. when inlining
     # pre-computed bundles. In that case, update the common
     # set based on the results and pull another bundle.
     #
     # There are two indicators that the process is finished:
     # - no changeset has been added, or
     # - all remote heads are known locally.
     # The head check must use the unfiltered view as obsoletion
     # markers can hide heads.
     unfi = repo.unfiltered()
     unficl = unfi.changelog
 
     def headsofdiff(h1, h2):
         """Returns heads(h1 % h2)"""
         res = unfi.set(b'heads(%ln %% %ln)', h1, h2)
         return {ctx.node() for ctx in res}
 
     def headsofunion(h1, h2):
         """Returns heads((h1 + h2) - null)"""
         res = unfi.set(b'heads((%ln + %ln - null))', h1, h2)
         return {ctx.node() for ctx in res}
 
     while True:
         old_heads = unficl.heads()
         clstart = len(unficl)
         _pullbundle2(pullop)
-        if repository.NARROW_REQUIREMENT in repo.requirements:
+        if requirements.NARROW_REQUIREMENT in repo.requirements:
             # XXX narrow clones filter the heads on the server side during
             # XXX getbundle and result in partial replies as well.
             # XXX Disable pull bundles in this case as band aid to avoid
             # XXX extra round trips.
             break
         if clstart == len(unficl):
             break
         if all(unficl.hasnode(n) for n in pullop.rheads):
             break
         new_heads = headsofdiff(unficl.heads(), old_heads)
         pullop.common = headsofunion(new_heads, pullop.common)
         pullop.rheads = set(pullop.rheads) - pullop.common
 
 
 def add_confirm_callback(repo, pullop):
     """ adds a finalize callback to transaction which can be used to show stats
     to user and confirm the pull before committing transaction """
 
     tr = pullop.trmanager.transaction()
     scmutil.registersummarycallback(
         repo, tr, txnname=b'pull', as_validator=True
     )
     reporef = weakref.ref(repo.unfiltered())
 
     def prompt(tr):
         repo = reporef()
         cm = _(b'accept incoming changes (yn)?$$ &Yes $$ &No')
         if repo.ui.promptchoice(cm):
             raise error.Abort("user aborted")
 
     tr.addvalidator(b'900-pull-prompt', prompt)
 
 
 def pull(
     repo,
     remote,
     heads=None,
     force=False,
     bookmarks=(),
     opargs=None,
     streamclonerequested=None,
     includepats=None,
     excludepats=None,
     depth=None,
     confirm=None,
 ):
     """Fetch repository data from a remote.
 
     This is the main function used to retrieve data from a remote repository.
 
     ``repo`` is the local repository to clone into.
     ``remote`` is a peer instance.
     ``heads`` is an iterable of revisions we want to pull. ``None`` (the
     default) means to pull everything from the remote.
     ``bookmarks`` is an iterable of bookmarks requesting to be pulled. By
     default, all remote bookmarks are pulled.
     ``opargs`` are additional keyword arguments to pass to ``pulloperation``
     initialization.
     ``streamclonerequested`` is a boolean indicating whether a "streaming
     clone" is requested. A "streaming clone" is essentially a raw file copy
     of revlogs from the server. This only works when the local repository is
     empty. The default value of ``None`` means to respect the server
     configuration for preferring stream clones.
     ``includepats`` and ``excludepats`` define explicit file patterns to
     include and exclude in storage, respectively. If not defined, narrow
     patterns from the repo instance are used, if available.
     ``depth`` is an integer indicating the DAG depth of history we're
     interested in. If defined, for each revision specified in ``heads``, we
     will fetch up to this many of its ancestors and data associated with them.
     ``confirm`` is a boolean indicating whether the pull should be confirmed
     before committing the transaction. This overrides HGPLAIN.
 
     Returns the ``pulloperation`` created for this pull.
     """
     if opargs is None:
         opargs = {}
 
     # We allow the narrow patterns to be passed in explicitly to provide more
     # flexibility for API consumers.
     if includepats or excludepats:
         includepats = includepats or set()
         excludepats = excludepats or set()
     else:
         includepats, excludepats = repo.narrowpats
 
     narrowspec.validatepatterns(includepats)
     narrowspec.validatepatterns(excludepats)
 
     pullop = pulloperation(
         repo,
         remote,
         heads,
         force,
         bookmarks=bookmarks,
         streamclonerequested=streamclonerequested,
         includepats=includepats,
         excludepats=excludepats,
         depth=depth,
         **pycompat.strkwargs(opargs)
     )
 
     peerlocal = pullop.remote.local()
     if peerlocal:
         missing = set(peerlocal.requirements) - pullop.repo.supported
         if missing:
             msg = _(
                 b"required features are not"
                 b" supported in the destination:"
                 b" %s"
             ) % (b', '.join(sorted(missing)))
             raise error.Abort(msg)
 
     pullop.trmanager = transactionmanager(repo, b'pull', remote.url())
     wlock = util.nullcontextmanager()
     if not bookmod.bookmarksinstore(repo):
         wlock = repo.wlock()
     with wlock, repo.lock(), pullop.trmanager:
         if confirm or (
             repo.ui.configbool(b"pull", b"confirm") and not repo.ui.plain()
         ):
             add_confirm_callback(repo, pullop)
 
         # Use the modern wire protocol, if available.
         if remote.capable(b'command-changesetdata'):
             exchangev2.pull(pullop)
         else:
             # This should ideally be in _pullbundle2(). However, it needs to run
             # before discovery to avoid extra work.
             _maybeapplyclonebundle(pullop)
             streamclone.maybeperformlegacystreamclone(pullop)
             _pulldiscovery(pullop)
             if pullop.canusebundle2:
                 _fullpullbundle2(repo, pullop)
             _pullchangeset(pullop)
             _pullphase(pullop)
             _pullbookmarks(pullop)
             _pullobsolete(pullop)
 
     # storing remotenames
     if repo.ui.configbool(b'experimental', b'remotenames'):
         logexchange.pullremotenames(repo, remote)
 
     return pullop
 
 
 # list of steps to perform discovery before pull
 pulldiscoveryorder = []
 
 # Mapping between step name and function
 #
 # This exists to help extensions wrap steps if necessary
 pulldiscoverymapping = {}
 
 
 def pulldiscovery(stepname):
     """decorator for function performing discovery before pull
 
     The function is added to the step -> function mapping and appended to the
     list of steps.  Beware that decorated function will be added in order (this
     may matter).
 
     You can only use this decorator for a new step, if you want to wrap a step
     from an extension, change the pulldiscovery dictionary directly."""
 
     def dec(func):
         assert stepname not in pulldiscoverymapping
         pulldiscoverymapping[stepname] = func
         pulldiscoveryorder.append(stepname)
         return func
 
     return dec
 
 
 def _pulldiscovery(pullop):
     """Run all discovery steps"""
     for stepname in pulldiscoveryorder:
         step = pulldiscoverymapping[stepname]
         step(pullop)
 
 
 @pulldiscovery(b'b1:bookmarks')
 def _pullbookmarkbundle1(pullop):
     """fetch bookmark data in bundle1 case
 
     If not using bundle2, we have to fetch bookmarks before changeset
     discovery to reduce the chance and impact of race conditions."""
     if pullop.remotebookmarks is not None:
         return
     if pullop.canusebundle2 and b'listkeys' in pullop.remotebundle2caps:
         # all known bundle2 servers now support listkeys, but lets be nice with
         # new implementation.
         return
     books = listkeys(pullop.remote, b'bookmarks')
     pullop.remotebookmarks = bookmod.unhexlifybookmarks(books)
 
 
 @pulldiscovery(b'changegroup')
 def _pulldiscoverychangegroup(pullop):
     """discovery phase for the pull
 
     Current handle changeset discovery only, will change handle all discovery
     at some point."""
     tmp = discovery.findcommonincoming(
         pullop.repo, pullop.remote, heads=pullop.heads, force=pullop.force
     )
     common, fetch, rheads = tmp
     has_node = pullop.repo.unfiltered().changelog.index.has_node
     if fetch and rheads:
         # If a remote heads is filtered locally, put in back in common.
         #
         # This is a hackish solution to catch most of "common but locally
         # hidden situation".  We do not performs discovery on unfiltered
         # repository because it end up doing a pathological amount of round
         # trip for w huge amount of changeset we do not care about.
         #
         # If a set of such "common but filtered" changeset exist on the server
         # but are not including a remote heads, we'll not be able to detect it,
         scommon = set(common)
         for n in rheads:
             if has_node(n):
                 if n not in scommon:
                     common.append(n)
         if set(rheads).issubset(set(common)):
             fetch = []
     pullop.common = common
     pullop.fetch = fetch
     pullop.rheads = rheads
 
 
 def _pullbundle2(pullop):
     """pull data using bundle2
 
     For now, the only supported data are changegroup."""
     kwargs = {b'bundlecaps': caps20to10(pullop.repo, role=b'client')}
 
     # make ui easier to access
     ui = pullop.repo.ui
 
     # At the moment we don't do stream clones over bundle2. If that is
     # implemented then here's where the check for that will go.
     streaming = streamclone.canperformstreamclone(pullop, bundle2=True)[0]
 
     # declare pull perimeters
     kwargs[b'common'] = pullop.common
     kwargs[b'heads'] = pullop.heads or pullop.rheads
 
     # check server supports narrow and then adding includepats and excludepats
     servernarrow = pullop.remote.capable(wireprototypes.NARROWCAP)
     if servernarrow and pullop.includepats:
         kwargs[b'includepats'] = pullop.includepats
     if servernarrow and pullop.excludepats:
         kwargs[b'excludepats'] = pullop.excludepats
 
     if streaming:
         kwargs[b'cg'] = False
         kwargs[b'stream'] = True
         pullop.stepsdone.add(b'changegroup')
         pullop.stepsdone.add(b'phases')
 
     else:
         # pulling changegroup
         pullop.stepsdone.add(b'changegroup')
 
         kwargs[b'cg'] = pullop.fetch
 
         legacyphase = b'phases' in ui.configlist(b'devel', b'legacy.exchange')
         hasbinaryphase = b'heads' in pullop.remotebundle2caps.get(b'phases', ())
         if not legacyphase and hasbinaryphase:
             kwargs[b'phases'] = True
             pullop.stepsdone.add(b'phases')
 
         if b'listkeys' in pullop.remotebundle2caps:
             if b'phases' not in pullop.stepsdone:
                 kwargs[b'listkeys'] = [b'phases']
 
     bookmarksrequested = False
     legacybookmark = b'bookmarks' in ui.configlist(b'devel', b'legacy.exchange')
     hasbinarybook = b'bookmarks' in pullop.remotebundle2caps
 
     if pullop.remotebookmarks is not None:
         pullop.stepsdone.add(b'request-bookmarks')
 
     if (
         b'request-bookmarks' not in pullop.stepsdone
         and pullop.remotebookmarks is None
         and not legacybookmark
         and hasbinarybook
     ):
         kwargs[b'bookmarks'] = True
         bookmarksrequested = True
 
     if b'listkeys' in pullop.remotebundle2caps:
         if b'request-bookmarks' not in pullop.stepsdone:
             # make sure to always includes bookmark data when migrating
             # `hg incoming --bundle` to using this function.
             pullop.stepsdone.add(b'request-bookmarks')
             kwargs.setdefault(b'listkeys', []).append(b'bookmarks')
 
     # If this is a full pull / clone and the server supports the clone bundles
     # feature, tell the server whether we attempted a clone bundle. The
     # presence of this flag indicates the client supports clone bundles. This
     # will enable the server to treat clients that support clone bundles
     # differently from those that don't.
     if (
         pullop.remote.capable(b'clonebundles')
         and pullop.heads is None
         and list(pullop.common) == [nullid]
     ):
         kwargs[b'cbattempted'] = pullop.clonebundleattempted
 
     if streaming:
         pullop.repo.ui.status(_(b'streaming all changes\n'))
     elif not pullop.fetch:
         pullop.repo.ui.status(_(b"no changes found\n"))
         pullop.cgresult = 0
     else:
         if pullop.heads is None and list(pullop.common) == [nullid]:
             pullop.repo.ui.status(_(b"requesting all changes\n"))
     if obsolete.isenabled(pullop.repo, obsolete.exchangeopt):
         remoteversions = bundle2.obsmarkersversion(pullop.remotebundle2caps)
         if obsolete.commonversion(remoteversions) is not None:
             kwargs[b'obsmarkers'] = True
             pullop.stepsdone.add(b'obsmarkers')
     _pullbundle2extraprepare(pullop, kwargs)
 
     with pullop.remote.commandexecutor() as e:
         args = dict(kwargs)
         args[b'source'] = b'pull'
         bundle = e.callcommand(b'getbundle', args).result()
 
         try:
             op = bundle2.bundleoperation(
                 pullop.repo, pullop.gettransaction, source=b'pull'
             )
             op.modes[b'bookmarks'] = b'records'
             bundle2.processbundle(pullop.repo, bundle, op=op)
         except bundle2.AbortFromPart as exc:
             pullop.repo.ui.status(_(b'remote: abort: %s\n') % exc)
             raise error.Abort(_(b'pull failed on remote'), hint=exc.hint)
         except error.BundleValueError as exc:
             raise error.Abort(_(b'missing support for %s') % exc)
 
     if pullop.fetch:
         pullop.cgresult = bundle2.combinechangegroupresults(op)
 
     # processing phases change
     for namespace, value in op.records[b'listkeys']:
         if namespace == b'phases':
             _pullapplyphases(pullop, value)
 
     # processing bookmark update
     if bookmarksrequested:
         books = {}
         for record in op.records[b'bookmarks']:
             books[record[b'bookmark']] = record[b"node"]
         pullop.remotebookmarks = books
     else:
         for namespace, value in op.records[b'listkeys']:
             if namespace == b'bookmarks':
                 pullop.remotebookmarks = bookmod.unhexlifybookmarks(value)
 
     # bookmark data were either already there or pulled in the bundle
     if pullop.remotebookmarks is not None:
         _pullbookmarks(pullop)
 
 
 def _pullbundle2extraprepare(pullop, kwargs):
     """hook function so that extensions can extend the getbundle call"""
 
 
 def _pullchangeset(pullop):
     """pull changeset from unbundle into the local repo"""
     # We delay the open of the transaction as late as possible so we
     # don't open transaction for nothing or you break future useful
     # rollback call
     if b'changegroup' in pullop.stepsdone:
         return
     pullop.stepsdone.add(b'changegroup')
     if not pullop.fetch:
         pullop.repo.ui.status(_(b"no changes found\n"))
         pullop.cgresult = 0
         return
     tr = pullop.gettransaction()
     if pullop.heads is None and list(pullop.common) == [nullid]:
         pullop.repo.ui.status(_(b"requesting all changes\n"))
     elif pullop.heads is None and pullop.remote.capable(b'changegroupsubset'):
         # issue1320, avoid a race if remote changed after discovery
         pullop.heads = pullop.rheads
 
     if pullop.remote.capable(b'getbundle'):
         # TODO: get bundlecaps from remote
         cg = pullop.remote.getbundle(
             b'pull', common=pullop.common, heads=pullop.heads or pullop.rheads
         )
     elif pullop.heads is None:
         with pullop.remote.commandexecutor() as e:
             cg = e.callcommand(
                 b'changegroup', {b'nodes': pullop.fetch, b'source': b'pull',}
             ).result()
 
     elif not pullop.remote.capable(b'changegroupsubset'):
         raise error.Abort(
             _(
                 b"partial pull cannot be done because "
                 b"other repository doesn't support "
                 b"changegroupsubset."
             )
         )
     else:
         with pullop.remote.commandexecutor() as e:
             cg = e.callcommand(
                 b'changegroupsubset',
                 {
                     b'bases': pullop.fetch,
                     b'heads': pullop.heads,
                     b'source': b'pull',
                 },
             ).result()
 
     bundleop = bundle2.applybundle(
         pullop.repo, cg, tr, b'pull', pullop.remote.url()
     )
     pullop.cgresult = bundle2.combinechangegroupresults(bundleop)
 
 
 def _pullphase(pullop):
     # Get remote phases data from remote
     if b'phases' in pullop.stepsdone:
         return
     remotephases = listkeys(pullop.remote, b'phases')
     _pullapplyphases(pullop, remotephases)
 
 
 def _pullapplyphases(pullop, remotephases):
     """apply phase movement from observed remote state"""
     if b'phases' in pullop.stepsdone:
         return
     pullop.stepsdone.add(b'phases')
     publishing = bool(remotephases.get(b'publishing', False))
     if remotephases and not publishing:
         # remote is new and non-publishing
         pheads, _dr = phases.analyzeremotephases(
             pullop.repo, pullop.pulledsubset, remotephases
         )
         dheads = pullop.pulledsubset
     else:
         # Remote is old or publishing all common changesets
         # should be seen as public
         pheads = pullop.pulledsubset
         dheads = []
     unfi = pullop.repo.unfiltered()
     phase = unfi._phasecache.phase
     rev = unfi.changelog.index.get_rev
     public = phases.public
     draft = phases.draft
 
     # exclude changesets already public locally and update the others
     pheads = [pn for pn in pheads if phase(unfi, rev(pn)) > public]
     if pheads:
         tr = pullop.gettransaction()
         phases.advanceboundary(pullop.repo, tr, public, pheads)
 
     # exclude changesets already draft locally and update the others
     dheads = [pn for pn in dheads if phase(unfi, rev(pn)) > draft]
     if dheads:
         tr = pullop.gettransaction()
         phases.advanceboundary(pullop.repo, tr, draft, dheads)
 
 
 def _pullbookmarks(pullop):
     """process the remote bookmark information to update the local one"""
     if b'bookmarks' in pullop.stepsdone:
         return
     pullop.stepsdone.add(b'bookmarks')
     repo = pullop.repo
     remotebookmarks = pullop.remotebookmarks
     bookmod.updatefromremote(
         repo.ui,
         repo,
         remotebookmarks,
         pullop.remote.url(),
         pullop.gettransaction,
         explicit=pullop.explicitbookmarks,
     )
 
 
 def _pullobsolete(pullop):
     """utility function to pull obsolete markers from a remote
 
     The `gettransaction` is function that return the pull transaction, creating
     one if necessary. We return the transaction to inform the calling code that
     a new transaction have been created (when applicable).
 
     Exists mostly to allow overriding for experimentation purpose"""
     if b'obsmarkers' in pullop.stepsdone:
         return
     pullop.stepsdone.add(b'obsmarkers')
     tr = None
     if obsolete.isenabled(pullop.repo, obsolete.exchangeopt):
         pullop.repo.ui.debug(b'fetching remote obsolete markers\n')
         remoteobs = listkeys(pullop.remote, b'obsolete')
         if b'dump0' in remoteobs:
             tr = pullop.gettransaction()
             markers = []
             for key in sorted(remoteobs, reverse=True):
                 if key.startswith(b'dump'):
                     data = util.b85decode(remoteobs[key])
                     version, newmarks = obsolete._readmarkers(data)
                     markers += newmarks
             if markers:
                 pullop.repo.obsstore.add(tr, markers)
             pullop.repo.invalidatevolatilesets()
     return tr
 
 
 def applynarrowacl(repo, kwargs):
     """Apply narrow fetch access control.
 
     This massages the named arguments for getbundle wire protocol commands
     so requested data is filtered through access control rules.
     """
     ui = repo.ui
     # TODO this assumes existence of HTTP and is a layering violation.
     username = ui.shortuser(ui.environ.get(b'REMOTE_USER') or ui.username())
     user_includes = ui.configlist(
         _NARROWACL_SECTION,
         username + b'.includes',
         ui.configlist(_NARROWACL_SECTION, b'default.includes'),
     )
     user_excludes = ui.configlist(
         _NARROWACL_SECTION,
         username + b'.excludes',
         ui.configlist(_NARROWACL_SECTION, b'default.excludes'),
     )
     if not user_includes:
         raise error.Abort(
             _(b"%s configuration for user %s is empty")
             % (_NARROWACL_SECTION, username)
         )
 
     user_includes = [
         b'path:.' if p == b'*' else b'path:' + p for p in user_includes
     ]
     user_excludes = [
         b'path:.' if p == b'*' else b'path:' + p for p in user_excludes
     ]
 
     req_includes = set(kwargs.get('includepats', []))
     req_excludes = set(kwargs.get('excludepats', []))
 
     req_includes, req_excludes, invalid_includes = narrowspec.restrictpatterns(
         req_includes, req_excludes, user_includes, user_excludes
     )
 
     if invalid_includes:
         raise error.Abort(
             _(b"The following includes are not accessible for %s: %s")
             % (username, stringutil.pprint(invalid_includes))
         )
 
     new_args = {}
     new_args.update(kwargs)
     new_args['narrow'] = True
     new_args['narrow_acl'] = True
     new_args['includepats'] = req_includes
     if req_excludes:
         new_args['excludepats'] = req_excludes
 
     return new_args
 
 
 def _computeellipsis(repo, common, heads, known, match, depth=None):
     """Compute the shape of a narrowed DAG.
 
     Args:
       repo: The repository we're transferring.
       common: The roots of the DAG range we're transferring.
               May be just [nullid], which means all ancestors of heads.
       heads: The heads of the DAG range we're transferring.
       match: The narrowmatcher that allows us to identify relevant changes.
       depth: If not None, only consider nodes to be full nodes if they are at
              most depth changesets away from one of heads.
 
     Returns:
       A tuple of (visitnodes, relevant_nodes, ellipsisroots) where:
 
         visitnodes: The list of nodes (either full or ellipsis) which
                     need to be sent to the client.
         relevant_nodes: The set of changelog nodes which change a file inside
                  the narrowspec. The client needs these as non-ellipsis nodes.
         ellipsisroots: A dict of {rev: parents} that is used in
                        narrowchangegroup to produce ellipsis nodes with the
                        correct parents.
     """
     cl = repo.changelog
     mfl = repo.manifestlog
 
     clrev = cl.rev
 
     commonrevs = {clrev(n) for n in common} | {nullrev}
     headsrevs = {clrev(n) for n in heads}
 
     if depth:
         revdepth = {h: 0 for h in headsrevs}
 
     ellipsisheads = collections.defaultdict(set)
     ellipsisroots = collections.defaultdict(set)
 
     def addroot(head, curchange):
         """Add a root to an ellipsis head, splitting heads with 3 roots."""
         ellipsisroots[head].add(curchange)
         # Recursively split ellipsis heads with 3 roots by finding the
         # roots' youngest common descendant which is an elided merge commit.
         # That descendant takes 2 of the 3 roots as its own, and becomes a
         # root of the head.
         while len(ellipsisroots[head]) > 2:
             child, roots = splithead(head)
             splitroots(head, child, roots)
             head = child  # Recurse in case we just added a 3rd root
 
     def splitroots(head, child, roots):
         ellipsisroots[head].difference_update(roots)
         ellipsisroots[head].add(child)
         ellipsisroots[child].update(roots)
         ellipsisroots[child].discard(child)
 
     def splithead(head):
         r1, r2, r3 = sorted(ellipsisroots[head])
         for nr1, nr2 in ((r2, r3), (r1, r3), (r1, r2)):
             mid = repo.revs(
                 b'sort(merge() & %d::%d & %d::%d, -rev)', nr1, head, nr2, head
             )
             for j in mid:
                 if j == nr2:
                     return nr2, (nr1, nr2)
                 if j not in ellipsisroots or len(ellipsisroots[j]) < 2:
                     return j, (nr1, nr2)
         raise error.Abort(
             _(
                 b'Failed to split up ellipsis node! head: %d, '
                 b'roots: %d %d %d'
             )
             % (head, r1, r2, r3)
         )
 
     missing = list(cl.findmissingrevs(common=commonrevs, heads=headsrevs))
     visit = reversed(missing)
     relevant_nodes = set()
     visitnodes = [cl.node(m) for m in missing]
     required = set(headsrevs) | known
     for rev in visit:
         clrev = cl.changelogrevision(rev)
         ps = [prev for prev in cl.parentrevs(rev) if prev != nullrev]
         if depth is not None:
             curdepth = revdepth[rev]
             for p in ps:
                 revdepth[p] = min(curdepth + 1, revdepth.get(p, depth + 1))
         needed = False
         shallow_enough = depth is None or revdepth[rev] <= depth
         if shallow_enough:
             curmf = mfl[clrev.manifest].read()
             if ps:
                 # We choose to not trust the changed files list in
                 # changesets because it's not always correct. TODO: could
                 # we trust it for the non-merge case?
                 p1mf = mfl[cl.changelogrevision(ps[0]).manifest].read()
                 needed = bool(curmf.diff(p1mf, match))
                 if not needed and len(ps) > 1:
                     # For merge changes, the list of changed files is not
                     # helpful, since we need to emit the merge if a file
                     # in the narrow spec has changed on either side of the
                     # merge. As a result, we do a manifest diff to check.
                     p2mf = mfl[cl.changelogrevision(ps[1]).manifest].read()
                     needed = bool(curmf.diff(p2mf, match))
             else:
                 # For a root node, we need to include the node if any
                 # files in the node match the narrowspec.
                 needed = any(curmf.walk(match))
 
         if needed:
             for head in ellipsisheads[rev]:
                 addroot(head, rev)
             for p in ps:
                 required.add(p)
             relevant_nodes.add(cl.node(rev))
         else:
             if not ps:
                 ps = [nullrev]
             if rev in required:
                 for head in ellipsisheads[rev]:
                     addroot(head, rev)
                 for p in ps:
                     ellipsisheads[p].add(rev)
             else:
                 for p in ps:
                     ellipsisheads[p] |= ellipsisheads[rev]
 
     # add common changesets as roots of their reachable ellipsis heads
     for c in commonrevs:
         for head in ellipsisheads[c]:
             addroot(head, c)
     return visitnodes, relevant_nodes, ellipsisroots
 
 
 def caps20to10(repo, role):
     """return a set with appropriate options to use bundle20 during getbundle"""
     caps = {b'HG20'}
     capsblob = bundle2.encodecaps(bundle2.getrepocaps(repo, role=role))
     caps.add(b'bundle2=' + urlreq.quote(capsblob))
     return caps
 
 
 # List of names of steps to perform for a bundle2 for getbundle, order matters.
 getbundle2partsorder = []
 
 # Mapping between step name and function
 #
 # This exists to help extensions wrap steps if necessary
 getbundle2partsmapping = {}
 
 
 def getbundle2partsgenerator(stepname, idx=None):
     """decorator for function generating bundle2 part for getbundle
 
     The function is added to the step -> function mapping and appended to the
     list of steps.  Beware that decorated functions will be added in order
     (this may matter).
 
     You can only use this decorator for new steps, if you want to wrap a step
     from an extension, attack the getbundle2partsmapping dictionary directly."""
 
     def dec(func):
         assert stepname not in getbundle2partsmapping
         getbundle2partsmapping[stepname] = func
         if idx is None:
             getbundle2partsorder.append(stepname)
         else:
             getbundle2partsorder.insert(idx, stepname)
         return func
 
     return dec
 
 
 def bundle2requested(bundlecaps):
     if bundlecaps is not None:
         return any(cap.startswith(b'HG2') for cap in bundlecaps)
     return False
 
 
 def getbundlechunks(
     repo, source, heads=None, common=None, bundlecaps=None, **kwargs
 ):
     """Return chunks constituting a bundle's raw data.
 
     Could be a bundle HG10 or a bundle HG20 depending on bundlecaps
     passed.
 
     Returns a 2-tuple of a dict with metadata about the generated bundle
     and an iterator over raw chunks (of varying sizes).
     """
     kwargs = pycompat.byteskwargs(kwargs)
     info = {}
     usebundle2 = bundle2requested(bundlecaps)
     # bundle10 case
     if not usebundle2:
         if bundlecaps and not kwargs.get(b'cg', True):
             raise ValueError(
                 _(b'request for bundle10 must include changegroup')
             )
 
         if kwargs:
             raise ValueError(
                 _(b'unsupported getbundle arguments: %s')
                 % b', '.join(sorted(kwargs.keys()))
             )
         outgoing = _computeoutgoing(repo, heads, common)
         info[b'bundleversion'] = 1
         return (
             info,
             changegroup.makestream(
                 repo, outgoing, b'01', source, bundlecaps=bundlecaps
             ),
         )
 
     # bundle20 case
     info[b'bundleversion'] = 2
     b2caps = {}
     for bcaps in bundlecaps:
         if bcaps.startswith(b'bundle2='):
             blob = urlreq.unquote(bcaps[len(b'bundle2=') :])
             b2caps.update(bundle2.decodecaps(blob))
     bundler = bundle2.bundle20(repo.ui, b2caps)
 
     kwargs[b'heads'] = heads
     kwargs[b'common'] = common
 
     for name in getbundle2partsorder:
         func = getbundle2partsmapping[name]
         func(
             bundler,
             repo,
             source,
             bundlecaps=bundlecaps,
             b2caps=b2caps,
             **pycompat.strkwargs(kwargs)
         )
 
     info[b'prefercompressed'] = bundler.prefercompressed
 
     return info, bundler.getchunks()
 
 
 @getbundle2partsgenerator(b'stream2')
 def _getbundlestream2(bundler, repo, *args, **kwargs):
     return bundle2.addpartbundlestream2(bundler, repo, **kwargs)
 
 
 @getbundle2partsgenerator(b'changegroup')
 def _getbundlechangegrouppart(
     bundler,
     repo,
     source,
     bundlecaps=None,
     b2caps=None,
     heads=None,
     common=None,
     **kwargs
 ):
     """add a changegroup part to the requested bundle"""
     if not kwargs.get('cg', True) or not b2caps:
         return
 
     version = b'01'
     cgversions = b2caps.get(b'changegroup')
     if cgversions:  # 3.1 and 3.2 ship with an empty value
         cgversions = [
             v
             for v in cgversions
             if v in changegroup.supportedoutgoingversions(repo)
         ]
         if not cgversions:
             raise error.Abort(_(b'no common changegroup version'))
         version = max(cgversions)
 
     outgoing = _computeoutgoing(repo, heads, common)
     if not outgoing.missing:
         return
 
     if kwargs.get('narrow', False):
         include = sorted(filter(bool, kwargs.get('includepats', [])))
         exclude = sorted(filter(bool, kwargs.get('excludepats', [])))
         matcher = narrowspec.match(repo.root, include=include, exclude=exclude)
     else:
         matcher = None
 
     cgstream = changegroup.makestream(
         repo, outgoing, version, source, bundlecaps=bundlecaps, matcher=matcher
     )
 
     part = bundler.newpart(b'changegroup', data=cgstream)
     if cgversions:
         part.addparam(b'version', version)
 
     part.addparam(b'nbchanges', b'%d' % len(outgoing.missing), mandatory=False)
 
-    if repository.TREEMANIFEST_REQUIREMENT in repo.requirements:
+    if requirements.TREEMANIFEST_REQUIREMENT in repo.requirements:
         part.addparam(b'treemanifest', b'1')
 
     if b'exp-sidedata-flag' in repo.requirements:
         part.addparam(b'exp-sidedata', b'1')
 
     if (
         kwargs.get('narrow', False)
         and kwargs.get('narrow_acl', False)
         and (include or exclude)
     ):
         # this is mandatory because otherwise ACL clients won't work
         narrowspecpart = bundler.newpart(b'Narrow:responsespec')
         narrowspecpart.data = b'%s\0%s' % (
             b'\n'.join(include),
             b'\n'.join(exclude),
         )
 
 
 @getbundle2partsgenerator(b'bookmarks')
 def _getbundlebookmarkpart(
     bundler, repo, source, bundlecaps=None, b2caps=None, **kwargs
 ):
     """add a bookmark part to the requested bundle"""
     if not kwargs.get('bookmarks', False):
         return
     if not b2caps or b'bookmarks' not in b2caps:
         raise error.Abort(_(b'no common bookmarks exchange method'))
     books = bookmod.listbinbookmarks(repo)
     data = bookmod.binaryencode(books)
     if data:
         bundler.newpart(b'bookmarks', data=data)
 
 
 @getbundle2partsgenerator(b'listkeys')
 def _getbundlelistkeysparts(
     bundler, repo, source, bundlecaps=None, b2caps=None, **kwargs
 ):
     """add parts containing listkeys namespaces to the requested bundle"""
     listkeys = kwargs.get('listkeys', ())
     for namespace in listkeys:
         part = bundler.newpart(b'listkeys')
         part.addparam(b'namespace', namespace)
         keys = repo.listkeys(namespace).items()
         part.data = pushkey.encodekeys(keys)
 
 
 @getbundle2partsgenerator(b'obsmarkers')
 def _getbundleobsmarkerpart(
     bundler, repo, source, bundlecaps=None, b2caps=None, heads=None, **kwargs
 ):
     """add an obsolescence markers part to the requested bundle"""
     if kwargs.get('obsmarkers', False):
         if heads is None:
             heads = repo.heads()
         subset = [c.node() for c in repo.set(b'::%ln', heads)]
         markers = repo.obsstore.relevantmarkers(subset)
         markers = obsutil.sortedmarkers(markers)
         bundle2.buildobsmarkerspart(bundler, markers)
 
 
 @getbundle2partsgenerator(b'phases')
 def _getbundlephasespart(
     bundler, repo, source, bundlecaps=None, b2caps=None, heads=None, **kwargs
 ):
     """add phase heads part to the requested bundle"""
     if kwargs.get('phases', False):
         if not b2caps or b'heads' not in b2caps.get(b'phases'):
             raise error.Abort(_(b'no common phases exchange method'))
         if heads is None:
             heads = repo.heads()
 
         headsbyphase = collections.defaultdict(set)
         if repo.publishing():
             headsbyphase[phases.public] = heads
         else:
             # find the appropriate heads to move
 
             phase = repo._phasecache.phase
             node = repo.changelog.node
             rev = repo.changelog.rev
             for h in heads:
                 headsbyphase[phase(repo, rev(h))].add(h)
             seenphases = list(headsbyphase.keys())
 
             # We do not handle anything but public and draft phase for now)
             if seenphases:
                 assert max(seenphases) <= phases.draft
 
             # if client is pulling non-public changesets, we need to find
             # intermediate public heads.
             draftheads = headsbyphase.get(phases.draft, set())
             if draftheads:
                 publicheads = headsbyphase.get(phases.public, set())
 
                 revset = b'heads(only(%ln, %ln) and public())'
                 extraheads = repo.revs(revset, draftheads, publicheads)
                 for r in extraheads:
                     headsbyphase[phases.public].add(node(r))
 
         # transform data in a format used by the encoding function
         phasemapping = {
             phase: sorted(headsbyphase[phase]) for phase in phases.allphases
         }
 
         # generate the actual part
         phasedata = phases.binaryencode(phasemapping)
         bundler.newpart(b'phase-heads', data=phasedata)
 
 
 @getbundle2partsgenerator(b'hgtagsfnodes')
 def _getbundletagsfnodes(
     bundler,
     repo,
     source,
     bundlecaps=None,
     b2caps=None,
     heads=None,
     common=None,
     **kwargs
 ):
     """Transfer the .hgtags filenodes mapping.
 
     Only values for heads in this bundle will be transferred.
 
     The part data consists of pairs of 20 byte changeset node and .hgtags
     filenodes raw values.
     """
     # Don't send unless:
     # - changeset are being exchanged,
     # - the client supports it.
     if not b2caps or not (kwargs.get('cg', True) and b'hgtagsfnodes' in b2caps):
         return
 
     outgoing = _computeoutgoing(repo, heads, common)
     bundle2.addparttagsfnodescache(repo, bundler, outgoing)
 
 
 @getbundle2partsgenerator(b'cache:rev-branch-cache')
 def _getbundlerevbranchcache(
     bundler,
     repo,
     source,
     bundlecaps=None,
     b2caps=None,
     heads=None,
     common=None,
     **kwargs
 ):
     """Transfer the rev-branch-cache mapping
 
     The payload is a series of data related to each branch
 
     1) branch name length
     2) number of open heads
     3) number of closed heads
     4) open heads nodes
     5) closed heads nodes
     """
     # Don't send unless:
     # - changeset are being exchanged,
     # - the client supports it.
     # - narrow bundle isn't in play (not currently compatible).
     if (
         not kwargs.get('cg', True)
         or not b2caps
         or b'rev-branch-cache' not in b2caps
         or kwargs.get('narrow', False)
         or repo.ui.has_section(_NARROWACL_SECTION)
     ):
         return
 
     outgoing = _computeoutgoing(repo, heads, common)
     bundle2.addpartrevbranchcache(repo, bundler, outgoing)
 
 
 def check_heads(repo, their_heads, context):
     """check if the heads of a repo have been modified
 
     Used by peer for unbundling.
     """
     heads = repo.heads()
     heads_hash = hashutil.sha1(b''.join(sorted(heads))).digest()
     if not (
         their_heads == [b'force']
         or their_heads == heads
         or their_heads == [b'hashed', heads_hash]
     ):
         # someone else committed/pushed/unbundled while we
         # were transferring data
         raise error.PushRaced(
             b'repository changed while %s - please try again' % context
         )
 
 
 def unbundle(repo, cg, heads, source, url):
     """Apply a bundle to a repo.
 
     this function makes sure the repo is locked during the application and have
     mechanism to check that no push race occurred between the creation of the
     bundle and its application.
 
     If the push was raced as PushRaced exception is raised."""
     r = 0
     # need a transaction when processing a bundle2 stream
     # [wlock, lock, tr] - needs to be an array so nested functions can modify it
     lockandtr = [None, None, None]
     recordout = None
     # quick fix for output mismatch with bundle2 in 3.4
     captureoutput = repo.ui.configbool(
         b'experimental', b'bundle2-output-capture'
     )
     if url.startswith(b'remote:http:') or url.startswith(b'remote:https:'):
         captureoutput = True
     try:
         # note: outside bundle1, 'heads' is expected to be empty and this
         # 'check_heads' call wil be a no-op
         check_heads(repo, heads, b'uploading changes')
         # push can proceed
         if not isinstance(cg, bundle2.unbundle20):
             # legacy case: bundle1 (changegroup 01)
             txnname = b"\n".join([source, util.hidepassword(url)])
             with repo.lock(), repo.transaction(txnname) as tr:
                 op = bundle2.applybundle(repo, cg, tr, source, url)
                 r = bundle2.combinechangegroupresults(op)
         else:
             r = None
             try:
 
                 def gettransaction():
                     if not lockandtr[2]:
                         if not bookmod.bookmarksinstore(repo):
                             lockandtr[0] = repo.wlock()
                         lockandtr[1] = repo.lock()
                         lockandtr[2] = repo.transaction(source)
                         lockandtr[2].hookargs[b'source'] = source
                         lockandtr[2].hookargs[b'url'] = url
                         lockandtr[2].hookargs[b'bundle2'] = b'1'
                     return lockandtr[2]
 
                 # Do greedy locking by default until we're satisfied with lazy
                 # locking.
                 if not repo.ui.configbool(
                     b'experimental', b'bundle2lazylocking'
                 ):
                     gettransaction()
 
                 op = bundle2.bundleoperation(
                     repo,
                     gettransaction,
                     captureoutput=captureoutput,
                     source=b'push',
                 )
                 try:
                     op = bundle2.processbundle(repo, cg, op=op)
                 finally:
                     r = op.reply
                     if captureoutput and r is not None:
                         repo.ui.pushbuffer(error=True, subproc=True)
 
                         def recordout(output):
                             r.newpart(b'output', data=output, mandatory=False)
 
                 if lockandtr[2] is not None:
                     lockandtr[2].close()
             except BaseException as exc:
                 exc.duringunbundle2 = True
                 if captureoutput and r is not None:
                     parts = exc._bundle2salvagedoutput = r.salvageoutput()
 
                     def recordout(output):
                         part = bundle2.bundlepart(
                             b'output', data=output, mandatory=False
                         )
                         parts.append(part)
 
                 raise
     finally:
         lockmod.release(lockandtr[2], lockandtr[1], lockandtr[0])
         if recordout is not None:
             recordout(repo.ui.popbuffer())
     return r
 
 
 def _maybeapplyclonebundle(pullop):
     """Apply a clone bundle from a remote, if possible."""
 
     repo = pullop.repo
     remote = pullop.remote
 
     if not repo.ui.configbool(b'ui', b'clonebundles'):
         return
 
     # Only run if local repo is empty.
     if len(repo):
         return
 
     if pullop.heads:
         return
 
     if not remote.capable(b'clonebundles'):
         return
 
     with remote.commandexecutor() as e:
         res = e.callcommand(b'clonebundles', {}).result()
 
     # If we call the wire protocol command, that's good enough to record the
     # attempt.
     pullop.clonebundleattempted = True
 
     entries = parseclonebundlesmanifest(repo, res)
     if not entries:
         repo.ui.note(
             _(
                 b'no clone bundles available on remote; '
                 b'falling back to regular clone\n'
             )
         )
         return
 
     entries = filterclonebundleentries(
         repo, entries, streamclonerequested=pullop.streamclonerequested
     )
 
     if not entries:
         # There is a thundering herd concern here. However, if a server
         # operator doesn't advertise bundles appropriate for its clients,
         # they deserve what's coming. Furthermore, from a client's
         # perspective, no automatic fallback would mean not being able to
         # clone!
         repo.ui.warn(
             _(
                 b'no compatible clone bundles available on server; '
                 b'falling back to regular clone\n'
             )
         )
         repo.ui.warn(
             _(b'(you may want to report this to the server operator)\n')
         )
         return
 
     entries = sortclonebundleentries(repo.ui, entries)
 
     url = entries[0][b'URL']
     repo.ui.status(_(b'applying clone bundle from %s\n') % url)
     if trypullbundlefromurl(repo.ui, repo, url):
         repo.ui.status(_(b'finished applying clone bundle\n'))
     # Bundle failed.
     #
     # We abort by default to avoid the thundering herd of
     # clients flooding a server that was expecting expensive
     # clone load to be offloaded.
     elif repo.ui.configbool(b'ui', b'clonebundlefallback'):
         repo.ui.warn(_(b'falling back to normal clone\n'))
     else:
         raise error.Abort(
             _(b'error applying bundle'),
             hint=_(
                 b'if this error persists, consider contacting '
                 b'the server operator or disable clone '
                 b'bundles via '
                 b'"--config ui.clonebundles=false"'
             ),
         )
 
 
 def parseclonebundlesmanifest(repo, s):
     """Parses the raw text of a clone bundles manifest.
 
     Returns a list of dicts. The dicts have a ``URL`` key corresponding
     to the URL and other keys are the attributes for the entry.
     """
     m = []
     for line in s.splitlines():
         fields = line.split()
         if not fields:
             continue
         attrs = {b'URL': fields[0]}
         for rawattr in fields[1:]:
             key, value = rawattr.split(b'=', 1)
             key = urlreq.unquote(key)
             value = urlreq.unquote(value)
             attrs[key] = value
 
             # Parse BUNDLESPEC into components. This makes client-side
             # preferences easier to specify since you can prefer a single
             # component of the BUNDLESPEC.
             if key == b'BUNDLESPEC':
                 try:
                     bundlespec = parsebundlespec(repo, value)
                     attrs[b'COMPRESSION'] = bundlespec.compression
                     attrs[b'VERSION'] = bundlespec.version
                 except error.InvalidBundleSpecification:
                     pass
                 except error.UnsupportedBundleSpecification:
                     pass
 
         m.append(attrs)
 
     return m
 
 
 def isstreamclonespec(bundlespec):
     # Stream clone v1
     if bundlespec.wirecompression == b'UN' and bundlespec.wireversion == b's1':
         return True
 
     # Stream clone v2
     if (
         bundlespec.wirecompression == b'UN'
         and bundlespec.wireversion == b'02'
         and bundlespec.contentopts.get(b'streamv2')
     ):
         return True
 
     return False
 
 
 def filterclonebundleentries(repo, entries, streamclonerequested=False):
     """Remove incompatible clone bundle manifest entries.
 
     Accepts a list of entries parsed with ``parseclonebundlesmanifest``
     and returns a new list consisting of only the entries that this client
     should be able to apply.
 
     There is no guarantee we'll be able to apply all returned entries because
     the metadata we use to filter on may be missing or wrong.
     """
     newentries = []
     for entry in entries:
         spec = entry.get(b'BUNDLESPEC')
         if spec:
             try:
                 bundlespec = parsebundlespec(repo, spec, strict=True)
 
                 # If a stream clone was requested, filter out non-streamclone
                 # entries.
                 if streamclonerequested and not isstreamclonespec(bundlespec):
                     repo.ui.debug(
                         b'filtering %s because not a stream clone\n'
                         % entry[b'URL']
                     )
                     continue
 
             except error.InvalidBundleSpecification as e:
                 repo.ui.debug(stringutil.forcebytestr(e) + b'\n')
                 continue
             except error.UnsupportedBundleSpecification as e:
                 repo.ui.debug(
                     b'filtering %s because unsupported bundle '
                     b'spec: %s\n' % (entry[b'URL'], stringutil.forcebytestr(e))
                 )
                 continue
         # If we don't have a spec and requested a stream clone, we don't know
         # what the entry is so don't attempt to apply it.
         elif streamclonerequested:
             repo.ui.debug(
                 b'filtering %s because cannot determine if a stream '
                 b'clone bundle\n' % entry[b'URL']
             )
             continue
 
         if b'REQUIRESNI' in entry and not sslutil.hassni:
             repo.ui.debug(
                 b'filtering %s because SNI not supported\n' % entry[b'URL']
             )
             continue
 
         if b'REQUIREDRAM' in entry:
             try:
                 requiredram = util.sizetoint(entry[b'REQUIREDRAM'])
             except error.ParseError:
                 repo.ui.debug(
                     b'filtering %s due to a bad REQUIREDRAM attribute\n'
                     % entry[b'URL']
                 )
                 continue
             actualram = repo.ui.estimatememory()
             if actualram is not None and actualram * 0.66 < requiredram:
                 repo.ui.debug(
                     b'filtering %s as it needs more than 2/3 of system memory\n'
                     % entry[b'URL']
                 )
                 continue
 
         newentries.append(entry)
 
     return newentries
 
 
 class clonebundleentry(object):
     """Represents an item in a clone bundles manifest.
 
     This rich class is needed to support sorting since sorted() in Python 3
     doesn't support ``cmp`` and our comparison is complex enough that ``key=``
     won't work.
     """
 
     def __init__(self, value, prefers):
         self.value = value
         self.prefers = prefers
 
     def _cmp(self, other):
         for prefkey, prefvalue in self.prefers:
             avalue = self.value.get(prefkey)
             bvalue = other.value.get(prefkey)
 
             # Special case for b missing attribute and a matches exactly.
             if avalue is not None and bvalue is None and avalue == prefvalue:
                 return -1
 
             # Special case for a missing attribute and b matches exactly.
             if bvalue is not None and avalue is None and bvalue == prefvalue:
                 return 1
 
             # We can't compare unless attribute present on both.
             if avalue is None or bvalue is None:
                 continue
 
             # Same values should fall back to next attribute.
             if avalue == bvalue:
                 continue
 
             # Exact matches come first.
             if avalue == prefvalue:
                 return -1
             if bvalue == prefvalue:
                 return 1
 
             # Fall back to next attribute.
             continue
 
         # If we got here we couldn't sort by attributes and prefers. Fall
         # back to index order.
         return 0
 
     def __lt__(self, other):
         return self._cmp(other) < 0
 
     def __gt__(self, other):
         return self._cmp(other) > 0
 
     def __eq__(self, other):
         return self._cmp(other) == 0
 
     def __le__(self, other):
         return self._cmp(other) <= 0
 
     def __ge__(self, other):
         return self._cmp(other) >= 0
 
     def __ne__(self, other):
         return self._cmp(other) != 0
 
 
 def sortclonebundleentries(ui, entries):
     prefers = ui.configlist(b'ui', b'clonebundleprefers')
     if not prefers:
         return list(entries)
 
     def _split(p):
         if b'=' not in p:
             hint = _(b"each comma separated item should be key=value pairs")
             raise error.Abort(
                 _(b"invalid ui.clonebundleprefers item: %s") % p, hint=hint
             )
         return p.split(b'=', 1)
 
     prefers = [_split(p) for p in prefers]
 
     items = sorted(clonebundleentry(v, prefers) for v in entries)
     return [i.value for i in items]
 
 
 def trypullbundlefromurl(ui, repo, url):
     """Attempt to apply a bundle from a URL."""
     with repo.lock(), repo.transaction(b'bundleurl') as tr:
         try:
             fh = urlmod.open(ui, url)
             cg = readbundle(ui, fh, b'stream')
 
             if isinstance(cg, streamclone.streamcloneapplier):
                 cg.apply(repo)
             else:
                 bundle2.applybundle(repo, cg, tr, b'clonebundles', url)
             return True
         except urlerr.httperror as e:
             ui.warn(
                 _(b'HTTP error fetching bundle: %s\n')
                 % stringutil.forcebytestr(e)
             )
         except urlerr.urlerror as e:
             ui.warn(
                 _(b'error fetching bundle: %s\n')
                 % stringutil.forcebytestr(e.reason)
             )
 
         return False